@adhd/apigen-core-client 0.1.0

package/index.mjs

@@ -0,0 +1,1618 @@
+import { Project as te, Scope as R } from "ts-morph";
+import $e from "node:fs";
+import * as Ae from "node:path";
+import Q from "node:path";
+import { createParser as Pe, createFormatter as Ne, SchemaGenerator as Oe, AnnotatedType as ne, StringType as re } from "ts-json-schema-generator";
+const le = Symbol.for("adhd.apigen.extraction-session");
+function pe(e, t) {
+  const r = [
+    ...e.getImportDeclarations().map((o) => o.getModuleSpecifierSourceFile()),
+    ...e.getExportDeclarations().map((o) => o.getModuleSpecifierSourceFile())
+  ];
+  for (const o of r) {
+    if (!o)
+      continue;
+    const n = o.getFilePath();
+    if (!n.includes("/node_modules/") && !t.has(n)) {
+      t.add(n);
+      try {
+        o.refreshFromFileSystemSync();
+      } catch {
+      }
+      pe(o, t);
+    }
+  }
+}
+function me(e) {
+  try {
+    const t = $e.statSync(e);
+    return `${t.mtimeMs}:${t.size}`;
+  } catch {
+    return "nostat";
+  }
+}
+const I = /* @__PURE__ */ new Map(), B = /* @__PURE__ */ new Map();
+function Ee(e, t, r) {
+  const o = t ?? "", n = I.get(o);
+  let i = r;
+  if (n && n.fileVersions.size > 0) {
+    const c = [r], u = [...n.fileVersions.entries()].sort(
+      ([f], [l]) => f.localeCompare(l)
+    );
+    for (const [f, l] of u)
+      f !== e && c.push(`${f}:${l}`);
+    i = c.join("|");
+  }
+  const s = `${e}\0${t ?? ""}`;
+  let a = B.get(s);
+  return (!a || a.version !== i) && (a = { version: i, schemas: /* @__PURE__ */ new Map() }, B.set(s, a)), a.schemas;
+}
+function At() {
+  I.clear(), B.clear();
+}
+function ge() {
+  const e = {
+    projectsBuilt: 0,
+    generatorsBuilt: 0,
+    schemaCacheHits: 0,
+    schemaCacheMisses: 0
+  }, t = /* @__PURE__ */ new Map();
+  let r = !1;
+  return {
+    [le]: !0,
+    stats: e,
+    schemaCache: /* @__PURE__ */ new Map(),
+    aliasCache: /* @__PURE__ */ new WeakMap(),
+    zodImportCache: /* @__PURE__ */ new WeakMap(),
+    generatorCache: /* @__PURE__ */ new Map(),
+    projectFor(n) {
+      if (r)
+        throw new Error("apigen-core: ExtractionSession used after dispose()");
+      const i = n ?? "", s = n ? this.statVersion(n) : "";
+      let a = I.get(i);
+      return a && a.tsconfigVersion !== s && (a = void 0), a || (a = { project: n ? new te({
+        tsConfigFilePath: n,
+        skipAddingFilesFromTsConfig: !0
+      }) : new te({ skipAddingFilesFromTsConfig: !0 }), tsconfigVersion: s, fileVersions: /* @__PURE__ */ new Map() }, I.set(i, a), e.projectsBuilt++), a.project;
+    },
+    sourceFileFor(n, i) {
+      const s = this.projectFor(i), a = I.get(i ?? ""), c = this.statVersion(n);
+      let u = s.getSourceFile(n);
+      if (u === void 0 ? u = s.addSourceFileAtPath(n) : a && a.fileVersions.get(n) !== c && u.refreshFromFileSystemSync(), a == null || a.fileVersions.set(n, c), a) {
+        const f = /* @__PURE__ */ new Set([n]);
+        pe(u, f);
+        for (const l of f)
+          l !== n && a.fileVersions.set(l, this.statVersion(l));
+      }
+      return u;
+    },
+    statVersion(n) {
+      let i = t.get(n);
+      return i === void 0 && (i = me(n), t.set(n, i)), i;
+    },
+    dispose() {
+      r = !0, this.schemaCache.clear(), this.generatorCache.clear(), t.clear();
+    }
+  };
+}
+function de(e) {
+  const t = e;
+  if (t[le] !== !0)
+    throw new Error(
+      "apigen-core: unknown ExtractionSession implementation — create sessions with createExtractionSession()"
+    );
+  return t;
+}
+const z = "x-apigen-logical";
+function oe(e, t) {
+  const r = /* @__PURE__ */ new Set(), o = [e];
+  for (; o.length > 0; ) {
+    const n = o.pop();
+    if (!n || r.has(n))
+      continue;
+    r.add(n);
+    const i = n.$ref;
+    if (typeof i == "string") {
+      if (t) {
+        const l = t[i];
+        if (!l) {
+          const g = Object.keys(t).join(", ") || "(none)";
+          throw new Error(
+            `[apigen-logical] $ref "${i}" cannot be resolved. Available $defs: ${g}`
+          );
+        }
+        o.push(l);
+      }
+      continue;
+    }
+    const s = n.oneOf;
+    if (Array.isArray(s))
+      for (const l of s)
+        typeof l == "object" && l !== null && o.push(l);
+    const a = n.properties;
+    if (a)
+      for (const l of Object.values(a))
+        o.push(l);
+    const c = n.items;
+    if (Array.isArray(c))
+      for (const l of c)
+        typeof l == "object" && l !== null && o.push(l);
+    else
+      typeof c == "object" && c !== null && o.push(c);
+    const u = n.additionalProperties;
+    typeof u == "object" && u !== null && o.push(u);
+    const f = n.propertyNames;
+    typeof f == "object" && f !== null && o.push(f);
+  }
+}
+const ie = /* @__PURE__ */ new Set(["string", "number", "boolean", "integer"]);
+function ke(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" ? ie.has(r) : Array.isArray(r) ? r.every((o) => ie.has(o) || o === "null") : Array.isArray(t.enum) && t.enum.length > 0 ? t.enum.every((o) => ["string", "number", "boolean"].includes(typeof o)) : !1;
+}
+function Ce(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(
+    ke
+  );
+}
+function Ie(e) {
+  const t = {}, r = (o) => {
+    for (const n of ["definitions", "$defs"]) {
+      const i = o[n];
+      if (i)
+        for (const [s, a] of Object.entries(i)) {
+          const c = s.startsWith("#/") ? s : `#/${n}/${s}`;
+          t[c] = a;
+        }
+    }
+  };
+  for (const o of Object.values(e.schemas))
+    r(o.input), r(o.output);
+  if (Object.keys(t).length !== 0)
+    for (const [o, n] of Object.entries(e.schemas))
+      try {
+        oe(n.input, t), oe(n.output, t);
+      } catch (i) {
+        throw new Error(
+          `[apigen-core-client] Schema validation failed for function "${o}": ${i.message}`
+        );
+      }
+}
+function Fe(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((o) => `"${o}"`).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 Pt(e, t, r) {
+  Ie(e);
+  const o = {};
+  for (const [n, i] of Object.entries(e.schemas)) {
+    const s = (r == null ? void 0 : r[n]) ?? {}, a = i.input.properties ?? {}, c = i.input.required ?? [], u = {}, f = [];
+    for (const y of t)
+      if (y.envelope && s[y.id] !== !1)
+        for (const [h, T] of Object.entries(y.envelope))
+          u[h] = T, f.includes(h) || f.push(h);
+    const l = {
+      type: "object",
+      properties: a,
+      additionalProperties: !1,
+      ...c.length > 0 ? { required: c } : {}
+    }, g = i.safe === !0 || Ce(i.input), m = i.input.definitions, p = i.input.$defs;
+    o[n] = {
+      input: {
+        type: "object",
+        properties: { ...u, data: l },
+        required: [
+          ...f,
+          ...c.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: Fe(
+          Object.keys(u),
+          Object.keys(a).length > 0
+        ),
+        ...m ? { definitions: m } : {},
+        ...p ? { $defs: p } : {}
+      },
+      output: i.output,
+      // Carry the ctx-param flag through to dispatch (BUG-APIGEN-001).
+      ...i.hasCtx ? { hasCtx: !0 } : {},
+      "x-apigen-safe": g
+    };
+  }
+  return o;
+}
+const Re = 8;
+function Le(e, t) {
+  try {
+    return t ? e.getText(t) : e.getText();
+  } catch {
+    try {
+      return e.getText();
+    } catch {
+      return;
+    }
+  }
+}
+let _e = 0;
+async function Me(e, t, r, o) {
+  const n = `__ApigenProbe_${process.pid}_${_e++}`;
+  let i;
+  try {
+    i = t.addTypeAlias({ name: n, type: r });
+    const s = i.getType();
+    return await o(s);
+  } catch {
+    return;
+  } finally {
+    try {
+      i == null || i.remove();
+    } catch {
+    }
+  }
+}
+async function ye(e, t, r) {
+  if (r > Re)
+    return {};
+  if (e.isString() || e.isStringLiteral())
+    return e.isStringLiteral() ? { type: "string", enum: [e.getLiteralValue()] } : { type: "string" };
+  if (e.isNumber() || e.isNumberLiteral())
+    return e.isNumberLiteral() ? { type: "number", enum: [e.getLiteralValue()] } : { type: "number" };
+  if (e.isBoolean())
+    return { type: "boolean" };
+  if (e.isBooleanLiteral())
+    return { type: "boolean" };
+  if (e.isNull() || e.isUndefined() || e.isVoid())
+    return { type: "null" };
+  if (e.isUnion()) {
+    const o = e.getUnionTypes();
+    if (o.every((c) => c.isStringLiteral()) && o.length > 0)
+      return {
+        type: "string",
+        enum: o.map((c) => c.getLiteralValue())
+      };
+    if (o.every((c) => c.isNumberLiteral()) && o.length > 0)
+      return {
+        type: "number",
+        enum: o.map((c) => c.getLiteralValue())
+      };
+    const s = await Promise.all(
+      o.map((c) => ye(c, t, r + 1))
+    ), a = J(s);
+    return {
+      oneOf: s,
+      ...a ? { discriminator: a } : {},
+      [z]: "union"
+    };
+  }
+  if (e.isArray()) {
+    const o = e.getArrayElementType();
+    return { type: "array", items: o ? await t(o.getText()) : {} };
+  }
+  if (e.isTuple()) {
+    const o = e.getTupleElements(), n = await Promise.all(
+      o.map((i) => t(i.getText()))
+    );
+    return {
+      type: "array",
+      items: n,
+      minItems: n.length,
+      maxItems: n.length
+    };
+  }
+  if (e.isObject()) {
+    const o = e.getStringIndexType(), n = e.getNumberIndexType(), i = o ?? n, s = e.getProperties();
+    if (i && s.length === 0)
+      return { type: "object", additionalProperties: await t(i.getText()) };
+    const a = {};
+    for (const c of s) {
+      const u = c.getName(), l = c.getDeclarations()[0];
+      let g;
+      if (l)
+        try {
+          g = c.getTypeAtLocation(l);
+        } catch {
+          g = void 0;
+        }
+      if (g !== void 0 && g.getCallSignatures().length > 0)
+        continue;
+      const m = g !== void 0 ? Le(g, l) : void 0;
+      a[u] = m !== void 0 ? await t(m) : {};
+    }
+    return Object.keys(a).length > 0 ? { type: "object", properties: a } : {};
+  }
+  return {};
+}
+function J(e) {
+  if (e.length < 2)
+    return;
+  const t = [];
+  for (const o of e) {
+    if (o.type !== "object")
+      return;
+    const n = o.properties;
+    if (!n || typeof n != "object")
+      return;
+    t.push(n);
+  }
+  const r = Object.keys(t[0]).filter(
+    (o) => t.every((n) => Object.prototype.hasOwnProperty.call(n, o))
+  );
+  for (const o of r) {
+    const n = [];
+    let i = !0;
+    for (const a of t) {
+      const c = a[o], u = c && (c.type === "string" || c.type === "number"), f = c == null ? void 0 : c.enum;
+      if (!u || !Array.isArray(f) || f.length !== 1) {
+        i = !1;
+        break;
+      }
+      n.push(String(f[0]));
+    }
+    if (!i || new Set(n).size !== n.length)
+      continue;
+    const s = {};
+    return n.forEach((a, c) => {
+      s[a] = `#/oneOf/${c}`;
+    }), { propertyName: o, mapping: s };
+  }
+}
+function M(e, t, r) {
+  if (t > 6)
+    return {};
+  const o = e.trim();
+  if (o === "string")
+    return { type: "string" };
+  if (o === "number")
+    return { type: "number" };
+  if (o === "boolean")
+    return { type: "boolean" };
+  if (o === "null")
+    return { type: "null" };
+  if (o === "undefined")
+    return { type: "null" };
+  const n = U[o];
+  if (n !== void 0)
+    return n;
+  if (r != null && r.size) {
+    const i = r.get(o);
+    if (i !== void 0) {
+      const s = U[i];
+      if (s !== void 0)
+        return s;
+    }
+  }
+  if (o.endsWith("[]"))
+    return {
+      type: "array",
+      items: M(o.slice(0, -2), t + 1, r)
+    };
+  if (o.includes("|")) {
+    const i = o.split("|").map((c) => c.trim());
+    if (i.every((c) => c.startsWith("'")))
+      return { type: "string", enum: i.map((c) => c.replace(/'/g, "")) };
+    const s = i.map((c) => M(c, t + 1, r)), a = J(s);
+    return {
+      oneOf: s,
+      ...a ? { discriminator: a } : {},
+      [z]: "union"
+    };
+  }
+  if (o.startsWith("{") && o.endsWith("}")) {
+    const i = o.slice(1, -1).trim(), s = {};
+    for (const a of i.split(";").filter(Boolean)) {
+      const [c, u] = a.split(":").map((f) => f.trim());
+      c && u && (s[c.replace("?", "")] = M(u, t + 1, r));
+    }
+    return { type: "object", properties: s };
+  }
+  return {};
+}
+function he(e) {
+  const t = [];
+  let r = 0, o = 0;
+  for (let i = 0; i < e.length; i++) {
+    const s = e[i];
+    s === "<" || s === "[" || s === "{" || s === "(" ? r++ : s === ">" || s === "]" || s === "}" || s === ")" ? r-- : s === "," && r === 0 && (t.push(e.slice(o, i).trim()), o = i + 1);
+  }
+  const n = e.slice(o).trim();
+  return n.length > 0 && t.push(n), t;
+}
+function Ve(e) {
+  const t = /^(?:Readonly)?Map<(.+)>$/.exec(e);
+  return t ? t[1] : void 0;
+}
+function ze(e) {
+  const t = /^(?:Readonly)?Set<(.+)>$/.exec(e);
+  return t ? t[1] : void 0;
+}
+function Ke(e) {
+  let t = e.trim();
+  if (t.startsWith("readonly ") && (t = t.slice(9).trim()), !t.startsWith("[") || !t.endsWith("]"))
+    return;
+  const r = t.slice(1, -1).trim();
+  if (r.length !== 0)
+    return he(r);
+}
+async function De(e, t) {
+  const r = e.trim(), o = Ve(r);
+  if (o !== void 0) {
+    const s = he(o);
+    if (s.length === 2) {
+      const [a, c] = await Promise.all([
+        t(s[0]),
+        t(s[1])
+      ]);
+      return {
+        type: "array",
+        items: {
+          type: "array",
+          items: [a, c],
+          minItems: 2,
+          maxItems: 2
+        }
+      };
+    }
+  }
+  const n = ze(r);
+  if (n !== void 0)
+    return { type: "array", items: await t(n), uniqueItems: !0 };
+  const i = Ke(r);
+  if (i !== void 0) {
+    const s = await Promise.all(i.map((a) => t(a)));
+    return {
+      type: "array",
+      items: s,
+      minItems: s.length,
+      maxItems: s.length
+    };
+  }
+}
+const Te = {
+  "decimal.js": "Decimal"
+}, U = {
+  Date: { type: "string", format: "date-time" },
+  bigint: { type: "string", format: "int64" },
+  Uint8Array: { type: "string", format: "byte" },
+  Buffer: { type: "string", format: "byte" },
+  URL: { type: "string", format: "uri" },
+  RegExp: { type: "string", format: "regex" },
+  Decimal: { type: "string", format: "decimal" }
+}, se = {
+  Uint8Array: "byte",
+  Buffer: "byte",
+  Decimal: "decimal"
+};
+function ae(e) {
+  var r;
+  const t = /* @__PURE__ */ new Map();
+  for (const o of e.getImportDeclarations()) {
+    const n = o.getModuleSpecifierValue(), i = Te[n];
+    if (!i)
+      continue;
+    const s = o.getDefaultImport();
+    if (s) {
+      const a = s.getText();
+      a !== i && t.set(a, i);
+    }
+    for (const a of o.getNamedImports()) {
+      const c = ((r = a.getAliasNode()) == null ? void 0 : r.getText()) ?? a.getName();
+      c !== i && t.set(c, i);
+    }
+  }
+  return t;
+}
+function qe(e, t) {
+  return (r) => {
+    r.addNodeParser({
+      supportsNode(o) {
+        var i, s, a;
+        if (o.kind !== t)
+          return !1;
+        const n = ((i = o.typeName) == null ? void 0 : i.escapedText) ?? ((a = (s = o.typeName) == null ? void 0 : s.right) == null ? void 0 : a.escapedText);
+        return n !== void 0 && Object.prototype.hasOwnProperty.call(se, n);
+      },
+      createType(o) {
+        var i, s, a;
+        const n = ((i = o.typeName) == null ? void 0 : i.escapedText) ?? ((a = (s = o.typeName) == null ? void 0 : s.right) == null ? void 0 : a.escapedText);
+        return new ne(
+          new re(),
+          { format: se[n] },
+          !1
+        );
+      }
+    }), r.addNodeParser({
+      supportsNode(o) {
+        return o.kind === e;
+      },
+      createType() {
+        return new ne(new re(), { format: "int64" }, !1);
+      }
+    });
+  };
+}
+let k;
+function We() {
+  if (k)
+    return k;
+  try {
+    const e = Q.dirname(
+      require.resolve("ts-json-schema-generator/package.json")
+    );
+    k = require(require.resolve("typescript", {
+      paths: [e]
+    }));
+  } catch {
+    k = require("typescript");
+  }
+  return k;
+}
+const O = /* @__PURE__ */ new Map();
+function Be() {
+  const e = process.env.APIGEN_PROGRAM_CACHE, t = e === void 0 ? NaN : Number(e);
+  return Number.isFinite(t) && t >= 0 ? t : 8;
+}
+function Ue(e) {
+  const t = O.get(e);
+  return t && (O.delete(e), O.set(e, t)), t;
+}
+function Ge(e, t) {
+  const r = Be();
+  if (r !== 0)
+    for (O.delete(e), O.set(e, t); O.size > r; ) {
+      const o = O.keys().next().value;
+      O.delete(o);
+    }
+}
+function He(e, t) {
+  return `${e}\0${t ?? ""}`;
+}
+const Ze = /* @__PURE__ */ new Set(["zod", /^zod\/./]);
+function Qe(e) {
+  for (const t of e.getImportDeclarations()) {
+    const r = t.getModuleSpecifierValue();
+    for (const o of Ze)
+      if (typeof o == "string") {
+        if (r === o)
+          return !0;
+      } else if (o.test(r))
+        return !0;
+  }
+  return !1;
+}
+function Je(e) {
+  for (const t of ["$defs", "definitions"]) {
+    const r = e[t];
+    if (!r || typeof r != "object")
+      continue;
+    const o = Object.keys(r);
+    if (o.length === 0)
+      continue;
+    const n = new Set(o.filter((i) => /zod/i.test(i)));
+    for (const [i, s] of Object.entries(r)) {
+      if (n.has(i) || typeof s != "object" || s === null)
+        continue;
+      const a = s, c = typeof a.$ref == "string" ? a.$ref : "";
+      if (c) {
+        for (const u of n)
+          if (c.includes(u)) {
+            n.add(i);
+            break;
+          }
+      }
+    }
+    for (const i of n)
+      delete r[i];
+  }
+  G(e);
+}
+function G(e, t) {
+  if (!e || typeof e != "object")
+    return;
+  const r = t ?? /* @__PURE__ */ new WeakSet();
+  if (!r.has(e)) {
+    r.add(e);
+    for (const o of Object.keys(e))
+      if (o === "$ref" && typeof e[o] == "string") {
+        const n = e[o];
+        /zod/i.test(n) && delete e[o];
+      }
+    for (const [, o] of Object.entries(e))
+      if (typeof o == "object" && o !== null)
+        if (Array.isArray(o))
+          for (const n of o)
+            typeof n == "object" && n !== null && G(n, r);
+        else
+          G(o, r);
+  }
+}
+function Xe(e) {
+  const t = /* @__PURE__ */ new Set();
+  for (const o of ["$defs", "definitions"]) {
+    const n = e[o];
+    if (n && typeof n == "object")
+      for (const i of Object.keys(n))
+        t.add(i);
+  }
+  const r = H(e, t);
+  if (r.length > 0)
+    throw new Error(
+      `[apigen-core-client] Generated schema contains ${r.length} unresolvable $ref(s): ${r.join(", ")}. This usually means zod-internal definitions were stripped but $ref references to them remain. Check the source file's imports or the ts-json-schema-generator output.`
+    );
+}
+function H(e, t) {
+  if (!e || typeof e != "object")
+    return [];
+  const r = [];
+  for (const [o, n] of Object.entries(e))
+    if (o === "$ref" && typeof n == "string") {
+      const i = n.match(/#\/(?:\$defs|definitions)\/(.+)$/);
+      i && !t.has(i[1]) && r.push(n);
+    } else if (typeof n == "object" && n !== null)
+      if (Array.isArray(n))
+        for (const i of n)
+          typeof i == "object" && i !== null && r.push(
+            ...H(i, t)
+          );
+      else
+        r.push(
+          ...H(n, t)
+        );
+  return r;
+}
+function Ye(e) {
+  const t = e.anyOf;
+  if (!Array.isArray(t) || t.length < 2)
+    return e;
+  const r = t, o = J(r), n = { ...e };
+  return delete n.anyOf, {
+    ...n,
+    oneOf: r,
+    ...o ? { discriminator: o } : {},
+    [z]: n[z] ?? "union"
+  };
+}
+function et(e, t, r) {
+  const { DEFAULT_CONFIG: o } = require("ts-json-schema-generator/dist/src/Config.js"), n = { ...o, ...e }, i = n.path, s = He(i, n.tsconfig);
+  let a;
+  a = r ? r.statVersion(i) : me(i);
+  let c;
+  if (s !== void 0) {
+    const f = (r == null ? void 0 : r.generatorCache.get(s)) ?? Ue(s);
+    f && f.version === a && (c = f.gen);
+  }
+  if (!c) {
+    const { createProgram: f } = require("ts-json-schema-generator/dist/factory/program.js"), l = We(), g = qe(
+      l.SyntaxKind.BigIntKeyword,
+      l.SyntaxKind.TypeReference
+    ), m = f(n), p = Pe(
+      m,
+      n,
+      g
+    ), y = Ne(n);
+    if (c = new Oe(
+      m,
+      p,
+      y,
+      n
+    ), r && r.stats.generatorsBuilt++, s !== void 0 && a !== void 0) {
+      const h = { version: a, gen: c };
+      Ge(s, h), r == null || r.generatorCache.set(s, h);
+    }
+  }
+  const u = c.createSchema(n.type);
+  return Je(u), Xe(u), u;
+}
+function tt(e, t) {
+  let r = e.trim();
+  if (r = be(r), t != null && t.size) {
+    const n = t.get(r);
+    if (n !== void 0)
+      return n;
+  }
+  const o = r.match(/^ReadonlyArray<(.+)>$/);
+  for (o && (r = `${o[1].trim()}[]`); r.startsWith("readonly "); )
+    r = r.slice(9).trim();
+  return r;
+}
+function Se(e) {
+  return e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+const nt = Object.entries(Te).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\\(["'][^"']*${Se(e)}[^"']*["']\\)\\.\\w+`,
+    "g"
+  ),
+  key: t
+}));
+function be(e) {
+  let t = e;
+  for (const { pattern: r, key: o } of nt)
+    t = t.replace(r, o);
+  return t;
+}
+function rt(e, t) {
+  let r = be(e);
+  for (const [o, n] of t)
+    r = r.replace(
+      new RegExp(`\\b${Se(o)}\\b`, "g"),
+      n
+    );
+  return r;
+}
+async function A(e, t, r, o, n, i) {
+  const s = t.getFilePath(), a = `${s}\0${o ?? ""}\0${r}`, c = i ?? /* @__PURE__ */ new Set();
+  if (c.has(a))
+    return {};
+  if (!n) {
+    const p = new Set(c);
+    return p.add(a), ce(
+      e,
+      t,
+      r,
+      o,
+      void 0,
+      p
+    );
+  }
+  const u = n.schemaCache.get(a);
+  if (u !== void 0)
+    return n.stats.schemaCacheHits++, u;
+  const f = Ee(
+    s,
+    o,
+    n.statVersion(s)
+  ), l = f.get(r);
+  if (l !== void 0)
+    return n.stats.schemaCacheHits++, n.schemaCache.set(a, Promise.resolve(l)), l;
+  n.stats.schemaCacheMisses++;
+  const g = new Set(c);
+  g.add(a);
+  const m = ce(
+    e,
+    t,
+    r,
+    o,
+    n,
+    g
+  ).then((p) => (f.set(r, p), p)).catch((p) => {
+    throw n.schemaCache.delete(a), p;
+  });
+  return n.schemaCache.set(a, m), m;
+}
+async function ce(e, t, r, o, n, i) {
+  if (["void", "undefined", "null", "Promise<void>"].includes(r))
+    return { type: "null" };
+  let s;
+  if (n) {
+    const g = n.aliasCache.get(t);
+    s = g ?? ae(t), g || n.aliasCache.set(t, s);
+  } else
+    s = ae(t);
+  const a = tt(r, s), c = U[a];
+  if (c !== void 0)
+    return c;
+  const u = await De(
+    a,
+    (g) => A(e, t, g, o, n, i)
+  );
+  if (u !== void 0)
+    return u;
+  const f = (n == null ? void 0 : n.zodImportCache.get(t)) ?? Qe(t);
+  if (n && n.zodImportCache.set(t, f), !f)
+    try {
+      const g = {
+        path: t.getFilePath(),
+        type: a,
+        skipTypeCheck: !0,
+        tsconfig: o,
+        // BUG-APIGEN-026: ts-json-schema-generator's own default (topRef:
+        // true) wraps EVERY named-type schema as `{ $ref: "#/definitions/X",
+        // definitions: { X: {...} } }` instead of inlining it. This function
+        // returns that whole fragment, which `extract.ts` then splices into
+        // an arbitrarily nested property position inside a much larger
+        // composed function schema (see `compose-schemas.ts`'s `data`
+        // wrapper). JSON-Schema `$ref` resolution is root-relative to the
+        // document being compiled, NOT fragment-relative -- so a `$ref`
+        // sitting several levels deep, whose matching `definitions` sibling
+        // landed at that SAME nested depth (not the true document root),
+        // permanently dangles once AJV compiles the full composed schema
+        // (`validate-layer.ts`'s `ajv.compile(schema.input)`, one schema per
+        // function, no shared multi-schema registry to resolve against).
+        // `topRef: false` inlines the entry type directly instead, which
+        // eliminates the dangling ref for the common (non-recursive)
+        // named-type case. It does NOT fully solve genuinely self-
+        // referential/cyclic named types, which still need an internal
+        // `$ref` to model the cycle and would carry the identical class of
+        // bug if ever embedded nested -- that needs a proper
+        // dereference/hoist pass and is tracked separately, unresolved, in
+        // BUG-APIGEN-026's BACKLOG entry.
+        topRef: !1
+      }, m = et(g, !0, n);
+      return Ye(m);
+    } catch {
+    }
+  try {
+    const g = await Me(
+      e,
+      t,
+      a,
+      (m) => ye(
+        m,
+        (p) => A(e, t, p, o, n, i),
+        0
+      )
+    );
+    if (g !== void 0)
+      return g;
+  } catch {
+  }
+  const l = rt(a, s);
+  return M(l, 0, s);
+}
+function X(e, t, r) {
+  if (e != null && e.hasInitializer()) {
+    const o = e.getInitializer();
+    if (o)
+      return o.getText();
+  }
+  return ot(r, t);
+}
+function ot(e, t) {
+  var s;
+  const r = e, o = ((s = r == null ? void 0 : r.getJsDocs) == null ? void 0 : s.call(r)) ?? [], n = t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), i = new RegExp(`\\[\\s*${n}\\s*=\\s*([^\\]]+)\\]`);
+  for (const a of o)
+    for (const c of a.getTags()) {
+      if (c.getTagName() !== "param")
+        continue;
+      const u = c.getText().match(i);
+      if (u)
+        return u[1].trim();
+    }
+}
+function it(e) {
+  const t = e.trim(), r = t.match(/^(['"`])([\s\S]*)\1$/);
+  if (r)
+    return r[2];
+  if (t === "true")
+    return !0;
+  if (t === "false")
+    return !1;
+  if (t === "null")
+    return null;
+  if (t !== "undefined") {
+    if (/^-?\d+(\.\d+)?$/.test(t))
+      return Number(t);
+    try {
+      return JSON.parse(t);
+    } catch {
+      return t;
+    }
+  }
+}
+function st(e, t) {
+  const r = it(t);
+  if (r === void 0)
+    return;
+  e.default = r;
+  const o = typeof r == "string" ? r : JSON.stringify(r), n = typeof e.description == "string" ? e.description : void 0;
+  e.description = n ? `${n} (default: ${o})` : `(default: ${o})`;
+}
+async function Nt(e) {
+  const t = e.session === void 0, r = de(e.session ?? ge());
+  try {
+    return await at(e, r);
+  } finally {
+    t && r.dispose();
+  }
+}
+async function at(e, t) {
+  const { sourceFile: r, namespace: o = "", tsconfig: n } = e, i = t.projectFor(n), s = t.sourceFileFor(r, n), a = Q.basename(r), c = P(ft(a)), u = P(o), f = [];
+  for (const [m, p] of s.getExportedDeclarations()) {
+    if (m === "default" || _(m))
+      continue;
+    const y = pt(p);
+    if (y) {
+      const d = y.getSignature(), S = ue(d, y), b = d.getReturnType().getText();
+      f.push(
+        await L(
+          i,
+          s,
+          u,
+          c,
+          m,
+          S,
+          b,
+          y.isAsync(),
+          n,
+          t
+        )
+      );
+      continue;
+    }
+    const h = p.find(
+      (d) => d.getKindName() === "VariableDeclaration"
+    );
+    if (!h)
+      continue;
+    const T = h.getInitializer(), x = T == null ? void 0 : T.getKindName();
+    if (T && ["ArrowFunction", "FunctionExpression"].includes(x ?? "")) {
+      const S = h.getType().getCallSignatures();
+      if (S.length === 0)
+        continue;
+      const b = S[0], $ = fe(
+        b,
+        h,
+        h.getVariableStatement()
+      ), j = b.getReturnType().getText(), v = T.isAsync();
+      f.push(
+        await L(
+          i,
+          s,
+          u,
+          c,
+          m,
+          $,
+          j,
+          v,
+          n,
+          t
+        )
+      );
+    } else if (x === "ObjectLiteralExpression") {
+      const d = h.getType();
+      for (const S of d.getProperties()) {
+        const b = S.getName();
+        if (_(b))
+          continue;
+        const j = S.getTypeAtLocation(h).getCallSignatures();
+        if (j.length === 0)
+          continue;
+        const v = j[0], w = fe(
+          v,
+          h,
+          h.getVariableStatement()
+        ), F = v.getReturnType().getText(), K = [
+          c,
+          P(m),
+          P(b)
+        ];
+        f.push(
+          await V(
+            i,
+            s,
+            u,
+            K,
+            b,
+            w,
+            F,
+            !1,
+            n,
+            t
+          )
+        );
+      }
+    } else {
+      const d = h.getType(), S = d.getText();
+      if (E(d, h)) {
+        const b = await A(
+          i,
+          s,
+          S,
+          n,
+          t
+        );
+        f.push(
+          ut(u, c, m, b)
+        );
+      } else
+        console.warn(
+          `[apigen-core] Skipping non-callable, non-serializable export: ${m}`
+        );
+    }
+  }
+  const l = s.getDefaultExportSymbol();
+  if (l) {
+    const m = s.getExportAssignment((p) => !p.isExportEquals());
+    if (m) {
+      const p = m.getExpression(), y = p.getKindName();
+      if (["ArrowFunction", "FunctionExpression"].includes(y)) {
+        const T = p.getType().getCallSignatures();
+        if (T.length > 0) {
+          const x = T[0], d = D(x, m), S = x.getReturnType().getText(), b = p.isAsync();
+          f.push(
+            await L(
+              i,
+              s,
+              u,
+              c,
+              "default",
+              d,
+              S,
+              b,
+              n,
+              t
+            )
+          );
+        }
+      } else {
+        const h = p.getType();
+        for (const T of h.getProperties()) {
+          const x = T.getName();
+          if (_(x))
+            continue;
+          const S = T.getTypeAtLocation(m).getCallSignatures();
+          if (S.length === 0)
+            continue;
+          const b = S[0], $ = D(b, m), j = b.getReturnType().getText(), v = [
+            c,
+            P("default"),
+            P(x)
+          ];
+          f.push(
+            await V(
+              i,
+              s,
+              u,
+              v,
+              x,
+              $,
+              j,
+              !1,
+              n,
+              t
+            )
+          );
+        }
+      }
+    } else {
+      const p = l.getDeclarations();
+      for (const y of p) {
+        if (y.getKindName() !== "FunctionDeclaration")
+          continue;
+        const h = y, T = h.getName(), x = T && T.length > 0 ? T : "default", d = h.getSignature(), S = ue(d, h), b = d.getReturnType().getText();
+        f.push(
+          await L(
+            i,
+            s,
+            u,
+            c,
+            x,
+            S,
+            b,
+            h.isAsync(),
+            n,
+            t
+          )
+        );
+      }
+    }
+  }
+  const g = lt(s);
+  if (g.length > 0)
+    for (const { name: m, sig: p } of g) {
+      if (_(m))
+        continue;
+      const y = D(p), h = p.getReturnType().getText(), T = [c, P(m)];
+      f.push(
+        await V(
+          i,
+          s,
+          u,
+          T,
+          m,
+          y,
+          h,
+          !1,
+          n,
+          t
+        )
+      );
+    }
+  return f;
+}
+function ct(e, t, r, o) {
+  const n = /* @__PURE__ */ new Set(), i = (s) => {
+    if (Array.isArray(s))
+      return s.map(i);
+    if (!s || typeof s != "object" || n.has(s))
+      return s;
+    n.add(s);
+    try {
+      const a = s, c = {};
+      for (const [u, f] of Object.entries(a)) {
+        if (u === "definitions" || u === "$defs") {
+          const l = u, g = t[l];
+          for (const [m, p] of Object.entries(
+            f
+          )) {
+            const y = i(p), h = g[m];
+            if (h !== void 0 && JSON.stringify(h) !== JSON.stringify(y))
+              throw new Error(
+                `[apigen-core-client] Function "${r}": param "${o}" contributes a "${l}.${m}" definition that conflicts with an identically-named definition already hoisted from another param/output in the same function. Two structurally different types share the same generated definition key, so apigen cannot safely merge them into one function-level schema.`
+              );
+            g[m] = y;
+          }
+          continue;
+        }
+        c[u] = i(f);
+      }
+      return c;
+    } finally {
+      n.delete(s);
+    }
+  };
+  return i(e);
+}
+async function L(e, t, r, o, n, i, s, a, c, u) {
+  const f = P(n);
+  return V(
+    e,
+    t,
+    r,
+    [o, f],
+    n,
+    i,
+    s,
+    a,
+    c,
+    u
+  );
+}
+async function V(e, t, r, o, n, i, s, a, c, u) {
+  const f = i.length > 0 && i[0].name === "ctx", l = i.filter((d) => d.name !== "ctx"), g = l.filter((d) => !d.optional).map((d) => d.name), m = {}, p = {
+    definitions: {},
+    $defs: {}
+  };
+  for (const d of l) {
+    const S = await A(e, t, d.type, c, u), b = ct(S, p, n, d.name);
+    d.defaultValue !== void 0 && st(b, d.defaultValue), m[d.name] = b;
+  }
+  const y = s.replace(/^Promise<(.+)>$/, "$1").trim(), h = await A(
+    e,
+    t,
+    y,
+    c,
+    u
+  ), T = {
+    type: "object",
+    properties: m,
+    required: g,
+    // BUG-APIGEN-029: hoisted definitions from param fragments — see
+    // hoistNestedDefs. Only attached when non-empty so the common
+    // (no-recursive-type) case's schema shape is unchanged.
+    ...Object.keys(p.definitions).length > 0 ? { definitions: p.definitions } : {},
+    ...Object.keys(p.$defs).length > 0 ? { $defs: p.$defs } : {}
+  };
+  return {
+    id: xe(r, o),
+    host: "ts",
+    namespace: r,
+    path: o,
+    kind: "action",
+    async: a,
+    streaming: !1,
+    safe: !1,
+    // action → false per §4
+    input: T,
+    output: h,
+    envelope: {},
+    typeText: {
+      lang: "ts",
+      input: mt(i),
+      output: y
+    },
+    ...f ? { hasCtx: !0 } : {}
+  };
+}
+function ut(e, t, r, o) {
+  const n = P(r), i = [t, n];
+  return {
+    id: xe(e, i),
+    host: "ts",
+    namespace: e,
+    path: i,
+    kind: "query",
+    async: !1,
+    streaming: !1,
+    safe: !0,
+    // query → true per §4
+    input: { type: "object", properties: {}, required: [] },
+    output: o,
+    envelope: {},
+    typeText: null
+  };
+}
+function xe(e, t) {
+  return (e.raw ? [e, ...t] : t).map((o) => o.words.join("-")).join("/");
+}
+function ve(e) {
+  return e.split(/[-_.]+/).flatMap(
+    (t) => (
+      // Then split PascalCase / camelCase transitions
+      t.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z\d])([A-Z])/g, "$1_$2").split("_").filter(Boolean)
+    )
+  ).map((t) => t.toLowerCase()).filter(Boolean);
+}
+function P(e) {
+  return { raw: e, words: ve(e) };
+}
+function ft(e) {
+  return e.replace(/\.[^.]+$/, "").replace(/[._]+/g, "-");
+}
+function lt(e) {
+  const t = [];
+  for (const r of e.getStatements()) {
+    if (r.getKindName() !== "ExpressionStatement")
+      continue;
+    const o = r.getExpression();
+    if (o.getKindName() !== "BinaryExpression")
+      continue;
+    const n = o;
+    if (n.getLeft().getText().trim() !== "module.exports" || n.getOperatorToken().getKindName() !== "EqualsToken")
+      continue;
+    const s = n.getRight(), a = s.getType();
+    for (const c of a.getProperties()) {
+      const f = c.getTypeAtLocation(s).getCallSignatures();
+      f.length !== 0 && t.push({ name: c.getName(), sig: f[0] });
+    }
+  }
+  return t;
+}
+function pt(e) {
+  let t;
+  for (const r of e) {
+    if (r.getKindName() !== "FunctionDeclaration")
+      continue;
+    const o = r;
+    if (t || (t = o), o.getBody())
+      return o;
+  }
+  return t;
+}
+function ue(e, t) {
+  return e.getParameters().map((r) => {
+    var s;
+    const o = r.getDeclarations(), n = o.length > 0 && o[0].getKindName() === "Parameter" ? o[0] : null, i = r.isOptional() || ((n == null ? void 0 : n.hasInitializer()) ?? !1) || (((s = n == null ? void 0 : n.hasQuestionToken) == null ? void 0 : s.call(n)) ?? !1);
+    return {
+      name: r.getName(),
+      type: r.getTypeAtLocation(e.getDeclaration()).getText(),
+      optional: i,
+      defaultValue: X(n, r.getName(), t)
+    };
+  });
+}
+function fe(e, t, r) {
+  return e.getParameters().map((o) => {
+    var a;
+    const n = o.getDeclarations(), i = n.length > 0 && n[0].getKindName() === "Parameter" ? n[0] : null, s = o.isOptional() || ((i == null ? void 0 : i.hasInitializer()) ?? !1) || (((a = i == null ? void 0 : i.hasQuestionToken) == null ? void 0 : a.call(i)) ?? !1);
+    return {
+      name: o.getName(),
+      type: o.getTypeAtLocation(t).getText(),
+      optional: s,
+      defaultValue: X(
+        i,
+        o.getName(),
+        r ?? t
+      )
+    };
+  });
+}
+function D(e, t) {
+  return e.getParameters().map((r) => {
+    var s, a, c;
+    const o = r.getDeclarations(), n = o.length > 0 && o[0].getKindName() === "Parameter" ? o[0] : null, i = r.isOptional() || ((n == null ? void 0 : n.hasInitializer()) ?? !1) || (((s = n == null ? void 0 : n.hasQuestionToken) == null ? void 0 : s.call(n)) ?? !1);
+    return {
+      name: r.getName(),
+      type: n ? n.getType().getText() : ((c = (a = r.getValueDeclaration()) == null ? void 0 : a.getType()) == null ? void 0 : c.getText()) ?? "unknown",
+      optional: i,
+      defaultValue: X(n, r.getName(), t)
+    };
+  });
+}
+function mt(e) {
+  const t = e.filter((r) => r.name !== "ctx");
+  return t.length === 0 ? "()" : "(" + t.map((r) => `${r.name}${r.optional ? "?" : ""}: ${r.type}`).join(", ") + ")";
+}
+function _(e) {
+  return !!(e === "__samples__" || e.startsWith("__"));
+}
+function E(e, t, r = /* @__PURE__ */ new Set()) {
+  if (e.getCallSignatures().length > 0 || e.getConstructSignatures().length > 0)
+    return !1;
+  if (e.isString() || e.isNumber() || e.isBoolean() || e.isNull() || e.isUndefined() || e.isStringLiteral() || e.isNumberLiteral() || e.isBooleanLiteral() || e.isEnumLiteral())
+    return !0;
+  if (e.isArray() || e.isReadonlyArray()) {
+    const o = e.getArrayElementType();
+    return o ? E(o, t, r) : !1;
+  }
+  if (e.isTuple())
+    return e.getTupleElements().every((o) => E(o, t, r));
+  if (e.isUnion())
+    return e.getUnionTypes().every((o) => E(o, t, r));
+  if (e.isIntersection())
+    return e.getIntersectionTypes().every((o) => E(o, t, r));
+  if (e.isObject()) {
+    const o = e.getText(t);
+    if (r.has(o))
+      return !0;
+    r.add(o);
+    const n = e.getStringIndexType(), i = e.getNumberIndexType();
+    if (n || i)
+      return [n, i].every(
+        (a) => !a || E(a, t, r)
+      );
+    const s = e.getProperties();
+    return s.length === 0 ? !0 : s.every((a) => {
+      const c = a.getTypeAtLocation(t);
+      return E(c, t, r);
+    });
+  }
+  return !1;
+}
+async function Ot(e) {
+  const t = e.session === void 0, r = de(e.session ?? ge());
+  try {
+    return await gt(e, r);
+  } finally {
+    t && r.dispose();
+  }
+}
+async function gt(e, t) {
+  const {
+    sourceFile: r,
+    namespace: o = "",
+    tsconfig: n,
+    includeInstances: i = !1
+  } = e, s = t.projectFor(n), a = t.sourceFileFor(r, n), c = Q.basename(r), u = C(yt(c)), f = C(o), l = [];
+  for (const [g, m] of a.getExportedDeclarations()) {
+    const p = m.find(
+      (T) => T.getKindName() === "ClassDeclaration"
+    );
+    if (!p)
+      continue;
+    const y = g === "default" ? p.getName() : g;
+    if (!y || W(y))
+      continue;
+    const h = C(y);
+    for (const T of p.getStaticMethods()) {
+      const x = T.getName();
+      if (W(x))
+        continue;
+      const d = T.getScope();
+      if (d === R.Private || d === R.Protected)
+        continue;
+      const S = T.getSignature(), b = q(S, T), $ = S.getReturnType().getText(), j = T.isAsync(), v = [u, h, C(x)];
+      l.push(
+        await dt(
+          s,
+          a,
+          f,
+          v,
+          b,
+          $,
+          j,
+          n,
+          t
+        )
+      );
+    }
+    if (i) {
+      {
+        const x = p.getConstructors()[0] ?? null;
+        let d = [];
+        if (x) {
+          const w = x.getSignature();
+          d = q(w, x);
+        }
+        const S = [u, h], b = Z(f, S), $ = d.filter((w) => w.name !== "ctx"), j = $.filter((w) => !w.optional).map((w) => w.name), v = {};
+        for (const w of $)
+          v[w.name] = await A(
+            s,
+            a,
+            w.type,
+            n,
+            t
+          );
+        l.push({
+          id: b,
+          host: "ts",
+          namespace: f,
+          path: S,
+          kind: "constructor",
+          async: !1,
+          streaming: !1,
+          safe: !1,
+          input: { type: "object", properties: v, required: j },
+          output: {
+            type: "object",
+            properties: { instanceId: { type: "string" } },
+            required: ["instanceId"]
+          },
+          envelope: {},
+          typeText: {
+            lang: "ts",
+            input: ht(d),
+            output: "{ instanceId: string }"
+          }
+        });
+      }
+      for (const T of p.getInstanceMethods()) {
+        const x = T.getName();
+        if (W(x))
+          continue;
+        const d = T.getScope();
+        if (d === R.Private || d === R.Protected)
+          continue;
+        const S = T.getSignature(), b = q(S, T), $ = S.getReturnType().getText(), j = T.isAsync(), v = [u, h, C(x)], w = Z(f, v), F = b.filter((N) => N.name !== "ctx"), K = F.filter((N) => !N.optional).map((N) => N.name), Y = {};
+        for (const N of F)
+          Y[N.name] = await A(
+            s,
+            a,
+            N.type,
+            n,
+            t
+          );
+        const ee = $.replace(/^Promise<(.+)>$/, "$1").trim(), je = await A(
+          s,
+          a,
+          ee,
+          n,
+          t
+        );
+        l.push({
+          id: w,
+          host: "ts",
+          namespace: f,
+          path: v,
+          kind: "instance-method",
+          async: j,
+          streaming: !1,
+          safe: !1,
+          input: { type: "object", properties: Y, required: K },
+          output: je,
+          envelope: {
+            type: "object",
+            properties: { instanceId: { type: "string" } },
+            required: ["instanceId"]
+          },
+          typeText: {
+            lang: "ts",
+            input: we(b),
+            output: ee
+          }
+        });
+      }
+    }
+  }
+  return l;
+}
+async function dt(e, t, r, o, n, i, s, a, c) {
+  const u = n.filter((y) => y.name !== "ctx"), f = u.filter((y) => !y.optional).map((y) => y.name), l = {};
+  for (const y of u)
+    l[y.name] = await A(
+      e,
+      t,
+      y.type,
+      a,
+      c
+    );
+  const g = i.replace(/^Promise<(.+)>$/, "$1").trim(), m = await A(
+    e,
+    t,
+    g,
+    a,
+    c
+  );
+  return {
+    id: Z(r, o),
+    host: "ts",
+    namespace: r,
+    path: o,
+    kind: "action",
+    async: s,
+    streaming: !1,
+    safe: !1,
+    // action → false per §4
+    input: { type: "object", properties: l, required: f },
+    output: m,
+    envelope: {},
+    typeText: {
+      lang: "ts",
+      input: we(n),
+      output: g
+    }
+  };
+}
+function Z(e, t) {
+  return (e.raw ? [e, ...t] : t).map((o) => o.words.join("-")).join("/");
+}
+function C(e) {
+  return { raw: e, words: ve(e) };
+}
+function yt(e) {
+  return e.replace(/\.[^.]+$/, "").replace(/[._]+/g, "-");
+}
+function q(e, t) {
+  return e.getParameters().map((r) => {
+    var s;
+    const o = r.getDeclarations(), n = o.length > 0 && o[0].getKindName() === "Parameter" ? o[0] : null, i = r.isOptional() || ((n == null ? void 0 : n.hasInitializer()) ?? !1) || (((s = n == null ? void 0 : n.hasQuestionToken) == null ? void 0 : s.call(n)) ?? !1);
+    return {
+      name: r.getName(),
+      type: r.getTypeAtLocation(t).getText(),
+      optional: i
+    };
+  });
+}
+function we(e) {
+  const t = e.filter((r) => r.name !== "ctx");
+  return t.length === 0 ? "()" : "(" + t.map((r) => `${r.name}${r.optional ? "?" : ""}: ${r.type}`).join(", ") + ")";
+}
+function ht(e) {
+  return e.length === 0 ? "()" : "(" + e.map((t) => `${t.name}${t.optional ? "?" : ""}: ${t.type}`).join(", ") + ")";
+}
+function W(e) {
+  return !!(e === "__samples__" || e.startsWith("__") || e.startsWith("_"));
+}
+const Tt = /* @__PURE__ */ new Map([
+  // TypeScript variants
+  [".ts", "ts"],
+  [".tsx", "ts"],
+  [".mts", "ts"],
+  [".cts", "ts"],
+  // Python
+  [".py", "py"],
+  // Rust
+  [".rs", "rust"],
+  // Go
+  [".go", "go"],
+  // Java / Kotlin (both are JVM host languages for the purposes of routing)
+  [".java", "java"]
+]);
+function St(e) {
+  const t = Ae.extname(e).toLowerCase();
+  return Tt.get(t);
+}
+function bt(e) {
+  return e.language ?? "ts";
+}
+function xt(e, t) {
+  const r = St(t);
+  return r === void 0 ? !1 : r === bt(e);
+}
+function Et(e, t) {
+  return t.filter((r) => xt(e, r));
+}
+export {
+  At as clearPersistentProjectCache,
+  Pt as composeSchemas,
+  ge as createExtractionSession,
+  bt as effectiveLanguage,
+  Nt as extract,
+  Ot as extractClasses,
+  Ce as isPrimitiveOnlyInputSchema,
+  St as languageOfSource,
+  xt as pluginConsumesSource,
+  Et as sourcesForPlugin,
+  ve as tokenize
+};