#!/usr/bin/env node
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJS = (cb, mod) => function __require() {
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));

// ../node_modules/@emprespresso/pengueno/dist/leftpadesque/prepend.js
var require_prepend = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/leftpadesque/prepend.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.prependWith = void 0;
    var prependWith = (arr, prep) => Array(arr.length * 2).fill(0).map((_, i) => i % 2 === 0).map((isPrep, i) => isPrep ? prep : arr[Math.floor(i / 2)]);
    exports2.prependWith = prependWith;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/leftpadesque/debug.js
var require_debug = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/leftpadesque/debug.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.isDebug = exports2.isProd = void 0;
    var _hasEnv = true;
    var _env = _hasEnv && (process.env.ENVIRONMENT ?? "").toLowerCase().includes("prod") ? "production" : "development";
    var isProd = () => _env === "production";
    exports2.isProd = isProd;
    var _debug = !(0, exports2.isProd)() || _hasEnv && ["y", "t"].some((process.env.DEBUG ?? "").toLowerCase().startsWith);
    var isDebug = () => _debug;
    exports2.isDebug = isDebug;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/leftpadesque/memoize.js
var require_memoize = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/leftpadesque/memoize.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.memoize = void 0;
    var memoize = (fn) => {
      const cache = /* @__PURE__ */ new Map();
      return (...args) => {
        const key = JSON.stringify(args);
        if (cache.has(key)) {
          return cache.get(key);
        }
        const res = fn(...args);
        cache.set(key, res);
        return res;
      };
    };
    exports2.memoize = memoize;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/leftpadesque/index.js
var require_leftpadesque = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/leftpadesque/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_prepend(), exports2);
    __exportStar(require_debug(), exports2);
    __exportStar(require_memoize(), exports2);
  }
});

// ../node_modules/@emprespresso/pengueno/dist/types/misc.js
var require_misc = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/types/misc.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
  }
});

// ../node_modules/@emprespresso/pengueno/dist/types/object.js
var require_object = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/types/object.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.isObject = void 0;
    var isObject3 = (o) => typeof o === "object" && !Array.isArray(o) && !!o;
    exports2.isObject = isObject3;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/types/tagged.js
var require_tagged = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/types/tagged.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.isTagged = void 0;
    var index_1 = require_types();
    var isTagged = (o, tag) => !!((0, index_1.isObject)(o) && "_tag" in o && o._tag === tag);
    exports2.isTagged = isTagged;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/types/fn/callable.js
var require_callable = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/types/fn/callable.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
  }
});

// ../node_modules/@emprespresso/pengueno/dist/types/fn/optional.js
var require_optional = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/types/fn/optional.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Optional = exports2.IOptionalEmptyError = exports2.isOptional = exports2.IOptionalTag = void 0;
    var pengueno_1 = require_dist();
    exports2.IOptionalTag = "IOptional";
    var isOptional = (o) => (0, pengueno_1.isTagged)(o, exports2.IOptionalTag);
    exports2.isOptional = isOptional;
    var IOptionalEmptyError = class extends Error {
    };
    exports2.IOptionalEmptyError = IOptionalEmptyError;
    var OSomeTag = "O.Some";
    var ONoneTag = "O.None";
    var isNone = (o) => (0, pengueno_1.isTagged)(o, ONoneTag);
    var isSome = (o) => (0, pengueno_1.isTagged)(o, OSomeTag);
    var _Tagged = class {
      _tag;
      constructor(_tag = exports2.IOptionalTag) {
        this._tag = _tag;
      }
    };
    var Optional = class _Optional extends _Tagged {
      self;
      constructor(self) {
        super();
        this.self = self;
      }
      move(t) {
        return this.map(() => t);
      }
      orSome(supplier) {
        if (isNone(this.self))
          return _Optional.from(supplier());
        return this;
      }
      get() {
        if (isNone(this.self))
          throw new IOptionalEmptyError("called get() on None optional");
        return this.self.value;
      }
      filter(mapper) {
        if (isNone(this.self) || !mapper(this.self.value))
          return _Optional.none();
        return _Optional.some(this.self.value);
      }
      map(mapper) {
        if (isNone(this.self))
          return _Optional.none();
        return _Optional.from(mapper(this.self.value));
      }
      flatMap(mapper) {
        if (isNone(this.self))
          return _Optional.none();
        return _Optional.from(mapper(this.self.value)).orSome(() => _Optional.none()).get();
      }
      present() {
        return isSome(this.self);
      }
      *[Symbol.iterator]() {
        if (isSome(this.self))
          yield this.self.value;
      }
      static some(value) {
        return new _Optional({ value, _tag: OSomeTag });
      }
      static _none = new _Optional({ _tag: ONoneTag });
      static none() {
        return this._none;
      }
      static from(value) {
        if (value === null || value === void 0)
          return _Optional.none();
        return _Optional.some(value);
      }
    };
    exports2.Optional = Optional;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/types/fn/either.js
var require_either = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/types/fn/either.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Either = exports2.isRight = exports2.isLeft = exports2.isEither = exports2.IEitherTag = void 0;
    var pengueno_1 = require_dist();
    exports2.IEitherTag = "IEither";
    var isEither = (o) => (0, pengueno_1.isTagged)(o, exports2.IEitherTag);
    exports2.isEither = isEither;
    var ELeftTag = "E.Left";
    var isLeft = (o) => (0, pengueno_1.isTagged)(o, ELeftTag);
    exports2.isLeft = isLeft;
    var ERightTag = "E.Right";
    var isRight = (o) => (0, pengueno_1.isTagged)(o, ERightTag);
    exports2.isRight = isRight;
    var _Tagged = class {
      _tag;
      constructor(_tag = exports2.IEitherTag) {
        this._tag = _tag;
      }
    };
    var Either2 = class _Either extends _Tagged {
      self;
      constructor(self) {
        super();
        this.self = self;
      }
      moveRight(t) {
        return this.mapRight(() => t);
      }
      mapBoth(errBranch, okBranch) {
        if ((0, exports2.isLeft)(this.self))
          return _Either.left(errBranch(this.self.err));
        return _Either.right(okBranch(this.self.ok));
      }
      mapRight(mapper) {
        if ((0, exports2.isRight)(this.self))
          return _Either.right(mapper(this.self.ok));
        return _Either.left(this.self.err);
      }
      mapLeft(mapper) {
        if ((0, exports2.isLeft)(this.self))
          return _Either.left(mapper(this.self.err));
        return _Either.right(this.self.ok);
      }
      flatMap(mapper) {
        if ((0, exports2.isRight)(this.self))
          return mapper(this.self.ok);
        return _Either.left(this.self.err);
      }
      filter(mapper) {
        if ((0, exports2.isLeft)(this.self))
          return _Either.left(this.self.err);
        return _Either.fromFailable(() => this.right().filter(mapper).get());
      }
      async flatMapAsync(mapper) {
        if ((0, exports2.isLeft)(this.self))
          return Promise.resolve(_Either.left(this.self.err));
        return await mapper(this.self.ok).catch((err) => _Either.left(err));
      }
      fold(leftFolder, rightFolder) {
        if ((0, exports2.isLeft)(this.self))
          return leftFolder(this.self.err);
        return rightFolder(this.self.ok);
      }
      left() {
        if ((0, exports2.isLeft)(this.self))
          return pengueno_1.Optional.from(this.self.err);
        return pengueno_1.Optional.none();
      }
      right() {
        if ((0, exports2.isRight)(this.self))
          return pengueno_1.Optional.from(this.self.ok);
        return pengueno_1.Optional.none();
      }
      joinRight(other, mapper) {
        return this.flatMap((t) => other.mapRight((o) => mapper(o, t)));
      }
      joinRightAsync(other, mapper) {
        return this.flatMapAsync(async (t) => {
          const o = typeof other === "function" ? other() : other;
          return await o.then((other2) => other2.mapRight((o2) => mapper(o2, t)));
        });
      }
      static left(e) {
        return new _Either({ err: e, _tag: ELeftTag });
      }
      static right(t) {
        return new _Either({ ok: t, _tag: ERightTag });
      }
      static fromFailable(s) {
        try {
          return _Either.right(s());
        } catch (e) {
          return _Either.left(e);
        }
      }
      static async fromFailableAsync(s) {
        return await (typeof s === "function" ? s() : s).then((t) => _Either.right(t)).catch((e) => _Either.left(e));
      }
    };
    exports2.Either = Either2;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/types/fn/index.js
var require_fn = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/types/fn/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_callable(), exports2);
    __exportStar(require_optional(), exports2);
    __exportStar(require_either(), exports2);
  }
});

// ../node_modules/@emprespresso/pengueno/dist/types/collections/cons.js
var require_cons = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/types/collections/cons.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.ListZipper = exports2.Cons = void 0;
    var pengueno_1 = require_dist();
    var Cons = class _Cons {
      value;
      next;
      constructor(value, next = pengueno_1.Optional.none()) {
        this.value = value;
        this.next = next;
      }
      before(head) {
        return new _Cons(this.value, head);
      }
      replace(_value) {
        return new _Cons(_value, this.next);
      }
      *[Symbol.iterator]() {
        for (let cur = pengueno_1.Optional.some(this); cur.present(); cur = cur.flatMap((cur2) => cur2.next)) {
          yield cur.get().value;
        }
      }
      static addOnto(items, tail) {
        return Array.from(items).reverse().reduce((cons, value) => pengueno_1.Optional.from(new _Cons(value, cons)), tail);
      }
      static from(items) {
        return _Cons.addOnto(items, pengueno_1.Optional.none());
      }
    };
    exports2.Cons = Cons;
    var ListZipper = class _ListZipper {
      reversedPathToHead;
      currentHead;
      constructor(reversedPathToHead, currentHead) {
        this.reversedPathToHead = reversedPathToHead;
        this.currentHead = currentHead;
      }
      read() {
        return this.currentHead.map(({ value }) => value);
      }
      next() {
        return this.currentHead.map((head) => new _ListZipper(pengueno_1.Optional.some(head.before(this.reversedPathToHead)), head.next));
      }
      previous() {
        return this.reversedPathToHead.map((lastVisited) => new _ListZipper(lastVisited.next, pengueno_1.Optional.some(lastVisited.before(this.currentHead))));
      }
      prependChunk(values) {
        return new _ListZipper(Cons.addOnto(Array.from(values).reverse(), this.reversedPathToHead), this.currentHead);
      }
      prepend(value) {
        return this.prependChunk([value]);
      }
      remove() {
        const newHead = this.currentHead.flatMap((right) => right.next);
        return new _ListZipper(this.reversedPathToHead, newHead);
      }
      replace(value) {
        const newHead = this.currentHead.map((right) => right.replace(value));
        return new _ListZipper(this.reversedPathToHead, newHead);
      }
      *[Symbol.iterator]() {
        let head = this;
        for (let prev = head.previous(); prev.present(); prev = prev.flatMap((p) => p.previous())) {
          head = prev.get();
        }
        if (head.currentHead.present())
          yield* head.currentHead.get();
      }
      collection() {
        return Array.from(this);
      }
      static from(iterable) {
        return new _ListZipper(pengueno_1.Optional.none(), Cons.from(iterable));
      }
    };
    exports2.ListZipper = ListZipper;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/types/collections/index.js
var require_collections = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/types/collections/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_cons(), exports2);
  }
});

// ../node_modules/@emprespresso/pengueno/dist/types/index.js
var require_types = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/types/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_misc(), exports2);
    __exportStar(require_object(), exports2);
    __exportStar(require_tagged(), exports2);
    __exportStar(require_fn(), exports2);
    __exportStar(require_collections(), exports2);
  }
});

// ../node_modules/@emprespresso/pengueno/dist/trace/itrace.js
var require_itrace = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/trace/itrace.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.TraceableImpl = void 0;
    var TraceableImpl = class _TraceableImpl {
      item;
      trace;
      constructor(item, trace) {
        this.item = item;
        this.trace = trace;
      }
      map(mapper) {
        const result = mapper(this);
        return new _TraceableImpl(result, this.trace);
      }
      coExtend(mapper) {
        const results = mapper(this);
        return Array.from(results).map((result) => this.move(result));
      }
      flatMap(mapper) {
        return mapper(this);
      }
      flatMapAsync(mapper) {
        return new _TraceableImpl(mapper(this).then((t) => t.get()), this.trace);
      }
      traceScope(mapper) {
        return new _TraceableImpl(this.get(), this.trace.traceScope(mapper(this)));
      }
      peek(peek) {
        peek(this);
        return this;
      }
      move(t) {
        return this.map(() => t);
      }
      bimap(mapper) {
        const { item, trace: _trace } = mapper(this);
        return this.move(item).traceScope(() => _trace);
      }
      get() {
        return this.item;
      }
    };
    exports2.TraceableImpl = TraceableImpl;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/trace/metric/emittable.js
var require_emittable = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/trace/metric/emittable.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.EmittableMetric = void 0;
    var index_1 = require_metric2();
    var EmittableMetric = class {
      name;
      unit;
      constructor(name, unit) {
        this.name = name;
        this.unit = unit;
      }
      withValue(value) {
        return {
          name: this.name,
          unit: this.unit,
          emissionTimestamp: Date.now(),
          value,
          _tag: index_1.MetricValueTag
        };
      }
    };
    exports2.EmittableMetric = EmittableMetric;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/trace/metric/metric.js
var require_metric = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/trace/metric/metric.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.ResultMetric = exports2.Metric = void 0;
    var index_1 = require_metric2();
    var _Tagged = class {
      _tag;
      constructor(_tag = index_1.IMetricTag) {
        this._tag = _tag;
      }
    };
    var Metric = class _Metric extends _Tagged {
      name;
      parent;
      count;
      time;
      static DELIM = ".";
      constructor(name, parent = void 0, count = new index_1.EmittableMetric(_Metric.join(name, "count"), index_1.Unit.COUNT), time = new index_1.EmittableMetric(_Metric.join(name, "time"), index_1.Unit.MILLISECONDS)) {
        super();
        this.name = name;
        this.parent = parent;
        this.count = count;
        this.time = time;
      }
      child(_name) {
        const childName = _Metric.join(this.name, _name);
        return new _Metric(childName, this);
      }
      asResult() {
        return ResultMetric.from(this);
      }
      static join(...name) {
        return name.join(_Metric.DELIM);
      }
      static fromName(name) {
        return new _Metric(name);
      }
    };
    exports2.Metric = Metric;
    var ResultMetric = class _ResultMetric extends Metric {
      name;
      parent;
      failure;
      success;
      warn;
      constructor(name, parent = void 0, failure, success, warn) {
        super(name, parent);
        this.name = name;
        this.parent = parent;
        this.failure = failure;
        this.success = success;
        this.warn = warn;
      }
      static from(metric) {
        const failure = metric.child("failure");
        const success = metric.child("success");
        const warn = metric.child("warn");
        return new _ResultMetric(metric.name, metric.parent, failure, success, warn);
      }
    };
    exports2.ResultMetric = ResultMetric;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/trace/metric/trace.js
var require_trace = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/trace/metric/trace.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.MetricsTrace = exports2.isMetricsTraceSupplier = void 0;
    var pengueno_1 = require_dist();
    var isMetricsTraceSupplier = (t) => (0, pengueno_1.isMetricValue)(t) || (0, pengueno_1.isIMetric)(t) || Array.isArray(t) && t.every((_m) => (0, pengueno_1.isMetricValue)(_m) || (0, pengueno_1.isIMetric)(_m));
    exports2.isMetricsTraceSupplier = isMetricsTraceSupplier;
    var MetricsTrace = class _MetricsTrace {
      metricConsumer;
      activeTraces;
      completedTraces;
      constructor(metricConsumer, activeTraces = /* @__PURE__ */ new Map(), completedTraces = /* @__PURE__ */ new Set()) {
        this.metricConsumer = metricConsumer;
        this.activeTraces = activeTraces;
        this.completedTraces = completedTraces;
      }
      traceScope(trace) {
        const now = Date.now();
        const metricsToTrace = (Array.isArray(trace) ? trace : [trace]).filter(pengueno_1.isIMetric);
        const initialTraces = new Map(metricsToTrace.map((metric) => [metric, now]));
        return new _MetricsTrace(this.metricConsumer, initialTraces);
      }
      trace(metrics) {
        if (!metrics || typeof metrics === "string") {
          return this;
        }
        const now = Date.now();
        const allMetrics = Array.isArray(metrics) ? metrics : [metrics];
        const valuesToEmit = allMetrics.filter(pengueno_1.isMetricValue);
        const traceableMetrics = allMetrics.filter(pengueno_1.isIMetric);
        const metricsToStart = traceableMetrics.filter((m) => !this.activeTraces.has(m));
        const metricsToEnd = traceableMetrics.filter((m) => this.activeTraces.has(m) && !this.completedTraces.has(m));
        const endedMetricValues = metricsToEnd.flatMap((metric) => [
          metric.count.withValue(1),
          metric.time.withValue(now - this.activeTraces.get(metric))
        ]);
        const allMetricsToEmit = [...valuesToEmit, ...endedMetricValues];
        if (allMetricsToEmit.length > 0) {
          this.metricConsumer(allMetricsToEmit);
        }
        const nextActiveTraces = new Map([
          ...this.activeTraces,
          ...metricsToStart.map((m) => [m, now])
        ]);
        const nextCompletedTraces = /* @__PURE__ */ new Set([...this.completedTraces, ...metricsToEnd]);
        return new _MetricsTrace(this.metricConsumer, nextActiveTraces, nextCompletedTraces);
      }
    };
    exports2.MetricsTrace = MetricsTrace;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/trace/metric/index.js
var require_metric2 = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/trace/metric/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.isIMetric = exports2.IMetricTag = exports2.isMetricValue = exports2.MetricValueTag = exports2.Unit = void 0;
    var pengueno_1 = require_dist();
    var Unit;
    (function(Unit2) {
      Unit2["COUNT"] = "COUNT";
      Unit2["MILLISECONDS"] = "MILLISECONDS";
    })(Unit || (exports2.Unit = Unit = {}));
    exports2.MetricValueTag = "MetricValue";
    var isMetricValue = (t) => (0, pengueno_1.isTagged)(t, exports2.MetricValueTag);
    exports2.isMetricValue = isMetricValue;
    exports2.IMetricTag = "IMetric";
    var isIMetric = (t) => (0, pengueno_1.isTagged)(t, exports2.IMetricTag);
    exports2.isIMetric = isIMetric;
    __exportStar(require_emittable(), exports2);
    __exportStar(require_metric(), exports2);
    __exportStar(require_trace(), exports2);
  }
});

// ../node_modules/@emprespresso/pengueno/dist/trace/log/ansi.js
var require_ansi = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/trace/log/ansi.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.ANSI = void 0;
    exports2.ANSI = {
      RESET: "\x1B[0m",
      BOLD: "\x1B[1m",
      DIM: "\x1B[2m",
      RED: "\x1B[31m",
      GREEN: "\x1B[32m",
      YELLOW: "\x1B[33m",
      BLUE: "\x1B[34m",
      MAGENTA: "\x1B[35m",
      CYAN: "\x1B[36m",
      WHITE: "\x1B[37m",
      BRIGHT_RED: "\x1B[91m",
      BRIGHT_YELLOW: "\x1B[93m",
      GRAY: "\x1B[90m"
    };
  }
});

// ../node_modules/@emprespresso/pengueno/dist/trace/log/level.js
var require_level = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/trace/log/level.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.isLogLevel = exports2.logLevelOrder = exports2.LogLevel = void 0;
    var LogLevel;
    (function(LogLevel2) {
      LogLevel2["UNKNOWN"] = "UNKNOWN";
      LogLevel2["INFO"] = "INFO";
      LogLevel2["WARN"] = "WARN";
      LogLevel2["DEBUG"] = "DEBUG";
      LogLevel2["ERROR"] = "ERROR";
      LogLevel2["SYS"] = "SYS";
    })(LogLevel || (exports2.LogLevel = LogLevel = {}));
    exports2.logLevelOrder = [
      LogLevel.DEBUG,
      LogLevel.INFO,
      LogLevel.WARN,
      LogLevel.ERROR,
      LogLevel.SYS
    ];
    var isLogLevel = (l) => typeof l === "string" && exports2.logLevelOrder.some((level) => level === l);
    exports2.isLogLevel = isLogLevel;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/trace/log/logger.js
var require_logger = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/trace/log/logger.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
  }
});

// ../node_modules/@emprespresso/pengueno/dist/trace/log/pretty_json_console.js
var require_pretty_json_console = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/trace/log/pretty_json_console.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.PrettyJsonConsoleLogger = void 0;
    var index_1 = require_log();
    var PrettyJsonConsoleLogger = class {
      log(level, ...trace) {
        const message = JSON.stringify({
          level,
          trace
        }, null, 4);
        const styled = `${this.getStyle(level)}${message}${index_1.ANSI.RESET}
`;
        this.getStream(level)(styled);
      }
      getStream(level) {
        if (level === index_1.LogLevel.ERROR) {
          return console.error;
        }
        return console.log;
      }
      getStyle(level) {
        switch (level) {
          case index_1.LogLevel.UNKNOWN:
          case index_1.LogLevel.INFO:
            return `${index_1.ANSI.MAGENTA}`;
          case index_1.LogLevel.DEBUG:
            return `${index_1.ANSI.CYAN}`;
          case index_1.LogLevel.WARN:
            return `${index_1.ANSI.BRIGHT_YELLOW}`;
          case index_1.LogLevel.ERROR:
            return `${index_1.ANSI.BRIGHT_RED}`;
          case index_1.LogLevel.SYS:
            return `${index_1.ANSI.DIM}${index_1.ANSI.BLUE}`;
        }
      }
    };
    exports2.PrettyJsonConsoleLogger = PrettyJsonConsoleLogger;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/trace/log/trace.js
var require_trace2 = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/trace/log/trace.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.LogTrace = void 0;
    var pengueno_1 = require_dist();
    var index_1 = require_log();
    var LogTrace = class _LogTrace {
      logger;
      traces;
      defaultLevel;
      allowedLevels;
      constructor(logger = new index_1.PrettyJsonConsoleLogger(), traces = [defaultTrace], defaultLevel = index_1.LogLevel.INFO, allowedLevels = defaultAllowedLevelsSupplier) {
        this.logger = logger;
        this.traces = traces;
        this.defaultLevel = defaultLevel;
        this.allowedLevels = allowedLevels;
      }
      traceScope(trace) {
        return new _LogTrace(this.logger, this.traces.concat(trace), this.defaultLevel, this.allowedLevels);
      }
      trace(trace) {
        const { traces, level: _level } = this.foldTraces(this.traces.concat(trace));
        if (!this.allowedLevels().has(_level))
          return;
        const level = _level === index_1.LogLevel.UNKNOWN ? this.defaultLevel : _level;
        this.logger.log(level, ...traces);
      }
      foldTraces(_traces) {
        const _logTraces = _traces.map((trace) => typeof trace === "function" ? trace() : trace);
        const _level = _logTraces.filter((trace) => (0, index_1.isLogLevel)(trace)).reduce((acc, level2) => Math.max(index_1.logLevelOrder.indexOf(level2), acc), -1);
        const level = index_1.logLevelOrder[_level] ?? index_1.LogLevel.UNKNOWN;
        const traces = _logTraces.filter((trace) => !(0, index_1.isLogLevel)(trace)).map((trace) => {
          if (typeof trace === "object") {
            return `TracedException.Name = ${trace.name}, TracedException.Message = ${trace.message}, TracedException.Stack = ${trace.stack}`;
          }
          return trace;
        });
        return {
          level,
          traces
        };
      }
    };
    exports2.LogTrace = LogTrace;
    var defaultTrace = () => `TimeStamp = ${(/* @__PURE__ */ new Date()).toISOString()}`;
    var defaultAllowedLevels = (0, pengueno_1.memoize)((isDebug) => /* @__PURE__ */ new Set([
      index_1.LogLevel.UNKNOWN,
      ...isDebug ? [index_1.LogLevel.DEBUG] : [],
      index_1.LogLevel.INFO,
      index_1.LogLevel.WARN,
      index_1.LogLevel.ERROR,
      index_1.LogLevel.SYS
    ]));
    var defaultAllowedLevelsSupplier = () => defaultAllowedLevels((0, pengueno_1.isDebug)());
  }
});

// ../node_modules/@emprespresso/pengueno/dist/trace/log/index.js
var require_log = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/trace/log/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_ansi(), exports2);
    __exportStar(require_level(), exports2);
    __exportStar(require_logger(), exports2);
    __exportStar(require_pretty_json_console(), exports2);
    __exportStar(require_trace2(), exports2);
  }
});

// ../node_modules/@emprespresso/pengueno/dist/trace/trace.js
var require_trace3 = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/trace/trace.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.LogMetricTraceable = exports2.LogMetricTrace = exports2.EmbeddedMetricsTraceable = exports2.LogTraceable = void 0;
    var _1 = require_trace4();
    var LogTraceable = class _LogTraceable extends _1.TraceableImpl {
      static LogTrace = new _1.LogTrace();
      static of(t) {
        return new _LogTraceable(t, _LogTraceable.LogTrace);
      }
    };
    exports2.LogTraceable = LogTraceable;
    var getEmbeddedMetricConsumer = (logTrace) => (metrics) => {
      if (metrics.length === 0)
        return;
      logTrace.traceScope(_1.LogLevel.SYS).trace(`Metrics = <metrics>${JSON.stringify(metrics)}</metrics>`);
    };
    var EmbeddedMetricsTraceable = class _EmbeddedMetricsTraceable extends _1.TraceableImpl {
      static MetricsTrace = new _1.MetricsTrace(getEmbeddedMetricConsumer(LogTraceable.LogTrace));
      static of(t, metricsTrace = _EmbeddedMetricsTraceable.MetricsTrace) {
        return new _EmbeddedMetricsTraceable(t, metricsTrace);
      }
    };
    exports2.EmbeddedMetricsTraceable = EmbeddedMetricsTraceable;
    var LogMetricTrace = class _LogMetricTrace {
      logTrace;
      metricsTrace;
      constructor(logTrace, metricsTrace) {
        this.logTrace = logTrace;
        this.metricsTrace = metricsTrace;
      }
      // public traceScope(trace: LogTraceSupplier | MetricsTraceSupplier): LogMetricTrace {
      //     if (isMetricsTraceSupplier(trace)) {
      //         this.metricsTrace = this.metricsTrace.traceScope(trace);
      //         return this;
      //     }
      //     this.logTrace = this.logTrace.traceScope(trace);
      //     return this;
      // }
      traceScope(trace) {
        if ((0, _1.isMetricsTraceSupplier)(trace)) {
          return new _LogMetricTrace(this.logTrace, this.metricsTrace.traceScope(trace));
        }
        return new _LogMetricTrace(this.logTrace.traceScope(trace), this.metricsTrace);
      }
      trace(trace) {
        if ((0, _1.isMetricsTraceSupplier)(trace)) {
          this.metricsTrace.trace(trace);
          return this;
        }
        this.logTrace.trace(trace);
        return this;
      }
    };
    exports2.LogMetricTrace = LogMetricTrace;
    var LogMetricTraceable = class _LogMetricTraceable extends _1.TraceableImpl {
      static ofLogTraceable(t) {
        const metricsTrace = new _1.MetricsTrace(getEmbeddedMetricConsumer(t.trace));
        return new _LogMetricTraceable(t.get(), new LogMetricTrace(t.trace, metricsTrace));
      }
      static of(t) {
        const logTrace = LogTraceable.of(t);
        return _LogMetricTraceable.ofLogTraceable(logTrace);
      }
    };
    exports2.LogMetricTraceable = LogMetricTraceable;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/trace/util.js
var require_util = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/trace/util.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.TraceUtil = void 0;
    var pengueno_1 = require_dist();
    var TraceUtil = class _TraceUtil {
      static promiseify(mapper) {
        return (traceablePromise) => traceablePromise.flatMapAsync(async (t) => t.move(await t.get()).map(mapper)).get();
      }
      static traceResultingEither(metric, warnOnFailure = false) {
        return (t) => {
          if (metric)
            t.trace.trace(t.get().fold((_err) => warnOnFailure ? metric.warn : metric.failure, (_ok) => metric.success));
          return t.traceScope((_t) => _t.get().fold((_err) => warnOnFailure ? pengueno_1.LogLevel.WARN : pengueno_1.LogLevel.ERROR, (_ok) => pengueno_1.LogLevel.INFO));
        };
      }
      static withTrace(trace) {
        return (t) => t.traceScope(() => trace);
      }
      static withMetricTrace(metric) {
        return _TraceUtil.withTrace(metric);
      }
      static withFunctionTrace(f) {
        return _TraceUtil.withTrace(`fn.${f.name}`);
      }
      static withClassTrace(c) {
        return _TraceUtil.withTrace(`class.${c.constructor.name}`);
      }
    };
    exports2.TraceUtil = TraceUtil;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/trace/index.js
var require_trace4 = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/trace/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_itrace(), exports2);
    __exportStar(require_metric2(), exports2);
    __exportStar(require_log(), exports2);
    __exportStar(require_trace3(), exports2);
    __exportStar(require_util(), exports2);
  }
});

// ../node_modules/@emprespresso/pengueno/dist/process/exec.js
var require_exec = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/process/exec.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.getStdoutMany = exports2.getStdout = exports2.CmdMetric = void 0;
    var pengueno_1 = require_dist();
    var node_child_process_1 = require("node:child_process");
    exports2.CmdMetric = pengueno_1.Metric.fromName("Exec").asResult();
    var getStdout = (cmd, options = { streamTraceable: [] }) => cmd.flatMap(pengueno_1.TraceUtil.withFunctionTrace(exports2.getStdout)).flatMap((tCmd) => tCmd.traceScope(() => `Command = ${tCmd.get()}`)).map((tCmd) => {
      const cmd2 = tCmd.get();
      const _exec = typeof cmd2 === "string" ? cmd2 : cmd2.join(" ");
      const env = options.clearEnv ? options.env : { ...process.env, ...options.env };
      return pengueno_1.Either.fromFailableAsync(new Promise((res, rej) => {
        const proc = (0, node_child_process_1.exec)(_exec, { env });
        let stdout = "";
        proc.stdout?.on("data", (d) => {
          const s = d.toString();
          stdout += s;
          if (options.streamTraceable?.includes("stdout")) {
            tCmd.trace.trace(s);
          }
        });
        const stderr = "";
        proc.stderr?.on("data", (d) => {
          const s = d.toString();
          stdout += s;
          if (options.streamTraceable?.includes("stderr")) {
            tCmd.trace.trace(s);
          }
        });
        proc.on("exit", (code) => {
          const streams = { stdout, stderr };
          if (code === 0) {
            res(streams);
          } else {
            rej(new Error(`exited with non-zero code: ${code}. ${stderr}`));
          }
        });
      }));
    }).map(pengueno_1.TraceUtil.promiseify((tEitherStdStreams) => tEitherStdStreams.get().mapRight(({ stderr, stdout }) => {
      if (stderr)
        tEitherStdStreams.trace.traceScope(pengueno_1.LogLevel.DEBUG).trace(`StdErr = ${stderr}`);
      return stdout;
    }))).peek(pengueno_1.TraceUtil.promiseify(pengueno_1.TraceUtil.traceResultingEither(exports2.CmdMetric))).get();
    exports2.getStdout = getStdout;
    var getStdoutMany = (cmds, options = { streamTraceable: [] }) => cmds.coExtend((t) => t.get()).reduce(async (_result, tCmd) => {
      const result = await _result;
      return result.joinRightAsync(() => tCmd.map((cmd) => (0, exports2.getStdout)(cmd, options)).get(), (stdout, pre) => pre.concat(stdout));
    }, Promise.resolve(pengueno_1.Either.right([])));
    exports2.getStdoutMany = getStdoutMany;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/process/env.js
var require_env = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/process/env.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.getRequiredEnvVars = exports2.getRequiredEnv = exports2.getEnv = void 0;
    var pengueno_1 = require_dist();
    var getEnv = (name) => pengueno_1.Optional.from(process.env[name]);
    exports2.getEnv = getEnv;
    var getRequiredEnv = (name) => pengueno_1.Either.fromFailable(() => (0, exports2.getEnv)(name).get()).mapLeft(() => new Error(`environment variable "${name}" is required D:`));
    exports2.getRequiredEnv = getRequiredEnv;
    var getRequiredEnvVars = (vars) => {
      const emptyEnvironment = pengueno_1.Either.right({});
      const addTo = (env, key, val) => ({
        ...env,
        [key]: val
      });
      return vars.reduce((environment, key) => environment.joinRight((0, exports2.getRequiredEnv)(key), (value, environment2) => addTo(environment2, key, value)), emptyEnvironment);
    };
    exports2.getRequiredEnvVars = getRequiredEnvVars;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/process/validate_identifier.js
var require_validate_identifier = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/process/validate_identifier.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.validateExecutionEntries = exports2.validateIdentifier = void 0;
    var pengueno_1 = require_dist();
    var validateIdentifier = (token) => {
      return /^[a-zA-Z0-9_\-:. \/]+$/.test(token) && !token.includes("..");
    };
    exports2.validateIdentifier = validateIdentifier;
    var validateExecutionEntries = (obj) => {
      const invalidEntries = Object.entries(obj).filter((e) => !e.every((x) => typeof x === "string" && (0, exports2.validateIdentifier)(x)));
      if (invalidEntries.length > 0)
        return pengueno_1.Either.left(invalidEntries);
      return pengueno_1.Either.right(obj);
    };
    exports2.validateExecutionEntries = validateExecutionEntries;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/process/argv.js
var require_argv = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/process/argv.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.argv = exports2.getArg = exports2.isArgKey = void 0;
    var pengueno_1 = require_dist();
    var isArgKey = (k) => k.startsWith("--");
    exports2.isArgKey = isArgKey;
    var getArg = (arg, argv2, whenValue) => {
      const argIndex = pengueno_1.Optional.from(argv2.findIndex((_argv) => (0, exports2.isArgKey)(_argv) && _argv.split("=")[0] === arg)).filter((index) => index >= 0 && index < argv2.length);
      if (!argIndex.present()) {
        return pengueno_1.Optional.from(whenValue.absent).map((v) => pengueno_1.Either.right(v)).orSome(() => pengueno_1.Either.left(new Error(`arg ${arg} is not present in arguments list and does not have an 'absent' value`))).get();
      }
      return argIndex.flatMap((idx) => pengueno_1.Optional.from(argv2.at(idx)).map((_argv) => _argv.includes("=") ? _argv.split("=")[1] : argv2.at(idx + 1))).filter((next) => !(0, exports2.isArgKey)(next)).map((next) => whenValue.present(next)).orSome(() => whenValue.unspecified).map((v) => pengueno_1.Either.right(v)).get();
    };
    exports2.getArg = getArg;
    var argv = (args, handlers, argv2 = process.argv.slice(2)) => {
      const defaultHandler = { present: (value) => value };
      const processArg = (arg) => {
        const handler = handlers?.[arg] ?? defaultHandler;
        return (0, exports2.getArg)(arg, argv2, handler).mapRight((value) => [arg, value]);
      };
      const res = args.map(processArg).reduce((acc, current) => acc.flatMap((accValue) => current.mapRight(([key, value]) => ({
        ...accValue,
        [key]: value
      }))), pengueno_1.Either.right({})).mapRight((result) => result);
      return res;
    };
    exports2.argv = argv;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/process/signals.js
var require_signals = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/process/signals.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Signals = exports2.SigTermMetric = exports2.SigIntMetric = void 0;
    var pengueno_1 = require_dist();
    exports2.SigIntMetric = pengueno_1.Metric.fromName("SigInt").asResult();
    exports2.SigTermMetric = pengueno_1.Metric.fromName("SigTerm").asResult();
    var Signals = class {
      static async awaitClose(t) {
        const success = pengueno_1.Either.right(void 0);
        return new Promise((res) => {
          const metricizedInterruptHandler = (metric) => (err) => t.flatMap(pengueno_1.TraceUtil.withMetricTrace(metric)).peek((_t) => _t.trace.trace("closing")).move(pengueno_1.Optional.from(err).map((e) => pengueno_1.Either.left(e)).orSome(() => success).get()).flatMap(pengueno_1.TraceUtil.traceResultingEither(metric)).map((e) => res(e.get())).peek((_t) => _t.trace.trace("finished")).get();
          const sigintCloser = metricizedInterruptHandler(exports2.SigIntMetric);
          const sigtermCloser = metricizedInterruptHandler(exports2.SigTermMetric);
          process.on("SIGINT", () => t.flatMap(pengueno_1.TraceUtil.withTrace("SIGINT")).get().close(sigintCloser));
          process.on("SIGTERM", () => t.flatMap(pengueno_1.TraceUtil.withTrace("SIGTERM")).get().close(sigtermCloser));
        });
      }
    };
    exports2.Signals = Signals;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/process/index.js
var require_process = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/process/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_exec(), exports2);
    __exportStar(require_env(), exports2);
    __exportStar(require_validate_identifier(), exports2);
    __exportStar(require_argv(), exports2);
    __exportStar(require_signals(), exports2);
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/http/body.js
var require_body = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/http/body.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/http/status.js
var require_status = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/http/status.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.HttpStatusCodes = void 0;
    exports2.HttpStatusCodes = {
      100: "Continue",
      101: "Switching Protocols",
      102: "Processing (WebDAV)",
      200: "OK",
      201: "Created",
      202: "Accepted",
      203: "Non-Authoritative Information",
      204: "No Content",
      205: "Reset Content",
      206: "Partial Content",
      207: "Multi-Status (WebDAV)",
      208: "Already Reported (WebDAV)",
      226: "IM Used",
      300: "Multiple Choices",
      301: "Moved Permanently",
      302: "Found",
      303: "See Other",
      304: "Not Modified",
      305: "Use Proxy",
      306: "(Unused)",
      307: "Temporary Redirect",
      308: "Permanent Redirect (experimental)",
      400: "Bad Request",
      401: "Unauthorized",
      402: "Payment Required",
      403: "Forbidden",
      404: "Not Found",
      405: "Method Not Allowed",
      406: "Not Acceptable",
      407: "Proxy Authentication Required",
      408: "Request Timeout",
      409: "Conflict",
      410: "Gone",
      411: "Length Required",
      412: "Precondition Failed",
      413: "Request Entity Too Large",
      414: "Request-URI Too Long",
      415: "Unsupported Media Type",
      416: "Requested Range Not Satisfiable",
      417: "Expectation Failed",
      418: "I'm a teapot (RFC 2324)",
      420: "Enhance Your Calm (Twitter)",
      422: "Unprocessable Entity (WebDAV)",
      423: "Locked (WebDAV)",
      424: "Failed Dependency (WebDAV)",
      425: "Reserved for WebDAV",
      426: "Upgrade Required",
      428: "Precondition Required",
      429: "Too Many Requests",
      431: "Request Header Fields Too Large",
      444: "No Response (Nginx)",
      449: "Retry With (Microsoft)",
      450: "Blocked by Windows Parental Controls (Microsoft)",
      451: "Unavailable For Legal Reasons",
      499: "Client Closed Request (Nginx)",
      500: "Internal Server Error",
      501: "Not Implemented",
      502: "Bad Gateway",
      503: "Service Unavailable",
      504: "Gateway Timeout",
      505: "HTTP Version Not Supported",
      506: "Variant Also Negotiates (Experimental)",
      507: "Insufficient Storage (WebDAV)",
      508: "Loop Detected (WebDAV)",
      509: "Bandwidth Limit Exceeded (Apache)",
      510: "Not Extended",
      511: "Network Authentication Required",
      598: "Network read timeout error",
      599: "Network connect timeout error"
    };
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/http/method.js
var require_method = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/http/method.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/http/index.js
var require_http = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/http/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_body(), exports2);
    __exportStar(require_status(), exports2);
    __exportStar(require_method(), exports2);
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/response/pengueno.js
var require_pengueno = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/response/pengueno.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.JsonResponse = exports2.PenguenoResponse = exports2.getResponseMetrics = void 0;
    var pengueno_1 = require_dist();
    var getHeaders = (req, extraHeaders) => {
      const optHeaders = {
        ...req.getResponseHeaders(),
        ...extraHeaders
      };
      optHeaders["Content-Type"] = (optHeaders["Content-Type"] ?? "text/plain") + "; charset=utf-8";
      return optHeaders;
    };
    var ResponseCodeMetrics = [0, 1, 2, 3, 4, 5].map((x) => pengueno_1.Metric.fromName(`response.${x}xx`).asResult());
    var getResponseMetrics = (status, elapsedMs) => {
      const index = Math.floor(status / 100);
      return ResponseCodeMetrics.flatMap((metric, i) => pengueno_1.Optional.from(i).filter((i2) => i2 === index).map(() => [metric.count.withValue(1)]).flatMap((metricValues) => pengueno_1.Optional.from(elapsedMs).map((ms) => metricValues.concat(metric.time.withValue(ms))).orSome(() => metricValues)).orSome(() => [metric.count.withValue(0)]).get());
    };
    exports2.getResponseMetrics = getResponseMetrics;
    var PenguenoResponse = class {
      _body;
      statusText;
      status;
      headers;
      constructor(req, _body, opts) {
        this._body = _body;
        this.headers = getHeaders(req.get(), opts?.headers ?? {});
        this.status = opts.status;
        this.statusText = opts.statusText ?? pengueno_1.HttpStatusCodes[this.status];
        req.trace.trace((0, exports2.getResponseMetrics)(opts.status, req.get().elapsedTimeMs()));
      }
      body() {
        return this._body;
      }
    };
    exports2.PenguenoResponse = PenguenoResponse;
    var JsonResponse = class extends PenguenoResponse {
      constructor(req, e, _opts) {
        const opts = { ..._opts, headers: { ..._opts.headers, "Content-Type": "application/json" } };
        if ((0, pengueno_1.isEither)(e)) {
          super(req, JSON.stringify(e.fold((error) => ({ error, ok: void 0 }), (ok) => ({ ok }))), opts);
          return;
        }
        super(req, JSON.stringify(Math.floor(opts.status / 100) > 4 ? { error: e } : { ok: e }), opts);
      }
    };
    exports2.JsonResponse = JsonResponse;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/response/index.js
var require_response = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/response/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_pengueno(), exports2);
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/request/pengueno.js
var require_pengueno2 = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/request/pengueno.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.PenguenoRequest = void 0;
    var greetings = ["hewwo :D", "hiya cutie", "boop!", "sending virtual hugs!", "stay pawsitive"];
    var penguenoGreeting = () => greetings[Math.floor(Math.random() * greetings.length)];
    var PenguenoRequest = class _PenguenoRequest {
      req;
      id;
      at;
      constructor(req, id, at) {
        this.req = req;
        this.id = id;
        this.at = at;
      }
      elapsedTimeMs(after = () => Date.now()) {
        return after() - this.at.getTime();
      }
      getResponseHeaders() {
        const RequestId = this.id;
        const RequestReceivedUnix = this.at.getTime();
        const RequestHandleUnix = Date.now();
        const DeltaUnix = this.elapsedTimeMs(() => RequestHandleUnix);
        const Hai = penguenoGreeting();
        return Object.entries({
          RequestId,
          RequestReceivedUnix,
          RequestHandleUnix,
          DeltaUnix,
          Hai
        }).reduce((acc, [key, val]) => ({ ...acc, [key]: val.toString() }), {});
      }
      static from(request) {
        const id = crypto.randomUUID();
        return request.bimap((tRequest) => {
          const request2 = tRequest.get();
          const url = new URL(request2.url);
          const { pathname } = url;
          const trace = `RequestId = ${id}, Method = ${request2.method}, Path = ${pathname}`;
          return { item: new _PenguenoRequest(request2, id, /* @__PURE__ */ new Date()), trace };
        });
      }
    };
    exports2.PenguenoRequest = PenguenoRequest;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/request/index.js
var require_request = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/request/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_pengueno2(), exports2);
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/activity/health.js
var require_health = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/activity/health.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.HealthCheckActivityImpl = exports2.HealthCheckOutput = exports2.HealthCheckInput = void 0;
    var pengueno_1 = require_dist();
    var HealthCheckInput;
    (function(HealthCheckInput2) {
      HealthCheckInput2[HealthCheckInput2["CHECK"] = 0] = "CHECK";
    })(HealthCheckInput || (exports2.HealthCheckInput = HealthCheckInput = {}));
    var HealthCheckOutput;
    (function(HealthCheckOutput2) {
      HealthCheckOutput2[HealthCheckOutput2["YAASSSLAYQUEEN"] = 0] = "YAASSSLAYQUEEN";
    })(HealthCheckOutput || (exports2.HealthCheckOutput = HealthCheckOutput = {}));
    var healthCheckMetric = pengueno_1.Metric.fromName("Health").asResult();
    var HealthCheckActivityImpl = class {
      check;
      constructor(check) {
        this.check = check;
      }
      checkHealth(req) {
        return req.flatMap(pengueno_1.TraceUtil.withFunctionTrace(this.checkHealth)).flatMap(pengueno_1.TraceUtil.withMetricTrace(healthCheckMetric)).flatMap((r) => r.move(HealthCheckInput.CHECK).map((input) => this.check(input))).peek(pengueno_1.TraceUtil.promiseify(pengueno_1.TraceUtil.traceResultingEither(healthCheckMetric))).map(pengueno_1.TraceUtil.promiseify((h) => {
          const { status, message } = h.get().fold(() => ({ status: 500, message: "err" }), () => ({ status: 200, message: "ok" }));
          return new pengueno_1.JsonResponse(req, message, { status });
        })).get();
      }
    };
    exports2.HealthCheckActivityImpl = HealthCheckActivityImpl;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/activity/fourohfour.js
var require_fourohfour = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/activity/fourohfour.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.FourOhFourActivityImpl = void 0;
    var pengueno_1 = require_dist();
    var messages = [
      "D: meow-t found! your api call ran away!",
      "404-bidden! but like...in a cute way >:3 !",
      ":< your data went on a paw-sible vacation!",
      "uwu~ not found, but found our hearts instead!"
    ];
    var randomFourOhFour = () => messages[Math.floor(Math.random() * messages.length)];
    var FourOhFourActivityImpl = class {
      fourOhFour(req) {
        return req.move(new pengueno_1.JsonResponse(req, randomFourOhFour(), { status: 404 })).map((resp) => Promise.resolve(resp.get())).get();
      }
    };
    exports2.FourOhFourActivityImpl = FourOhFourActivityImpl;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/activity/index.js
var require_activity = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/activity/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_health(), exports2);
    __exportStar(require_fourohfour(), exports2);
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/filter/method.js
var require_method2 = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/filter/method.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.requireMethod = void 0;
    var pengueno_1 = require_dist();
    var requireMethod = (methods) => (req) => req.flatMap(pengueno_1.TraceUtil.withFunctionTrace(exports2.requireMethod)).map((t) => {
      const { req: { method } } = t.get();
      if (!methods.includes(method)) {
        const msg = "that's not how you pet me (\u22DF\uFE4F\u22DE)~";
        t.trace.traceScope(pengueno_1.LogLevel.WARN).trace(msg);
        return pengueno_1.Either.left(new pengueno_1.PenguenoError(msg, 405));
      }
      return pengueno_1.Either.right(method);
    }).get();
    exports2.requireMethod = requireMethod;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/filter/json.js
var require_json = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/filter/json.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.jsonModel = void 0;
    var pengueno_1 = require_dist();
    var ParseJsonMetric = pengueno_1.Metric.fromName("JsonParse").asResult();
    var jsonModel = (jsonTransformer) => (r) => r.flatMap(pengueno_1.TraceUtil.withFunctionTrace(exports2.jsonModel)).flatMap(pengueno_1.TraceUtil.withMetricTrace(ParseJsonMetric)).map((j) => pengueno_1.Either.fromFailableAsync(j.get().req.json()).then((either) => either.mapLeft((errReason) => {
      j.trace.traceScope(pengueno_1.LogLevel.WARN).trace(errReason);
      return new pengueno_1.PenguenoError("seems to be invalid JSON (>//<) can you fix?", 400);
    }))).flatMapAsync(pengueno_1.TraceUtil.promiseify(pengueno_1.TraceUtil.traceResultingEither(ParseJsonMetric))).map(pengueno_1.TraceUtil.promiseify((traceableEitherJson) => traceableEitherJson.get().mapRight((j) => traceableEitherJson.move(j)).flatMap(jsonTransformer))).get();
    exports2.jsonModel = jsonModel;
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/filter/index.js
var require_filter = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/filter/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.PenguenoError = exports2.ErrorSource = void 0;
    var pengueno_1 = require_dist();
    var ErrorSource;
    (function(ErrorSource2) {
      ErrorSource2["USER"] = "WARN";
      ErrorSource2["SYSTEM"] = "ERROR";
    })(ErrorSource || (exports2.ErrorSource = ErrorSource = {}));
    var PenguenoError = class extends Error {
      message;
      status;
      source;
      constructor(message, status) {
        super(message);
        this.message = message;
        this.status = status;
        this.source = Math.floor(status / 100) === 4 ? ErrorSource.USER : ErrorSource.SYSTEM;
      }
    };
    exports2.PenguenoError = PenguenoError;
    __exportStar(require_method2(), exports2);
    __exportStar(require_json(), exports2);
  }
});

// ../node_modules/@emprespresso/pengueno/dist/server/index.js
var require_server = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/server/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_http(), exports2);
    __exportStar(require_response(), exports2);
    __exportStar(require_request(), exports2);
    __exportStar(require_activity(), exports2);
    __exportStar(require_filter(), exports2);
  }
});

// ../node_modules/@emprespresso/pengueno/dist/index.js
var require_dist = __commonJS({
  "../node_modules/@emprespresso/pengueno/dist/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_leftpadesque(), exports2);
    __exportStar(require_types(), exports2);
    __exportStar(require_trace4(), exports2);
    __exportStar(require_process(), exports2);
    __exportStar(require_server(), exports2);
  }
});

// ../model/job/index.ts
var import_pengueno = __toESM(require_dist(), 1);
var JobTypes = [
  "fetch_code",
  "ci_pipeline",
  "build_docker_image.js",
  "ansible_playbook.js",
  "checkout_ci.js",
  "npm_publish.js"
];
var isJobType = (j) => typeof j === "string" && JobTypes.includes(j);
var isJob = (j) => !!((0, import_pengueno.isObject)(j) && "arguments" in j && (0, import_pengueno.isObject)(j.arguments) && "type" in j && isJobType(j.type) && j);

// ../model/pipeline/index.ts
var import_pengueno3 = __toESM(require_dist(), 1);

// ../model/pipeline/builder.ts
var BasePipelineBuilder = class {
  stages = [];
  addStage(stage) {
    this.stages.push(stage);
    return this;
  }
  build() {
    return new PipelineImpl(this.stages);
  }
};
var DefaultGitHookPipelineBuilder = class extends BasePipelineBuilder {
  constructor(remoteUrl = process.env.remote, rev = process.env.rev, refname = process.env.refname) {
    super();
    this.remoteUrl = remoteUrl;
    this.refname = refname;
    this.addStage({
      parallelJobs: [
        {
          type: "fetch_code",
          arguments: {
            remoteUrl,
            checkout: rev,
            path: this.getSourceDestination()
          }
        }
      ]
    });
  }
  getSourceDestination() {
    return this.remoteUrl.replace(".git", "").split("/").at(-1) ?? "src";
  }
  getBranch() {
    const branchRefPrefix = "refs/heads/";
    return this.refname.split(branchRefPrefix).at(1);
  }
};

// ../model/pipeline/impl.ts
var import_pengueno2 = __toESM(require_dist(), 1);
var PipelineImpl = class _PipelineImpl {
  constructor(serialJobs) {
    this.serialJobs = serialJobs;
  }
  serialize() {
    return JSON.stringify({ serialJobs: this.serialJobs });
  }
  static from(s) {
    return import_pengueno2.Either.fromFailable(() => JSON.parse(s)).flatMap(
      (eitherPipelineJson) => isPipeline(eitherPipelineJson) ? import_pengueno2.Either.right(eitherPipelineJson) : import_pengueno2.Either.left(new Error("oh noes D: its a bad pipewine :(("))
    ).mapRight((pipeline) => new _PipelineImpl(pipeline.serialJobs));
  }
};

// ../model/pipeline/index.ts
var isPipelineStage = (t) => (0, import_pengueno3.isObject)(t) && "parallelJobs" in t && Array.isArray(t.parallelJobs) && t.parallelJobs.every((j) => isJob(j));
var isPipeline = (t) => (0, import_pengueno3.isObject)(t) && "serialJobs" in t && Array.isArray(t.serialJobs) && t.serialJobs.every((p) => isPipelineStage(p));

// dist/ci.js
var import_path = require("path");
var REGISTRY = "oci.liz.coffee";
var NAMESPACE = "emprespresso";
var IMG = "ci";
var REMOTE = "ssh://src.liz.coffee:2222";
var getPipeline = () => {
  const gitHookPipeline = new DefaultGitHookPipelineBuilder();
  const branch = gitHookPipeline.getBranch();
  if (!branch)
    return gitHookPipeline.build();
  const commonBuildArgs = {
    context: gitHookPipeline.getSourceDestination(),
    registry: REGISTRY,
    namespace: NAMESPACE,
    imageTag: branch
  };
  const baseCiPackageBuild = {
    type: "build_docker_image.js",
    arguments: {
      ...commonBuildArgs,
      repository: IMG + "_base",
      buildTarget: IMG + "_base",
      dockerfile: "Dockerfile"
    }
  };
  gitHookPipeline.addStage({
    parallelJobs: [baseCiPackageBuild]
  });
  const subPackages = ["worker", "server"].map((_package) => ({
    type: "build_docker_image.js",
    arguments: {
      ...commonBuildArgs,
      repository: `${IMG}_${_package}`,
      buildTarget: _package,
      dockerfile: `${_package}/Dockerfile`
    }
  }));
  subPackages.push({
    type: "build_docker_image.js",
    arguments: {
      ...commonBuildArgs,
      repository: `${IMG}_packpub_npm`,
      buildTarget: "packpub_npm",
      dockerfile: `Dockerfile`,
      context: (0, import_path.join)(commonBuildArgs.context, "packpub/npm")
    }
  });
  gitHookPipeline.addStage({
    parallelJobs: subPackages
  });
  const isRelease = branch === "release";
  if (!isRelease) {
    return gitHookPipeline.build();
  }
  const fetchAnsibleCode = {
    type: "fetch_code",
    arguments: {
      remoteUrl: `${REMOTE}/infra`,
      checkout: "main",
      path: "infra"
    }
  };
  const thenDeploy = {
    type: "ansible_playbook.js",
    arguments: {
      path: "infra",
      playbooks: "playbooks/ci.yml"
    }
  };
  [fetchAnsibleCode, thenDeploy].forEach((deploymentStage) => gitHookPipeline.addStage({ parallelJobs: [deploymentStage] }));
  return gitHookPipeline.build();
};
var main = () => {
  const data = getPipeline().serialize();
  process.stdout.write(data);
};
main();