Rookery: penguin-themed cubing toolkit, phases 0-1 and GAN BLE

Kotlin Multiplatform + Compose desktop app.

- Sync: per-device append-only op logs (HLC-stamped LWW) in a plain
  folder, safe under Syncthing/Drive; content-addressed image blobs.
- Timer: WCA inspection, +2/DNF, solve table, WCA-correct aoN/moN,
  per-event lifetime PBs with a pixel-penguin party and synthesized
  8-bit chime. Mascot sprite from liz.coffee.
- Scrambles for all WCA events + FTO via tnoodle-lib, with previews.
- Importers: csTimer exports (incl. smart-cube reconstructions and
  cube MACs) and the Letter Pair Gym prototype (words, notes, images,
  history, practice stats). Idempotent; headless `--import`.
- Letter-pair grid with miss heatmap, glance lookup and editor.
- 3D puzzle engine (polyhedron + cut planes) and Canvas renderer:
  NxN 2-7, Pyraminx, Skewb, verified sticker-for-sticker against
  tnoodle; 3D replay of smart-cube solves.
- GAN Gen2/3/4 smart-cube protocol (ported from gan-web-bluetooth,
  MIT) with a BlueZ D-Bus transport and `--cube scan|monitor` CLI.
  Not yet tested against hardware.
- lizCI pipeline (.ci) building a test+package Docker target.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

1 files changed, 5047 insertions, 0 deletions

diff --git a/.ci/ci.cjs b/.ci/ci.cjs
new file mode 100755
index 0000000..f7a5dec
--- /dev/null
+++ b/.ci/ci.cjs
@@ -0,0 +1,5047 @@
+#!/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_dist2();
+    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_dist2();
+    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)));
+        });
+      }
+      swap() {
+        if ((0, exports2.isRight)(this.self))
+          return _Either.left(this.self.ok);
+        return _Either.right(this.self.err);
+      }
+      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));
+      }
+      static async retrying(s, attempts = 3, interval = (attempt) => _Either.attemptWait(attempt)) {
+        let result = _Either.right(new Error("No attempts made"));
+        for (let attempt = 0; attempt < attempts && result.right().present(); attempt++) {
+          await interval(attempt);
+          const currentAttempt = await s().then((s2) => s2.swap());
+          result = await result.joinRightAsync(() => Promise.resolve(currentAttempt), (res, _prevError) => res);
+        }
+        return result.swap();
+      }
+      static attemptWait(attempt, backoffFactor = 500, jitter = 300, exponent = 1.3) {
+        if (attempt === 0) {
+          return Promise.resolve();
+        }
+        const wait = Math.pow(exponent, attempt) * backoffFactor + jitter * Math.random() * Math.pow(exponent, attempt);
+        return new Promise((res) => setTimeout(res, wait));
+      }
+    };
+    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_dist2();
+    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/jsonds.js
+var require_jsonds = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/types/collections/jsonds.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.JSONHashMap = exports2.JSONSet = void 0;
+    var JSONSet = class {
+      items;
+      constructor(items = /* @__PURE__ */ new Set()) {
+        this.items = items;
+      }
+      add(item) {
+        const itemJson = JSON.stringify(item, Object.keys(item).sort());
+        this.items.add(itemJson);
+      }
+      has(item) {
+        const itemJson = JSON.stringify(item, Object.keys(item).sort());
+        return this.items.has(itemJson);
+      }
+      delete(item) {
+        const itemJson = JSON.stringify(item, Object.keys(item).sort());
+        return this.items.delete(itemJson);
+      }
+      clear() {
+        this.items.clear();
+      }
+      size() {
+        return this.items.size;
+      }
+    };
+    exports2.JSONSet = JSONSet;
+    var JSONHashMap = class {
+      map;
+      constructor(map = /* @__PURE__ */ new Map()) {
+        this.map = map;
+      }
+      set(key, value) {
+        const keyJson = JSON.stringify(key, Object.keys(key).sort());
+        this.map.set(keyJson, value);
+      }
+      get(key) {
+        const keyJson = JSON.stringify(key, Object.keys(key).sort());
+        return this.map.get(keyJson);
+      }
+      has(key) {
+        const keyJson = JSON.stringify(key, Object.keys(key).sort());
+        return this.map.has(keyJson);
+      }
+      keys() {
+        return Array.from(this.map.keys()).map((x) => JSON.parse(x));
+      }
+      delete(key) {
+        const keyJson = JSON.stringify(key, Object.keys(key).sort());
+        return this.map.delete(keyJson);
+      }
+      clear() {
+        this.map.clear();
+      }
+      size() {
+        return this.map.size;
+      }
+    };
+    exports2.JSONHashMap = JSONHashMap;
+  }
+});
+
+// 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);
+    __exportStar(require_jsonds(), 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_dist2();
+    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.name, now]));
+        return new _MetricsTrace(this.metricConsumer, initialTraces, this.completedTraces);
+      }
+      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.name));
+        const metricsToEnd = traceableMetrics.filter((m) => this.activeTraces.has(m.name) && !this.completedTraces.has(m.name));
+        const endedMetricValues = metricsToEnd.flatMap((metric) => [
+          metric.count.withValue(1),
+          metric.time.withValue(now - this.activeTraces.get(metric.name))
+        ]);
+        const parentBasedMetrics = metricsToStart.filter((metric) => {
+          const parent = metric.parent;
+          return parent && this.activeTraces.has(parent.name);
+        });
+        const parentBasedValues = parentBasedMetrics.flatMap((metric) => {
+          const parentStart = this.activeTraces.get(metric.parent.name);
+          return [metric.count.withValue(1), metric.time.withValue(now - parentStart)];
+        });
+        const allMetricsToEmit = [...valuesToEmit, ...endedMetricValues, ...parentBasedValues];
+        if (allMetricsToEmit.length > 0) {
+          this.metricConsumer(allMetricsToEmit);
+        }
+        const nextActiveTraces = new Map([
+          ...this.activeTraces,
+          ...metricsToStart.map((m) => [m.name, now])
+        ]);
+        const nextCompletedTraces = /* @__PURE__ */ new Set([
+          ...this.completedTraces,
+          ...metricsToEnd.map((m) => m.name),
+          ...parentBasedMetrics.map((m) => m.name)
+        ]);
+        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_dist2();
+    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_dist2();
+    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;
+      }
+      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_dist2();
+    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_dist2();
+    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_dist2();
+    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_dist2();
+    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_dist2();
+    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_dist2();
+    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_dist2();
+    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_dist2();
+    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_dist2();
+    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_dist2();
+    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_dist2();
+    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_dist2();
+    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/hono/dist/cjs/http-exception.js
+var require_http_exception = __commonJS({
+  "node_modules/hono/dist/cjs/http-exception.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var HTTPException = class extends Error {
+      res;
+      status;
+      /**
+      * Creates an instance of `HTTPException`.
+      * @param status - HTTP status code for the exception. Defaults to 500.
+      * @param options - Additional options for the exception.
+      */
+      constructor(status = 500, options) {
+        super(options?.message, { cause: options?.cause });
+        this.res = options?.res;
+        this.status = status;
+      }
+      /**
+      * Returns the response object associated with the exception.
+      * If a response object is not provided, a new response is created with the error message and status code.
+      * @returns The response object.
+      */
+      getResponse() {
+        if (this.res) return new Response(this.res.body, {
+          status: this.status,
+          headers: this.res.headers
+        });
+        return new Response(this.message, { status: this.status });
+      }
+    };
+    exports2.HTTPException = HTTPException;
+  }
+});
+
+// node_modules/hono/dist/cjs/request/constants.js
+var require_constants = __commonJS({
+  "node_modules/hono/dist/cjs/request/constants.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var GET_MATCH_RESULT = Symbol();
+    exports2.GET_MATCH_RESULT = GET_MATCH_RESULT;
+  }
+});
+
+// node_modules/hono/dist/cjs/utils/crypto.js
+var require_crypto = __commonJS({
+  "node_modules/hono/dist/cjs/utils/crypto.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var sha256 = async (data) => {
+      return await createHash(data, {
+        name: "SHA-256",
+        alias: "sha256"
+      });
+    };
+    var sha1 = async (data) => {
+      return await createHash(data, {
+        name: "SHA-1",
+        alias: "sha1"
+      });
+    };
+    var md5 = async (data) => {
+      return await createHash(data, {
+        name: "MD5",
+        alias: "md5"
+      });
+    };
+    var createHash = async (data, algorithm) => {
+      let sourceBuffer;
+      if (ArrayBuffer.isView(data) || data instanceof ArrayBuffer) sourceBuffer = data;
+      else {
+        if (typeof data === "object") data = JSON.stringify(data);
+        sourceBuffer = new TextEncoder().encode(String(data));
+      }
+      if (crypto && crypto.subtle) {
+        const buffer = await crypto.subtle.digest({ name: algorithm.name }, sourceBuffer);
+        return Array.prototype.map.call(new Uint8Array(buffer), (x) => ("00" + x.toString(16)).slice(-2)).join("");
+      }
+      return null;
+    };
+    exports2.createHash = createHash;
+    exports2.md5 = md5;
+    exports2.sha1 = sha1;
+    exports2.sha256 = sha256;
+  }
+});
+
+// node_modules/hono/dist/cjs/utils/buffer.js
+var require_buffer = __commonJS({
+  "node_modules/hono/dist/cjs/utils/buffer.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_utils_crypto = require_crypto();
+    var equal = (a, b) => {
+      if (a === b) return true;
+      if (a.byteLength !== b.byteLength) return false;
+      const va = new DataView(a);
+      const vb = new DataView(b);
+      let i = va.byteLength;
+      while (i--) if (va.getUint8(i) !== vb.getUint8(i)) return false;
+      return true;
+    };
+    var constantTimeEqualString = (a, b) => {
+      const aLen = a.length;
+      const bLen = b.length;
+      const maxLen = Math.max(aLen, bLen);
+      let out = aLen ^ bLen;
+      for (let i = 0; i < maxLen; i++) {
+        const aChar = i < aLen ? a.charCodeAt(i) : 0;
+        const bChar = i < bLen ? b.charCodeAt(i) : 0;
+        out |= aChar ^ bChar;
+      }
+      return out === 0;
+    };
+    var timingSafeEqualString = async (a, b, hashFunction) => {
+      if (!hashFunction) hashFunction = require_utils_crypto.sha256;
+      const [sa, sb] = await Promise.all([hashFunction(a), hashFunction(b)]);
+      if (sa == null || sb == null || typeof sa !== "string" || typeof sb !== "string") return false;
+      const hashEqual = constantTimeEqualString(sa, sb);
+      const originalEqual = constantTimeEqualString(a, b);
+      return hashEqual && originalEqual;
+    };
+    var timingSafeEqual = async (a, b, hashFunction) => {
+      if (typeof a === "string" && typeof b === "string") return timingSafeEqualString(a, b, hashFunction);
+      if (!hashFunction) hashFunction = require_utils_crypto.sha256;
+      const [sa, sb] = await Promise.all([hashFunction(a), hashFunction(b)]);
+      if (!sa || !sb || typeof sa !== "string" || typeof sb !== "string") return false;
+      return timingSafeEqualString(sa, sb);
+    };
+    var bufferToString = (buffer) => {
+      if (buffer instanceof ArrayBuffer) return new TextDecoder("utf-8").decode(buffer);
+      return buffer;
+    };
+    var bufferToFormData = (arrayBuffer, contentType) => {
+      return new Response(arrayBuffer, { headers: { "Content-Type": contentType.replace(/^[^;]+/, (mediaType) => mediaType.toLowerCase()) } }).formData();
+    };
+    exports2.bufferToFormData = bufferToFormData;
+    exports2.bufferToString = bufferToString;
+    exports2.equal = equal;
+    exports2.timingSafeEqual = timingSafeEqual;
+  }
+});
+
+// node_modules/hono/dist/cjs/utils/body.js
+var require_body2 = __commonJS({
+  "node_modules/hono/dist/cjs/utils/body.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_utils_buffer = require_buffer();
+    var MAX_NESTED_OBJECTS = 1e4;
+    var isRawRequest = (request) => "headers" in request;
+    var parseBody = async (request, options = /* @__PURE__ */ Object.create(null)) => {
+      const { all = false, dot = false } = options;
+      const mediaType = (isRawRequest(request) ? request.headers : request.raw.headers).get("Content-Type")?.split(";")[0].trim().toLowerCase();
+      if (mediaType === "multipart/form-data" || mediaType === "application/x-www-form-urlencoded") return parseFormData(request, {
+        all,
+        dot
+      });
+      return {};
+    };
+    async function parseFormData(request, options) {
+      if (!isRawRequest(request) && request.bodyCache.formData) return convertFormDataToBodyData(await request.bodyCache.formData, options);
+      const headers = isRawRequest(request) ? request.headers : request.raw.headers;
+      const arrayBuffer = await request.arrayBuffer();
+      const formDataPromise = require_utils_buffer.bufferToFormData(arrayBuffer, headers.get("Content-Type") || "");
+      if (!isRawRequest(request)) request.bodyCache.formData = formDataPromise;
+      const formData = await formDataPromise;
+      if (formData) return convertFormDataToBodyData(formData, options);
+      return {};
+    }
+    function convertFormDataToBodyData(formData, options) {
+      const form = /* @__PURE__ */ Object.create(null);
+      const nestingState = { count: 0 };
+      formData.forEach((value, key) => {
+        if (!(options.all || key.endsWith("[]"))) form[key] = value;
+        else handleParsingAllValues(form, key, value);
+      });
+      if (options.dot) Object.entries(form).forEach(([key, value]) => {
+        if (key.includes(".")) {
+          handleParsingNestedValues(form, key, value, nestingState);
+          delete form[key];
+        }
+      });
+      return form;
+    }
+    var handleParsingAllValues = (form, key, value) => {
+      if (form[key] !== void 0) {
+        if (Array.isArray(form[key])) form[key].push(value);
+        else form[key] = [form[key], value];
+      } else if (!key.endsWith("[]")) form[key] = value;
+      else form[key] = [value];
+    };
+    var handleParsingNestedValues = (form, key, value, state) => {
+      if (/(?:^|\.)__proto__\./.test(key)) return;
+      let nestedForm = form;
+      const keys = key.split(".", 34);
+      if (keys.length > 33) throwNestingLimitExceeded();
+      keys.forEach((key2, index) => {
+        if (index === keys.length - 1) nestedForm[key2] = value;
+        else {
+          if (!nestedForm[key2] || typeof nestedForm[key2] !== "object" || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) {
+            if (state.count++ >= MAX_NESTED_OBJECTS) throwNestingLimitExceeded();
+            nestedForm[key2] = /* @__PURE__ */ Object.create(null);
+          }
+          nestedForm = nestedForm[key2];
+        }
+      });
+    };
+    var throwNestingLimitExceeded = () => {
+      throw new Error("Nesting limit exceeded");
+    };
+    exports2.parseBody = parseBody;
+  }
+});
+
+// node_modules/hono/dist/cjs/utils/url.js
+var require_url = __commonJS({
+  "node_modules/hono/dist/cjs/utils/url.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var splitPath = (path) => {
+      const paths = path.split("/");
+      if (paths[0] === "") paths.shift();
+      return paths;
+    };
+    var splitRoutingPath = (routePath) => {
+      const { groups, path } = extractGroupsFromPath(routePath);
+      const paths = splitPath(path);
+      return replaceGroupMarks(paths, groups);
+    };
+    var extractGroupsFromPath = (path) => {
+      const groups = [];
+      path = path.replace(/\{[^}]+\}/g, (match, index) => {
+        const mark = `@${index}`;
+        groups.push([mark, match]);
+        return mark;
+      });
+      return {
+        groups,
+        path
+      };
+    };
+    var replaceGroupMarks = (paths, groups) => {
+      for (let i = groups.length - 1; i >= 0; i--) {
+        const [mark] = groups[i];
+        for (let j = paths.length - 1; j >= 0; j--) if (paths[j].includes(mark)) {
+          paths[j] = paths[j].replace(mark, groups[i][1]);
+          break;
+        }
+      }
+      return paths;
+    };
+    var patternCache = {};
+    var getPattern = (label, next) => {
+      if (label === "*") return "*";
+      const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+      if (match) {
+        const cacheKey = `${label}#${next}`;
+        if (!patternCache[cacheKey]) {
+          if (match[2]) patternCache[cacheKey] = next && next[0] !== ":" && next[0] !== "*" ? [
+            cacheKey,
+            match[1],
+            new RegExp(`^${match[2]}(?=/${next})`)
+          ] : [
+            label,
+            match[1],
+            new RegExp(`^${match[2]}$`)
+          ];
+          else patternCache[cacheKey] = [
+            label,
+            match[1],
+            true
+          ];
+        }
+        return patternCache[cacheKey];
+      }
+      return null;
+    };
+    var tryDecode = (str, decoder) => {
+      try {
+        return decoder(str);
+      } catch {
+        return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
+          try {
+            return decoder(match);
+          } catch {
+            return match;
+          }
+        });
+      }
+    };
+    var tryDecodeURI = (str) => tryDecode(str, decodeURI);
+    var decodeURIWithPreservedPercent = (value) => decodeURI(value.includes("%25") ? value.replace(/%25/g, "%2525") : value);
+    var getPath = (request) => {
+      const url = request.url;
+      const start = url.indexOf("/", url.indexOf(":") + 4);
+      let i = start;
+      for (; i < url.length; i++) {
+        const charCode = url.charCodeAt(i);
+        if (charCode === 37) {
+          const queryIndex = url.indexOf("?", i);
+          const hashIndex = url.indexOf("#", i);
+          const end = queryIndex === -1 ? hashIndex === -1 ? void 0 : hashIndex : hashIndex === -1 ? queryIndex : Math.min(queryIndex, hashIndex);
+          const path = url.slice(start, end);
+          const decoded = tryDecode(path, decodeURIWithPreservedPercent);
+          if (/%(?![0-9A-Fa-f]{2})/.test(path)) {
+            const rewritten = new URL("http://localhost");
+            rewritten.pathname = decoded.replace(/[\\\t\n\r]/g, encodeURIComponent);
+            if (tryDecode(rewritten.pathname, decodeURIWithPreservedPercent) !== decoded) return tryDecode(path.replace(/%(?![0-9A-Fa-f]{2})/g, "%25"), decodeURIWithPreservedPercent);
+          }
+          return decoded;
+        } else if (charCode === 63 || charCode === 35) break;
+      }
+      return url.slice(start, i);
+    };
+    var getQueryStrings = (url) => {
+      const queryIndex = url.indexOf("?", 8);
+      if (queryIndex === -1) return "";
+      const hashIndex = url.indexOf("#", 8);
+      return hashIndex === -1 ? url.slice(queryIndex) : queryIndex < hashIndex ? url.slice(queryIndex, hashIndex) : "";
+    };
+    var getPathNoStrict = (request) => {
+      const result = getPath(request);
+      return result.length > 1 && result.at(-1) === "/" ? result.slice(0, -1) : result;
+    };
+    var mergePath = (base, sub, ...rest) => {
+      if (rest.length) sub = mergePath(sub, ...rest);
+      return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
+    };
+    var checkOptionalParameter = (path) => {
+      if (path.charCodeAt(path.length - 1) !== 63 || !path.includes(":")) return null;
+      const segments = path.split("/");
+      const results = [];
+      let basePath = "";
+      segments.forEach((segment) => {
+        if (segment !== "" && !/\:/.test(segment)) basePath += "/" + segment;
+        else if (/\:/.test(segment)) {
+          if (segment.charCodeAt(segment.length - 1) === 63) {
+            if (results.length === 0 && basePath === "") results.push("/");
+            else results.push(basePath);
+            const optionalSegment = segment.slice(0, -1);
+            basePath += "/" + optionalSegment;
+            results.push(basePath);
+          } else basePath += "/" + segment;
+        }
+      });
+      return results.filter((v, i, a) => a.indexOf(v) === i);
+    };
+    var tryDecodeURIComponent = (str) => str.indexOf("%") !== -1 ? tryDecode(str, decodeURIComponent_) : str;
+    var _decodeURI = (value) => {
+      if (value.indexOf("+") !== -1) value = value.replace(/\+/g, " ");
+      return tryDecodeURIComponent(value);
+    };
+    var _getQueryParam = (url, key, multiple) => {
+      const hashIndex = url.indexOf("#", 8);
+      if (hashIndex !== -1) url = url.slice(0, hashIndex);
+      let encoded;
+      if (!multiple && key && !/[%+&=]/.test(key)) {
+        const queryIndex = url.indexOf("?", 8);
+        let keyIndex2 = queryIndex;
+        if (keyIndex2 === -1) return;
+        if (!url.startsWith(key, keyIndex2 + 1)) keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
+        while (keyIndex2 !== -1) {
+          const trailingKeyCode = url.charCodeAt(keyIndex2 + key.length + 1);
+          if (trailingKeyCode === 61 || trailingKeyCode === 38 || isNaN(trailingKeyCode)) {
+            if (keyIndex2 > queryIndex && /(?:^|&)[^=&]*[%+]/.test(url.slice(queryIndex + 1, keyIndex2))) break;
+            if (trailingKeyCode === 61) {
+              const valueIndex = keyIndex2 + key.length + 2;
+              const endIndex = url.indexOf("&", valueIndex);
+              return _decodeURI(url.slice(valueIndex, endIndex === -1 ? void 0 : endIndex));
+            }
+            return "";
+          }
+          keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
+        }
+        encoded = /[%+]/.test(url);
+        if (!encoded) return;
+      }
+      const results = /* @__PURE__ */ Object.create(null);
+      encoded ??= /[%+]/.test(url);
+      let keyIndex = url.indexOf("?", 8);
+      while (keyIndex !== -1) {
+        const nextKeyIndex = url.indexOf("&", keyIndex + 1);
+        let valueIndex = url.indexOf("=", keyIndex);
+        if (valueIndex > nextKeyIndex && nextKeyIndex !== -1) valueIndex = -1;
+        let name = url.slice(keyIndex + 1, valueIndex === -1 ? nextKeyIndex === -1 ? void 0 : nextKeyIndex : valueIndex);
+        if (encoded) name = _decodeURI(name);
+        keyIndex = nextKeyIndex;
+        if (name === "") continue;
+        let value;
+        if (valueIndex === -1) value = "";
+        else {
+          value = url.slice(valueIndex + 1, nextKeyIndex === -1 ? void 0 : nextKeyIndex);
+          if (encoded) value = _decodeURI(value);
+        }
+        if (multiple) {
+          if (!(results[name] && Array.isArray(results[name]))) results[name] = [];
+          results[name].push(value);
+        } else results[name] ??= value;
+      }
+      return key ? results[key] : results;
+    };
+    var getQueryParam = _getQueryParam;
+    var getQueryParams = (url, key) => {
+      return _getQueryParam(url, key, true);
+    };
+    var decodeURIComponent_ = decodeURIComponent;
+    exports2.checkOptionalParameter = checkOptionalParameter;
+    exports2.decodeURIComponent_ = decodeURIComponent_;
+    exports2.getPath = getPath;
+    exports2.getPathNoStrict = getPathNoStrict;
+    exports2.getPattern = getPattern;
+    exports2.getQueryParam = getQueryParam;
+    exports2.getQueryParams = getQueryParams;
+    exports2.getQueryStrings = getQueryStrings;
+    exports2.mergePath = mergePath;
+    exports2.splitPath = splitPath;
+    exports2.splitRoutingPath = splitRoutingPath;
+    exports2.tryDecode = tryDecode;
+    exports2.tryDecodeURI = tryDecodeURI;
+    exports2.tryDecodeURIComponent = tryDecodeURIComponent;
+  }
+});
+
+// node_modules/hono/dist/cjs/request.js
+var require_request2 = __commonJS({
+  "node_modules/hono/dist/cjs/request.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_http_exception2 = require_http_exception();
+    var require_request_constants = require_constants();
+    var require_utils_body = require_body2();
+    var require_utils_url = require_url();
+    var HonoRequest = class {
+      /**
+      * `.raw` can get the raw Request object.
+      *
+      * @see {@link https://hono.dev/docs/api/request#raw}
+      *
+      * @example
+      * ```ts
+      * // For Cloudflare Workers
+      * app.post('/', async (c) => {
+      *   const metadata = c.req.raw.cf?.hostMetadata?
+      *   ...
+      * })
+      * ```
+      */
+      raw;
+      #validatedData;
+      #matchResult;
+      routeIndex = 0;
+      /**
+      * `.path` can get the pathname of the request.
+      *
+      * @see {@link https://hono.dev/docs/api/request#path}
+      *
+      * @example
+      * ```ts
+      * app.get('/about/me', (c) => {
+      *   const pathname = c.req.path // `/about/me`
+      * })
+      * ```
+      */
+      path;
+      bodyCache = {};
+      constructor(request, path = "/", matchResult = [[]]) {
+        this.raw = request;
+        this.path = path;
+        this.#matchResult = matchResult;
+      }
+      param(key) {
+        return key ? this.#getDecodedParam(key) : this.#getAllDecodedParams();
+      }
+      #getDecodedParam(key) {
+        const paramKey = this.#matchResult[0][this.routeIndex]?.[1][key];
+        const param = this.#getParamValue(paramKey);
+        return param && require_utils_url.tryDecodeURIComponent(param);
+      }
+      #getAllDecodedParams() {
+        const decoded = {};
+        const keys = Object.keys(this.#matchResult[0][this.routeIndex]?.[1] ?? {});
+        for (const key of keys) {
+          const value = this.#getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
+          if (value !== void 0) decoded[key] = require_utils_url.tryDecodeURIComponent(value);
+        }
+        return decoded;
+      }
+      #getParamValue(paramKey) {
+        return this.#matchResult[1] ? this.#matchResult[1][paramKey] : paramKey;
+      }
+      query(key) {
+        return require_utils_url.getQueryParam(this.url, key);
+      }
+      queries(key) {
+        return require_utils_url.getQueryParams(this.url, key);
+      }
+      header(name) {
+        if (name) return this.raw.headers.get(name) ?? void 0;
+        const headerData = /* @__PURE__ */ Object.create(null);
+        this.raw.headers.forEach((value, key) => {
+          headerData[key] = value;
+        });
+        return headerData;
+      }
+      async parseBody(options) {
+        return require_utils_body.parseBody(this, options);
+      }
+      #cachedBody = (key) => {
+        const { bodyCache, raw } = this;
+        const cachedBody = bodyCache[key];
+        if (cachedBody) return cachedBody;
+        for (const anyCachedKey in bodyCache) return bodyCache[anyCachedKey].then((body) => {
+          if (anyCachedKey === "json") body = JSON.stringify(body);
+          const contentType = anyCachedKey === "formData" ? void 0 : raw.headers.get("content-type");
+          return new Response(body, { headers: contentType ? { "Content-Type": contentType } : void 0 })[key]();
+        });
+        return bodyCache[key] = raw[key]();
+      };
+      /**
+      * `.json()` can parse Request body of type `application/json`
+      *
+      * @see {@link https://hono.dev/docs/api/request#json}
+      *
+      * @example
+      * ```ts
+      * app.post('/entry', async (c) => {
+      *   const body = await c.req.json()
+      * })
+      * ```
+      */
+      json() {
+        return this.#cachedBody("text").then((text) => JSON.parse(text));
+      }
+      /**
+      * `.text()` can parse Request body of type `text/plain`
+      *
+      * @see {@link https://hono.dev/docs/api/request#text}
+      *
+      * @example
+      * ```ts
+      * app.post('/entry', async (c) => {
+      *   const body = await c.req.text()
+      * })
+      * ```
+      */
+      text() {
+        return this.#cachedBody("text");
+      }
+      /**
+      * `.arrayBuffer()` parse Request body as an `ArrayBuffer`
+      *
+      * @see {@link https://hono.dev/docs/api/request#arraybuffer}
+      *
+      * @example
+      * ```ts
+      * app.post('/entry', async (c) => {
+      *   const body = await c.req.arrayBuffer()
+      * })
+      * ```
+      */
+      arrayBuffer() {
+        return this.#cachedBody("arrayBuffer");
+      }
+      /**
+      * `.bytes()` parses the request body as a `Uint8Array`.
+      *
+      * @see {@link https://hono.dev/docs/api/request#bytes}
+      *
+      * @example
+      * ```ts
+      * app.post('/entry', async (c) => {
+      *   const body = await c.req.bytes()
+      * })
+      * ```
+      */
+      bytes() {
+        return this.#cachedBody("arrayBuffer").then((buffer) => new Uint8Array(buffer));
+      }
+      /**
+      * Parses the request body as a `Blob`.
+      * @example
+      * ```ts
+      * app.post('/entry', async (c) => {
+      *   const body = await c.req.blob();
+      * });
+      * ```
+      * @see https://hono.dev/docs/api/request#blob
+      */
+      blob() {
+        return this.#cachedBody("blob");
+      }
+      /**
+      * Parses the request body as `FormData`.
+      * @example
+      * ```ts
+      * app.post('/entry', async (c) => {
+      *   const body = await c.req.formData();
+      * });
+      * ```
+      * @see https://hono.dev/docs/api/request#formdata
+      */
+      formData() {
+        return this.#cachedBody("formData");
+      }
+      /**
+      * Adds validated data to the request.
+      *
+      * @param target - The target of the validation.
+      * @param data - The validated data to add.
+      */
+      addValidatedData(target, data) {
+        (this.#validatedData ??= {})[target] = data;
+      }
+      valid(target) {
+        return this.#validatedData?.[target];
+      }
+      /**
+      * `.url` can get the request url strings.
+      *
+      * @see {@link https://hono.dev/docs/api/request#url}
+      *
+      * @example
+      * ```ts
+      * app.get('/about/me', (c) => {
+      *   const url = c.req.url // `http://localhost:8787/about/me`
+      *   ...
+      * })
+      * ```
+      */
+      get url() {
+        return this.raw.url;
+      }
+      /**
+      * `.method` can get the method name of the request.
+      *
+      * @see {@link https://hono.dev/docs/api/request#method}
+      *
+      * @example
+      * ```ts
+      * app.get('/about/me', (c) => {
+      *   const method = c.req.method // `GET`
+      * })
+      * ```
+      */
+      get method() {
+        return this.raw.method;
+      }
+      get [require_request_constants.GET_MATCH_RESULT]() {
+        return this.#matchResult;
+      }
+      /**
+      * `.matchedRoutes` can return a matched route in the handler
+      *
+      * @deprecated
+      *
+      * Use matchedRoutes helper defined in "hono/route" instead.
+      *
+      * @see {@link https://hono.dev/docs/api/request#matchedroutes}
+      *
+      * @example
+      * ```ts
+      * app.use('*', async function logger(c, next) {
+      *   await next()
+      *   c.req.matchedRoutes.forEach(({ handler, method, path }, i) => {
+      *     const name = handler.name || (handler.length < 2 ? '[handler]' : '[middleware]')
+      *     console.log(
+      *       method,
+      *       ' ',
+      *       path,
+      *       ' '.repeat(Math.max(10 - path.length, 0)),
+      *       name,
+      *       i === c.req.routeIndex ? '<- respond from here' : ''
+      *     )
+      *   })
+      * })
+      * ```
+      */
+      get matchedRoutes() {
+        return this.#matchResult[0].map(([[, route]]) => route);
+      }
+      /**
+      * `.routePath` can retrieve the path registered within the handler
+      *
+      * @deprecated
+      *
+      * Use routePath helper defined in "hono/route" instead.
+      *
+      * @see {@link https://hono.dev/docs/api/request#routepath}
+      *
+      * @example
+      * ```ts
+      * app.get('/posts/:id', (c) => {
+      *   return c.json({ path: c.req.routePath })
+      * })
+      * ```
+      */
+      get routePath() {
+        return this.#matchResult[0].map(([[, route]]) => route)[this.routeIndex].path;
+      }
+    };
+    var cloneRawRequest = async (req) => {
+      if (!req.raw.bodyUsed) return req.raw.clone();
+      const cacheKey = Object.keys(req.bodyCache)[0];
+      if (!cacheKey) throw new require_http_exception2.HTTPException(500, { message: "Cannot clone request: body was already consumed and not cached. Please use HonoRequest methods (e.g., req.json(), req.text()) instead of consuming req.raw directly." });
+      let body = await req[cacheKey]();
+      const headers = req.header();
+      if (cacheKey === "json") {
+        body = JSON.stringify(body);
+        delete headers["content-length"];
+      } else if (body instanceof FormData) {
+        delete headers["content-type"];
+        delete headers["content-length"];
+      }
+      const requestInit = {
+        body,
+        cache: req.raw.cache,
+        credentials: req.raw.credentials,
+        headers,
+        integrity: req.raw.integrity,
+        keepalive: req.raw.keepalive,
+        method: req.method,
+        mode: req.raw.mode,
+        redirect: req.raw.redirect,
+        referrer: req.raw.referrer,
+        referrerPolicy: req.raw.referrerPolicy,
+        signal: req.raw.signal
+      };
+      return new Request(req.url, requestInit);
+    };
+    exports2.HonoRequest = HonoRequest;
+    exports2.cloneRawRequest = cloneRawRequest;
+  }
+});
+
+// node_modules/hono/dist/cjs/utils/html.js
+var require_html = __commonJS({
+  "node_modules/hono/dist/cjs/utils/html.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var HtmlEscapedCallbackPhase = {
+      Stringify: 1,
+      BeforeStream: 2,
+      Stream: 3
+    };
+    var raw = (value, callbacks) => {
+      const escapedString = new String(value);
+      escapedString.isEscaped = true;
+      escapedString.callbacks = callbacks;
+      return escapedString;
+    };
+    var escapeRe = /[&<>'"]/;
+    var stringBufferToString = async (buffer, callbacks) => {
+      let str = "";
+      callbacks ||= [];
+      const resolvedBuffer = await Promise.all(buffer);
+      for (let i = resolvedBuffer.length - 1; ; i--) {
+        str += resolvedBuffer[i];
+        i--;
+        if (i < 0) break;
+        let r = resolvedBuffer[i];
+        if (typeof r === "object") callbacks.push(...r.callbacks || []);
+        const isEscaped = r.isEscaped;
+        r = await (typeof r === "object" ? r.toString() : r);
+        if (typeof r === "object") callbacks.push(...r.callbacks || []);
+        if (r.isEscaped ?? isEscaped) str += r;
+        else {
+          const buf = [str];
+          escapeToBuffer(r, buf);
+          str = buf[0];
+        }
+      }
+      return raw(str, callbacks);
+    };
+    var escapeToBuffer = (str, buffer) => {
+      const match = str.search(escapeRe);
+      if (match === -1) {
+        buffer[0] += str;
+        return;
+      }
+      let escape;
+      let index;
+      let lastIndex = 0;
+      for (index = match; index < str.length; index++) {
+        switch (str.charCodeAt(index)) {
+          case 34:
+            escape = "&quot;";
+            break;
+          case 39:
+            escape = "&#39;";
+            break;
+          case 38:
+            escape = "&amp;";
+            break;
+          case 60:
+            escape = "&lt;";
+            break;
+          case 62:
+            escape = "&gt;";
+            break;
+          default:
+            continue;
+        }
+        buffer[0] += str.substring(lastIndex, index) + escape;
+        lastIndex = index + 1;
+      }
+      buffer[0] += str.substring(lastIndex, index);
+    };
+    var resolveCallbackSync = (str) => {
+      const callbacks = str.callbacks;
+      if (!callbacks?.length) return str;
+      const buffer = [str];
+      const context = {};
+      callbacks.forEach((c) => c({
+        phase: HtmlEscapedCallbackPhase.Stringify,
+        buffer,
+        context
+      }));
+      return buffer[0];
+    };
+    var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) => {
+      if (typeof str === "object" && !(str instanceof String)) {
+        if (!(str instanceof Promise)) str = str.toString();
+        if (str instanceof Promise) str = await str;
+      }
+      const callbacks = str.callbacks;
+      if (!callbacks?.length) return Promise.resolve(str);
+      if (buffer) buffer[0] += str;
+      else buffer = [str];
+      const resStr = Promise.all(callbacks.map((c) => c({
+        phase,
+        buffer,
+        context
+      }))).then((res) => Promise.all(res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context, buffer))).then(() => buffer[0]));
+      if (preserveCallbacks) return raw(await resStr, callbacks);
+      else return resStr;
+    };
+    exports2.HtmlEscapedCallbackPhase = HtmlEscapedCallbackPhase;
+    exports2.escapeToBuffer = escapeToBuffer;
+    exports2.raw = raw;
+    exports2.resolveCallback = resolveCallback;
+    exports2.resolveCallbackSync = resolveCallbackSync;
+    exports2.stringBufferToString = stringBufferToString;
+  }
+});
+
+// node_modules/hono/dist/cjs/context.js
+var require_context = __commonJS({
+  "node_modules/hono/dist/cjs/context.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_request3 = require_request2();
+    var require_utils_html = require_html();
+    var TEXT_PLAIN = "text/plain; charset=UTF-8";
+    var setDefaultContentType = (contentType, headers) => {
+      return {
+        "Content-Type": contentType,
+        ...headers
+      };
+    };
+    var createResponseInstance = (body, init) => new Response(body, init);
+    var Context = class {
+      #rawRequest;
+      #req;
+      /**
+      * `.env` can get bindings (environment variables, secrets, KV namespaces, D1 database, R2 bucket etc.) in Cloudflare Workers.
+      *
+      * @see {@link https://hono.dev/docs/api/context#env}
+      *
+      * @example
+      * ```ts
+      * // Environment object for Cloudflare Workers
+      * app.get('*', async c => {
+      *   const counter = c.env.COUNTER
+      * })
+      * ```
+      */
+      env = {};
+      #var;
+      finalized = false;
+      /**
+      * `.error` can get the error object from the middleware if the Handler throws an error.
+      *
+      * @see {@link https://hono.dev/docs/api/context#error}
+      *
+      * @example
+      * ```ts
+      * app.use('*', async (c, next) => {
+      *   await next()
+      *   if (c.error) {
+      *     // do something...
+      *   }
+      * })
+      * ```
+      */
+      error;
+      #status;
+      #executionCtx;
+      #res;
+      #layout;
+      #renderer;
+      #notFoundHandler;
+      #preparedHeaders;
+      #matchResult;
+      #path;
+      /**
+      * Creates an instance of the Context class.
+      *
+      * @param req - The Request object.
+      * @param options - Optional configuration options for the context.
+      */
+      constructor(req, options) {
+        this.#rawRequest = req;
+        if (options) {
+          this.#executionCtx = options.executionCtx;
+          this.env = options.env;
+          this.#notFoundHandler = options.notFoundHandler;
+          this.#path = options.path;
+          this.#matchResult = options.matchResult;
+        }
+      }
+      /**
+      * `.req` is the instance of {@link HonoRequest}.
+      */
+      get req() {
+        this.#req ??= new require_request3.HonoRequest(this.#rawRequest, this.#path, this.#matchResult);
+        return this.#req;
+      }
+      /**
+      * @see {@link https://hono.dev/docs/api/context#event}
+      * The FetchEvent associated with the current request.
+      *
+      * @throws Will throw an error if the context does not have a FetchEvent.
+      */
+      get event() {
+        if (this.#executionCtx && "respondWith" in this.#executionCtx) return this.#executionCtx;
+        else throw Error("This context has no FetchEvent");
+      }
+      /**
+      * @see {@link https://hono.dev/docs/api/context#executionctx}
+      * The ExecutionContext associated with the current request.
+      *
+      * @throws Will throw an error if the context does not have an ExecutionContext.
+      */
+      get executionCtx() {
+        if (this.#executionCtx) return this.#executionCtx;
+        else throw Error("This context has no ExecutionContext");
+      }
+      /**
+      * @see {@link https://hono.dev/docs/api/context#res}
+      * The Response object for the current request.
+      */
+      get res() {
+        return this.#res ||= createResponseInstance(null, { headers: this.#preparedHeaders ??= new Headers() });
+      }
+      /**
+      * Sets the Response object for the current request.
+      *
+      * @param _res - The Response object to set.
+      */
+      set res(_res) {
+        if (this.#res && _res) {
+          _res = createResponseInstance(_res.body, _res);
+          for (const [k, v] of this.#res.headers.entries()) {
+            if (k === "content-type") continue;
+            if (k === "set-cookie") {
+              const cookies = this.#res.headers.getSetCookie();
+              _res.headers.delete("set-cookie");
+              for (const cookie of cookies) _res.headers.append("set-cookie", cookie);
+            } else _res.headers.set(k, v);
+          }
+        }
+        this.#res = _res;
+        this.finalized = true;
+      }
+      /**
+      * `.render()` can create a response within a layout.
+      *
+      * @see {@link https://hono.dev/docs/api/context#render-setrenderer}
+      *
+      * @example
+      * ```ts
+      * app.get('/', (c) => {
+      *   return c.render('Hello!')
+      * })
+      * ```
+      */
+      render = (...args) => {
+        this.#renderer ??= (content) => this.html(content);
+        return this.#renderer(...args);
+      };
+      /**
+      * Sets the layout for the response.
+      *
+      * @param layout - The layout to set.
+      * @returns The layout function.
+      */
+      setLayout = (layout) => this.#layout = layout;
+      /**
+      * Gets the current layout for the response.
+      *
+      * @returns The current layout function.
+      */
+      getLayout = () => this.#layout;
+      /**
+      * `.setRenderer()` can set the layout in the custom middleware.
+      *
+      * @see {@link https://hono.dev/docs/api/context#render-setrenderer}
+      *
+      * @example
+      * ```tsx
+      * app.use('*', async (c, next) => {
+      *   c.setRenderer((content) => {
+      *     return c.html(
+      *       <html>
+      *         <body>
+      *           <p>{content}</p>
+      *         </body>
+      *       </html>
+      *     )
+      *   })
+      *   await next()
+      * })
+      * ```
+      */
+      setRenderer = (renderer) => {
+        this.#renderer = renderer;
+      };
+      /**
+      * `.header()` can set headers.
+      *
+      * @see {@link https://hono.dev/docs/api/context#header}
+      *
+      * @example
+      * ```ts
+      * app.get('/welcome', (c) => {
+      *   // Set headers
+      *   c.header('X-Message', 'Hello!')
+      *   c.header('Content-Type', 'text/plain')
+      *
+      *   // Append multiple headers using the append option (e.g. Vary)
+      *   c.header('Vary', 'Accept-Encoding', { append: true })
+      *   c.header('Vary', 'User-Agent', { append: true })
+      *
+      *   return c.body('Thank you for coming')
+      * })
+      * ```
+      */
+      header = (name, value, options) => {
+        if (this.finalized && !this.#res.bodyUsed) this.#res = createResponseInstance(this.#res.body, this.#res);
+        const headers = this.#res ? this.#res.headers : this.#preparedHeaders ??= new Headers();
+        if (value === void 0) headers.delete(name);
+        else if (options?.append) headers.append(name, value);
+        else headers.set(name, value);
+      };
+      status = (status) => {
+        this.#status = status;
+      };
+      /**
+      * `.set()` can set the value specified by the key.
+      *
+      * @see {@link https://hono.dev/docs/api/context#set-get}
+      *
+      * @example
+      * ```ts
+      * app.use('*', async (c, next) => {
+      *   c.set('message', 'Hono is hot!!')
+      *   await next()
+      * })
+      * ```
+      */
+      set = (key, value) => {
+        this.#var ??= /* @__PURE__ */ new Map();
+        this.#var.set(key, value);
+      };
+      /**
+      * `.get()` can use the value specified by the key.
+      *
+      * @see {@link https://hono.dev/docs/api/context#set-get}
+      *
+      * @example
+      * ```ts
+      * app.get('/', (c) => {
+      *   const message = c.get('message')
+      *   return c.text(`The message is "${message}"`)
+      * })
+      * ```
+      */
+      get = (key) => {
+        return this.#var ? this.#var.get(key) : void 0;
+      };
+      /**
+      * `.var` can access the value of a variable.
+      *
+      * @see {@link https://hono.dev/docs/api/context#var}
+      *
+      * @example
+      * ```ts
+      * const result = c.var.client.oneMethod()
+      * ```
+      */
+      get var() {
+        if (!this.#var) return {};
+        return Object.fromEntries(this.#var);
+      }
+      #newResponse(data, arg, headers) {
+        let responseHeaders = this.#res ? new Headers(this.#res.headers) : this.#preparedHeaders;
+        if (typeof arg === "object" && arg.headers) {
+          responseHeaders ??= new Headers();
+          for (const [key, value] of new Headers(arg.headers)) if (key === "set-cookie") responseHeaders.append(key, value);
+          else responseHeaders.set(key, value);
+        }
+        if (headers) {
+          if (!responseHeaders) {
+            let count = 0;
+            for (const k in headers) if (++count > 1 || typeof headers[k] !== "string") {
+              responseHeaders = new Headers();
+              break;
+            }
+          }
+          if (responseHeaders) for (const k in headers) {
+            const v = headers[k];
+            if (typeof v === "string") responseHeaders.set(k, v);
+            else {
+              responseHeaders.delete(k);
+              for (const v2 of v) responseHeaders.append(k, v2);
+            }
+          }
+        }
+        const status = typeof arg === "number" ? arg : arg?.status ?? this.#status;
+        return createResponseInstance(data, {
+          status,
+          headers: responseHeaders ?? headers
+        });
+      }
+      newResponse = (...args) => this.#newResponse(...args);
+      /**
+      * `.body()` can return the HTTP response.
+      * You can set headers with `.header()` and set HTTP status code with `.status`.
+      * This can also be set in `.text()`, `.json()` and so on.
+      *
+      * @see {@link https://hono.dev/docs/api/context#body}
+      *
+      * @example
+      * ```ts
+      * app.get('/welcome', (c) => {
+      *   // Set headers
+      *   c.header('X-Message', 'Hello!')
+      *   c.header('Content-Type', 'text/plain')
+      *   // Set HTTP status code
+      *   c.status(201)
+      *
+      *   // Return the response body
+      *   return c.body('Thank you for coming')
+      * })
+      * ```
+      */
+      body = (data, arg, headers) => this.#newResponse(data, arg, headers);
+      /**
+      * `.text()` can render text as `Content-Type:text/plain`.
+      *
+      * @see {@link https://hono.dev/docs/api/context#text}
+      *
+      * @example
+      * ```ts
+      * app.get('/say', (c) => {
+      *   return c.text('Hello!')
+      * })
+      * ```
+      */
+      text = (text, arg, headers) => {
+        return !this.#preparedHeaders && !this.#status && !arg && !headers && !this.finalized ? new Response(text) : this.#newResponse(text, arg, setDefaultContentType(TEXT_PLAIN, headers));
+      };
+      /**
+      * `.json()` can render JSON as `Content-Type:application/json`.
+      *
+      * @see {@link https://hono.dev/docs/api/context#json}
+      *
+      * @example
+      * ```ts
+      * app.get('/api', (c) => {
+      *   return c.json({ message: 'Hello!' })
+      * })
+      * ```
+      */
+      json = (object, arg, headers) => {
+        return this.#newResponse(JSON.stringify(object), arg, setDefaultContentType("application/json", headers));
+      };
+      html = (html, arg, headers) => {
+        const res = (html2) => this.#newResponse(html2, arg, setDefaultContentType("text/html; charset=UTF-8", headers));
+        return typeof html === "object" ? require_utils_html.resolveCallback(html, require_utils_html.HtmlEscapedCallbackPhase.Stringify, false, {}).then(res) : res(html);
+      };
+      /**
+      * `.redirect()` can Redirect, default status code is 302.
+      *
+      * @see {@link https://hono.dev/docs/api/context#redirect}
+      *
+      * @example
+      * ```ts
+      * app.get('/redirect', (c) => {
+      *   return c.redirect('/')
+      * })
+      * app.get('/redirect-permanently', (c) => {
+      *   return c.redirect('/', 301)
+      * })
+      * ```
+      */
+      redirect = (location, status) => {
+        const locationString = String(location);
+        this.header("Location", !/[^\x00-\xFF]/.test(locationString) ? locationString : encodeURI(locationString));
+        return this.newResponse(null, status ?? 302);
+      };
+      /**
+      * `.notFound()` can return the Not Found Response.
+      *
+      * @see {@link https://hono.dev/docs/api/context#notfound}
+      *
+      * @example
+      * ```ts
+      * app.get('/notfound', (c) => {
+      *   return c.notFound()
+      * })
+      * ```
+      */
+      notFound = () => {
+        this.#notFoundHandler ??= () => createResponseInstance();
+        return this.#notFoundHandler(this);
+      };
+    };
+    exports2.Context = Context;
+    exports2.TEXT_PLAIN = TEXT_PLAIN;
+  }
+});
+
+// node_modules/hono/dist/cjs/compose.js
+var require_compose = __commonJS({
+  "node_modules/hono/dist/cjs/compose.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var compose = (middleware, onError, onNotFound) => {
+      return (context, next) => {
+        let index = -1;
+        return dispatch(0);
+        async function dispatch(i) {
+          if (i <= index) throw new Error("next() called multiple times");
+          index = i;
+          let res;
+          let isError = false;
+          let handler;
+          if (middleware[i]) {
+            handler = middleware[i][0][0];
+            context.req.routeIndex = i;
+          } else handler = i === middleware.length && next || void 0;
+          if (handler) try {
+            res = await handler(context, () => dispatch(i + 1));
+          } catch (err) {
+            if (err instanceof Error && onError) {
+              context.error = err;
+              res = await onError(err, context);
+              isError = true;
+            } else throw err;
+          }
+          else if (context.finalized === false && onNotFound) res = await onNotFound(context);
+          if (res && (context.finalized === false || isError)) context.res = res;
+          return context;
+        }
+      };
+    };
+    exports2.compose = compose;
+  }
+});
+
+// node_modules/hono/dist/cjs/helper/route/index.js
+var require_route = __commonJS({
+  "node_modules/hono/dist/cjs/helper/route/index.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_request_constants = require_constants();
+    var require_utils_url = require_url();
+    var matchedRoutes = (c) => c.req[require_request_constants.GET_MATCH_RESULT][0].map(([[, route]]) => route);
+    var routePath = (c, index) => matchedRoutes(c).at(index ?? c.req.routeIndex)?.path ?? "";
+    var baseRoutePath = (c, index) => matchedRoutes(c).at(index ?? c.req.routeIndex)?.basePath ?? "";
+    var basePathCacheMap = /* @__PURE__ */ new WeakMap();
+    var basePath = (c, index) => {
+      index ??= c.req.routeIndex;
+      const cache = basePathCacheMap.get(c) || [];
+      if (typeof cache[index] === "string") return cache[index];
+      let result;
+      const rp = baseRoutePath(c, index);
+      if (!/[:*]/.test(rp)) result = rp;
+      else {
+        const paths = require_utils_url.splitRoutingPath(rp);
+        const reqPath = c.req.path;
+        let basePathLength = 0;
+        for (let i = 0, len = paths.length; i < len; i++) {
+          const pattern = require_utils_url.getPattern(paths[i], paths[i + 1]);
+          if (pattern) {
+            const re = pattern[2] === true || pattern === "*" ? /[^\/]+/ : pattern[2];
+            const restPath = reqPath.substring(basePathLength + 1);
+            const segment = restPath.split("/", 1)[0];
+            basePathLength += (restPath.match(re)?.[0] ?? (re.test(segment) ? segment : "")).length;
+          } else basePathLength += paths[i].length;
+          basePathLength += 1;
+        }
+        result = reqPath.substring(0, basePathLength);
+      }
+      cache[index] = result;
+      basePathCacheMap.set(c, cache);
+      return result;
+    };
+    exports2.basePath = basePath;
+    exports2.baseRoutePath = baseRoutePath;
+    exports2.matchedRoutes = matchedRoutes;
+    exports2.routePath = routePath;
+  }
+});
+
+// node_modules/hono/dist/cjs/router.js
+var require_router = __commonJS({
+  "node_modules/hono/dist/cjs/router.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var METHOD_NAME_ALL = "ALL";
+    var METHOD_NAME_ALL_LOWERCASE = "all";
+    var METHODS = [
+      "get",
+      "post",
+      "put",
+      "delete",
+      "options",
+      "patch",
+      "query"
+    ];
+    var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
+    var UnsupportedPathError = class extends Error {
+    };
+    exports2.MESSAGE_MATCHER_IS_ALREADY_BUILT = MESSAGE_MATCHER_IS_ALREADY_BUILT;
+    exports2.METHODS = METHODS;
+    exports2.METHOD_NAME_ALL = METHOD_NAME_ALL;
+    exports2.METHOD_NAME_ALL_LOWERCASE = METHOD_NAME_ALL_LOWERCASE;
+    exports2.UnsupportedPathError = UnsupportedPathError;
+  }
+});
+
+// node_modules/hono/dist/cjs/utils/constants.js
+var require_constants2 = __commonJS({
+  "node_modules/hono/dist/cjs/utils/constants.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var COMPOSED_HANDLER = "__COMPOSED_HANDLER";
+    exports2.COMPOSED_HANDLER = COMPOSED_HANDLER;
+  }
+});
+
+// node_modules/hono/dist/cjs/utils/mount.js
+var require_mount = __commonJS({
+  "node_modules/hono/dist/cjs/utils/mount.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_http_exception2 = require_http_exception();
+    var require_request_constants = require_constants();
+    var require_utils_url = require_url();
+    var countTrailingSlashes = (path) => {
+      let index = path.length;
+      while (index > 0 && path.charCodeAt(index - 1) === 47) index--;
+      return path.length - index;
+    };
+    var getPathPrefixLength = (c, pathPrefix, routePath) => {
+      if (!/[:*]/.test(pathPrefix)) return pathPrefix.length;
+      const path = c.req.path;
+      const matchResult = c.req[require_request_constants.GET_MATCH_RESULT];
+      const paramNames = /* @__PURE__ */ new Set();
+      let length = 0;
+      for (const part of require_utils_url.splitRoutingPath(pathPrefix)) {
+        if (part[0] === ":" && part.endsWith("}?")) throw new Error(`mount(): Optional regular expression parameters are not supported in "${routePath}".`);
+        const pattern = require_utils_url.getPattern(part);
+        if (pattern && pattern !== "*") {
+          const name = pattern[1];
+          if (paramNames.has(name)) throw new Error(`mount(): Duplicate path parameter "${name}" in "${routePath}".`);
+          paramNames.add(name);
+        }
+        if (pattern && pattern !== "*" && pattern[2] !== true) {
+          const value = matchResult.length === 2 ? matchResult[1][matchResult[0][c.req.routeIndex][1][pattern[1]]] : matchResult[0][c.req.routeIndex][1][pattern[1]];
+          length += value.length + 1;
+        } else if (pattern || part.endsWith("*")) {
+          const end = path.indexOf("/", length + 1);
+          length = end === -1 ? path.length : end;
+        } else length += part.length + 1;
+      }
+      return length;
+    };
+    var createMountedRequest = (c, pathPrefix, routePath) => {
+      if (/[^/]\*$/.test(routePath)) throw new Error(`mount(): Wildcard must follow "/" in "${routePath}".`);
+      const prefixLength = getPathPrefixLength(c, pathPrefix, routePath);
+      const path = c.req.path.slice(prefixLength) || "/";
+      if (prefixLength > c.req.path.length || path[0] !== "/" || /\/(?:\.|%2e){1,2}(?:\/|$)/i.test(path)) throw new require_http_exception2.HTTPException(400, { message: "Invalid mounted path" });
+      const rawUrl = c.req.raw.url;
+      if (/^[^/?#]*\/\/[^/?#\\]*[?#\\]/.test(rawUrl)) throw new require_http_exception2.HTTPException(400, { message: "Invalid mounted path" });
+      const rawPathEnd = rawUrl.search(/[?#]/);
+      const rawTrailingSlashes = countTrailingSlashes(rawPathEnd === -1 ? rawUrl : rawUrl.slice(0, rawPathEnd));
+      if (rawTrailingSlashes > 1 && countTrailingSlashes(c.req.path) === rawTrailingSlashes - 1) throw new require_http_exception2.HTTPException(400, { message: "Invalid mounted path" });
+      const url = new URL(rawUrl);
+      url.pathname = path.replace(/[\\\t\n\r]/g, encodeURIComponent);
+      if (path.includes("%")) {
+      }
+      return new Request(url, c.req.raw);
+    };
+    exports2.createMountedRequest = createMountedRequest;
+  }
+});
+
+// node_modules/hono/dist/cjs/hono-base.js
+var require_hono_base = __commonJS({
+  "node_modules/hono/dist/cjs/hono-base.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_compose2 = require_compose();
+    var require_utils_url = require_url();
+    var require_context2 = require_context();
+    var require_helper_route_index = require_route();
+    var require_router5 = require_router();
+    var require_utils_constants = require_constants2();
+    var require_utils_mount = require_mount();
+    var notFoundHandler = (c) => {
+      return c.text("404 Not Found", 404);
+    };
+    var errorHandler = (err, c) => {
+      if ("getResponse" in err) {
+        const res = err.getResponse();
+        return c.newResponse(res.body, res);
+      }
+      console.error(err);
+      return c.text("Internal Server Error", 500);
+    };
+    var Hono = class Hono2 {
+      get;
+      post;
+      put;
+      delete;
+      options;
+      patch;
+      query;
+      all;
+      on;
+      use;
+      router;
+      getPath;
+      _basePath = "/";
+      #path = "/";
+      routes = [];
+      constructor(options = {}) {
+        [...require_router5.METHODS, "all"].forEach((method) => {
+          this[method] = (args1, ...args) => {
+            const methodName = method.toUpperCase();
+            if (typeof args1 === "string") this.#path = args1;
+            else this.#addRoute(methodName, this.#path, args1);
+            args.forEach((handler) => {
+              this.#addRoute(methodName, this.#path, handler);
+            });
+            return this;
+          };
+        });
+        this.on = (method, path, ...handlers) => {
+          for (const p of [path].flat()) {
+            this.#path = p;
+            for (const m of [method].flat()) {
+              const methodName = m.toUpperCase();
+              for (const handler of handlers) this.#addRoute(methodName, this.#path, handler);
+            }
+          }
+          return this;
+        };
+        this.use = (arg1, ...handlers) => {
+          if (typeof arg1 === "string") this.#path = arg1;
+          else {
+            this.#path = "*";
+            handlers.unshift(arg1);
+          }
+          handlers.forEach((handler) => {
+            this.#addRoute("ALL", this.#path, handler);
+          });
+          return this;
+        };
+        const { strict, ...optionsWithoutStrict } = options;
+        Object.assign(this, optionsWithoutStrict);
+        this.getPath = strict ?? true ? options.getPath ?? require_utils_url.getPath : require_utils_url.getPathNoStrict;
+      }
+      #clone() {
+        const clone = new Hono2({
+          router: this.router,
+          getPath: this.getPath
+        });
+        clone.errorHandler = this.errorHandler;
+        clone.#notFoundHandler = this.#notFoundHandler;
+        clone.routes = this.routes;
+        return clone;
+      }
+      #notFoundHandler = notFoundHandler;
+      errorHandler = errorHandler;
+      /**
+      * `.route()` allows grouping other Hono instance in routes.
+      *
+      * @see {@link https://hono.dev/docs/api/routing#grouping}
+      *
+      * @param {string} path - base Path
+      * @param {Hono} app - other Hono instance
+      * @returns {Hono} routed Hono instance
+      *
+      * @example
+      * ```ts
+      * const app = new Hono()
+      * const app2 = new Hono()
+      *
+      * app2.get("/user", (c) => c.text("user"))
+      * app.route("/api", app2) // GET /api/user
+      * ```
+      */
+      route(path, app) {
+        const subApp = this.basePath(path);
+        app.routes.map((r) => {
+          let handler;
+          if (app.errorHandler === errorHandler) handler = r.handler;
+          else {
+            handler = async (c, next) => (await require_compose2.compose([], app.errorHandler)(c, () => r.handler(c, next))).res;
+            handler[require_utils_constants.COMPOSED_HANDLER] = r.handler;
+          }
+          subApp.#addRoute(r.method, r.path, handler, r.basePath);
+        });
+        return this;
+      }
+      /**
+      * `.basePath()` allows base paths to be specified.
+      *
+      * @see {@link https://hono.dev/docs/api/routing#base-path}
+      *
+      * @param {string} path - base Path
+      * @returns {Hono} changed Hono instance
+      *
+      * @example
+      * ```ts
+      * const api = new Hono().basePath('/api')
+      * ```
+      */
+      basePath(path) {
+        const subApp = this.#clone();
+        subApp._basePath = require_utils_url.mergePath(this._basePath, path);
+        return subApp;
+      }
+      /**
+      * `.onError()` handles an error and returns a customized Response.
+      *
+      * @see {@link https://hono.dev/docs/api/hono#error-handling}
+      *
+      * @param {ErrorHandler} handler - request Handler for error
+      * @returns {Hono} changed Hono instance
+      *
+      * @example
+      * ```ts
+      * app.onError((err, c) => {
+      *   console.error(`${err}`)
+      *   return c.text('Custom Error Message', 500)
+      * })
+      * ```
+      */
+      onError = (handler) => {
+        this.errorHandler = handler;
+        return this;
+      };
+      /**
+      * `.notFound()` allows you to customize a Not Found Response.
+      *
+      * @see {@link https://hono.dev/docs/api/hono#not-found}
+      *
+      * @param {NotFoundHandler} handler - request handler for not-found
+      * @returns {Hono} changed Hono instance
+      *
+      * @example
+      * ```ts
+      * app.notFound((c) => {
+      *   return c.text('Custom 404 Message', 404)
+      * })
+      * ```
+      */
+      notFound = (handler) => {
+        this.#notFoundHandler = handler;
+        return this;
+      };
+      /**
+      * `.mount()` allows you to mount applications built with other frameworks into your Hono application.
+      *
+      * @deprecated Use `mount()` from `hono/mount` instead. `.mount()` will be removed in v5.
+      *
+      * @see {@link https://hono.dev/docs/api/hono#mount}
+      *
+      * @param {string} path - base Path
+      * @param {Function} applicationHandler - other Request Handler
+      * @param {MountOptions} [options] - options of `.mount()`
+      * @returns {Hono} mounted Hono instance
+      * @throws {Error} If automatic request rewriting encounters duplicate path parameter names or an optional regular expression parameter.
+      * @throws {HTTPException} With status 400 if automatic request rewriting cannot safely preserve the routed path.
+      *
+      * @example
+      * ```ts
+      * import { Router as IttyRouter } from 'itty-router'
+      * import { Hono } from 'hono'
+      * // Create itty-router application
+      * const ittyRouter = IttyRouter()
+      * // GET /itty-router/hello
+      * ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
+      *
+      * const app = new Hono()
+      * app.mount('/itty-router', ittyRouter.handle)
+      * ```
+      *
+      * @example
+      * ```ts
+      * const app = new Hono()
+      * // Send the request to another application without modification.
+      * app.mount('/app', anotherApp, {
+      *   replaceRequest: (req) => req,
+      * })
+      * ```
+      */
+      mount(path, applicationHandler, options) {
+        let replaceRequest;
+        let optionHandler;
+        if (options) {
+          if (typeof options === "function") optionHandler = options;
+          else {
+            optionHandler = options.optionHandler;
+            if (options.replaceRequest === false) replaceRequest = (request) => request;
+            else replaceRequest = options.replaceRequest;
+          }
+        }
+        const getOptions = optionHandler ? (c) => {
+          const options2 = optionHandler(c);
+          return Array.isArray(options2) ? options2 : [options2];
+        } : (c) => {
+          let executionContext = void 0;
+          try {
+            executionContext = c.executionCtx;
+          } catch {
+          }
+          return [c.env, executionContext];
+        };
+        const defaultReplaceRequest = (c) => {
+          const mountedRoutePath = require_helper_route_index.routePath(c);
+          return require_utils_mount.createMountedRequest(c, mountedRoutePath.replace(/\/?\*$/, ""), mountedRoutePath);
+        };
+        const handler = async (c, next) => {
+          const res = await applicationHandler(replaceRequest ? replaceRequest(c.req.raw) : defaultReplaceRequest(c), ...getOptions(c));
+          if (res) return res;
+          await next();
+        };
+        this.#addRoute("ALL", require_utils_url.mergePath(path, "*"), handler);
+        return this;
+      }
+      #addRoute(method, path, handler, baseRoutePath) {
+        path = require_utils_url.mergePath(this._basePath, path);
+        const r = {
+          basePath: baseRoutePath !== void 0 ? require_utils_url.mergePath(this._basePath, baseRoutePath) : this._basePath,
+          path,
+          method,
+          handler
+        };
+        this.router.add(method, path, [handler, r]);
+        this.routes.push(r);
+      }
+      #handleError(err, c) {
+        if (err instanceof Error) return this.errorHandler(err, c);
+        throw err;
+      }
+      #dispatch(request, executionCtx, env, method) {
+        if (method === "HEAD") return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
+        const path = this.getPath(request, { env });
+        const matchResult = this.router.match(method, path);
+        const c = new require_context2.Context(request, {
+          path,
+          matchResult,
+          env,
+          executionCtx,
+          notFoundHandler: this.#notFoundHandler
+        });
+        if (matchResult[0].length === 1) {
+          let res;
+          try {
+            res = matchResult[0][0][0][0](c, async () => {
+              c.res = await this.#notFoundHandler(c);
+            });
+          } catch (err) {
+            return this.#handleError(err, c);
+          }
+          return res instanceof Promise ? res.then((resolved) => resolved || (c.finalized ? c.res : this.#notFoundHandler(c))).catch((err) => this.#handleError(err, c)) : res ?? this.#notFoundHandler(c);
+        }
+        const composed = require_compose2.compose(matchResult[0], this.errorHandler, this.#notFoundHandler);
+        return (async () => {
+          try {
+            const context = await composed(c);
+            if (!context.finalized) throw new Error("Context is not finalized. Did you forget to return a Response object or `await next()`?");
+            return context.res;
+          } catch (err) {
+            return this.#handleError(err, c);
+          }
+        })();
+      }
+      /**
+      * `.fetch()` will be entry point of your app.
+      *
+      * @see {@link https://hono.dev/docs/api/hono#fetch}
+      *
+      * @param {Request} request - request Object of request
+      * @param {Env} env - env Object
+      * @param {ExecutionContext} executionCtx - context of execution
+      * @returns {Response | Promise<Response>} response of request
+      *
+      */
+      fetch = (request, ...rest) => {
+        return this.#dispatch(request, rest[1], rest[0], request.method);
+      };
+      /**
+      * `.request()` is a useful method for testing.
+      * You can pass a URL or pathname to send a GET request.
+      * app will return a Response object.
+      * ```ts
+      * test('GET /hello is ok', async () => {
+      *   const res = await app.request('/hello')
+      *   expect(res.status).toBe(200)
+      * })
+      * ```
+      * @see https://hono.dev/docs/api/hono#request
+      */
+      request = (input, requestInit, Env, executionCtx) => {
+        if (input instanceof Request) return this.fetch(requestInit ? new Request(input, requestInit) : input, Env, executionCtx);
+        input = input.toString();
+        return this.fetch(new Request(/^https?:\/\//.test(input) ? input : `http://localhost${require_utils_url.mergePath("/", input)}`, requestInit), Env, executionCtx);
+      };
+      /**
+      * `.fire()` automatically adds a global fetch event listener.
+      * This can be useful for environments that adhere to the Service Worker API, such as non-ES module Cloudflare Workers.
+      * @deprecated
+      * Use `fire` from `hono/service-worker` instead.
+      * ```ts
+      * import { Hono } from 'hono'
+      * import { fire } from 'hono/service-worker'
+      *
+      * const app = new Hono()
+      * // ...
+      * fire(app)
+      * ```
+      * @see https://hono.dev/docs/api/hono#fire
+      * @see https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
+      * @see https://developers.cloudflare.com/workers/reference/migrate-to-module-workers/
+      */
+      fire = () => {
+        addEventListener("fetch", (event) => {
+          event.respondWith(this.#dispatch(event.request, event, void 0, event.request.method));
+        });
+      };
+    };
+    exports2.HonoBase = Hono;
+  }
+});
+
+// node_modules/hono/dist/cjs/router/utils.js
+var require_utils = __commonJS({
+  "node_modules/hono/dist/cjs/router/utils.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var createNullObject = () => /* @__PURE__ */ Object.create(null);
+    exports2.createNullObject = createNullObject;
+  }
+});
+
+// node_modules/hono/dist/cjs/router/reg-exp-router/matcher.js
+var require_matcher = __commonJS({
+  "node_modules/hono/dist/cjs/router/reg-exp-router/matcher.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    require_router();
+    var emptyParam = [];
+    function match(method, path) {
+      const matchers = this.buildAllMatchers();
+      const match2 = (method2, path2) => {
+        const matcher = matchers[method2] || matchers["ALL"];
+        const staticMatch = matcher[2][path2];
+        if (staticMatch) return staticMatch;
+        const match3 = path2.match(matcher[0]);
+        if (!match3) return [[], emptyParam];
+        const index = match3.indexOf("", 1);
+        return [matcher[1][index], match3];
+      };
+      this.match = match2;
+      return match2(method, path);
+    }
+    exports2.emptyParam = emptyParam;
+    exports2.match = match;
+  }
+});
+
+// node_modules/hono/dist/cjs/router/reg-exp-router/node.js
+var require_node = __commonJS({
+  "node_modules/hono/dist/cjs/router/reg-exp-router/node.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_router_utils = require_utils();
+    var LABEL_REG_EXP_STR = "[^/]+";
+    var ONLY_WILDCARD_REG_EXP_STR = "[^]*";
+    var TAIL_WILDCARD_REG_EXP_STR = "(?:|/[^]*)";
+    var PATH_ERROR = Symbol();
+    var regExpMetaChars = /* @__PURE__ */ new Set(".\\+*[^]$()");
+    function compareKey(a, b) {
+      if (a.length === 1) return b.length === 1 ? a < b ? -1 : 1 : -1;
+      if (b.length === 1) return 1;
+      if (a === "[^]*" || a === "(?:|/[^]*)") return b === "[^]*" ? -1 : 1;
+      else if (b === "[^]*" || b === "(?:|/[^]*)") return -1;
+      if (a === "[^/]+") return 1;
+      else if (b === "[^/]+") return -1;
+      return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
+    }
+    var Node = class Node2 {
+      #index;
+      #varIndex;
+      #children = require_router_utils.createNullObject();
+      insert(tokens, index, paramMap, context, keys) {
+        let node = this;
+        for (let i = 0, len = tokens.length; i < len; i++) {
+          const token = tokens[i];
+          const pattern = token.length === 1 ? token === "*" ? i === len - 1 ? [
+            "",
+            "",
+            ONLY_WILDCARD_REG_EXP_STR
+          ] : [
+            "",
+            "",
+            LABEL_REG_EXP_STR
+          ] : null : token === "/*" ? [
+            "",
+            "",
+            TAIL_WILDCARD_REG_EXP_STR
+          ] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+          let nextNode;
+          if (pattern) {
+            const name = pattern[1];
+            let regexpStr = pattern[2] || "[^/]+";
+            if (name && pattern[2]) {
+              if (new RegExp(regexpStr).test("")) throw PATH_ERROR;
+              regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, "(?:");
+              if (/\((?!\?:)/.test(regexpStr)) throw PATH_ERROR;
+              if (regexpStr.length === 1 && regExpMetaChars.has(regexpStr)) throw PATH_ERROR;
+            }
+            keys.push(regexpStr);
+            nextNode = node.#children[regexpStr];
+            if (!nextNode) {
+              if (regexpStr !== "[^]*" && regexpStr !== "(?:|/[^]*)") {
+                for (const k in node.#children) if ((regexpStr.length > 1 || k.length > 1) && k !== "[^]*" && k !== "(?:|/[^]*)") throw PATH_ERROR;
+              }
+              nextNode = node.#children[regexpStr] = new Node2();
+            }
+            if (name !== "") {
+              nextNode.#varIndex ??= context.varIndex++;
+              paramMap.push([name, nextNode.#varIndex]);
+            }
+          } else {
+            keys.push(token);
+            nextNode = node.#children[token];
+            if (!nextNode) {
+              for (const k in node.#children) if (k.length > 1 && k !== "[^]*" && k !== "(?:|/[^]*)") throw PATH_ERROR;
+              nextNode = node.#children[token] = new Node2();
+            }
+          }
+          node = nextNode;
+        }
+        if (node.#index !== void 0) throw PATH_ERROR;
+        node.#index = index;
+      }
+      buildRegExpStr() {
+        const strList = Object.keys(this.#children).sort(compareKey).map((k) => {
+          const c = this.#children[k];
+          const childStr = c.buildRegExpStr();
+          return childStr === "" ? "" : (typeof c.#varIndex === "number" ? `(${k})@${c.#varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + childStr;
+        }).filter(Boolean);
+        if (typeof this.#index === "number" && this.#index !== -1) strList.unshift(`#${this.#index}`);
+        if (strList.length === 0) return "";
+        if (strList.length === 1) return strList[0];
+        return "(?:" + strList.join("|") + ")";
+      }
+    };
+    exports2.LABEL_REG_EXP_STR = LABEL_REG_EXP_STR;
+    exports2.Node = Node;
+    exports2.ONLY_WILDCARD_REG_EXP_STR = ONLY_WILDCARD_REG_EXP_STR;
+    exports2.PATH_ERROR = PATH_ERROR;
+    exports2.TAIL_WILDCARD_REG_EXP_STR = TAIL_WILDCARD_REG_EXP_STR;
+  }
+});
+
+// node_modules/hono/dist/cjs/router/reg-exp-router/trie.js
+var require_trie = __commonJS({
+  "node_modules/hono/dist/cjs/router/reg-exp-router/trie.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_router_utils = require_utils();
+    var require_router_reg_exp_router_node = require_node();
+    var Trie = class {
+      #context = { varIndex: 0 };
+      #root = new require_router_reg_exp_router_node.Node();
+      #index = 0;
+      paths = require_router_utils.createNullObject();
+      insert(path, isStatic) {
+        const keys = [];
+        if (isStatic) {
+          this.#root.insert(path.split(""), -1, [], this.#context, keys);
+          this.paths[path] = [
+            -1,
+            [],
+            keys
+          ];
+          return;
+        }
+        const paramAssoc = [];
+        const groups = [];
+        let markedPath = path;
+        for (let i = 0; ; ) {
+          let replaced = false;
+          markedPath = markedPath.replace(/\{(?:\{[\d,]+\}|[^}])+\}/g, (m) => {
+            const mark = `@\\${i}`;
+            groups[i] = [mark, m];
+            i++;
+            replaced = true;
+            return mark;
+          });
+          if (!replaced) break;
+        }
+        const tokens = markedPath.match(/(?::[^\/]+)|(?:\/\*$)|./gs) || [];
+        for (let i = groups.length - 1; i >= 0; i--) {
+          const [mark] = groups[i];
+          for (let j = tokens.length - 1; j >= 0; j--) if (tokens[j].indexOf(mark) !== -1) {
+            tokens[j] = tokens[j].replace(mark, groups[i][1]);
+            break;
+          }
+        }
+        this.#root.insert(tokens, this.#index, paramAssoc, this.#context, keys);
+        this.paths[path] = [
+          this.#index++,
+          paramAssoc,
+          keys
+        ];
+      }
+      buildRegExp() {
+        let regexp = this.#root.buildRegExpStr();
+        if (regexp === "") return [
+          /^$/,
+          [],
+          []
+        ];
+        let captureIndex = 0;
+        const indexReplacementMap = [];
+        const paramReplacementMap = [];
+        regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
+          if (handlerIndex !== void 0) {
+            indexReplacementMap[++captureIndex] = Number(handlerIndex);
+            return "$()";
+          }
+          if (paramIndex !== void 0) {
+            paramReplacementMap[Number(paramIndex)] = ++captureIndex;
+            return "";
+          }
+          return "";
+        });
+        return [
+          new RegExp(`^${regexp}`),
+          indexReplacementMap,
+          paramReplacementMap
+        ];
+      }
+    };
+    exports2.Trie = Trie;
+  }
+});
+
+// node_modules/hono/dist/cjs/router/reg-exp-router/router.js
+var require_router2 = __commonJS({
+  "node_modules/hono/dist/cjs/router/reg-exp-router/router.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_utils_url = require_url();
+    var require_router5 = require_router();
+    var require_router_utils = require_utils();
+    var require_router_reg_exp_router_matcher = require_matcher();
+    var require_router_reg_exp_router_node = require_node();
+    var require_router_reg_exp_router_trie = require_trie();
+    function endsWithWildcard(keys) {
+      const tail = keys[keys.length - 1];
+      return tail === "[^]*" || tail === "(?:|/[^]*)";
+    }
+    function covers(wildcard, target) {
+      const last = wildcard.length - 1;
+      for (let i = 0; i < last; i++) if (wildcard[i] !== target[i]) return false;
+      return wildcard[last] === "[^]*" || target.length === last || target[last] === "/";
+    }
+    var RegExpRouter = class {
+      name = "RegExpRouter";
+      #handlers;
+      #tries;
+      constructor() {
+        this.#handlers = { ["ALL"]: [] };
+        this.#tries = { ["ALL"]: new require_router_reg_exp_router_trie.Trie() };
+      }
+      #insertPath(method, path) {
+        try {
+          this.#tries[method].insert(path, !/\*|\/:/.test(path));
+        } catch (e) {
+          throw e === require_router_reg_exp_router_node.PATH_ERROR ? new require_router5.UnsupportedPathError(path) : e;
+        }
+      }
+      add(method, path, handler) {
+        const handlers = this.#handlers;
+        if (!handlers) throw new Error(require_router5.MESSAGE_MATCHER_IS_ALREADY_BUILT);
+        const tries = this.#tries;
+        if (!handlers[method]) {
+          tries[method] = new require_router_reg_exp_router_trie.Trie();
+          handlers[method] = [...handlers["ALL"]];
+          for (const p in tries["ALL"].paths) this.#insertPath(method, p);
+        }
+        if (path === "/*") path = "*";
+        const methods = method === "ALL" ? Object.keys(handlers) : [method];
+        const paths = require_utils_url.checkOptionalParameter(path) || [path];
+        for (const path2 of paths) for (const m of methods) {
+          if (!tries[m].paths[path2]) this.#insertPath(m, path2);
+          handlers[m].push([handler, path2]);
+        }
+      }
+      match = require_router_reg_exp_router_matcher.match;
+      buildAllMatchers() {
+        const matchers = require_router_utils.createNullObject();
+        for (const method of Object.keys(this.#handlers)) matchers[method] = this.#buildMatcher(method);
+        this.#handlers = this.#tries = void 0;
+        return matchers;
+      }
+      #buildMatcher(method) {
+        const handlers = this.#handlers[method];
+        const trie = this.#tries[method];
+        const staticMap = require_router_utils.createNullObject();
+        const handlerData = [];
+        const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
+        const own = require_router_utils.createNullObject();
+        const entries = handlers.map(([h, p], i) => {
+          (own[p] ??= []).push(i);
+          return [h, trie.paths[p][1].reduceRight((map, [key, varIndex]) => {
+            map[key] = paramReplacementMap[varIndex];
+            return map;
+          }, require_router_utils.createNullObject())];
+        });
+        const wildcards = Object.keys(own).filter((p) => endsWithWildcard(trie.paths[p][2]));
+        for (const path in trie.paths) {
+          const [index, , keys] = trie.paths[path];
+          const indexes = [...own[path]];
+          for (const p of wildcards) if (p !== path && covers(trie.paths[p][2], keys)) indexes.push(...own[p]);
+          const data = indexes.sort((a, b) => a - b).map((i) => entries[i]);
+          if (index === -1) {
+            const last = Math.max(-1, ...data.flatMap(([, map]) => Object.values(map)));
+            staticMap[path] = [data, last === -1 ? require_router_reg_exp_router_matcher.emptyParam : path.match(regexp).slice(0, last + 1)];
+          } else handlerData[index] = data;
+        }
+        return [
+          regexp,
+          indexReplacementMap.map((i) => handlerData[i]),
+          staticMap
+        ];
+      }
+    };
+    exports2.RegExpRouter = RegExpRouter;
+  }
+});
+
+// node_modules/hono/dist/cjs/router/smart-router/router.js
+var require_router3 = __commonJS({
+  "node_modules/hono/dist/cjs/router/smart-router/router.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_router5 = require_router();
+    var SmartRouter = class {
+      name = "SmartRouter";
+      #routers = [];
+      #routes = [];
+      constructor(init) {
+        this.#routers = init.routers;
+      }
+      add(method, path, handler) {
+        if (!this.#routes) throw new Error(require_router5.MESSAGE_MATCHER_IS_ALREADY_BUILT);
+        this.#routes.push([
+          method,
+          path,
+          handler
+        ]);
+      }
+      match(method, path) {
+        if (!this.#routes) throw new Error("Fatal error");
+        const routers = this.#routers;
+        const routes = this.#routes;
+        const len = routers.length;
+        let i = 0;
+        let res;
+        for (; i < len; i++) {
+          const router = routers[i];
+          try {
+            for (let i2 = 0, len2 = routes.length; i2 < len2; i2++) router.add(...routes[i2]);
+            res = router.match(method, path);
+          } catch (e) {
+            if (e instanceof require_router5.UnsupportedPathError) continue;
+            throw e;
+          }
+          this.match = router.match.bind(router);
+          this.#routers = [router];
+          this.#routes = void 0;
+          break;
+        }
+        if (i === len) throw new Error("Fatal error");
+        this.name = `SmartRouter + ${this.activeRouter.name}`;
+        return res;
+      }
+      get activeRouter() {
+        if (this.#routes || this.#routers.length !== 1) throw new Error("No active router has been determined yet.");
+        return this.#routers[0];
+      }
+    };
+    exports2.SmartRouter = SmartRouter;
+  }
+});
+
+// node_modules/hono/dist/cjs/router/trie-router/node.js
+var require_node2 = __commonJS({
+  "node_modules/hono/dist/cjs/router/trie-router/node.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_utils_url = require_url();
+    require_router();
+    var require_router_utils = require_utils();
+    var emptyParams = require_router_utils.createNullObject();
+    var order = 0;
+    var Node = class Node2 {
+      #methods = [];
+      #children = require_router_utils.createNullObject();
+      #patterns = [];
+      #pattern;
+      #params = emptyParams;
+      insert(method, path, handler) {
+        let curNode = this;
+        const parts = require_utils_url.splitRoutingPath(path);
+        const possibleKeys = /* @__PURE__ */ new Set();
+        let i = 0;
+        for (const p of parts) {
+          const nextP = parts[++i];
+          const pattern = require_utils_url.getPattern(p, nextP) || (nextP === void 0 && p && p.indexOf("*") === p.length - 1 ? p : null);
+          const isParam = Array.isArray(pattern);
+          const key = isParam ? pattern[0] : pattern || p;
+          const child = curNode.#children[key] ||= new Node2();
+          if (pattern && !child.#pattern) {
+            child.#pattern = pattern;
+            curNode.#patterns.push(child);
+          }
+          curNode = child;
+          if (isParam) possibleKeys.add(pattern[1]);
+        }
+        curNode.#methods.push({ [method]: {
+          handler,
+          possibleKeys: [...possibleKeys],
+          score: ++order
+        } });
+      }
+      #pushHandlerSets(handlerSets, node, method, nodeParams, params) {
+        for (let i = 0, len = node.#methods.length; i < len; i++) {
+          const m = node.#methods[i];
+          const handlerSet = m[method] || m["ALL"];
+          if (handlerSet) {
+            handlerSet.params = require_router_utils.createNullObject();
+            handlerSets.push(handlerSet);
+            for (let i2 = 0, len2 = handlerSet.possibleKeys.length; i2 < len2; i2++) {
+              const key = handlerSet.possibleKeys[i2];
+              handlerSet.params[key] = params?.[key] && !i2 ? params[key] : nodeParams[key] ?? params?.[key];
+            }
+          }
+        }
+      }
+      search(method, path) {
+        const handlerSets = [];
+        this.#params = emptyParams;
+        let curNodes = [this];
+        const parts = require_utils_url.splitPath(path);
+        const curNodesQueue = [];
+        const len = parts.length;
+        let partOffsets = null;
+        for (let i = 0; i < len; i++) {
+          const part = parts[i];
+          const isLast = i === len - 1;
+          const tempNodes = [];
+          for (let j = 0, len2 = curNodes.length; j < len2; j++) {
+            const node = curNodes[j];
+            const nextNode = node.#children[part];
+            if (nextNode) {
+              nextNode.#params = node.#params;
+              if (isLast) {
+                if (nextNode.#children["*"]) this.#pushHandlerSets(handlerSets, nextNode.#children["*"], method, node.#params);
+                this.#pushHandlerSets(handlerSets, nextNode, method, node.#params);
+              } else tempNodes.push(nextNode);
+            }
+            for (const child of node.#patterns) {
+              const pattern = child.#pattern;
+              const params = node.#params === emptyParams ? {} : { ...node.#params };
+              if (typeof pattern === "string") {
+                if (pattern === "*" || part.startsWith(pattern.slice(0, -1))) {
+                  this.#pushHandlerSets(handlerSets, child, method, node.#params);
+                  if (pattern === "*") {
+                    child.#params = params;
+                    tempNodes.push(child);
+                  }
+                }
+                continue;
+              }
+              const [, name, matcher] = pattern;
+              if (!part && matcher === true) continue;
+              if (matcher !== true) {
+                if (!partOffsets) {
+                  partOffsets = [];
+                  let offset = path[0] === "/" ? 1 : 0;
+                  for (let p = 0; p < len; p++) {
+                    partOffsets[p] = offset;
+                    offset += parts[p].length + 1;
+                  }
+                }
+                const restPathString = path.slice(partOffsets[i]);
+                const m = matcher.exec(restPathString);
+                if (m) {
+                  if (!Object.hasOwn(params, name)) params[name] = m[0];
+                  this.#pushHandlerSets(handlerSets, child, method, node.#params, params);
+                  if (m[0].length === restPathString.length && child.#children["*"]) this.#pushHandlerSets(handlerSets, child.#children["*"], method, node.#params, params);
+                  for (const _ in child.#children) {
+                    child.#params = params;
+                    const componentCount = m[0].match(/\//g)?.length ?? 0;
+                    (curNodesQueue[componentCount] ||= []).push(child);
+                    break;
+                  }
+                  continue;
+                }
+              }
+              if (matcher === true || matcher.test(part)) {
+                if (!Object.hasOwn(params, name)) params[name] = part;
+                if (isLast) {
+                  this.#pushHandlerSets(handlerSets, child, method, params, node.#params);
+                  if (child.#children["*"]) this.#pushHandlerSets(handlerSets, child.#children["*"], method, params, node.#params);
+                } else {
+                  child.#params = params;
+                  tempNodes.push(child);
+                }
+              }
+            }
+          }
+          const shifted = curNodesQueue.shift();
+          curNodes = shifted ? tempNodes.concat(shifted) : tempNodes;
+        }
+        if (handlerSets[1]) handlerSets.sort((a, b) => {
+          return a.score - b.score;
+        });
+        return [handlerSets.map(({ handler, params }) => [handler, params])];
+      }
+    };
+    exports2.Node = Node;
+  }
+});
+
+// node_modules/hono/dist/cjs/router/trie-router/router.js
+var require_router4 = __commonJS({
+  "node_modules/hono/dist/cjs/router/trie-router/router.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_utils_url = require_url();
+    var require_router_trie_router_node = require_node2();
+    var TrieRouter = class {
+      name = "TrieRouter";
+      #node = new require_router_trie_router_node.Node();
+      add(method, path, handler) {
+        for (const result of require_utils_url.checkOptionalParameter(path) || [path]) this.#node.insert(method, result, handler);
+      }
+      match(method, path) {
+        return this.#node.search(method, path);
+      }
+    };
+    exports2.TrieRouter = TrieRouter;
+  }
+});
+
+// node_modules/hono/dist/cjs/router/trie-router/index.js
+var require_trie_router = __commonJS({
+  "node_modules/hono/dist/cjs/router/trie-router/index.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_router_trie_router_router = require_router4();
+    exports2.TrieRouter = require_router_trie_router_router.TrieRouter;
+  }
+});
+
+// node_modules/hono/dist/cjs/hono.js
+var require_hono = __commonJS({
+  "node_modules/hono/dist/cjs/hono.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_hono_base2 = require_hono_base();
+    var require_router_reg_exp_router_router = require_router2();
+    var require_router_smart_router_router = require_router3();
+    var require_router_trie_router_router = require_router4();
+    require_trie_router();
+    var Hono = class extends require_hono_base2.HonoBase {
+      /**
+      * Creates an instance of the Hono class.
+      *
+      * @param options - Optional configuration options for the Hono instance.
+      */
+      constructor(options = {}) {
+        super(options);
+        this.router = options.router ?? new require_router_smart_router_router.SmartRouter({ routers: [new require_router_reg_exp_router_router.RegExpRouter(), new require_router_trie_router_router.TrieRouter()] });
+      }
+    };
+    exports2.Hono = Hono;
+  }
+});
+
+// node_modules/hono/dist/cjs/index.js
+var require_cjs = __commonJS({
+  "node_modules/hono/dist/cjs/index.js"(exports2) {
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+    var require_context2 = require_context();
+    var require_hono3 = require_hono();
+    exports2.Context = require_context2.Context;
+    exports2.Hono = require_hono3.Hono;
+  }
+});
+
+// node_modules/@hono/node-server/dist/index.js
+var require_dist = __commonJS({
+  "node_modules/@hono/node-server/dist/index.js"(exports2, module2) {
+    "use strict";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // 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 ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var src_exports = {};
+    __export(src_exports, {
+      RequestError: () => RequestError,
+      createAdaptorServer: () => createAdaptorServer,
+      getRequestListener: () => getRequestListener,
+      serve: () => serve
+    });
+    module2.exports = __toCommonJS(src_exports);
+    var import_node_http = require("http");
+    var import_node_http22 = require("http2");
+    var import_node_http2 = require("http2");
+    var import_node_stream = require("stream");
+    var RequestError = class extends Error {
+      constructor(message, options) {
+        super(message, options);
+        this.name = "RequestError";
+      }
+    };
+    var validateRequestTarget = (target) => {
+      const backslash = target.indexOf("\\");
+      if (backslash !== -1) {
+        const query = target.indexOf("?");
+        if (query === -1 || backslash < query) {
+          throw new RequestError("Backslash in request path");
+        }
+      }
+    };
+    var toRequestError = (e) => {
+      if (e instanceof RequestError) {
+        return e;
+      }
+      return new RequestError(e.message, { cause: e });
+    };
+    var GlobalRequest = global.Request;
+    var Request2 = class extends GlobalRequest {
+      constructor(input, options) {
+        if (typeof input === "object" && getRequestCache in input) {
+          input = input[getRequestCache]();
+        }
+        if (typeof options?.body?.getReader !== "undefined") {
+          ;
+          options.duplex ??= "half";
+        }
+        super(input, options);
+      }
+    };
+    var newHeadersFromIncoming = (incoming) => {
+      const headerRecord = [];
+      const rawHeaders = incoming.rawHeaders;
+      for (let i = 0; i < rawHeaders.length; i += 2) {
+        const { [i]: key, [i + 1]: value } = rawHeaders;
+        if (key.charCodeAt(0) !== /*:*/
+        58) {
+          headerRecord.push([key, value]);
+        }
+      }
+      return new Headers(headerRecord);
+    };
+    var wrapBodyStream = Symbol("wrapBodyStream");
+    var newRequestFromIncoming = (method, url, headers, incoming, abortController) => {
+      const init = {
+        method,
+        headers,
+        signal: abortController.signal
+      };
+      if (method === "TRACE") {
+        init.method = "GET";
+        const req = new Request2(url, init);
+        Object.defineProperty(req, "method", {
+          get() {
+            return "TRACE";
+          }
+        });
+        return req;
+      }
+      if (!(method === "GET" || method === "HEAD")) {
+        if ("rawBody" in incoming && incoming.rawBody instanceof Buffer) {
+          init.body = new ReadableStream({
+            start(controller) {
+              controller.enqueue(incoming.rawBody);
+              controller.close();
+            }
+          });
+        } else if (incoming[wrapBodyStream]) {
+          let reader;
+          init.body = new ReadableStream({
+            async pull(controller) {
+              try {
+                reader ||= import_node_stream.Readable.toWeb(incoming).getReader();
+                const { done, value } = await reader.read();
+                if (done) {
+                  controller.close();
+                } else {
+                  controller.enqueue(value);
+                }
+              } catch (error) {
+                controller.error(error);
+              }
+            }
+          });
+        } else {
+          init.body = import_node_stream.Readable.toWeb(incoming);
+        }
+      }
+      return new Request2(url, init);
+    };
+    var getRequestCache = Symbol("getRequestCache");
+    var requestCache = Symbol("requestCache");
+    var incomingKey = Symbol("incomingKey");
+    var urlKey = Symbol("urlKey");
+    var headersKey = Symbol("headersKey");
+    var abortControllerKey = Symbol("abortControllerKey");
+    var getAbortController = Symbol("getAbortController");
+    var requestPrototype = {
+      get method() {
+        return this[incomingKey].method || "GET";
+      },
+      get url() {
+        return this[urlKey];
+      },
+      get headers() {
+        return this[headersKey] ||= newHeadersFromIncoming(this[incomingKey]);
+      },
+      [getAbortController]() {
+        this[getRequestCache]();
+        return this[abortControllerKey];
+      },
+      [getRequestCache]() {
+        this[abortControllerKey] ||= new AbortController();
+        return this[requestCache] ||= newRequestFromIncoming(
+          this.method,
+          this[urlKey],
+          this.headers,
+          this[incomingKey],
+          this[abortControllerKey]
+        );
+      }
+    };
+    [
+      "body",
+      "bodyUsed",
+      "cache",
+      "credentials",
+      "destination",
+      "integrity",
+      "mode",
+      "redirect",
+      "referrer",
+      "referrerPolicy",
+      "signal",
+      "keepalive"
+    ].forEach((k) => {
+      Object.defineProperty(requestPrototype, k, {
+        get() {
+          return this[getRequestCache]()[k];
+        }
+      });
+    });
+    ["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
+      Object.defineProperty(requestPrototype, k, {
+        value: function() {
+          return this[getRequestCache]()[k]();
+        }
+      });
+    });
+    Object.defineProperty(requestPrototype, Symbol.for("nodejs.util.inspect.custom"), {
+      value: function(depth, options, inspectFn) {
+        const props = {
+          method: this.method,
+          url: this.url,
+          headers: this.headers,
+          nativeRequest: this[requestCache]
+        };
+        return `Request (lightweight) ${inspectFn(props, { ...options, depth: depth == null ? null : depth - 1 })}`;
+      }
+    });
+    Object.setPrototypeOf(requestPrototype, Request2.prototype);
+    var newRequest = (incoming, defaultHostname) => {
+      const req = Object.create(requestPrototype);
+      req[incomingKey] = incoming;
+      const incomingUrl = incoming.url || "";
+      if (incomingUrl[0] !== "/" && // short-circuit for performance. most requests are relative URL.
+      (incomingUrl.startsWith("http://") || incomingUrl.startsWith("https://"))) {
+        if (incoming instanceof import_node_http2.Http2ServerRequest) {
+          throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
+        }
+        try {
+          validateRequestTarget(incomingUrl);
+          const url2 = new URL(incomingUrl);
+          req[urlKey] = url2.href;
+        } catch (e) {
+          throw new RequestError("Invalid absolute URL", { cause: e });
+        }
+        return req;
+      }
+      const host = (incoming instanceof import_node_http2.Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;
+      if (!host) {
+        throw new RequestError("Missing host header");
+      }
+      let scheme;
+      if (incoming instanceof import_node_http2.Http2ServerRequest) {
+        scheme = incoming.scheme;
+        if (!(scheme === "http" || scheme === "https")) {
+          throw new RequestError("Unsupported scheme");
+        }
+      } else {
+        scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
+      }
+      validateRequestTarget(incomingUrl);
+      const url = new URL(`${scheme}://${host}${incomingUrl}`);
+      if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) {
+        throw new RequestError("Invalid host header");
+      }
+      req[urlKey] = url.href;
+      return req;
+    };
+    var responseCache = Symbol("responseCache");
+    var getResponseCache = Symbol("getResponseCache");
+    var cacheKey = Symbol("cache");
+    var GlobalResponse = global.Response;
+    var Response2 = class _Response {
+      #body;
+      #init;
+      [getResponseCache]() {
+        delete this[cacheKey];
+        return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
+      }
+      constructor(body, init) {
+        let headers;
+        this.#body = body;
+        if (init instanceof _Response) {
+          const cachedGlobalResponse = init[responseCache];
+          if (cachedGlobalResponse) {
+            this.#init = cachedGlobalResponse;
+            this[getResponseCache]();
+            return;
+          } else {
+            this.#init = init.#init;
+            headers = new Headers(init.#init.headers);
+          }
+        } else {
+          this.#init = init;
+        }
+        if (typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) {
+          ;
+          this[cacheKey] = [init?.status || 200, body, headers || init?.headers];
+        }
+      }
+      get headers() {
+        const cache = this[cacheKey];
+        if (cache) {
+          if (!(cache[2] instanceof Headers)) {
+            cache[2] = new Headers(
+              cache[2] || { "content-type": "text/plain; charset=UTF-8" }
+            );
+          }
+          return cache[2];
+        }
+        return this[getResponseCache]().headers;
+      }
+      get status() {
+        return this[cacheKey]?.[0] ?? this[getResponseCache]().status;
+      }
+      get ok() {
+        const status = this.status;
+        return status >= 200 && status < 300;
+      }
+    };
+    ["body", "bodyUsed", "redirected", "statusText", "trailers", "type", "url"].forEach((k) => {
+      Object.defineProperty(Response2.prototype, k, {
+        get() {
+          return this[getResponseCache]()[k];
+        }
+      });
+    });
+    ["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
+      Object.defineProperty(Response2.prototype, k, {
+        value: function() {
+          return this[getResponseCache]()[k]();
+        }
+      });
+    });
+    Object.defineProperty(Response2.prototype, Symbol.for("nodejs.util.inspect.custom"), {
+      value: function(depth, options, inspectFn) {
+        const props = {
+          status: this.status,
+          headers: this.headers,
+          ok: this.ok,
+          nativeResponse: this[responseCache]
+        };
+        return `Response (lightweight) ${inspectFn(props, { ...options, depth: depth == null ? null : depth - 1 })}`;
+      }
+    });
+    Object.setPrototypeOf(Response2, GlobalResponse);
+    Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
+    async function readWithoutBlocking(readPromise) {
+      return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(void 0))]);
+    }
+    function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromise) {
+      const cancel = (error) => {
+        reader.cancel(error).catch(() => {
+        });
+      };
+      writable.on("close", cancel);
+      writable.on("error", cancel);
+      (currentReadPromise ?? reader.read()).then(flow, handleStreamError);
+      return reader.closed.finally(() => {
+        writable.off("close", cancel);
+        writable.off("error", cancel);
+      });
+      function handleStreamError(error) {
+        if (error) {
+          writable.destroy(error);
+        }
+      }
+      function onDrain() {
+        reader.read().then(flow, handleStreamError);
+      }
+      function flow({ done, value }) {
+        try {
+          if (done) {
+            writable.end();
+          } else if (!writable.write(value)) {
+            writable.once("drain", onDrain);
+          } else {
+            return reader.read().then(flow, handleStreamError);
+          }
+        } catch (e) {
+          handleStreamError(e);
+        }
+      }
+    }
+    function writeFromReadableStream(stream, writable) {
+      if (stream.locked) {
+        throw new TypeError("ReadableStream is locked.");
+      } else if (writable.destroyed) {
+        return;
+      }
+      return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
+    }
+    var buildOutgoingHttpHeaders = (headers) => {
+      const res = {};
+      if (!(headers instanceof Headers)) {
+        headers = new Headers(headers ?? void 0);
+      }
+      const cookies = [];
+      for (const [k, v] of headers) {
+        if (k === "set-cookie") {
+          cookies.push(v);
+        } else {
+          res[k] = v;
+        }
+      }
+      if (cookies.length > 0) {
+        res["set-cookie"] = cookies;
+      }
+      res["content-type"] ??= "text/plain; charset=UTF-8";
+      return res;
+    };
+    var X_ALREADY_SENT = "x-hono-already-sent";
+    var import_node_crypto = __toESM2(require("crypto"));
+    if (typeof global.crypto === "undefined") {
+      global.crypto = import_node_crypto.default;
+    }
+    var outgoingEnded = Symbol("outgoingEnded");
+    var incomingDraining = Symbol("incomingDraining");
+    var DRAIN_TIMEOUT_MS = 500;
+    var MAX_DRAIN_BYTES = 64 * 1024 * 1024;
+    var drainIncoming = (incoming) => {
+      const incomingWithDrainState = incoming;
+      if (incoming.destroyed || incomingWithDrainState[incomingDraining]) {
+        return;
+      }
+      incomingWithDrainState[incomingDraining] = true;
+      if (incoming instanceof import_node_http22.Http2ServerRequest) {
+        try {
+          ;
+          incoming.stream?.close?.(import_node_http22.constants.NGHTTP2_NO_ERROR);
+        } catch {
+        }
+        return;
+      }
+      let bytesRead = 0;
+      const cleanup = () => {
+        clearTimeout(timer);
+        incoming.off("data", onData);
+        incoming.off("end", cleanup);
+        incoming.off("error", cleanup);
+      };
+      const forceClose = () => {
+        cleanup();
+        const socket = incoming.socket;
+        if (socket && !socket.destroyed) {
+          socket.destroySoon();
+        }
+      };
+      const timer = setTimeout(forceClose, DRAIN_TIMEOUT_MS);
+      timer.unref?.();
+      const onData = (chunk) => {
+        bytesRead += chunk.length;
+        if (bytesRead > MAX_DRAIN_BYTES) {
+          forceClose();
+        }
+      };
+      incoming.on("data", onData);
+      incoming.on("end", cleanup);
+      incoming.on("error", cleanup);
+      incoming.resume();
+    };
+    var handleRequestError = () => new Response(null, {
+      status: 400
+    });
+    var handleFetchError = (e) => new Response(null, {
+      status: e instanceof Error && (e.name === "TimeoutError" || e.constructor.name === "TimeoutError") ? 504 : 500
+    });
+    var handleResponseError = (e, outgoing) => {
+      const err = e instanceof Error ? e : new Error("unknown error", { cause: e });
+      if (err.code === "ERR_STREAM_PREMATURE_CLOSE") {
+        console.info("The user aborted a request.");
+      } else {
+        console.error(e);
+        if (!outgoing.headersSent) {
+          outgoing.writeHead(500, { "Content-Type": "text/plain" });
+        }
+        outgoing.end(`Error: ${err.message}`);
+        outgoing.destroy(err);
+      }
+    };
+    var flushHeaders = (outgoing) => {
+      if ("flushHeaders" in outgoing && outgoing.writable) {
+        outgoing.flushHeaders();
+      }
+    };
+    var responseViaCache = async (res, outgoing) => {
+      let [status, body, header] = res[cacheKey];
+      let hasContentLength = false;
+      if (!header) {
+        header = { "content-type": "text/plain; charset=UTF-8" };
+      } else if (header instanceof Headers) {
+        hasContentLength = header.has("content-length");
+        header = buildOutgoingHttpHeaders(header);
+      } else if (Array.isArray(header)) {
+        const headerObj = new Headers(header);
+        hasContentLength = headerObj.has("content-length");
+        header = buildOutgoingHttpHeaders(headerObj);
+      } else {
+        for (const key in header) {
+          if (key.length === 14 && key.toLowerCase() === "content-length") {
+            hasContentLength = true;
+            break;
+          }
+        }
+      }
+      if (!hasContentLength) {
+        if (typeof body === "string") {
+          header["Content-Length"] = Buffer.byteLength(body);
+        } else if (body instanceof Uint8Array) {
+          header["Content-Length"] = body.byteLength;
+        } else if (body instanceof Blob) {
+          header["Content-Length"] = body.size;
+        }
+      }
+      outgoing.writeHead(status, header);
+      if (typeof body === "string" || body instanceof Uint8Array) {
+        outgoing.end(body);
+      } else if (body instanceof Blob) {
+        outgoing.end(new Uint8Array(await body.arrayBuffer()));
+      } else {
+        flushHeaders(outgoing);
+        await writeFromReadableStream(body, outgoing)?.catch(
+          (e) => handleResponseError(e, outgoing)
+        );
+      }
+      ;
+      outgoing[outgoingEnded]?.();
+    };
+    var isPromise = (res) => typeof res.then === "function";
+    var responseViaResponseObject = async (res, outgoing, options = {}) => {
+      if (isPromise(res)) {
+        if (options.errorHandler) {
+          try {
+            res = await res;
+          } catch (err) {
+            const errRes = await options.errorHandler(err);
+            if (!errRes) {
+              return;
+            }
+            res = errRes;
+          }
+        } else {
+          res = await res.catch(handleFetchError);
+        }
+      }
+      if (cacheKey in res) {
+        return responseViaCache(res, outgoing);
+      }
+      const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
+      if (res.body) {
+        const reader = res.body.getReader();
+        const values = [];
+        let done = false;
+        let currentReadPromise = void 0;
+        if (resHeaderRecord["transfer-encoding"] !== "chunked") {
+          let maxReadCount = 2;
+          for (let i = 0; i < maxReadCount; i++) {
+            currentReadPromise ||= reader.read();
+            const chunk = await readWithoutBlocking(currentReadPromise).catch((e) => {
+              console.error(e);
+              done = true;
+            });
+            if (!chunk) {
+              if (i === 1) {
+                await new Promise((resolve) => setTimeout(resolve));
+                maxReadCount = 3;
+                continue;
+              }
+              break;
+            }
+            currentReadPromise = void 0;
+            if (chunk.value) {
+              values.push(chunk.value);
+            }
+            if (chunk.done) {
+              done = true;
+              break;
+            }
+          }
+          if (done && !("content-length" in resHeaderRecord)) {
+            resHeaderRecord["content-length"] = values.reduce((acc, value) => acc + value.length, 0);
+          }
+        }
+        outgoing.writeHead(res.status, resHeaderRecord);
+        values.forEach((value) => {
+          ;
+          outgoing.write(value);
+        });
+        if (done) {
+          outgoing.end();
+        } else {
+          if (values.length === 0) {
+            flushHeaders(outgoing);
+          }
+          await writeFromReadableStreamDefaultReader(reader, outgoing, currentReadPromise);
+        }
+      } else if (resHeaderRecord[X_ALREADY_SENT]) {
+      } else {
+        outgoing.writeHead(res.status, resHeaderRecord);
+        outgoing.end();
+      }
+      ;
+      outgoing[outgoingEnded]?.();
+    };
+    var getRequestListener = (fetchCallback, options = {}) => {
+      const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
+      if (options.overrideGlobalObjects !== false && global.Request !== Request2) {
+        Object.defineProperty(global, "Request", {
+          value: Request2
+        });
+        Object.defineProperty(global, "Response", {
+          value: Response2
+        });
+      }
+      return async (incoming, outgoing) => {
+        let res, req;
+        try {
+          req = newRequest(incoming, options.hostname);
+          let incomingEnded = !autoCleanupIncoming || incoming.method === "GET" || incoming.method === "HEAD";
+          if (!incomingEnded) {
+            ;
+            incoming[wrapBodyStream] = true;
+            incoming.on("end", () => {
+              incomingEnded = true;
+            });
+            if (incoming instanceof import_node_http22.Http2ServerRequest) {
+              ;
+              outgoing[outgoingEnded] = () => {
+                if (!incomingEnded) {
+                  setTimeout(() => {
+                    if (!incomingEnded) {
+                      setTimeout(() => {
+                        drainIncoming(incoming);
+                      });
+                    }
+                  });
+                }
+              };
+            }
+            outgoing.on("finish", () => {
+              if (!incomingEnded) {
+                drainIncoming(incoming);
+              }
+            });
+          }
+          outgoing.on("close", () => {
+            const abortController = req[abortControllerKey];
+            if (abortController) {
+              if (incoming.errored) {
+                req[abortControllerKey].abort(incoming.errored.toString());
+              } else if (!outgoing.writableFinished) {
+                req[abortControllerKey].abort("Client connection prematurely closed.");
+              }
+            }
+            if (!incomingEnded) {
+              setTimeout(() => {
+                if (!incomingEnded) {
+                  setTimeout(() => {
+                    drainIncoming(incoming);
+                  });
+                }
+              });
+            }
+          });
+          res = fetchCallback(req, { incoming, outgoing });
+          if (cacheKey in res) {
+            return responseViaCache(res, outgoing);
+          }
+        } catch (e) {
+          if (!res) {
+            if (options.errorHandler) {
+              res = await options.errorHandler(req ? e : toRequestError(e));
+              if (!res) {
+                return;
+              }
+            } else if (!req) {
+              res = handleRequestError();
+            } else {
+              res = handleFetchError(e);
+            }
+          } else {
+            return handleResponseError(e, outgoing);
+          }
+        }
+        try {
+          return await responseViaResponseObject(res, outgoing, options);
+        } catch (e) {
+          return handleResponseError(e, outgoing);
+        }
+      };
+    };
+    var createAdaptorServer = (options) => {
+      const fetchCallback = options.fetch;
+      const requestListener = getRequestListener(fetchCallback, {
+        hostname: options.hostname,
+        overrideGlobalObjects: options.overrideGlobalObjects,
+        autoCleanupIncoming: options.autoCleanupIncoming
+      });
+      const createServer = options.createServer || import_node_http.createServer;
+      const server = createServer(options.serverOptions || {}, requestListener);
+      return server;
+    };
+    var serve = (options, listeningListener) => {
+      const server = createAdaptorServer(options);
+      server.listen(options?.port ?? 3e3, options.hostname, () => {
+        const serverInfo = server.address();
+        listeningListener && listeningListener(serverInfo);
+      });
+      return server;
+    };
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/server/hono/proxy.js
+var require_proxy = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/server/hono/proxy.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 __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    }();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.HonoProxy = void 0;
+    var pengueno_1 = require_dist2();
+    var AppLifetimeMetric = pengueno_1.Metric.fromName("HonoAppLifetime").asResult();
+    var AppRequestMetric = pengueno_1.Metric.fromName("HonoAppRequest");
+    var HonoProxy = class {
+      server;
+      app;
+      constructor(server) {
+        this.server = server;
+      }
+      async initializeApp() {
+        if (this.app)
+          return this.app;
+        const { Hono } = await Promise.resolve().then(() => __importStar(require_cjs()));
+        this.app = pengueno_1.LogMetricTraceable.of(new Hono()).flatMap(pengueno_1.TraceUtil.withTrace(`AppId = ${crypto.randomUUID()}`)).flatMap(pengueno_1.TraceUtil.withMetricTrace(AppLifetimeMetric));
+        return this.app;
+      }
+      async serve(port, hostname) {
+        const { serve } = await Promise.resolve().then(() => __importStar(require_dist()));
+        const app = await this.initializeApp();
+        return app.map((tApp) => pengueno_1.Either.fromFailable(() => {
+          const app2 = tApp.get();
+          app2.all("*", async (c) => tApp.flatMap(pengueno_1.TraceUtil.withMetricTrace(AppRequestMetric)).move(c.req).flatMap((tRequest) => pengueno_1.PenguenoRequest.from(tRequest)).map((req) => this.server.serve(req)).map(pengueno_1.TraceUtil.promiseify((tResponse) => {
+            tResponse.trace.trace(AppRequestMetric.count.withValue(1));
+            return new Response(tResponse.get().body(), tResponse.get());
+          })).get());
+          return serve({
+            fetch: (_r) => app2.fetch(_r),
+            port,
+            hostname
+          });
+        })).peek(pengueno_1.TraceUtil.traceResultingEither()).peek((tServe) => tServe.get().mapRight(() => tServe.trace.trace(`haii im still listening at http://${hostname}:${port} ~uwu dont think i forgot`))).map((tEitherServer) => tEitherServer.get().mapRight((server) => tEitherServer.move(server)).flatMapAsync((tServer) => pengueno_1.Signals.awaitClose(tServer))).peek(pengueno_1.TraceUtil.promiseify(pengueno_1.TraceUtil.traceResultingEither(AppLifetimeMetric))).get();
+      }
+    };
+    exports2.HonoProxy = HonoProxy;
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/server/hono/index.js
+var require_hono2 = __commonJS({
+  "node_modules/@emprespresso/pengueno/dist/server/hono/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_proxy(), 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);
+    __exportStar(require_hono2(), exports2);
+  }
+});
+
+// node_modules/@emprespresso/pengueno/dist/index.js
+var require_dist2 = __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);
+  }
+});
+
+// node_modules/@emprespresso/ci_model/dist/job/index.js
+var import_pengueno = __toESM(require_dist2(), 1);
+var JobTypes = [
+  "fetch_code",
+  "ci_pipeline",
+  "build_docker_image.js",
+  "ansible_playbook.js",
+  "checkout_ci.js",
+  "npm_publish.js",
+  "coolify_webhook.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);
+
+// node_modules/@emprespresso/ci_model/dist/pipeline/index.js
+var import_pengueno3 = __toESM(require_dist2(), 1);
+
+// node_modules/@emprespresso/ci_model/dist/pipeline/builder.js
+var BasePipelineBuilder = class {
+  stages = [];
+  addStage(stage) {
+    this.stages.push(stage);
+    return this;
+  }
+  build() {
+    return new PipelineImpl(this.stages);
+  }
+};
+var DefaultGitHookPipelineBuilder = class extends BasePipelineBuilder {
+  remoteUrl;
+  rev;
+  refname;
+  constructor(remoteUrl = process.env.remote, rev = process.env.rev, refname = process.env.refname) {
+    super();
+    this.remoteUrl = remoteUrl;
+    this.rev = rev;
+    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";
+  }
+  getRev() {
+    return this.rev;
+  }
+  getBranch() {
+    const branchRefPrefix = "refs/heads/";
+    return this.refname.split(branchRefPrefix).at(1);
+  }
+};
+
+// node_modules/@emprespresso/ci_model/dist/pipeline/impl.js
+var import_pengueno2 = __toESM(require_dist2(), 1);
+var PipelineImpl = class _PipelineImpl {
+  serialJobs;
+  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));
+  }
+};
+
+// node_modules/@emprespresso/ci_model/dist/pipeline/index.js
+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 REGISTRY = "img.liz.coffee";
+var NAMESPACE = "emprespresso";
+var IMG = "rookery";
+var getPipeline = () => {
+  const gitHookPipeline = new DefaultGitHookPipelineBuilder();
+  const branch = gitHookPipeline.getBranch();
+  if (!branch)
+    return gitHookPipeline.build();
+  const build = {
+    type: "build_docker_image.js",
+    arguments: {
+      context: gitHookPipeline.getSourceDestination(),
+      registry: REGISTRY,
+      namespace: NAMESPACE,
+      repository: IMG,
+      imageTag: branch,
+      commit: gitHookPipeline.getRev(),
+      buildTarget: IMG,
+      dockerfile: "Dockerfile"
+    }
+  };
+  gitHookPipeline.addStage({ parallelJobs: [build] });
+  return gitHookPipeline.build();
+};
+var main = () => {
+  const data = getPipeline().serialize();
+  process.stdout.write(data);
+};
+main();