#!/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: `packpub/npm/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();