@emeryld/rrroutes-contract 2.7.12 → 2.8.0

package/dist/index.mjs

@@ -42,9 +42,9 @@ function collectNestedFieldSuggestions(shape, prefix = []) {
   }
   return suggestions;
 }
-function compilePath(path4, params) {
-  if (!params) return path4;
-  const withParams = path4.replace(/:([A-Za-z0-9_]+)/g, (_, k) => {
+function compilePath(path, params) {
+  if (!params) return path;
+  const withParams = path.replace(/:([A-Za-z0-9_]+)/g, (_, k) => {
     const v = params[k];
     if (v === void 0 || v === null) throw new Error(`Missing param :${k}`);
     return String(v);
@@ -119,8 +119,8 @@ function buildLowProfileLeaf(leaf) {
     }
   };
 }
-var keyOf = (method, path4, encodeSafe) => {
-  const key = `${method.toUpperCase()} ${path4}`;
+var keyOf = (method, path, encodeSafe) => {
+  const key = `${method.toUpperCase()} ${path}`;
   return encodeSafe ? encodeURIComponent(key) : key;
 };
 
@@ -296,8 +296,8 @@ function joinPaths(parent, child) {
   if (!trimmedChild) return trimmedParent;
   return `${trimmedParent}/${trimmedChild}`;
 }
-function assertDynamicLayerUniqueness(path4, dynamicLayerMap) {
-  const segments = path4.split("/").filter(Boolean);
+function assertDynamicLayerUniqueness(path, dynamicLayerMap) {
+  const segments = path.split("/").filter(Boolean);
   if (segments.length === 0) return;
   for (let i = 0; i < segments.length; i++) {
     const segment = segments[i];
@@ -335,1350 +335,21 @@ function finalize(leaves) {
 function defineSocketEvents(config, events) {
   return { config, events };
 }
-
-// src/export/schemaIntrospection.ts
-import * as z3 from "zod";
-var serializableSchemaKinds = [
-  "object",
-  "string",
-  "number",
-  "boolean",
-  "bigint",
-  "date",
-  "array",
-  "enum",
-  "literal",
-  "union",
-  "record",
-  "tuple",
-  "unknown",
-  "any"
-];
-var globalHandlers = {};
-function registerSchemaIntrospectionHandler(kind, handler) {
-  globalHandlers[kind] = handler;
-}
-function clearSchemaIntrospectionHandlers() {
-  for (const key of Object.keys(globalHandlers)) {
-    delete globalHandlers[key];
-  }
-}
-function getDef(schema) {
-  if (!schema || typeof schema !== "object") return void 0;
-  const anySchema = schema;
-  return anySchema._zod?.def ?? anySchema._def;
-}
-function getDescription(schema) {
-  const anyZ = z3;
-  const registry = anyZ.globalRegistry?.get ? anyZ.globalRegistry.get(schema) : void 0;
-  if (registry && typeof registry.description === "string") {
-    return registry.description;
-  }
-  const def = getDef(schema);
-  if (def && typeof def.description === "string") {
-    return def.description;
-  }
-  return void 0;
-}
-function unwrap(schema) {
-  let current = schema;
-  let optional = false;
-  let nullable = false;
-  const ZodEffectsCtor = z3.ZodEffects;
-  while (true) {
-    if (ZodEffectsCtor && current instanceof ZodEffectsCtor) {
-      const def = getDef(current) || {};
-      const sourceType = typeof current.sourceType === "function" ? current.sourceType() : def.schema;
-      if (!sourceType) break;
-      current = sourceType;
-      continue;
-    }
-    if (current instanceof z3.ZodOptional) {
-      optional = true;
-      const def = getDef(current);
-      current = def && def.innerType || current;
-      continue;
-    }
-    if (current instanceof z3.ZodNullable) {
-      nullable = true;
-      const def = getDef(current);
-      current = def && def.innerType || current;
-      continue;
-    }
-    if (current instanceof z3.ZodDefault) {
-      const def = getDef(current);
-      current = def && def.innerType || current;
-      continue;
-    }
-    break;
-  }
-  return { base: current, optional, nullable };
-}
-function mergeProps(a, b) {
-  if (!a && !b) return void 0;
-  return { ...a ?? {}, ...b ?? {} };
-}
-function inferKind(schema) {
-  if (schema instanceof z3.ZodString) return "string";
-  if (schema instanceof z3.ZodNumber) return "number";
-  if (schema instanceof z3.ZodBoolean) return "boolean";
-  if (schema instanceof z3.ZodBigInt) return "bigint";
-  if (schema instanceof z3.ZodDate) return "date";
-  if (schema instanceof z3.ZodArray) return "array";
-  if (schema instanceof z3.ZodObject) return "object";
-  if (schema instanceof z3.ZodUnion) return "union";
-  if (schema instanceof z3.ZodLiteral) return "literal";
-  if (schema instanceof z3.ZodEnum) return "enum";
-  if (schema instanceof z3.ZodRecord) return "record";
-  if (schema instanceof z3.ZodTuple) return "tuple";
-  if (schema instanceof z3.ZodUnknown) return "unknown";
-  if (schema instanceof z3.ZodAny) return "any";
-  return "unknown";
-}
-var defaultHandlers = {
-  intersection({ base, def, node }, ctx) {
-    const left = def?.left;
-    const right = def?.right;
-    const leftNode = left ? ctx.introspect(left) : void 0;
-    const rightNode = right ? ctx.introspect(right) : void 0;
-    const leftIsObj = leftNode?.kind === "object" && !!leftNode.properties;
-    const rightIsObj = rightNode?.kind === "object" && !!rightNode.properties;
-    if (leftIsObj && rightIsObj) {
-      node.kind = "object";
-      node.description = node.description ?? leftNode.description ?? rightNode.description;
-      node.properties = mergeProps(leftNode.properties, rightNode.properties);
-      return node;
-    }
-    if (leftNode && rightNode) {
-      node.properties = {
-        left: leftNode,
-        right: rightNode
-      };
-    }
-    return node;
-  },
-  object({ base, def, node }, ctx) {
-    const rawShape = base.shape ?? (def && typeof def.shape === "function" ? def.shape() : def?.shape);
-    const shape = typeof rawShape === "function" ? rawShape() : rawShape ?? {};
-    const props = {};
-    for (const key of Object.keys(shape)) {
-      const child = shape[key];
-      const childNode = ctx.introspect(child);
-      if (childNode) props[key] = childNode;
-    }
-    node.properties = props;
-    return node;
-  },
-  array({ def, node }, ctx) {
-    const inner = def && def.element || def && def.type || void 0;
-    if (inner) {
-      node.element = ctx.introspect(inner);
-    }
-    return node;
-  },
-  union({ def, node }, ctx) {
-    const options = def && def.options || [];
-    node.union = options.map((opt) => ctx.introspect(opt)).filter(Boolean);
-    return node;
-  },
-  literal({ def, node }) {
-    if (def) {
-      if (Array.isArray(def.values)) {
-        node.literal = def.values.length === 1 ? def.values[0] : def.values.slice();
-      } else {
-        node.literal = def.value;
-      }
-    }
-    return node;
-  },
-  enum({ def, node }) {
-    if (def) {
-      if (Array.isArray(def.values)) {
-        node.enumValues = def.values.slice();
-      } else if (def.entries && typeof def.entries === "object") {
-        node.enumValues = Object.values(def.entries).map((v) => String(v));
-      }
-    }
-    return node;
-  }
-};
-function createSchemaIntrospector(options = {}) {
-  const handlers = {
-    ...defaultHandlers,
-    ...globalHandlers,
-    ...options.handlers ?? {}
-  };
-  const introspect = (schema) => {
-    if (!schema) return void 0;
-    const unwrapped = unwrap(schema);
-    const base = unwrapped.base;
-    const def = getDef(base);
-    const kind = base instanceof z3.ZodIntersection ? "intersection" : inferKind(base);
-    const node = {
-      kind: kind === "intersection" ? "unknown" : kind,
-      optional: unwrapped.optional || void 0,
-      nullable: unwrapped.nullable || void 0,
-      description: getDescription(base)
-    };
-    const handler = handlers[kind];
-    if (!handler) return node;
-    return handler(
-      {
-        schema,
-        base,
-        def,
-        kind,
-        optional: unwrapped.optional,
-        nullable: unwrapped.nullable,
-        node
-      },
-      {
-        zod: z3,
-        introspect,
-        getDef,
-        unwrap,
-        getDescription
-      }
-    );
-  };
-  return introspect;
-}
-function introspectSchema(schema, options = {}) {
-  const introspect = createSchemaIntrospector(options);
-  return introspect(schema);
-}
-
-// src/export/serializeLeafContract.ts
-function serializeContractSchema(schema, options) {
-  return schema ? introspectSchema(routeSchemaParse(schema), options) : void 0;
-}
-function serializeBodyFiles(cfg) {
-  if (!Array.isArray(cfg.bodyFiles) || cfg.bodyFiles.length === 0) {
-    return void 0;
-  }
-  return cfg.bodyFiles.map(({ name, maxCount }) => ({ name, maxCount }));
-}
-function serializeLeafContract(leaf, options = {}) {
-  const cfg = leaf.cfg;
-  return {
-    key: `${leaf.method.toUpperCase()} ${leaf.path}`,
-    method: leaf.method,
-    path: leaf.path,
-    cfg: {
-      description: cfg.description,
-      summary: cfg.summary,
-      docsGroup: cfg.docsGroup,
-      tags: Array.isArray(cfg.tags) ? cfg.tags.slice() : void 0,
-      deprecated: cfg.deprecated,
-      stability: cfg.stability,
-      docsHidden: cfg.docsHidden,
-      docsMeta: cfg.docsMeta,
-      feed: cfg.feed,
-      bodyFiles: serializeBodyFiles(cfg),
-      schemas: {
-        body: serializeContractSchema(cfg.bodySchema, options),
-        query: serializeContractSchema(cfg.querySchema, options),
-        params: serializeContractSchema(cfg.paramsSchema, options),
-        output: serializeContractSchema(cfg.outputSchema, options),
-        outputMeta: serializeContractSchema(cfg.outputMetaSchema, options),
-        queryExtension: serializeContractSchema(cfg.queryExtensionSchema, options)
-      }
-    }
-  };
-}
-function serializeLeavesContract(leaves, options = {}) {
-  return leaves.map((leaf) => serializeLeafContract(leaf, options));
-}
-
-// src/export/flattenSchema.ts
-function formatLiteralType(literal) {
-  if (typeof literal === "string") return literal;
-  if (typeof literal === "number" || typeof literal === "boolean" || typeof literal === "bigint") {
-    return String(literal);
-  }
-  if (literal === null) return "null";
-  if (Array.isArray(literal)) {
-    return literal.map((item) => formatLiteralType(item)).join("|");
-  }
-  if (typeof literal === "object") {
-    try {
-      return JSON.stringify(literal);
-    } catch {
-      return "object";
-    }
-  }
-  return "unknown";
-}
-function normalizeType(schema) {
-  switch (schema.kind) {
-    case "string":
-    case "number":
-    case "date":
-    case "boolean":
-    case "object":
-    case "array":
-      return schema.kind;
-    case "enum": {
-      if (Array.isArray(schema.enumValues) && schema.enumValues.length > 0) {
-        return schema.enumValues.join("|");
-      }
-      return "unknown";
-    }
-    case "literal": {
-      return formatLiteralType(schema.literal);
-    }
-    default:
-      return "unknown";
-  }
-}
-function isNonEmptyPath(path4) {
-  return typeof path4 === "string" && path4.length > 0;
-}
-function setNode(out, path4, schema, inherited) {
-  if (!isNonEmptyPath(path4)) return;
-  out[path4] = {
-    type: normalizeType(schema),
-    nullable: inherited.nullable || Boolean(schema.nullable),
-    optional: inherited.optional || Boolean(schema.optional),
-    literal: schema.kind === "literal" ? schema.literal : void 0
-  };
-}
-function flattenInto(out, schema, path4, inherited) {
-  if (!schema || !isNonEmptyPath(path4)) return;
-  const nextInherited = {
-    optional: inherited.optional || Boolean(schema.optional),
-    nullable: inherited.nullable || Boolean(schema.nullable)
-  };
-  if (schema.kind === "union" && Array.isArray(schema.union) && schema.union.length > 0) {
-    schema.union.forEach((option, index) => {
-      const optionPath = `${path4}-${index + 1}`;
-      flattenInto(out, option, optionPath, inherited);
-    });
-    return;
-  }
-  setNode(out, path4, schema, inherited);
-  if (schema.kind === "object" && schema.properties) {
-    for (const [key, child] of Object.entries(schema.properties)) {
-      const childPath = `${path4}.${key}`;
-      flattenInto(out, child, childPath, nextInherited);
-    }
-    return;
-  }
-  if (schema.kind === "array" && schema.element) {
-    flattenInto(out, schema.element, `${path4}[]`, nextInherited);
-  }
-}
-function flattenSerializableSchema(schema, path4) {
-  const out = {};
-  flattenInto(out, schema, path4, { optional: false, nullable: false });
-  return out;
-}
-function isSerializedLeaf(value) {
-  if (!value || typeof value !== "object") return false;
-  const item = value;
-  return typeof item.key === "string" && !!item.cfg && typeof item.cfg === "object";
-}
-function flattenLeafSchemas(leaf) {
-  const serialized = isSerializedLeaf(leaf) ? leaf : serializeLeafContract(leaf);
-  const out = {};
-  const sections = serialized.cfg.schemas;
-  Object.assign(out, flattenSerializableSchema(sections.params, "params"));
-  Object.assign(out, flattenSerializableSchema(sections.query, "query"));
-  Object.assign(out, flattenSerializableSchema(sections.body, "body"));
-  Object.assign(out, flattenSerializableSchema(sections.output, "output"));
-  return out;
-}
-
-// src/export/exportFinalizedLeaves.ts
-import fs from "fs/promises";
-import path2 from "path";
-import { spawn } from "child_process";
-
-// src/export/defaultViewerTemplate.ts
-var DEFAULT_VIEWER_TEMPLATE = `<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Finalized Leaves Viewer</title>
-    <style>
-      :root {
-        --bg: #212121;
-        --surface: #2a2a2a;
-        --border: #4a4a4a;
-        --text: #fffafa;
-        --muted: #c8c2c2;
-        --accent: #a764d3;
-      }
-      body {
-        margin: 0;
-        font-family: 'Iosevka Web', 'SFMono-Regular', Menlo, Consolas, monospace;
-        color: var(--text);
-        background: var(--bg);
-      }
-      .wrap { max-width: 1100px; margin: 0 auto; padding: 20px; }
-      .card { background: var(--surface); border: 1px solid var(--border); border-radius: 12px; padding: 14px; }
-      .meta { color: var(--muted); font-size: 12px; }
-      #results { margin-top: 12px; display: grid; gap: 8px; }
-      details { background: var(--surface); border: 1px solid var(--border); border-radius: 10px; padding: 8px 10px; }
-      summary { cursor: pointer; font-weight: 700; color: var(--accent); }
-      pre { margin: 10px 0 0; overflow: auto; border: 1px solid var(--border); border-radius: 8px; padding: 10px; background: #303030; color: var(--text); }
-    </style>
-  </head>
-  <body>
-    <div class="wrap">
-      <h1>Finalized Leaves Viewer (Baked)</h1>
-      <div class="card">
-        <div id="status" class="meta">Waiting for baked payload...</div>
-      </div>
-      <div id="results"></div>
-    </div>
-
-    <!--__FINALIZED_LEAVES_BAKED_PAYLOAD__-->
-
-    <script>
-      const statusEl = document.getElementById('status')
-      const resultsEl = document.getElementById('results')
-      const payload = window.__FINALIZED_LEAVES_PAYLOAD
-
-      if (!payload || !Array.isArray(payload.leaves)) {
-        statusEl.textContent = 'No baked payload found in this HTML file.'
-      } else {
-        statusEl.textContent =           'Loaded baked payload with ' + payload.leaves.length + ' routes.'
-
-        const toHref = (source) => {
-          if (!source || !source.file) return null
-          const normalizedPath = String(source.file).replace(/\\\\/g, '/')
-          const platform =
-            (navigator.userAgentData && navigator.userAgentData.platform) ||
-            navigator.platform ||
-            ''
-          const isWindows = /win/i.test(platform)
-          const vscodePath = isWindows
-            ? normalizedPath.replace(/^\\/+/, '')
-            : normalizedPath.startsWith('/')
-              ? normalizedPath
-              : '/' + normalizedPath
-          const line = Number.isFinite(source.line) ? source.line : 1
-          const column = Number.isFinite(source.column) ? source.column : 1
-          return 'vscode://file/' + encodeURI(vscodePath) + ':' + line + ':' + column
-        }
-
-        const sourceDisplay = (source) => {
-          return ''
-        }
-
-        payload.leaves.forEach((leaf) => {
-          const details = document.createElement('details')
-          const summary = document.createElement('summary')
-          summary.textContent = String(leaf.method || '').toUpperCase() + ' ' + (leaf.path || '')
-
-          const pre = document.createElement('pre')
-          pre.textContent = JSON.stringify(leaf, null, 2)
-
-          const source = payload.sourceByLeaf && payload.sourceByLeaf[leaf.key]
-          let sourceWrap = null
-          if (source) {
-            sourceWrap = document.createElement('div')
-            sourceWrap.className = 'meta'
-
-            const definitionHref = toHref(source.definition)
-            if (definitionHref) {
-              const label = document.createElement('div')
-              const link = document.createElement('a')
-              link.href = definitionHref
-              link.target = '_blank'
-              link.rel = 'noopener noreferrer'
-              link.textContent = 'definition'
-              label.appendChild(link)
-              sourceWrap.appendChild(label)
-            }
-
-            if (source.schemas && typeof source.schemas === 'object') {
-              Object.entries(source.schemas).forEach(([name, schema]) => {
-                if (!schema) return
-                const href = toHref(schema)
-                const row = document.createElement('div')
-                if (href) {
-                  const link = document.createElement('a')
-                  link.href = href
-                  link.target = '_blank'
-                  link.rel = 'noopener noreferrer'
-                  link.textContent =
-                    name + ': ' + (schema.sourceName || schema.tag || '<anonymous>')
-                  row.appendChild(link)
-                } else {
-                  row.textContent = name + ': ' + (schema.sourceName || schema.tag || '<anonymous>')
-                }
-                sourceWrap.appendChild(row)
-              })
-            }
-
-          }
-
-          details.appendChild(summary)
-          if (sourceWrap) details.appendChild(sourceWrap)
-          details.appendChild(pre)
-          resultsEl.appendChild(details)
-        })
-      }
-    </script>
-  </body>
-</html>
-`;
-
-// src/export/extractLeafSourceByAst.ts
-import path from "path";
-import ts from "typescript";
-var SCHEMA_KEYS = [
-  "bodySchema",
-  "querySchema",
-  "paramsSchema",
-  "outputSchema",
-  "outputMetaSchema",
-  "queryExtensionSchema"
-];
-var HTTP_METHODS = /* @__PURE__ */ new Set(["get", "post", "put", "patch", "delete"]);
-var MAX_RECURSION_DEPTH = 120;
-function toLocation(node) {
-  const sourceFile = node.getSourceFile();
-  const { line, character } = sourceFile.getLineAndCharacterOfPosition(
-    node.getStart(sourceFile)
-  );
-  return {
-    file: path.resolve(sourceFile.fileName),
-    line: line + 1,
-    column: character + 1
-  };
-}
-function markFile(ctx, sourceFile) {
-  if (!sourceFile) return;
-  ctx.visitedFilePaths.add(path.resolve(sourceFile.fileName));
-}
-function trimPreview(text, max = 80) {
-  const normalized = text.replace(/\s+/g, " ").trim();
-  return normalized.length > max ? `${normalized.slice(0, max)}...` : normalized;
-}
-function unwrapExpression(expression) {
-  let current = expression;
-  while (true) {
-    if (ts.isParenthesizedExpression(current) || ts.isAsExpression(current) || ts.isTypeAssertionExpression(current) || ts.isNonNullExpression(current) || ts.isSatisfiesExpression(current)) {
-      current = current.expression;
-      continue;
-    }
-    break;
-  }
-  return current;
-}
-function getTextName(name) {
-  if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
-    return name.text;
-  }
-  return void 0;
-}
-function joinPaths2(parent, child) {
-  if (!parent) return child;
-  if (!child) return parent;
-  const trimmedParent = parent.endsWith("/") ? parent.replace(/\/+$/, "") : parent;
-  const trimmedChild = child.startsWith("/") ? child.replace(/^\/+/, "") : child;
-  if (!trimmedChild) return trimmedParent;
-  return `${trimmedParent}/${trimmedChild}`;
-}
-function buildLeafKey(method, leafPath) {
-  return `${method.toUpperCase()} ${leafPath}`;
-}
-function normalizeResourceBase(raw) {
-  if (raw === "") return "";
-  if (raw.startsWith("/") || raw.startsWith(":") || raw.startsWith("*")) {
-    return raw;
-  }
-  return `/${raw}`;
-}
-function getModuleSymbol(checker, sourceFile) {
-  return checker.getSymbolAtLocation(sourceFile);
-}
-function getAliasedSymbolIfNeeded(checker, symbol) {
-  if ((symbol.flags & ts.SymbolFlags.Alias) !== 0) {
-    try {
-      return checker.getAliasedSymbol(symbol);
-    } catch {
-      return symbol;
-    }
-  }
-  return symbol;
-}
-function findSourceFile(program, filePath) {
-  const wanted = path.resolve(filePath);
-  const normalizedWanted = path.normalize(wanted);
-  return program.getSourceFiles().find((file) => path.normalize(path.resolve(file.fileName)) === normalizedWanted);
-}
-function declarationToExpression(declaration) {
-  if (!declaration) return void 0;
-  if (ts.isVariableDeclaration(declaration)) {
-    return declaration.initializer;
-  }
-  if (ts.isExportAssignment(declaration)) {
-    return declaration.expression;
-  }
-  if (ts.isPropertyAssignment(declaration)) {
-    return declaration.initializer;
-  }
-  if (ts.isShorthandPropertyAssignment(declaration)) {
-    return declaration.name;
-  }
-  if (ts.isBindingElement(declaration)) {
-    return declaration.initializer;
-  }
-  if (ts.isEnumMember(declaration)) {
-    return declaration.initializer;
-  }
-  return void 0;
-}
-function symbolKey(symbol) {
-  const decl = symbol.declarations?.[0];
-  if (!decl) return `${symbol.getName()}#${symbol.flags}`;
-  const file = path.resolve(decl.getSourceFile().fileName);
-  return `${file}:${decl.getStart()}:${symbol.getName()}`;
-}
-function resolveSymbolFromNode(node, ctx) {
-  const symbol = ctx.checker.getSymbolAtLocation(node);
-  if (!symbol) {
-    ctx.unresolvedReferences += 1;
-    return void 0;
-  }
-  const target = getAliasedSymbolIfNeeded(ctx.checker, symbol);
-  const key = symbolKey(target);
-  ctx.visitedSymbolKeys.add(key);
-  return target;
-}
-function getExpressionFromSymbol(symbol, ctx, depth) {
-  const key = symbolKey(symbol);
-  if (ctx.activeSymbols.has(key)) return void 0;
-  if (depth > MAX_RECURSION_DEPTH) return void 0;
-  ctx.activeSymbols.add(key);
-  try {
-    const declaration = symbol.declarations?.[0];
-    markFile(ctx, declaration?.getSourceFile());
-    const direct = declarationToExpression(declaration);
-    if (direct) return direct;
-    if (declaration && ts.isImportSpecifier(declaration)) {
-      const target = getAliasedSymbolIfNeeded(ctx.checker, symbol);
-      if (target !== symbol) {
-        return getExpressionFromSymbol(target, ctx, depth + 1);
-      }
-    }
-    return void 0;
-  } finally {
-    ctx.activeSymbols.delete(key);
-  }
-}
-function resolveIdentifierExpression(identifier, ctx, depth) {
-  const symbol = resolveSymbolFromNode(identifier, ctx);
-  if (!symbol) return void 0;
-  return getExpressionFromSymbol(symbol, ctx, depth);
-}
-function resolvePropertyExpression(expression, ctx, depth) {
-  if (depth > MAX_RECURSION_DEPTH) return void 0;
-  if (ts.isPropertyAccessExpression(expression)) {
-    const symbol = resolveSymbolFromNode(expression.name, ctx);
-    if (symbol) {
-      const fromSymbol = getExpressionFromSymbol(symbol, ctx, depth + 1);
-      if (fromSymbol) return fromSymbol;
-    }
-  } else if (expression.argumentExpression) {
-    const symbol = resolveSymbolFromNode(expression.argumentExpression, ctx);
-    if (symbol) {
-      const fromSymbol = getExpressionFromSymbol(symbol, ctx, depth + 1);
-      if (fromSymbol) return fromSymbol;
-    }
-  }
-  const ownerExpr = evaluateExpressionReference(expression.expression, ctx, depth + 1);
-  const owner = ownerExpr ? maybeObjectLiteral(ownerExpr, ctx, depth + 1) : void 0;
-  if (!owner) return void 0;
-  const propName = ts.isPropertyAccessExpression(expression) ? expression.name.text : expression.argumentExpression && ts.isStringLiteralLike(expression.argumentExpression) ? expression.argumentExpression.text : void 0;
-  if (!propName) return void 0;
-  for (const property of owner.properties) {
-    if (ts.isPropertyAssignment(property) && getTextName(property.name) === propName) {
-      return property.initializer;
-    }
-    if (ts.isShorthandPropertyAssignment(property) && property.name.text === propName) {
-      return property.name;
-    }
-  }
-  return void 0;
-}
-function evaluateExpressionReference(expression, ctx, depth) {
-  const resolved = unwrapExpression(expression);
-  markFile(ctx, resolved.getSourceFile());
-  if (depth > MAX_RECURSION_DEPTH) return void 0;
-  if (ts.isIdentifier(resolved)) {
-    return resolveIdentifierExpression(resolved, ctx, depth + 1);
-  }
-  if (ts.isPropertyAccessExpression(resolved) || ts.isElementAccessExpression(resolved)) {
-    return resolvePropertyExpression(resolved, ctx, depth + 1);
-  }
-  return void 0;
-}
-function resolveExportExpression(sourceFile, exportName, checker) {
-  const moduleSymbol = getModuleSymbol(checker, sourceFile);
-  if (!moduleSymbol) return void 0;
-  const exports = checker.getExportsOfModule(moduleSymbol);
-  const explicit = exports.find((entry) => entry.getName() === exportName);
-  if (explicit) {
-    const declaration = getAliasedSymbolIfNeeded(checker, explicit).declarations?.[0];
-    return declarationToExpression(declaration);
-  }
-  const defaultExport = exports.find((entry) => entry.getName() === "default");
-  if (!defaultExport) return void 0;
-  const defaultDecl = getAliasedSymbolIfNeeded(checker, defaultExport).declarations?.[0];
-  const defaultExpr = declarationToExpression(defaultDecl);
-  if (!defaultExpr) return void 0;
-  const resolved = unwrapExpression(defaultExpr);
-  if (!ts.isObjectLiteralExpression(resolved)) return void 0;
-  for (const property of resolved.properties) {
-    if (!ts.isPropertyAssignment(property)) continue;
-    const propertyName = getTextName(property.name);
-    if (propertyName !== exportName) continue;
-    return property.initializer;
-  }
-  return void 0;
-}
-function maybeObjectLiteral(expression, ctx, depth = 0) {
-  if (!expression || depth > MAX_RECURSION_DEPTH) return void 0;
-  const resolved = unwrapExpression(expression);
-  markFile(ctx, resolved.getSourceFile());
-  if (ts.isObjectLiteralExpression(resolved)) return resolved;
-  const referenced = evaluateExpressionReference(resolved, ctx, depth + 1);
-  if (!referenced) return void 0;
-  return maybeObjectLiteral(referenced, ctx, depth + 1);
-}
-function collectSchemaExpressionsFromObject(objectLiteral, ctx, depth) {
-  const schemas = {};
-  for (const property of objectLiteral.properties) {
-    if (ts.isSpreadAssignment(property)) {
-      const spreadObject = maybeObjectLiteral(property.expression, ctx, depth + 1);
-      if (!spreadObject) continue;
-      Object.assign(
-        schemas,
-        collectSchemaExpressionsFromObject(spreadObject, ctx, depth + 1)
-      );
-      continue;
-    }
-    if (ts.isPropertyAssignment(property)) {
-      const key = getTextName(property.name);
-      if (!key || !SCHEMA_KEYS.includes(key)) continue;
-      schemas[key] = property.initializer;
-      continue;
-    }
-    if (ts.isShorthandPropertyAssignment(property)) {
-      const key = property.name.text;
-      if (!SCHEMA_KEYS.includes(key)) continue;
-      schemas[key] = property.name;
-    }
-  }
-  return schemas;
-}
-function extractSchemaExpressions(cfgExpression, ctx, depth) {
-  const objectLiteral = maybeObjectLiteral(cfgExpression, ctx, depth);
-  if (!objectLiteral) return {};
-  return collectSchemaExpressionsFromObject(objectLiteral, ctx, depth);
-}
-function getNearestVariableName(node) {
-  let current = node;
-  while (current) {
-    if (ts.isVariableDeclaration(current) && ts.isIdentifier(current.name)) {
-      return current.name.text;
-    }
-    current = current.parent;
-  }
-  return void 0;
-}
-function isAllAccess(expression) {
-  if (ts.isPropertyAccessExpression(expression)) {
-    return expression.name.text === "all";
-  }
-  return Boolean(
-    expression.argumentExpression && ts.isStringLiteralLike(expression.argumentExpression) && expression.argumentExpression.text === "all"
-  );
-}
-function evaluateBranchExpression(expression, ctx, depth) {
-  const resolved = unwrapExpression(expression);
-  markFile(ctx, resolved.getSourceFile());
-  if (depth > MAX_RECURSION_DEPTH) return void 0;
-  if (ts.isIdentifier(resolved)) {
-    const valueExpr = resolveIdentifierExpression(resolved, ctx, depth + 1);
-    if (!valueExpr) return void 0;
-    return evaluateBranchExpression(valueExpr, ctx, depth + 1);
-  }
-  if (!ts.isCallExpression(resolved)) return void 0;
-  const call = resolved;
-  if (ts.isIdentifier(call.expression) && call.expression.text === "resource") {
-    const firstArg = call.arguments[0];
-    if (!firstArg || !ts.isStringLiteralLike(firstArg)) {
-      ctx.unsupportedShapeSeen = true;
-      return void 0;
-    }
-    return { base: normalizeResourceBase(firstArg.text), leaves: [] };
-  }
-  if (!ts.isPropertyAccessExpression(call.expression)) {
-    ctx.unsupportedShapeSeen = true;
-    return void 0;
-  }
-  const owner = call.expression.expression;
-  const method = call.expression.name.text;
-  const branch = evaluateBranchExpression(owner, ctx, depth + 1);
-  if (!branch) return void 0;
-  if (method === "with") return branch;
-  if (HTTP_METHODS.has(method)) {
-    const cfgExpression = call.arguments[0];
-    const schemas = extractSchemaExpressions(cfgExpression, ctx, depth + 1);
-    const nextLeaf = {
-      method,
-      path: branch.base,
-      definitionNode: call.expression.name,
-      schemas
-    };
-    return {
-      ...branch,
-      leaves: [...branch.leaves, nextLeaf]
-    };
-  }
-  if (method === "sub") {
-    const mountedLeaves = call.arguments.flatMap(
-      (arg) => evaluateLeavesFromExpression(arg, ctx, depth + 1)
-    );
-    const prefixed = mountedLeaves.map((leaf) => ({
-      ...leaf,
-      path: joinPaths2(branch.base, leaf.path)
-    }));
-    return {
-      ...branch,
-      leaves: [...branch.leaves, ...prefixed]
-    };
-  }
-  ctx.unsupportedShapeSeen = true;
-  return void 0;
-}
-function expressionKey(expression) {
-  const source = expression.getSourceFile();
-  return `${path.resolve(source.fileName)}:${expression.getStart(source)}:${expression.getEnd()}:${expression.kind}`;
-}
-function evaluateLeavesFromExpression(expression, ctx, depth = 0) {
-  const resolved = unwrapExpression(expression);
-  markFile(ctx, resolved.getSourceFile());
-  const key = expressionKey(resolved);
-  if (ctx.activeExpressionKeys.has(key)) return [];
-  if (depth > MAX_RECURSION_DEPTH) return [];
-  ctx.activeExpressionKeys.add(key);
-  try {
-    if (ts.isIdentifier(resolved)) {
-      const valueExpr = resolveIdentifierExpression(resolved, ctx, depth + 1);
-      if (!valueExpr) return [];
-      return evaluateLeavesFromExpression(valueExpr, ctx, depth + 1);
-    }
-    if (ts.isPropertyAccessExpression(resolved) || ts.isElementAccessExpression(resolved)) {
-      if (isAllAccess(resolved)) {
-        return evaluateLeavesFromExpression(resolved.expression, ctx, depth + 1);
-      }
-      const refExpr = resolvePropertyExpression(resolved, ctx, depth + 1);
-      if (refExpr) {
-        return evaluateLeavesFromExpression(refExpr, ctx, depth + 1);
-      }
-      return [];
-    }
-    if (ts.isArrayLiteralExpression(resolved)) {
-      const leaves = [];
-      for (const element of resolved.elements) {
-        if (ts.isSpreadElement(element)) {
-          leaves.push(...evaluateLeavesFromExpression(element.expression, ctx, depth + 1));
-          continue;
-        }
-        leaves.push(...evaluateLeavesFromExpression(element, ctx, depth + 1));
-      }
-      return leaves;
-    }
-    if (ts.isCallExpression(resolved)) {
-      if (ts.isIdentifier(resolved.expression)) {
-        const callName = resolved.expression.text;
-        if (callName === "finalize") {
-          const arg = resolved.arguments[0];
-          if (!arg) return [];
-          return evaluateLeavesFromExpression(arg, ctx, depth + 1);
-        }
-        if (callName === "mergeArrays") {
-          return resolved.arguments.flatMap(
-            (arg) => evaluateLeavesFromExpression(arg, ctx, depth + 1)
-          );
-        }
-      }
-      if (ts.isPropertyAccessExpression(resolved.expression)) {
-        const prop = resolved.expression.name.text;
-        if (prop === "done") {
-          const branch2 = evaluateBranchExpression(
-            resolved.expression.expression,
-            ctx,
-            depth + 1
-          );
-          return branch2?.leaves ?? [];
-        }
-      }
-      const refExpr = evaluateExpressionReference(resolved, ctx, depth + 1);
-      if (refExpr) return evaluateLeavesFromExpression(refExpr, ctx, depth + 1);
-      ctx.unsupportedShapeSeen = true;
-      return [];
-    }
-    const branch = evaluateBranchExpression(resolved, ctx, depth + 1);
-    if (branch) return branch.leaves;
-    ctx.unsupportedShapeSeen = true;
-    return [];
-  } finally {
-    ctx.activeExpressionKeys.delete(key);
-  }
-}
-function resolveSchemaMetadata(expression, ctx) {
-  const resolved = unwrapExpression(expression);
-  if (ts.isIdentifier(resolved)) {
-    const symbol = resolveSymbolFromNode(resolved, ctx);
-    const declaration = symbol?.declarations?.[0];
-    const locationNode = declaration ? ts.isVariableDeclaration(declaration) ? declaration.name : declaration : resolved;
-    const sourceName = declaration && ts.isVariableDeclaration(declaration) && ts.isIdentifier(declaration.name) ? declaration.name.text : resolved.text;
-    return {
-      ...toLocation(locationNode),
-      sourceName,
-      tag: declaration ? void 0 : "<anonymous>"
-    };
-  }
-  if (ts.isPropertyAccessExpression(resolved) || ts.isElementAccessExpression(resolved)) {
-    return {
-      ...toLocation(resolved),
-      sourceName: trimPreview(resolved.getText()),
-      tag: "<expression>"
-    };
-  }
-  return {
-    ...toLocation(resolved),
-    sourceName: trimPreview(resolved.getText()),
-    tag: "<inline>"
-  };
-}
-function parseTsConfig(cwd, tsconfigPath) {
-  const resolvedTsconfig = tsconfigPath ? path.resolve(cwd, tsconfigPath) : ts.findConfigFile(cwd, ts.sys.fileExists, "tsconfig.json");
-  if (!resolvedTsconfig) {
-    return void 0;
-  }
-  const read = ts.readConfigFile(resolvedTsconfig, ts.sys.readFile);
-  if (read.error) {
-    throw new Error(ts.flattenDiagnosticMessageText(read.error.messageText, "\n"));
-  }
-  const parsed = ts.parseJsonConfigFileContent(
-    read.config,
-    ts.sys,
-    path.dirname(resolvedTsconfig),
-    void 0,
-    resolvedTsconfig
-  );
-  const nonEmptyInputErrors = parsed.errors.filter((entry) => entry.code !== 18003);
-  if (nonEmptyInputErrors.length > 0) {
-    throw new Error(
-      nonEmptyInputErrors.map((entry) => ts.flattenDiagnosticMessageText(entry.messageText, "\n")).join("\n")
-    );
-  }
-  return { resolvedTsconfig, parsed };
-}
-function createProgramWithFallback(parsed, moduleFileAbs) {
-  const base = ts.createProgram({
-    rootNames: parsed.fileNames,
-    options: parsed.options
-  });
-  if (findSourceFile(base, moduleFileAbs)) {
-    return base;
-  }
-  const rootNames = Array.from(/* @__PURE__ */ new Set([...parsed.fileNames, moduleFileAbs]));
-  return ts.createProgram({ rootNames, options: parsed.options });
-}
-function extractLeafSourceByAst({
-  modulePath,
-  exportName,
-  tsconfigPath,
-  cwd = process.cwd()
-}) {
-  const parsedConfig = parseTsConfig(cwd, tsconfigPath);
-  if (!parsedConfig) {
-    return {
-      sourceByLeaf: {},
-      reason: "module_not_in_program",
-      stats: { visitedSymbols: 0, visitedFiles: 0, unresolvedReferences: 0 }
-    };
-  }
-  const moduleAbs = path.resolve(cwd, modulePath);
-  const program = createProgramWithFallback(parsedConfig.parsed, moduleAbs);
-  const checker = program.getTypeChecker();
-  const moduleFile = findSourceFile(program, moduleAbs);
-  if (!moduleFile) {
-    return {
-      sourceByLeaf: {},
-      tsconfigPath: parsedConfig.resolvedTsconfig,
-      reason: "module_not_in_program",
-      stats: { visitedSymbols: 0, visitedFiles: 0, unresolvedReferences: 0 }
-    };
-  }
-  const exportedExpression = resolveExportExpression(moduleFile, exportName, checker);
-  if (!exportedExpression) {
-    return {
-      sourceByLeaf: {},
-      tsconfigPath: parsedConfig.resolvedTsconfig,
-      reason: "export_not_found",
-      stats: { visitedSymbols: 0, visitedFiles: 1, unresolvedReferences: 0 }
-    };
-  }
-  const ctx = {
-    checker,
-    activeExpressionKeys: /* @__PURE__ */ new Set(),
-    activeSymbols: /* @__PURE__ */ new Set(),
-    visitedSymbolKeys: /* @__PURE__ */ new Set(),
-    visitedFilePaths: /* @__PURE__ */ new Set([path.resolve(moduleFile.fileName)]),
-    unresolvedReferences: 0,
-    unsupportedShapeSeen: false
-  };
-  const evaluatedLeaves = evaluateLeavesFromExpression(exportedExpression, ctx, 0);
-  const sourceByLeaf = {};
-  for (const leaf of evaluatedLeaves) {
-    const key = buildLeafKey(leaf.method, leaf.path);
-    const definition = {
-      ...toLocation(leaf.definitionNode),
-      symbolName: getNearestVariableName(leaf.definitionNode)
-    };
-    ctx.visitedFilePaths.add(definition.file);
-    const schemas = {};
-    for (const schemaKey of SCHEMA_KEYS) {
-      const schemaExpression = leaf.schemas[schemaKey];
-      if (!schemaExpression) continue;
-      const schemaMeta = resolveSchemaMetadata(schemaExpression, ctx);
-      ctx.visitedFilePaths.add(schemaMeta.file);
-      schemas[schemaKey] = schemaMeta;
-    }
-    sourceByLeaf[key] = { definition, schemas };
-  }
-  const reason = Object.keys(sourceByLeaf).length > 0 ? void 0 : ctx.unsupportedShapeSeen ? "unsupported_expression_shape" : "resolved_zero_leaves";
-  return {
-    sourceByLeaf,
-    tsconfigPath: parsedConfig.resolvedTsconfig,
-    reason,
-    stats: {
-      visitedSymbols: ctx.visitedSymbolKeys.size,
-      visitedFiles: ctx.visitedFilePaths.size,
-      unresolvedReferences: ctx.unresolvedReferences
-    }
-  };
-}
-
-// src/export/exportFinalizedLeaves.ts
-function isRegistry(value) {
-  return typeof value === "object" && value !== null && "all" in value && "byKey" in value;
-}
-function getLeaves(input) {
-  return isRegistry(input) ? input.all : input;
-}
-function buildMeta(sourceExtraction) {
-  return {
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    description: "Finalized RRRoutes leaves export with serialized schemas and flattened schema paths for downstream processing.",
-    sourceExtraction,
-    fieldCatalog: {
-      leaf: ["key", "method", "path", "cfg"],
-      cfg: [
-        "description?",
-        "summary?",
-        "docsGroup?",
-        "tags?",
-        "deprecated?",
-        "stability?",
-        "docsHidden?",
-        "docsMeta?",
-        "feed?",
-        "bodyFiles?",
-        "schemas"
-      ],
-      schemaNode: [
-        "kind",
-        "optional?",
-        "nullable?",
-        "description?",
-        "properties?",
-        "element?",
-        "union?",
-        "literal?",
-        "enumValues?"
-      ],
-      flatSchemaEntry: ["type", "nullable", "optional", "literal?"]
-    },
-    flattening: {
-      notation: "dot+[]",
-      unionBranchSuffix: "-N",
-      sections: ["params", "query", "body", "output"]
-    }
-  };
-}
-var BAKED_PAYLOAD_MARKER = "<!--__FINALIZED_LEAVES_BAKED_PAYLOAD__-->";
-function escapePayloadForInlineScript(payload) {
-  return JSON.stringify(payload).replace(/<\//g, "<\\/").replace(/<!--/g, "<\\!--");
-}
-function injectPayloadIntoViewerHtml(htmlTemplate, payload) {
-  const payloadScript = `${BAKED_PAYLOAD_MARKER}
-<script id="finalized-leaves-baked-payload">window.__FINALIZED_LEAVES_PAYLOAD = ${escapePayloadForInlineScript(
-    payload
-  )};</script>`;
-  if (htmlTemplate.includes(BAKED_PAYLOAD_MARKER)) {
-    return htmlTemplate.replace(BAKED_PAYLOAD_MARKER, payloadScript);
-  }
-  if (htmlTemplate.includes("</body>")) {
-    return htmlTemplate.replace("</body>", `${payloadScript}
-</body>`);
-  }
-  return `${payloadScript}
-${htmlTemplate}`;
-}
-async function resolveViewerTemplatePath(viewerTemplateFile) {
-  if (viewerTemplateFile) {
-    const resolved = path2.resolve(viewerTemplateFile);
-    await fs.access(resolved);
-    return resolved;
-  }
-  const candidates = [
-    path2.resolve(
-      process.cwd(),
-      "node_modules/@emeryld/rrroutes-contract/tools/finalized-leaves-viewer.html"
-    ),
-    path2.resolve(
-      process.cwd(),
-      "tools/finalized-leaves-viewer.html"
-    ),
-    path2.resolve(
-      process.cwd(),
-      "packages/contract/tools/finalized-leaves-viewer.html"
-    )
-  ];
-  for (const candidate of candidates) {
-    try {
-      await fs.access(candidate);
-      return candidate;
-    } catch {
-    }
-  }
-  return void 0;
-}
-async function writeJsonExport(payload, outFile) {
-  const resolved = path2.resolve(outFile);
-  await fs.mkdir(path2.dirname(resolved), { recursive: true });
-  await fs.writeFile(resolved, `${JSON.stringify(payload, null, 2)}
-`, "utf8");
-  return resolved;
-}
-async function writeBakedHtmlExport(payload, htmlFile, viewerTemplateFile) {
-  const templatePath = await resolveViewerTemplatePath(viewerTemplateFile);
-  const template = templatePath ? await fs.readFile(templatePath, "utf8") : DEFAULT_VIEWER_TEMPLATE;
-  const baked = injectPayloadIntoViewerHtml(template, payload);
-  const resolved = path2.resolve(htmlFile);
-  await fs.mkdir(path2.dirname(resolved), { recursive: true });
-  await fs.writeFile(resolved, baked, "utf8");
-  return resolved;
-}
-async function openHtmlInBrowser(filePath) {
-  const resolved = path2.resolve(filePath);
-  const platform = process.platform;
-  if (platform === "darwin") {
-    spawn("open", [resolved], { detached: true, stdio: "ignore" }).unref();
-    return;
-  }
-  if (platform === "win32") {
-    spawn("cmd", ["/c", "start", "", resolved], {
-      detached: true,
-      stdio: "ignore"
-    }).unref();
-    return;
-  }
-  spawn("xdg-open", [resolved], { detached: true, stdio: "ignore" }).unref();
-}
-async function writeFinalizedLeavesExport(payload, outFileOrOptions) {
-  const options = typeof outFileOrOptions === "string" ? { outFile: outFileOrOptions } : outFileOrOptions;
-  const written = {};
-  if (options.outFile) {
-    written.outFile = await writeJsonExport(payload, options.outFile);
-  }
-  if (options.htmlFile) {
-    written.htmlFile = await writeBakedHtmlExport(
-      payload,
-      options.htmlFile,
-      options.viewerTemplateFile
-    );
-  }
-  if (options.openOnFinish) {
-    if (!written.htmlFile) {
-      throw new Error(
-        "openOnFinish requires htmlFile. Provide htmlFile to open the baked viewer."
-      );
-    }
-    await openHtmlInBrowser(written.htmlFile);
-  }
-  return written;
-}
-async function exportFinalizedLeaves(input, options = {}) {
-  const leaves = getLeaves(input);
-  const serializedLeaves = serializeLeavesContract(leaves, options);
-  const schemaFlatByLeaf = Object.fromEntries(
-    serializedLeaves.map((leaf) => [leaf.key, flattenLeafSchemas(leaf)])
-  );
-  const sourceByLeaf = {};
-  let sourceExtraction;
-  if (options.includeSource) {
-    const modulePath = options.sourceModulePath;
-    const exportName = options.sourceExportName ?? "leaves";
-    if (modulePath) {
-      const extracted = extractLeafSourceByAst({
-        modulePath,
-        exportName,
-        tsconfigPath: options.tsconfigPath
-      });
-      const allowedLeafKeys = new Set(serializedLeaves.map((leaf) => leaf.key));
-      for (const [key, source] of Object.entries(extracted.sourceByLeaf)) {
-        if (allowedLeafKeys.has(key)) {
-          sourceByLeaf[key] = source;
-        }
-      }
-      sourceExtraction = {
-        mode: "ast",
-        enabled: true,
-        modulePath: path2.resolve(modulePath),
-        exportName,
-        tsconfigPath: extracted.tsconfigPath,
-        resolvedLeafCount: Object.keys(sourceByLeaf).length,
-        reason: extracted.reason,
-        stats: extracted.stats
-      };
-    } else {
-      sourceExtraction = {
-        mode: "ast",
-        enabled: false,
-        exportName,
-        tsconfigPath: options.tsconfigPath ? path2.resolve(options.tsconfigPath) : void 0,
-        resolvedLeafCount: 0,
-        reason: "resolved_zero_leaves",
-        stats: {
-          visitedSymbols: 0,
-          visitedFiles: 0,
-          unresolvedReferences: 0
-        }
-      };
-    }
-  }
-  const payload = {
-    _meta: buildMeta(sourceExtraction),
-    leaves: serializedLeaves,
-    schemaFlatByLeaf,
-    sourceByLeaf: options.includeSource && Object.keys(sourceByLeaf).length > 0 ? sourceByLeaf : void 0
-  };
-  if (options.outFile || options.htmlFile) {
-    await writeFinalizedLeavesExport(payload, {
-      outFile: options.outFile,
-      htmlFile: options.htmlFile,
-      viewerTemplateFile: options.viewerTemplateFile,
-      openOnFinish: options.openOnFinish
-    });
-  }
-  return payload;
-}
-
-// src/export/exportFinalizedLeaves.cli.ts
-import path3 from "path";
-import { pathToFileURL } from "url";
-function parseFinalizedLeavesCliArgs(argv) {
-  const args = /* @__PURE__ */ new Map();
-  let withSource = false;
-  for (let i = 0; i < argv.length; i += 1) {
-    const key = argv[i];
-    if (key === "--") continue;
-    if (!key.startsWith("--")) continue;
-    if (key === "--with-source") {
-      withSource = true;
-      continue;
-    }
-    const value = argv[i + 1];
-    if (!value || value.startsWith("--")) {
-      throw new Error(`Missing value for ${key}`);
-    }
-    args.set(key, value);
-    i += 1;
-  }
-  const modulePath = args.get("--module");
-  if (!modulePath) {
-    throw new Error("Missing required --module argument");
-  }
-  return {
-    modulePath,
-    exportName: args.get("--export") ?? "leaves",
-    outFile: args.get("--out") ?? "finalized-leaves.export.json",
-    withSource,
-    tsconfigPath: args.get("--tsconfig") ?? void 0
-  };
-}
-async function loadFinalizedLeavesInput({
-  modulePath,
-  exportName
-}) {
-  const resolvedModule = path3.resolve(process.cwd(), modulePath);
-  const mod = await import(pathToFileURL(resolvedModule).href);
-  const value = mod[exportName] ?? (mod.default && mod.default[exportName]);
-  if (!value) {
-    throw new Error(`Export "${exportName}" not found in module: ${resolvedModule}`);
-  }
-  return value;
-}
-async function runExportFinalizedLeavesCli(argv) {
-  const args = parseFinalizedLeavesCliArgs(argv);
-  const input = await loadFinalizedLeavesInput(args);
-  const payload = await exportFinalizedLeaves(input, {
-    outFile: args.outFile,
-    includeSource: args.withSource,
-    tsconfigPath: args.tsconfigPath,
-    sourceModulePath: args.modulePath,
-    sourceExportName: args.exportName
-  });
-  return {
-    payload,
-    outFile: path3.resolve(args.outFile)
-  };
-}
 export {
-  DEFAULT_VIEWER_TEMPLATE,
   buildCacheKey,
   buildLowProfileLeaf,
-  clearSchemaIntrospectionHandlers,
   collectNestedFieldSuggestions,
   compilePath,
-  createSchemaIntrospector,
   defineSocketEvents,
-  exportFinalizedLeaves,
-  extractLeafSourceByAst,
   finalize,
-  flattenLeafSchemas,
-  flattenSerializableSchema,
   getZodShape,
-  introspectSchema,
   keyOf,
-  loadFinalizedLeavesInput,
   lowProfileParse,
   lowProfileSafeParse,
   mergeArrays,
   mergeSchemas,
-  parseFinalizedLeavesCliArgs,
-  registerSchemaIntrospectionHandler,
   resource,
   routeSchemaParse,
-  runExportFinalizedLeavesCli,
-  serializableSchemaKinds,
-  serializeLeafContract,
-  serializeLeavesContract,
-  staticBase,
-  writeFinalizedLeavesExport
+  staticBase
 };
 //# sourceMappingURL=index.mjs.map