recompile ci.cjs

2 files changed, 491 insertions, 505 deletions

diff --git a/.ci/ci.cjs b/.ci/ci.cjs
index 97655e7..0fa8947 100755
--- a/.ci/ci.cjs
+++ b/.ci/ci.cjs
@@ -1,621 +1,605 @@
 #!/usr/bin/env node
-'use strict';
+"use strict";
 
 // ../u/leftpadesque/debug.ts
 var _hasEnv = true;
-var _env = _hasEnv && (process.env.ENVIRONMENT ?? '').toLowerCase().includes('prod') ? 'production' : 'development';
-var isProd = () => _env === 'production';
-var _debug = !isProd() || (_hasEnv && ['y', 't'].some((process.env.DEBUG ?? '').toLowerCase().startsWith));
+var _env = _hasEnv && (process.env.ENVIRONMENT ?? "").toLowerCase().includes("prod") ? "production" : "development";
+var isProd = () => _env === "production";
+var _debug = !isProd() || _hasEnv && ["y", "t"].some((process.env.DEBUG ?? "").toLowerCase().startsWith);
 var isDebug = () => _debug;
 
 // ../u/leftpadesque/memoize.ts
 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.apply(args);
-        cache.set(key, res);
-        return res;
-    };
+  const cache = /* @__PURE__ */ new Map();
+  return (...args) => {
+    const key = JSON.stringify(args);
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    const res = fn.apply(args);
+    cache.set(key, res);
+    return res;
+  };
 };
 
 // ../u/trace/itrace.ts
 var TraceableImpl = class _TraceableImpl {
-    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;
-    }
+  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;
+  }
 };
 
 // ../u/trace/metric/emittable.ts
 var EmittableMetric = class {
-    constructor(name, unit) {
-        this.name = name;
-        this.unit = unit;
-    }
-    withValue(value) {
-        return {
-            name: this.name,
-            unit: this.unit,
-            emissionTimestamp: Date.now(),
-            value,
-            _tag: MetricValueTag,
-        };
-    }
+  constructor(name, unit) {
+    this.name = name;
+    this.unit = unit;
+  }
+  withValue(value) {
+    return {
+      name: this.name,
+      unit: this.unit,
+      emissionTimestamp: Date.now(),
+      value,
+      _tag: MetricValueTag
+    };
+  }
 };
 
 // ../u/trace/metric/metric.ts
 var _Tagged = class {
-    constructor(_tag = IMetricTag) {
-        this._tag = _tag;
-    }
+  constructor(_tag = IMetricTag) {
+    this._tag = _tag;
+  }
 };
 var Metric = class _Metric extends _Tagged {
-    constructor(
-        name,
-        parent = void 0,
-        count = new EmittableMetric(_Metric.join(name, 'count'), 'COUNT' /* COUNT */),
-        time = new EmittableMetric(_Metric.join(name, 'time'), 'MILLISECONDS' /* MILLISECONDS */),
-    ) {
-        super();
-        this.name = name;
-        this.parent = parent;
-        this.count = count;
-        this.time = time;
-    }
-    static DELIM = '.';
-    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);
-    }
+  constructor(name, parent = void 0, count = new EmittableMetric(_Metric.join(name, "count"), "COUNT" /* COUNT */), time = new EmittableMetric(_Metric.join(name, "time"), "MILLISECONDS" /* MILLISECONDS */)) {
+    super();
+    this.name = name;
+    this.parent = parent;
+    this.count = count;
+    this.time = time;
+  }
+  static DELIM = ".";
+  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);
+  }
 };
 var ResultMetric = class _ResultMetric extends Metric {
-    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);
-    }
+  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);
+  }
 };
 
 // ../u/trace/metric/trace.ts
 var MetricsTrace = class _MetricsTrace {
-    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(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(isMetricValue);
-        const traceableMetrics = allMetrics.filter(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);
-    }
+  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(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(isMetricValue);
+    const traceableMetrics = allMetrics.filter(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);
+  }
 };
 
 // ../u/trace/metric/index.ts
-var MetricValueTag = 'MetricValue';
+var MetricValueTag = "MetricValue";
 var isMetricValue = (t) => isTagged(t, MetricValueTag);
-var IMetricTag = 'IMetric';
+var IMetricTag = "IMetric";
 var isIMetric = (t) => isTagged(t, IMetricTag);
 
 // ../u/trace/log/ansi.ts
 var 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',
+  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"
 };
 
 // ../u/trace/log/level.ts
-var logLevelOrder = ['DEBUG' /* DEBUG */, 'INFO' /* INFO */, 'WARN' /* WARN */, 'ERROR' /* ERROR */, 'SYS' /* SYS */];
-var isLogLevel = (l) => typeof l === 'string' && logLevelOrder.some((level) => level === l);
+var logLevelOrder = [
+  "DEBUG" /* DEBUG */,
+  "INFO" /* INFO */,
+  "WARN" /* WARN */,
+  "ERROR" /* ERROR */,
+  "SYS" /* SYS */
+];
+var isLogLevel = (l) => typeof l === "string" && logLevelOrder.some((level) => level === l);
 
 // ../u/trace/log/pretty_json_console.ts
 var PrettyJsonConsoleLogger = class {
-    log(level, ...trace) {
-        const message = JSON.stringify(
-            {
-                level,
-                trace,
-            },
-            null,
-            4,
-        );
-        const styled = `${this.getStyle(level)}${message}${ANSI.RESET}
+  log(level, ...trace) {
+    const message = JSON.stringify(
+      {
+        level,
+        trace
+      },
+      null,
+      4
+    );
+    const styled = `${this.getStyle(level)}${message}${ANSI.RESET}
 `;
-        this.getStream(level)(styled);
-    }
-    getStream(level) {
-        if (level === 'ERROR' /* ERROR */) {
-            return console.error;
-        }
-        return console.log;
-    }
-    getStyle(level) {
-        switch (level) {
-            case 'UNKNOWN' /* UNKNOWN */:
-            case 'INFO' /* INFO */:
-                return `${ANSI.MAGENTA}`;
-            case 'DEBUG' /* DEBUG */:
-                return `${ANSI.CYAN}`;
-            case 'WARN' /* WARN */:
-                return `${ANSI.BRIGHT_YELLOW}`;
-            case 'ERROR' /* ERROR */:
-                return `${ANSI.BRIGHT_RED}`;
-            case 'SYS' /* SYS */:
-                return `${ANSI.DIM}${ANSI.BLUE}`;
-        }
-    }
+    this.getStream(level)(styled);
+  }
+  getStream(level) {
+    if (level === "ERROR" /* ERROR */) {
+      return console.error;
+    }
+    return console.log;
+  }
+  getStyle(level) {
+    switch (level) {
+      case "UNKNOWN" /* UNKNOWN */:
+      case "INFO" /* INFO */:
+        return `${ANSI.MAGENTA}`;
+      case "DEBUG" /* DEBUG */:
+        return `${ANSI.CYAN}`;
+      case "WARN" /* WARN */:
+        return `${ANSI.BRIGHT_YELLOW}`;
+      case "ERROR" /* ERROR */:
+        return `${ANSI.BRIGHT_RED}`;
+      case "SYS" /* SYS */:
+        return `${ANSI.DIM}${ANSI.BLUE}`;
+    }
+  }
 };
 
 // ../u/trace/log/trace.ts
 var LogTrace = class _LogTrace {
-    constructor(
-        logger = new PrettyJsonConsoleLogger(),
-        traces = [defaultTrace],
-        defaultLevel = 'INFO' /* 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 === 'UNKNOWN' /* 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) => isLogLevel(trace))
-            .reduce((acc, level2) => Math.max(logLevelOrder.indexOf(level2), acc), -1);
-        const level = logLevelOrder[_level] ?? 'UNKNOWN'; /* UNKNOWN */
-        const traces = _logTraces
-            .filter((trace) => !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,
-        };
-    }
+  constructor(logger = new PrettyJsonConsoleLogger(), traces = [defaultTrace], defaultLevel = "INFO" /* 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 === "UNKNOWN" /* 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) => isLogLevel(trace)).reduce((acc, level2) => Math.max(logLevelOrder.indexOf(level2), acc), -1);
+    const level = logLevelOrder[_level] ?? "UNKNOWN" /* UNKNOWN */;
+    const traces = _logTraces.filter((trace) => !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
+    };
+  }
 };
-var defaultTrace = () => `TimeStamp = ${/* @__PURE__ */ new Date().toISOString()}`;
+var defaultTrace = () => `TimeStamp = ${(/* @__PURE__ */ new Date()).toISOString()}`;
 var defaultAllowedLevels = memoize(
-    (isDebug2) =>
-        /* @__PURE__ */ new Set([
-            'UNKNOWN' /* UNKNOWN */,
-            ...(isDebug2 ? ['DEBUG' /* DEBUG */] : []),
-            'INFO' /* INFO */,
-            'WARN' /* WARN */,
-            'ERROR' /* ERROR */,
-            'SYS' /* SYS */,
-        ]),
+  (isDebug2) => /* @__PURE__ */ new Set([
+    "UNKNOWN" /* UNKNOWN */,
+    ...isDebug2 ? ["DEBUG" /* DEBUG */] : [],
+    "INFO" /* INFO */,
+    "WARN" /* WARN */,
+    "ERROR" /* ERROR */,
+    "SYS" /* SYS */
+  ])
 );
 var defaultAllowedLevelsSupplier = () => defaultAllowedLevels(isDebug());
 
 // ../u/trace/trace.ts
 var LogTraceable = class _LogTraceable extends TraceableImpl {
-    static LogTrace = new LogTrace();
-    static of(t) {
-        return new _LogTraceable(t, _LogTraceable.LogTrace);
-    }
+  static LogTrace = new LogTrace();
+  static of(t) {
+    return new _LogTraceable(t, _LogTraceable.LogTrace);
+  }
 };
 var getEmbeddedMetricConsumer = (logTrace) => (metrics) => {
-    if (metrics.length === 0) return;
-    logTrace.traceScope('SYS' /* SYS */).trace(`Metrics = <metrics>${JSON.stringify(metrics)}</metrics>`);
+  if (metrics.length === 0) return;
+  logTrace.traceScope("SYS" /* SYS */).trace(`Metrics = <metrics>${JSON.stringify(metrics)}</metrics>`);
 };
 var EmbeddedMetricsTraceable = class _EmbeddedMetricsTraceable extends TraceableImpl {
-    static MetricsTrace = new MetricsTrace(getEmbeddedMetricConsumer(LogTraceable.LogTrace));
-    static of(t, metricsTrace = _EmbeddedMetricsTraceable.MetricsTrace) {
-        return new _EmbeddedMetricsTraceable(t, metricsTrace);
-    }
+  static MetricsTrace = new MetricsTrace(getEmbeddedMetricConsumer(LogTraceable.LogTrace));
+  static of(t, metricsTrace = _EmbeddedMetricsTraceable.MetricsTrace) {
+    return new _EmbeddedMetricsTraceable(t, metricsTrace);
+  }
 };
 
 // ../u/process/exec.ts
-var import_node_util = require('node:util');
-var import_node_child_process = require('node:child_process');
+var import_node_util = require("node:util");
+var import_node_child_process = require("node:child_process");
 var exec = (0, import_node_util.promisify)(import_node_child_process.exec);
-var CmdMetric = Metric.fromName('Exec').asResult();
+var CmdMetric = Metric.fromName("Exec").asResult();
 
 // ../u/process/signals.ts
-var SigIntMetric = Metric.fromName('SigInt').asResult();
-var SigTermMetric = Metric.fromName('SigTerm').asResult();
+var SigIntMetric = Metric.fromName("SigInt").asResult();
+var SigTermMetric = Metric.fromName("SigTerm").asResult();
 
 // ../u/server/response/pengueno.ts
 var ResponseCodeMetrics = [0, 1, 2, 3, 4, 5].map((x) => Metric.fromName(`response.${x}xx`).asResult());
 
 // ../u/server/activity/health.ts
-var healthCheckMetric = Metric.fromName('Health').asResult();
+var healthCheckMetric = Metric.fromName("Health").asResult();
 
 // ../u/server/filter/json.ts
-var ParseJsonMetric = Metric.fromName('JsonParse').asResult();
+var ParseJsonMetric = Metric.fromName("JsonParse").asResult();
 
 // ../u/server/filter/index.ts
 var ErrorSource = ((ErrorSource2) => {
-    ErrorSource2[(ErrorSource2['USER'] = 'WARN') /* WARN */] = 'USER';
-    ErrorSource2[(ErrorSource2['SYSTEM'] = 'ERROR') /* ERROR */] = 'SYSTEM';
-    return ErrorSource2;
+  ErrorSource2[ErrorSource2["USER"] = "WARN" /* WARN */] = "USER";
+  ErrorSource2[ErrorSource2["SYSTEM"] = "ERROR" /* ERROR */] = "SYSTEM";
+  return ErrorSource2;
 })(ErrorSource || {});
 
 // ../u/types/object.ts
-var isObject = (o) => typeof o === 'object' && !Array.isArray(o) && !!o;
+var isObject = (o) => typeof o === "object" && !Array.isArray(o) && !!o;
 
 // ../u/types/tagged.ts
-var isTagged = (o, tag) => !!(isObject(o) && '_tag' in o && o._tag === tag);
+var isTagged = (o, tag) => !!(isObject(o) && "_tag" in o && o._tag === tag);
 
 // ../u/types/fn/either.ts
-var IEitherTag = 'IEither';
-var ELeftTag = 'E.Left';
+var IEitherTag = "IEither";
+var ELeftTag = "E.Left";
 var isLeft = (o) => isTagged(o, ELeftTag);
-var ERightTag = 'E.Right';
+var ERightTag = "E.Right";
 var isRight = (o) => isTagged(o, ERightTag);
 var _Tagged2 = class {
-    constructor(_tag = IEitherTag) {
-        this._tag = _tag;
-    }
+  constructor(_tag = IEitherTag) {
+    this._tag = _tag;
+  }
 };
 var Either = class _Either extends _Tagged2 {
-    constructor(self) {
-        super();
-        this.self = self;
-    }
-    moveRight(t) {
-        return this.mapRight(() => t);
-    }
-    mapBoth(errBranch, okBranch) {
-        if (isLeft(this.self)) return _Either.left(errBranch(this.self.err));
-        return _Either.right(okBranch(this.self.ok));
-    }
-    mapRight(mapper) {
-        if (isRight(this.self)) return _Either.right(mapper(this.self.ok));
-        return _Either.left(this.self.err);
-    }
-    mapLeft(mapper) {
-        if (isLeft(this.self)) return _Either.left(mapper(this.self.err));
-        return _Either.right(this.self.ok);
-    }
-    flatMap(mapper) {
-        if (isRight(this.self)) return mapper(this.self.ok);
-        return _Either.left(this.self.err);
-    }
-    filter(mapper) {
-        if (isLeft(this.self)) return _Either.left(this.self.err);
-        return _Either.fromFailable(() => this.right().filter(mapper).get());
-    }
-    async flatMapAsync(mapper) {
-        if (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 (isLeft(this.self)) return leftFolder(this.self.err);
-        return rightFolder(this.self.ok);
-    }
-    left() {
-        if (isLeft(this.self)) return Optional.from(this.self.err);
-        return Optional.none();
-    }
-    right() {
-        if (isRight(this.self)) return Optional.from(this.self.ok);
-        return 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 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));
-    }
+  constructor(self) {
+    super();
+    this.self = self;
+  }
+  moveRight(t) {
+    return this.mapRight(() => t);
+  }
+  mapBoth(errBranch, okBranch) {
+    if (isLeft(this.self)) return _Either.left(errBranch(this.self.err));
+    return _Either.right(okBranch(this.self.ok));
+  }
+  mapRight(mapper) {
+    if (isRight(this.self)) return _Either.right(mapper(this.self.ok));
+    return _Either.left(this.self.err);
+  }
+  mapLeft(mapper) {
+    if (isLeft(this.self)) return _Either.left(mapper(this.self.err));
+    return _Either.right(this.self.ok);
+  }
+  flatMap(mapper) {
+    if (isRight(this.self)) return mapper(this.self.ok);
+    return _Either.left(this.self.err);
+  }
+  filter(mapper) {
+    if (isLeft(this.self)) return _Either.left(this.self.err);
+    return _Either.fromFailable(() => this.right().filter(mapper).get());
+  }
+  async flatMapAsync(mapper) {
+    if (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 (isLeft(this.self)) return leftFolder(this.self.err);
+    return rightFolder(this.self.ok);
+  }
+  left() {
+    if (isLeft(this.self)) return Optional.from(this.self.err);
+    return Optional.none();
+  }
+  right() {
+    if (isRight(this.self)) return Optional.from(this.self.ok);
+    return 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 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));
+  }
 };
 
 // ../u/types/fn/optional.ts
-var IOptionalTag = 'IOptional';
-var IOptionalEmptyError = class extends Error {};
-var OSomeTag = 'O.Some';
-var ONoneTag = 'O.None';
+var IOptionalTag = "IOptional";
+var IOptionalEmptyError = class extends Error {
+};
+var OSomeTag = "O.Some";
+var ONoneTag = "O.None";
 var isNone = (o) => isTagged(o, ONoneTag);
 var isSome = (o) => isTagged(o, OSomeTag);
 var _Tagged3 = class {
-    constructor(_tag = IOptionalTag) {
-        this._tag = _tag;
-    }
+  constructor(_tag = IOptionalTag) {
+    this._tag = _tag;
+  }
 };
 var Optional = class _Optional extends _Tagged3 {
-    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);
-    }
+  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);
+  }
 };
 
 // ../model/job/index.ts
-var isJob = (j) =>
-    !!(isObject(j) && 'arguments' in j && isObject(j.arguments) && 'type' in j && typeof j.type === 'string' && j);
+var isJob = (j) => !!(isObject(j) && "arguments" in j && isObject(j.arguments) && "type" in j && typeof j.type === "string" && j);
 
 // ../model/pipeline/builder.ts
 var BasePipelineBuilder = class {
-    stages = [];
-    addStage(stage) {
-        this.stages.push(stage);
-        return this;
-    }
-    build() {
-        return new PipelineImpl(this.stages);
-    }
+  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.split('/').at(-1) ?? 'src';
-    }
-    getBranch() {
-        const branchRefPrefix = 'refs/heads/';
-        return this.refname.split(branchRefPrefix).at(1);
-    }
+  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.split("/").at(-1) ?? "src";
+  }
+  getBranch() {
+    const branchRefPrefix = "refs/heads/";
+    return this.refname.split(branchRefPrefix).at(1);
+  }
 };
 
 // ../model/pipeline/impl.ts
 var PipelineImpl = class _PipelineImpl {
-    constructor(serialJobs) {
-        this.serialJobs = serialJobs;
-    }
-    serialize() {
-        return JSON.stringify({ serialJobs: this.serialJobs });
-    }
-    static from(s) {
-        return Either.fromFailable(() => JSON.parse(s))
-            .flatMap((eitherPipelineJson) =>
-                isPipeline(eitherPipelineJson)
-                    ? Either.right(eitherPipelineJson)
-                    : Either.left(new Error('oh noes D: its a bad pipewine :((')),
-            )
-            .mapRight((pipeline) => new _PipelineImpl(pipeline.serialJobs));
-    }
+  constructor(serialJobs) {
+    this.serialJobs = serialJobs;
+  }
+  serialize() {
+    return JSON.stringify({ serialJobs: this.serialJobs });
+  }
+  static from(s) {
+    return Either.fromFailable(() => JSON.parse(s)).flatMap(
+      (eitherPipelineJson) => isPipeline(eitherPipelineJson) ? Either.right(eitherPipelineJson) : Either.left(new Error("oh noes D: its a bad pipewine :(("))
+    ).mapRight((pipeline) => new _PipelineImpl(pipeline.serialJobs));
+  }
 };
 
 // ../model/pipeline/index.ts
-var isPipelineStage = (t) =>
-    isObject(t) && 'parallelJobs' in t && Array.isArray(t.parallelJobs) && t.parallelJobs.every((j) => isJob(j));
-var isPipeline = (t) =>
-    isObject(t) && 'serialJobs' in t && Array.isArray(t.serialJobs) && t.serialJobs.every((p) => isPipelineStage(p));
+var isPipelineStage = (t) => isObject(t) && "parallelJobs" in t && Array.isArray(t.parallelJobs) && t.parallelJobs.every((j) => isJob(j));
+var isPipeline = (t) => isObject(t) && "serialJobs" in t && Array.isArray(t.serialJobs) && t.serialJobs.every((p) => isPipelineStage(p));
 
 // dist/ci.js
-var REGISTRY = 'oci.liz.coffee';
-var NAMESPACE = 'emprespresso';
-var IMG = 'ci';
-var REMOTE = 'ssh://src.liz.coffee:2222';
+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 = {
-        registry: REGISTRY,
-        namespace: NAMESPACE,
-        imageTag: branch,
-    };
-    const baseCiPackageBuild = {
-        type: 'build_docker_image.js',
-        arguments: {
-            ...commonBuildArgs,
-            context: gitHookPipeline.getSourceDestination(),
-            repository: IMG + '_base',
-            buildTarget: IMG + '_base',
-            dockerfile: 'Dockerfile',
-        },
-    };
-    gitHookPipeline.addStage({
-        parallelJobs: [baseCiPackageBuild],
-    });
-    const subPackages = ['worker', 'hooks'].map((_package) => ({
-        type: 'build_docker_image.js',
-        arguments: {
-            ...commonBuildArgs,
-            repository: `${IMG}_${_package}`,
-            buildTarget: _package,
-            dockerfile: `${_package}/Dockerfile`,
-        },
-    }));
-    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] }),
-    );
+  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", "hooks"].map((_package) => ({
+    type: "build_docker_image.js",
+    arguments: {
+      ...commonBuildArgs,
+      repository: `${IMG}_${_package}`,
+      buildTarget: _package,
+      dockerfile: `${_package}/Dockerfile`
+    }
+  }));
+  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);
+  const data = getPipeline().serialize();
+  process.stdout.write(data);
 };
 main();
diff --git a/worker/scripts/build_docker_image.ts b/worker/scripts/build_docker_image.ts
index 31bd260..dfb78e8 100755
--- a/worker/scripts/build_docker_image.ts
+++ b/worker/scripts/build_docker_image.ts
@@ -78,7 +78,9 @@ await LogMetricTraceable.ofLogTraceable(_logJob)
     .map(async (tEitherWithAuthdRegistryBuildJob) => {
         const eitherWithAuthdRegistryBuildJob = await tEitherWithAuthdRegistryBuildJob.get();
         tEitherWithAuthdRegistryBuildJob.trace.trace('finally building the image~ (◕ᴗ◕✿)');
-        const context = await eitherWithAuthdRegistryBuildJob.flatMapAsync((j) => getPathOnHost(j.arguments.context));
+        const context = await eitherWithAuthdRegistryBuildJob.flatMapAsync((job) =>
+            getPathOnHost(path.join(process.cwd(), job.arguments.context)),
+        );
         const buildJobArgs = eitherWithAuthdRegistryBuildJob.joinRight(context, (context, job) => ({
             ...job.arguments,
             context,