@adhd/apigen-engine-runtime 0.1.0

package/index.mjs

@@ -0,0 +1,1398 @@
+import "ts-morph";
+import "node:fs";
+import "node:path";
+import "ts-json-schema-generator";
+import N from "pino";
+import ae from "ajv";
+import ce from "ajv-formats";
+const I = "$apigen";
+class K extends Error {
+  constructor(t) {
+    super(t), this.code = "E_DUP_CODEC", this.name = "CodecRegistryError";
+  }
+}
+function fe(e) {
+  const t = /* @__PURE__ */ new Map();
+  return {
+    register(r, n) {
+      if (t.has(r.id) && !(n != null && n.override))
+        throw new K(
+          `E_DUP_CODEC: a codec is already registered for id "${r.id}"`
+        );
+      t.set(r.id, r);
+    },
+    resolve(r) {
+      for (const n of t.values())
+        if (n.matches(r))
+          return n;
+    },
+    get(r) {
+      return t.get(r);
+    },
+    ids() {
+      return [...t.keys()];
+    },
+    freeze() {
+      const r = new Map(t), n = {
+        register() {
+          throw new K(
+            "E_DUP_CODEC: registry is frozen and cannot accept new codecs"
+          );
+        },
+        resolve(o) {
+          for (const i of r.values())
+            if (i.matches(o))
+              return i;
+        },
+        get(o) {
+          return r.get(o);
+        },
+        ids() {
+          return [...r.keys()];
+        },
+        freeze() {
+          return n;
+        }
+      };
+      return n;
+    }
+  };
+}
+const U = "x-apigen-logical", L = "x-apigen-codec", k = "x-apigen-ctor", x = "x-apigen-tojson", ue = "0.1.0";
+function V(e, t) {
+  return {
+    registry: e,
+    resolve: (r) => {
+      throw new Error(
+        `[apigen-logical] $ref "${r}" cannot be resolved in run-mode without a descriptor root. Supply a resolve() in the ctx override to handle $ref.`
+      );
+    },
+    seen: /* @__PURE__ */ new WeakSet(),
+    path: "",
+    mode: "strict",
+    ...t
+  };
+}
+function b(e, t, r) {
+  const n = r.registry.resolve(t);
+  if (n)
+    return n.encode(e, t, r);
+  const o = t.$ref;
+  if (typeof o == "string") {
+    const s = r.resolve(o);
+    return b(e, s, r);
+  }
+  const i = t.oneOf;
+  if (Array.isArray(i)) {
+    const s = te(e, i, t);
+    return b(e, s, r);
+  }
+  const a = t.type;
+  if (a === "array") {
+    if (!Array.isArray(e))
+      return j(e, t, r);
+    const s = t.items;
+    if (!s)
+      return e.map((c) => g(c));
+    const u = r.path;
+    return Array.isArray(s) ? e.map((c, f) => {
+      const d = s[f];
+      return d === void 0 ? g(c) : b(c, d, { ...r, path: `${u}/${f}` });
+    }) : e.map(
+      (c, f) => b(c, s, { ...r, path: `${u}/${f}` })
+    );
+  }
+  if (a === "object") {
+    if (e === null || typeof e != "object" || Array.isArray(e))
+      return j(e, t, r);
+    const s = t.properties;
+    if (!s)
+      return g(e);
+    const u = r.path, c = {};
+    for (const [f, d] of Object.entries(s)) {
+      const p = e[f];
+      p !== void 0 && (c[f] = b(p, d, {
+        ...r,
+        path: `${u}/${f}`
+      }));
+    }
+    return c;
+  }
+  return a == null ? j(e, t, r) : g(e);
+}
+function v(e, t, r) {
+  const n = r.registry.resolve(t);
+  if (n)
+    return n.decode(e, t, r);
+  const o = t.$ref;
+  if (typeof o == "string") {
+    const s = r.resolve(o);
+    return v(e, s, r);
+  }
+  const i = t.oneOf;
+  if (Array.isArray(i)) {
+    const s = te(e, i, t);
+    return v(e, s, r);
+  }
+  const a = t.type;
+  if (a === "array") {
+    if (!Array.isArray(e))
+      return e;
+    const s = t.items;
+    if (!s)
+      return e;
+    const u = r.path;
+    return Array.isArray(s) ? e.map((c, f) => {
+      const d = s[f];
+      return d === void 0 ? c : v(c, d, { ...r, path: `${u}/${f}` });
+    }) : e.map(
+      (c, f) => v(c, s, { ...r, path: `${u}/${f}` })
+    );
+  }
+  if (a === "object") {
+    if (e === null || typeof e != "object" || Array.isArray(e))
+      return e;
+    const s = t.properties;
+    if (!s)
+      return e;
+    const u = r.path, c = {};
+    for (const [f, d] of Object.entries(s)) {
+      const p = e[f];
+      p !== void 0 && (c[f] = v(p, d, {
+        ...r,
+        path: `${u}/${f}`
+      }));
+    }
+    return c;
+  }
+  return a == null ? de(e, r) : e;
+}
+function te(e, t, r, n) {
+  const o = r.discriminator;
+  if (o != null && o.propertyName) {
+    const i = e !== null && typeof e == "object" ? e[o.propertyName] : void 0;
+    if (typeof i == "string" && o.mapping) {
+      const a = o.mapping[i];
+      if (a) {
+        const s = t.find((u) => u.$ref === a);
+        if (s)
+          return s;
+      }
+    }
+  }
+  return t[0] ?? {};
+}
+function j(e, t, r) {
+  for (const n of r.registry.ids()) {
+    const o = r.registry.get(n);
+    if (o)
+      try {
+        const i = o.encode(e, o.schema, r);
+        return { [I]: n, v: i };
+      } catch {
+      }
+  }
+  return g(e);
+}
+function de(e, t) {
+  if (e !== null && typeof e == "object" && !Array.isArray(e) && I in e) {
+    const r = e, n = r[I], o = t.registry.get(n);
+    if (o)
+      return o.decode(r.v, o.schema, t);
+  }
+  return e;
+}
+function g(e) {
+  if (e === null || typeof e == "string" || typeof e == "number" || typeof e == "boolean")
+    return e;
+  if (Array.isArray(e))
+    return e.map(g);
+  if (typeof e == "object") {
+    const t = {};
+    for (const [r, n] of Object.entries(e))
+      n !== void 0 && (t[r] = g(n));
+    return t;
+  }
+  return null;
+}
+function pe(e) {
+  return {
+    encode(t, r, n) {
+      const o = V(e, n);
+      return b(t, r, o);
+    },
+    decode(t, r, n) {
+      const o = V(e, n);
+      return v(t, r, o);
+    }
+  };
+}
+const R = {
+  id: "date-time",
+  kind: "scalar",
+  schema: { type: "string", format: "date-time" },
+  matches(e) {
+    return e.type === "string" && e.format === "date-time";
+  },
+  encode(e, t, r) {
+    return e.toISOString();
+  },
+  decode(e, t, r) {
+    if (typeof e != "string") {
+      if (r.mode === "strict")
+        throw new TypeError(
+          `[date-time] expected a string on the wire at "${r.path}", got ${typeof e}`
+        );
+      return new Date(String(e));
+    }
+    if (r.mode === "strict" && Number.isNaN(new Date(e).getTime()))
+      throw new TypeError(
+        `[date-time] invalid date-time string at "${r.path}": ${JSON.stringify(e)}`
+      );
+    return new Date(e);
+  }
+}, P = {
+  id: "int64",
+  kind: "scalar",
+  schema: { type: "string", format: "int64" },
+  matches(e) {
+    return e.type === "string" && e.format === "int64";
+  },
+  encode(e, t, r) {
+    return String(e);
+  },
+  decode(e, t, r) {
+    if (typeof e != "string") {
+      if (r.mode === "strict")
+        throw new TypeError(
+          `[int64] expected a string on the wire at "${r.path}", got ${typeof e}`
+        );
+      try {
+        return BigInt(Math.trunc(Number(e)));
+      } catch {
+        return BigInt(0);
+      }
+    }
+    if (r.mode === "strict")
+      return BigInt(e);
+    if (/^-?\d+$/.test(e))
+      try {
+        return BigInt(e);
+      } catch {
+        return BigInt(0);
+      }
+    return BigInt(0);
+  }
+}, B = {
+  id: "decimal",
+  kind: "scalar",
+  schema: { type: "string", format: "decimal" },
+  matches(e) {
+    return e.type === "string" && e.format === "decimal";
+  },
+  encode(e, t, r) {
+    return e;
+  },
+  decode(e, t, r) {
+    if (typeof e != "string") {
+      if (r.mode === "strict")
+        throw new TypeError(
+          `[decimal] expected a string on the wire at "${r.path}", got ${typeof e}`
+        );
+      return String(e);
+    }
+    if (r.mode === "strict" && !/^-?\d+(\.\d+)?$/.test(e))
+      throw new TypeError(
+        `[decimal] wire value "${e}" at "${r.path}" is not a valid decimal string`
+      );
+    return e;
+  }
+}, q = {
+  id: "byte",
+  kind: "scalar",
+  schema: { type: "string", format: "byte" },
+  matches(e) {
+    return e.type === "string" && e.format === "byte";
+  },
+  encode(e, t, r) {
+    return Buffer.from(e).toString("base64");
+  },
+  decode(e, t, r) {
+    if (typeof e != "string") {
+      if (r.mode === "strict")
+        throw new TypeError(
+          `[byte] expected a base64 string on the wire at "${r.path}", got ${typeof e}`
+        );
+      return new Uint8Array(0);
+    }
+    if (r.mode === "strict" && !/^[A-Za-z0-9+/]*={0,2}$/.test(e))
+      throw new TypeError(
+        `[byte] wire value at "${r.path}" is not standard base64 (format:byte): "${e}"`
+      );
+    return new Uint8Array(Buffer.from(e, "base64"));
+  }
+}, le = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/, z = {
+  id: "uuid",
+  kind: "scalar",
+  schema: { type: "string", format: "uuid" },
+  matches(e) {
+    return e.type === "string" && e.format === "uuid";
+  },
+  encode(e, t, r) {
+    return e.toLowerCase();
+  },
+  decode(e, t, r) {
+    if (typeof e != "string") {
+      if (r.mode === "strict")
+        throw new TypeError(
+          `[uuid] expected a string on the wire at "${r.path}", got ${typeof e}`
+        );
+      return String(e).toLowerCase();
+    }
+    if (r.mode === "strict" && !le.test(e))
+      throw new TypeError(
+        `[uuid] wire value "${e}" at "${r.path}" is not a lowercase-hyphenated RFC 4122 UUID`
+      );
+    return e;
+  }
+}, C = "NaN", T = "Infinity", M = "-Infinity", ye = /* @__PURE__ */ new Set([
+  C,
+  T,
+  M
+]), F = {
+  id: "number-special",
+  kind: "scalar",
+  schema: { type: "number" },
+  matches(e) {
+    return e.type === "number" && e.format === void 0;
+  },
+  encode(e, t, r) {
+    return Number.isNaN(e) ? C : e === 1 / 0 ? T : e === -1 / 0 ? M : e;
+  },
+  decode(e, t, r) {
+    if (typeof e == "number")
+      return e;
+    if (typeof e == "string") {
+      if (e === C)
+        return NaN;
+      if (e === T)
+        return 1 / 0;
+      if (e === M)
+        return -1 / 0;
+      const n = Number(e);
+      if (!Number.isNaN(n))
+        return n;
+    }
+    if (r.mode === "strict")
+      throw new TypeError(
+        `[number-special] unrecognized wire value at "${r.path}": ${JSON.stringify(e)}. Expected a number or one of ${[...ye].join(", ")}.`
+      );
+    return NaN;
+  }
+}, he = [
+  R,
+  P,
+  B,
+  q,
+  z,
+  F
+];
+function me(e, t = {}) {
+  for (const r of he)
+    e.register(r, { override: t.override ?? !1 });
+}
+R.id, // 'date-time'
+P.id, // 'int64'
+B.id, // 'decimal'
+q.id, // 'byte'
+z.id, // 'uuid'
+F.id;
+const re = fe();
+me(re);
+const ne = pe(re.freeze());
+function ge(e, t) {
+  var n;
+  const r = ((n = e.input) == null ? void 0 : n.properties) ?? {};
+  return t in r;
+}
+function we(e) {
+  var r, n;
+  const t = (n = (r = e.input) == null ? void 0 : r.properties) == null ? void 0 : n.data;
+  return Object.keys((t == null ? void 0 : t.properties) ?? {});
+}
+function be(e, t) {
+  var o, i, a;
+  const r = (a = (i = (o = e.input) == null ? void 0 : o.properties) == null ? void 0 : i.data) == null ? void 0 : a.properties, n = r == null ? void 0 : r[t];
+  return n !== void 0 ? n : void 0;
+}
+function ve(e, t) {
+  return t === void 0 || e === void 0 ? e : ne.decode(e, t);
+}
+function _(e, t) {
+  const r = t.output;
+  return !r || Object.keys(r).length === 0 ? e : ne.encode(e, r);
+}
+async function $e(e, t, r, n, o, i) {
+  const s = we(r).map(
+    (c) => ve(i[c], be(r, c))
+  );
+  if (ge(r, "session") && t) {
+    const c = await t({ session: o.session }), f = await e[n](c, ...s);
+    return _(f, r);
+  }
+  if (r.hasCtx) {
+    const c = t ? await t(o) : void 0, f = await e[n](c, ...s);
+    return _(f, r);
+  }
+  const u = await e[n](...s);
+  return _(u, r);
+}
+class nt {
+  constructor() {
+    this._map = /* @__PURE__ */ new Map();
+  }
+  set(t, r) {
+    this._map.set(t, r);
+  }
+  get(t) {
+    return this._map.get(t);
+  }
+  /** Returns true when the token has a stored value. */
+  has(t) {
+    return this._map.has(t);
+  }
+}
+function ot(e = []) {
+  return async function(r, n, o) {
+    const i = o.schemas[r];
+    if (!i)
+      throw new Error(
+        `apigen/invoke: no schema found for operation "${r}"`
+      );
+    const a = () => $e(
+      o.fns,
+      o.createClient,
+      i,
+      r,
+      n.envelope,
+      n.domainArgs
+    );
+    return e.reduceRight(
+      (u, c) => () => c(n, u),
+      a
+    )();
+  };
+}
+function it(e) {
+  return e;
+}
+class Ne {
+  constructor() {
+    this.handlers = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a handler. Returns an unsubscribe function — handlers registered
+   * per-request/per-package MUST be removed (via the returned fn, {@link off},
+   * or {@link clear}) or they accumulate for the bus's lifetime.
+   */
+  on(t, r) {
+    const n = this.handlers.get(t) ?? [];
+    return this.handlers.set(t, [...n, r]), () => this.off(t, r);
+  }
+  /** Remove a previously registered handler (no-op if absent). */
+  off(t, r) {
+    const n = this.handlers.get(t);
+    if (!n)
+      return;
+    const o = n.filter((i) => i !== r);
+    o.length === 0 ? this.handlers.delete(t) : this.handlers.set(t, o);
+  }
+  /** Remove every handler — call on package/server teardown. */
+  clear() {
+    this.handlers.clear();
+  }
+  async emit(t) {
+    for (const [r, n] of this.handlers)
+      if (Ae(r, t))
+        for (const o of n)
+          await o(t);
+  }
+}
+function Ae(e, t) {
+  const [r, n, o] = e.split(":");
+  return !(r !== "*" && r !== t.module || n && n !== "*" && n !== t.method || o && o !== "*" && o !== t.lifecycle);
+}
+function Oe(e, t) {
+  for (const r of e)
+    if (r.eventMapping)
+      for (const [n, o] of Object.entries(r.eventMapping))
+        t.on(n, o);
+}
+async function je(e, t, r) {
+  let n = { ...t };
+  for (const o of e)
+    if (o.createContext) {
+      await r.emit({
+        module: o.id,
+        method: "createContext",
+        lifecycle: "start",
+        ctx: n
+      });
+      try {
+        const i = await o.createContext(n);
+        n = { ...n, ...i }, await r.emit({
+          module: o.id,
+          method: "createContext",
+          lifecycle: "complete",
+          ctx: n
+        });
+      } catch (i) {
+        throw await r.emit({
+          module: o.id,
+          method: "createContext",
+          lifecycle: "error",
+          ctx: n,
+          error: i
+        }), i;
+      }
+    }
+  return n;
+}
+function J(e, t) {
+  const r = /* @__PURE__ */ new Set(), n = [e];
+  for (; n.length > 0; ) {
+    const o = n.pop();
+    if (!o || r.has(o))
+      continue;
+    r.add(o);
+    const i = o.$ref;
+    if (typeof i == "string") {
+      if (t) {
+        const d = t[i];
+        if (!d) {
+          const p = Object.keys(t).join(", ") || "(none)";
+          throw new Error(
+            `[apigen-logical] $ref "${i}" cannot be resolved. Available $defs: ${p}`
+          );
+        }
+        n.push(d);
+      }
+      continue;
+    }
+    const a = o.oneOf;
+    if (Array.isArray(a))
+      for (const d of a)
+        typeof d == "object" && d !== null && n.push(d);
+    const s = o.properties;
+    if (s)
+      for (const d of Object.values(s))
+        n.push(d);
+    const u = o.items;
+    if (Array.isArray(u))
+      for (const d of u)
+        typeof d == "object" && d !== null && n.push(d);
+    else
+      typeof u == "object" && u !== null && n.push(u);
+    const c = o.additionalProperties;
+    typeof c == "object" && c !== null && n.push(c);
+    const f = o.propertyNames;
+    typeof f == "object" && f !== null && n.push(f);
+  }
+}
+const H = /* @__PURE__ */ new Set(["string", "number", "boolean", "integer"]);
+function _e(e) {
+  if (typeof e != "object" || e === null)
+    return !1;
+  const t = e;
+  if (t.$ref !== void 0 || t.oneOf || t.anyOf || t.allOf)
+    return !1;
+  const { type: r } = t;
+  return typeof r == "string" ? H.has(r) : Array.isArray(r) ? r.every((n) => H.has(n) || n === "null") : Array.isArray(t.enum) && t.enum.length > 0 ? t.enum.every((n) => ["string", "number", "boolean"].includes(typeof n)) : !1;
+}
+function Ee(e) {
+  if (!e || typeof e != "object")
+    return !1;
+  const t = e.properties;
+  return t === void 0 || typeof t != "object" || t === null ? !1 : Object.values(t).every(
+    _e
+  );
+}
+function Se(e) {
+  const t = {}, r = (n) => {
+    for (const o of ["definitions", "$defs"]) {
+      const i = n[o];
+      if (i)
+        for (const [a, s] of Object.entries(i)) {
+          const u = a.startsWith("#/") ? a : `#/${o}/${a}`;
+          t[u] = s;
+        }
+    }
+  };
+  for (const n of Object.values(e.schemas))
+    r(n.input), r(n.output);
+  if (Object.keys(t).length !== 0)
+    for (const [n, o] of Object.entries(e.schemas))
+      try {
+        J(o.input, t), J(o.output, t);
+      } catch (i) {
+        throw new Error(
+          `[apigen-core-client] Schema validation failed for function "${n}": ${i.message}`
+        );
+      }
+}
+function Ie(e, t) {
+  const r = [
+    'apigen calling convention: all domain parameters go inside a "data" envelope — e.g. { "data": { ... } }' + (t ? "." : " (an empty object for this zero-parameter tool).")
+  ];
+  return e.length > 0 && r.push(
+    `Field(s) ${e.map((n) => `"${n}"`).join(", ")} are transport-level envelope metadata, NOT domain data — do not nest them under "data". Over MCP they are read from arguments._meta["x-<pluginId>-<field>"] (default pluginId "adhd"); see @adhd/apigen-naming's envelopeMetaKey/envelopeCliFlag/envelopeEnvVar for the HTTP-header / CLI-flag / env-var equivalents.`
+  ), r.join(" ");
+}
+function ke(e, t, r) {
+  Se(e);
+  const n = {};
+  for (const [o, i] of Object.entries(e.schemas)) {
+    const a = (r == null ? void 0 : r[o]) ?? {}, s = i.input.properties ?? {}, u = i.input.required ?? [], c = {}, f = [];
+    for (const y of t)
+      if (y.envelope && a[y.id] !== !1)
+        for (const [h, O] of Object.entries(y.envelope))
+          c[h] = O, f.includes(h) || f.push(h);
+    const d = {
+      type: "object",
+      properties: s,
+      additionalProperties: !1,
+      ...u.length > 0 ? { required: u } : {}
+    }, p = i.safe === !0 || Ee(i.input), w = i.input.definitions, l = i.input.$defs;
+    n[o] = {
+      input: {
+        type: "object",
+        properties: { ...c, data: d },
+        required: [
+          ...f,
+          ...u.length > 0 ? ["data"] : []
+        ],
+        // BUG-APIGEN-017: reject any property that isn't a declared envelope
+        // field or the "data" wrapper — no silently-ignored junk params.
+        additionalProperties: !1,
+        // BUG-APIGEN-020: document the envelope/data calling convention inline.
+        description: Ie(
+          Object.keys(c),
+          Object.keys(s).length > 0
+        ),
+        ...w ? { definitions: w } : {},
+        ...l ? { $defs: l } : {}
+      },
+      output: i.output,
+      // Carry the ctx-param flag through to dispatch (BUG-APIGEN-001).
+      ...i.hasCtx ? { hasCtx: !0 } : {},
+      "x-apigen-safe": p
+    };
+  }
+  return n;
+}
+const xe = {
+  "decimal.js": "Decimal"
+};
+function Ce(e) {
+  return e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+Object.entries(xe).map(([e, t]) => ({
+  // Matches: import("...{modSpec}...").<anyMemberName>  (single or double quotes)
+  // The module specifier appears inside an absolute path, so we allow any
+  // characters between the quote and the specifier, and between the specifier
+  // and the closing quote. The trailing member accessor (`.default`, `.Decimal`,
+  // …) is matched generically (`\w+`) rather than anchored to one spelling —
+  // see the doc comment above for why.
+  pattern: new RegExp(
+    `import\\(["'][^"']*${Ce(e)}[^"']*["']\\)\\.\\w+`,
+    "g"
+  ),
+  key: t
+}));
+class D extends Error {
+  constructor(t) {
+    super(t), this.name = "ConfigurationError";
+  }
+}
+function Te(e) {
+  for (const t of e)
+    for (const r of Object.keys(t.eventMapping ?? {})) {
+      const [n] = r.split(":");
+      if (n !== "*" && n === t.id)
+        throw new D(
+          `Middleware "${t.id}" subscribes to its own events via "${r}". This would cause infinite recursion.`
+        );
+    }
+}
+function st(e) {
+  const {
+    domainSchemas: t,
+    middlewares: r,
+    overrides: n = {},
+    strict: o = !1
+  } = e;
+  Te(r);
+  for (const c of Object.keys(n))
+    if (!(c in t.schemas)) {
+      const f = `Override key "${c}" not found in domain schemas.`;
+      if (o)
+        throw new D(f);
+      console.warn("[apigen-runtime]", f);
+    }
+  const i = new Set(r.map((c) => c.id));
+  for (const [c, f] of Object.entries(n))
+    for (const d of Object.keys(f ?? {}))
+      if (!i.has(d)) {
+        const p = `Override key "${c}.${d}" does not match any declared middleware id.`;
+        if (o)
+          throw new D(p);
+        console.warn("[apigen-runtime]", p);
+      }
+  const a = ke(
+    t,
+    r,
+    n
+  ), s = new Ne();
+  return Oe(r, s), { schemas: a, createClient: async (c) => je(r, c, s), dispose: () => s.clear() };
+}
+function at(e = {}) {
+  const t = e.level ?? "info", r = typeof e.destination == "string" && e.destination.length > 0, n = !r && !!process.stderr.isTTY, o = e.format ?? (n ? "pretty" : "json"), i = { level: t };
+  if (o === "pretty")
+    return i.transport = {
+      target: "pino-pretty",
+      options: {
+        colorize: !r,
+        translateTime: "SYS:HH:MM:ss.l",
+        ignore: "pid,hostname",
+        ...r ? { destination: e.destination, mkdir: !0 } : { destination: 2 }
+      }
+    }, N(i);
+  const a = r ? N.destination({ dest: e.destination, mkdir: !0, sync: !0 }) : N.destination(2);
+  return N(i, a);
+}
+function oe(e) {
+  return e ? e.type === "array" ? `${oe(e.items)}[]` : e.enum ? "enum" : e.$ref ? String(e.$ref).split("/").pop() || "object" : e.anyOf || e.oneOf ? "union" : e.type ?? "object" : "unknown";
+}
+function ct(e) {
+  var s;
+  const r = (s = ((e == null ? void 0 : e.input) ?? {}).properties) == null ? void 0 : s.data, n = (r == null ? void 0 : r.properties) ?? {}, o = new Set((r == null ? void 0 : r.required) ?? []), i = Object.entries(n).map(([u, c]) => ({
+    name: u,
+    type: oe(c),
+    required: o.has(u)
+  })), a = i.map((u) => `${u.name}${u.required ? "" : "?"}: ${u.type}`).join(", ");
+  return { params: i, text: a };
+}
+function Me(e) {
+  let t;
+  return Array.isArray(e) ? t = e : e ? t = [e] : t = [], t.find((r) => r === "number" || r === "integer" || r === "boolean");
+}
+function ft(e, t) {
+  var i, a;
+  const n = ((a = (i = ((t == null ? void 0 : t.input) ?? {}).properties) == null ? void 0 : i.data) == null ? void 0 : a.properties) ?? {}, o = { ...e };
+  for (const [s, u] of Object.entries(n)) {
+    const c = o[s];
+    if (typeof c != "string")
+      continue;
+    const f = Me(u == null ? void 0 : u.type);
+    if (f === "number" || f === "integer") {
+      const d = Number(c);
+      !Number.isNaN(d) && c.trim() !== "" && (o[s] = d);
+    } else
+      f === "boolean" && (c === "true" ? o[s] = !0 : c === "false" && (o[s] = !1));
+  }
+  return o;
+}
+const G = /* @__PURE__ */ new Set(["default", "module.exports", "__esModule"]);
+function ut(e) {
+  const t = {}, r = (n, o) => {
+    for (const [i, a] of Object.entries(n))
+      if (typeof a == "function") {
+        !G.has(i) && !(i in t) && (t[i] = a);
+        const s = a.name;
+        s && !(s in t) && (t[s] = a);
+      } else
+        a && typeof a == "object" && o < 2 && G.has(i) && r(a, o + 1);
+  };
+  return r(e, 0), t;
+}
+const De = [
+  "invalid_argument",
+  "unauthenticated",
+  "permission_denied",
+  "not_found",
+  "internal"
+];
+class W extends Error {
+  constructor(t, r, n) {
+    super(r), this.name = "ApiError", this.code = t, this.details = n, Object.setPrototypeOf(this, new.target.prototype);
+  }
+  /** Serialise to a plain object suitable for JSON transport. */
+  toJSON() {
+    const t = {
+      code: this.code,
+      message: this.message
+    };
+    return this.details !== void 0 && (t.details = this.details), t;
+  }
+}
+function Ue(e) {
+  return typeof e == "object" && e !== null && e.name === "ApiError" && De.includes(e.code) && typeof e.toJSON == "function";
+}
+function Y(e, t, r = 0) {
+  return e === "before-first-chunk" ? { phase: e, error: t } : { phase: e, error: t, chunksDelivered: r };
+}
+const $ = new ae({ allErrors: !0 });
+ce($);
+for (const e of [
+  U,
+  L,
+  k,
+  x,
+  "discriminator"
+])
+  $.addKeyword({ keyword: e, valid: !0 });
+$.addFormat("decimal", /^[+-]?(?:\d+(?:\.\d+)?|\.\d+)$/);
+function ie(e) {
+  return e.map(
+    (t) => `${t.instancePath || "(root)"} ${t.message ?? "failed schema check"}`
+  ).join("; ");
+}
+const dt = async (e, t) => {
+  const r = e.ctx.get(Le);
+  if (r === void 0)
+    return t();
+  const n = e.operation.id, o = r[n];
+  if (o === void 0)
+    return t();
+  const i = {
+    data: e.domainArgs,
+    ...e.envelope
+  }, a = $.compile(o.input);
+  if (!a(i)) {
+    const u = a.errors ?? [];
+    throw new W(
+      "invalid_argument",
+      `Validation failed: ${ie(u)}`,
+      u
+    );
+  }
+  return t();
+}, Le = Symbol("ValidateSchemasToken");
+function pt(e) {
+  return async function(r, n) {
+    const o = r.operation.id, i = e[o];
+    if (i === void 0)
+      return n();
+    const a = {
+      data: r.domainArgs,
+      ...r.envelope
+    }, s = $.compile(i.input);
+    if (!s(a)) {
+      const c = s.errors ?? [];
+      throw new W(
+        "invalid_argument",
+        `Validation failed: ${ie(c)}`,
+        c
+      );
+    }
+    return n();
+  };
+}
+function Re() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (e) => {
+    const t = Math.random() * 16 | 0;
+    return (e === "x" ? t : t & 3 | 8).toString(16);
+  });
+}
+class lt {
+  constructor(t = {}) {
+    var n, o;
+    this._store = /* @__PURE__ */ new Map(), this._sweeper = null, this._defaultTtlMs = t.defaultTtlMs;
+    let r = null;
+    t.sweepIntervalMs === 0 ? r = null : t.sweepIntervalMs !== void 0 ? r = t.sweepIntervalMs : this._defaultTtlMs !== void 0 ? r = Math.max(1e3, Math.floor(this._defaultTtlMs / 4)) : r = null, r !== null && r > 0 && (this._sweeper = setInterval(() => this._sweep(), r), (o = (n = this._sweeper).unref) == null || o.call(n));
+  }
+  // ---------------------------------------------------------------------------
+  // create — construct + register
+  // ---------------------------------------------------------------------------
+  /**
+   * Construct an instance of `Ctor` with `args` and store it in the registry.
+   *
+   * @param Ctor  - The class to instantiate.
+   * @param args  - Constructor arguments (positional).
+   * @param ttlMs - Per-entry TTL override.  Falls back to `defaultTtlMs`.
+   * @returns `{ instanceId }` — pass this to `dispatch()` / `get()`.
+   */
+  create(t, r = [], n) {
+    const o = new t(...r), i = Re(), a = n ?? this._defaultTtlMs, s = a !== void 0 ? Date.now() + a : null;
+    return this._store.set(i, { instance: o, expiresAt: s }), { instanceId: i };
+  }
+  // ---------------------------------------------------------------------------
+  // get — retrieve a live instance
+  // ---------------------------------------------------------------------------
+  /**
+   * Retrieve the instance stored under `instanceId`.
+   *
+   * @throws When `instanceId` is unknown or the entry has expired.
+   */
+  get(t) {
+    const r = this._store.get(t);
+    if (!r)
+      throw new Error(
+        `[instance-registry] Unknown instanceId: "${t}"`
+      );
+    if (r.expiresAt !== null && Date.now() > r.expiresAt)
+      throw this._evict(t, r), new Error(
+        `[instance-registry] Instance "${t}" has expired`
+      );
+    return r.instance;
+  }
+  // ---------------------------------------------------------------------------
+  // dispatch — call a method on a live instance
+  // ---------------------------------------------------------------------------
+  /**
+   * Look up `instanceId` and call `method` on it with `args`.
+   *
+   * @throws When `instanceId` is unknown/expired, or `method` is not a function
+   *   on the instance.
+   */
+  async dispatch(t, r, n = []) {
+    const o = this.get(t), i = o[r];
+    if (typeof i != "function")
+      throw new Error(
+        `[instance-registry] Method "${r}" not found on instance "${t}"`
+      );
+    return i.call(o, ...n);
+  }
+  // ---------------------------------------------------------------------------
+  // dispose — explicit teardown
+  // ---------------------------------------------------------------------------
+  /**
+   * Remove `instanceId` from the registry and call `instance.dispose()` if the
+   * instance exposes one (opt-in lifecycle hook).
+   */
+  async dispose(t) {
+    const r = this._store.get(t);
+    r && (this._store.delete(t), await E(r.instance));
+  }
+  // ---------------------------------------------------------------------------
+  // disposeAll — full teardown
+  // ---------------------------------------------------------------------------
+  /**
+   * Dispose every live instance and stop the background sweeper.  Call this
+   * when the server is shutting down.
+   */
+  async disposeAll() {
+    this._sweeper !== null && (clearInterval(this._sweeper), this._sweeper = null);
+    const t = [...this._store.entries()];
+    this._store.clear(), await Promise.all(t.map(([, r]) => E(r.instance)));
+  }
+  // ---------------------------------------------------------------------------
+  // size — diagnostic helper
+  // ---------------------------------------------------------------------------
+  /** Number of live (non-expired) entries currently in the registry. */
+  get size() {
+    return this._store.size;
+  }
+  // ---------------------------------------------------------------------------
+  // Internal sweeper
+  // ---------------------------------------------------------------------------
+  _sweep() {
+    const t = Date.now();
+    for (const [r, n] of this._store)
+      n.expiresAt !== null && t > n.expiresAt && this._evict(r, n);
+  }
+  _evict(t, r) {
+    this._store.delete(t), E(r.instance);
+  }
+}
+async function E(e) {
+  if (e !== null && typeof e == "object" && "dispose" in e) {
+    const t = e.dispose;
+    typeof t == "function" && await t.call(e);
+  }
+}
+function yt(e) {
+  const { produce: t, signal: r } = e, n = r ?? new AbortController().signal;
+  return {
+    [Symbol.asyncIterator]() {
+      const o = t(n);
+      return {
+        async next() {
+          return n.aborted ? (await o.return(void 0), { done: !0, value: void 0 }) : o.next();
+        },
+        async return(i) {
+          return await o.return(i), { done: !0, value: void 0 };
+        },
+        async throw(i) {
+          return await o.throw(i), { done: !0, value: void 0 };
+        }
+      };
+    }
+  };
+}
+async function ht(e) {
+  const t = [];
+  for await (const r of e)
+    t.push(r);
+  return t;
+}
+async function mt(e) {
+  const t = [];
+  try {
+    for await (const r of e)
+      t.push(r);
+    return { ok: !0, chunks: t };
+  } catch (r) {
+    const n = Ue(r) ? r : new W(
+      "internal",
+      r instanceof Error ? r.message : String(r)
+    );
+    return t.length === 0 ? {
+      ok: !1,
+      carrier: Y("before-first-chunk", n)
+    } : {
+      ok: !1,
+      carrier: Y("after-first-chunk", n, t.length)
+    };
+  }
+}
+function gt(e) {
+  return e !== null && typeof e == "object" && Symbol.asyncIterator in e;
+}
+class m extends Error {
+  constructor(t, r) {
+    super(r), this.name = "UnionCodecError", this.code = t;
+  }
+}
+function S(e) {
+  const t = e.discriminator;
+  if (t === null || typeof t != "object" || Array.isArray(t))
+    return;
+  const r = t;
+  if (typeof r.propertyName != "string")
+    return;
+  const n = r.mapping;
+  if (!(n === null || typeof n != "object" || Array.isArray(n)))
+    return {
+      propertyName: r.propertyName,
+      mapping: n
+    };
+}
+function se(e, t) {
+  const r = e[L];
+  if (typeof r == "string") {
+    const n = t.registry.get(r);
+    if (n)
+      return n;
+  }
+  return t.registry.resolve(e);
+}
+function Pe(e, t, r) {
+  const n = se(t, r);
+  return n ? n.encode(e, t, r) : e;
+}
+function Be(e, t, r) {
+  const n = se(t, r);
+  return n ? n.decode(e, t, r) : e;
+}
+function qe(e) {
+  const { id: t, schema: r } = e;
+  return {
+    id: t,
+    kind: "union",
+    schema: r,
+    /**
+     * Structural ownership test: the node carries both `oneOf` (non-empty array)
+     * and `discriminator.propertyName`. The `x-apigen-logical:"union"` hint
+     * accelerates the match but is advisory — the structure is authoritative.
+     */
+    matches(n) {
+      if (n[U] === "union")
+        return !0;
+      const o = n.oneOf;
+      return !Array.isArray(o) || o.length === 0 ? !1 : S(n) !== void 0;
+    },
+    encode(n, o, i) {
+      const a = S(o);
+      if (!a)
+        throw new m(
+          "E_UNION_NO_DISCRIMINATOR",
+          `[${t}] schema node at "${i.path}" has no discriminator.propertyName; cannot dispatch union branch.`
+        );
+      const { propertyName: s, mapping: u } = a, c = n[s];
+      if (c == null)
+        throw new m(
+          "E_UNION_NO_DISCRIMINATOR",
+          `[${t}] value at "${i.path}" is missing the discriminator property "${s}".`
+        );
+      const f = String(c), d = u[f];
+      if (!d)
+        throw new m(
+          "E_UNION_UNKNOWN_TAG",
+          `[${t}] discriminator tag "${f}" at "${i.path}" is not in the mapping (known: ${Object.keys(u).join(", ")}).`
+        );
+      const p = i.resolve(d);
+      return Pe(n, p, {
+        ...i,
+        path: `${i.path}[${f}]`
+      });
+    },
+    decode(n, o, i) {
+      if (n === null || typeof n != "object" || Array.isArray(n)) {
+        let l;
+        throw n === null ? l = "null" : Array.isArray(n) ? l = "array" : l = typeof n, new m(
+          "E_UNION_INVALID_WIRE",
+          `[${t}] expected a JSON object on the wire at "${i.path}", got ${l}.`
+        );
+      }
+      const a = n, s = S(o);
+      if (!s)
+        throw new m(
+          "E_UNION_NO_DISCRIMINATOR",
+          `[${t}] schema node at "${i.path}" has no discriminator.propertyName; cannot dispatch union branch.`
+        );
+      const { propertyName: u, mapping: c } = s, f = a[u];
+      if (f == null)
+        throw new m(
+          "E_UNION_NO_DISCRIMINATOR",
+          `[${t}] wire object at "${i.path}" is missing the discriminator property "${u}".`
+        );
+      const d = String(f), p = c[d];
+      if (!p)
+        throw new m(
+          "E_UNION_UNKNOWN_TAG",
+          `[${t}] discriminator tag "${d}" on the wire at "${i.path}" is not in the mapping (known: ${Object.keys(c).join(", ")}).`
+        );
+      const w = i.resolve(p);
+      return Be(n, w, {
+        ...i,
+        path: `${i.path}[${d}]`
+      });
+    }
+  };
+}
+const ze = "x-apigen-instances";
+class A extends Error {
+  constructor(t, r) {
+    super(r), this.name = "NominalCodecError", this.code = t;
+  }
+}
+function Q(e) {
+  const t = e.properties;
+  return t && typeof t == "object" && !Array.isArray(t) ? t : {};
+}
+function Fe(e) {
+  const t = e.required;
+  return Array.isArray(t) ? t.filter((r) => typeof r == "string") : [];
+}
+function X(e, t, r) {
+  if (t) {
+    const n = r.registry.resolve(t);
+    if (n)
+      return n.encode(e, t, r);
+  }
+  return e;
+}
+function We(e, t, r) {
+  if (t) {
+    const n = r.registry.resolve(t);
+    if (n)
+      return n.decode(e, t, r);
+  }
+  return e;
+}
+function Ke(e) {
+  const { id: t, schema: r, ctor: n } = e;
+  return {
+    id: t,
+    kind: "nominal",
+    schema: r,
+    /**
+     * Structural ownership test: the node advertises `x-apigen-logical:'nominal'`
+     * or carries an `x-apigen-codec` matching this codec's id. Per
+     * `[inv:hints-advisory]` these are accelerators; a later structural fallback
+     * (object `$def` with `properties`) is the authoritative signal and is
+     * handled by the transcoder walk, not by this cheap test.
+     */
+    matches(o) {
+      return o[U] === "nominal" ? !0 : o[L] === t;
+    },
+    encode(o, i, a) {
+      if (o === null || typeof o != "object")
+        return o;
+      if (a.seen.has(o)) {
+        if (a.mode === "strict")
+          throw new A(
+            "E_NOMINAL_CYCLE",
+            `[${t}] cycle detected at "${a.path}": a nominal instance references itself. Strict mode rejects cycles (DESIGN §8.3); break the cycle or use 'lossy' mode.`
+          );
+        return null;
+      }
+      a.seen.add(o);
+      try {
+        const s = Q(i), u = typeof i[x] == "string" ? i[x] : "toJSON", c = o[u];
+        if (typeof c == "function") {
+          const l = c.call(o);
+          if (l !== null && typeof l == "object" && !Array.isArray(l)) {
+            const y = {};
+            for (const [h, O] of Object.entries(
+              l
+            ))
+              y[h] = X(O, s[h], {
+                ...a,
+                path: `${a.path}/${h}`
+              });
+            return y;
+          }
+          return l;
+        }
+        const f = {}, d = Object.keys(s), p = o, w = d.length > 0 ? d : Object.keys(p);
+        for (const l of w) {
+          const y = p[l];
+          y !== void 0 && (f[l] = X(y, s[l], {
+            ...a,
+            path: `${a.path}/${l}`
+          }));
+        }
+        return f;
+      } finally {
+        a.seen.delete(o);
+      }
+    },
+    decode(o, i, a) {
+      if (o === null || typeof o != "object" || Array.isArray(o)) {
+        let f;
+        throw o === null ? f = "null" : Array.isArray(o) ? f = "array" : f = typeof o, new A(
+          "E_NOMINAL_INVALID_WIRE",
+          `[${t}] expected a JSON object on the wire at "${a.path}", got ${f}.`
+        );
+      }
+      const s = o;
+      for (const f of Fe(i))
+        if (!(f in s))
+          throw new A(
+            "E_NOMINAL_INVALID_WIRE",
+            `[${t}] required field "${f}" missing on the wire at "${a.path}".`
+          );
+      if (i[ze] === !1)
+        throw new A(
+          "E_NOMINAL_NONRECONSTRUCTABLE",
+          `[${t}] is encode-only: the extractor marked it non-reconstructable (x-apigen-instances:false). It cannot be decoded back to a live instance.`
+        );
+      const u = Q(i), c = {};
+      for (const [f, d] of Object.entries(s))
+        c[f] = We(d, u[f], {
+          ...a,
+          path: `${a.path}/${f}`
+        });
+      if (n) {
+        const f = typeof i[k] == "string" ? i[k] : "fromJSON", d = n[f];
+        if (typeof d == "function")
+          return d.call(
+            n,
+            c
+          );
+        const p = n;
+        return new p(c);
+      }
+      return c;
+    }
+  };
+}
+const Ve = [
+  R,
+  P,
+  B,
+  q,
+  z,
+  F
+], Je = {
+  type: "object",
+  "x-apigen-logical": "nominal",
+  "x-apigen-codec": "ts.NominalSentinel"
+}, Z = Ke({
+  id: "ts.NominalSentinel",
+  schema: Je
+}), He = {
+  oneOf: [],
+  discriminator: { propertyName: "kind", mapping: {} },
+  "x-apigen-logical": "union",
+  "x-apigen-codec": "ts.UnionSentinel"
+}, ee = qe({
+  id: "ts.UnionSentinel",
+  schema: He
+});
+function Ge() {
+  const e = [
+    // 6 well-known scalars
+    ...Ve.map((t) => [
+      t.id,
+      t
+    ]),
+    // nominal kind sentinel
+    [Z.id, Z],
+    // union kind sentinel
+    [ee.id, ee]
+  ];
+  return Object.freeze(new Map(e));
+}
+const wt = Object.freeze({
+  host: "ts",
+  logicalTypeVersion: ue,
+  codecs: Ge()
+});
+function bt(e, t, r) {
+  var i;
+  const n = typeof ((i = t == null ? void 0 : t.input) == null ? void 0 : i.description) == "string" ? t.input.description : void 0, o = [r, n].filter(
+    (a) => typeof a == "string" && a.length > 0
+  );
+  return o.length > 0 ? o.join(" — ") : e;
+}
+function vt(e) {
+  if (!e || typeof e != "object" || Array.isArray(e) || Object.keys(e).length === 0)
+    return { outputSchema: void 0, wrapped: !1 };
+  const t = e;
+  return t.type === "object" ? { outputSchema: t, wrapped: !1 } : {
+    outputSchema: {
+      type: "object",
+      properties: { result: t },
+      required: ["result"]
+    },
+    wrapped: !0
+  };
+}
+function $t(e, t) {
+  return e ? { result: t } : t && typeof t == "object" && !Array.isArray(t) ? t : void 0;
+}
+export {
+  Ne as EventBus,
+  lt as InstanceRegistry,
+  nt as LayerContext,
+  m as UnionCodecError,
+  Le as ValidateSchemasToken,
+  Ve as WELL_KNOWN_TS_CODECS,
+  Te as assertNoSelfSubscription,
+  je as buildContext,
+  ut as buildFnTable,
+  vt as buildMcpOutputSchema,
+  bt as buildToolDescription,
+  ft as coerceQueryParams,
+  mt as collectWithPhase,
+  st as createApiPackage,
+  ot as createInvoker,
+  at as createLogger,
+  yt as createStream,
+  qe as createUnionCodec,
+  we as dataParamNames,
+  it as defineMiddleware,
+  ct as describeParams,
+  $e as dispatch,
+  ht as drainStream,
+  gt as isApiStream,
+  pt as makeValidateLayer,
+  ge as needsEnvelopeField,
+  wt as tsHostBinding,
+  dt as validateLayer,
+  Oe as wireObservers,
+  $t as wrapMcpStructuredContent
+};