@emeryld/rrroutes-export 1.0.1

package/dist/index.cjs

@@ -0,0 +1,1386 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_VIEWER_TEMPLATE: () => DEFAULT_VIEWER_TEMPLATE,
+  clearSchemaIntrospectionHandlers: () => clearSchemaIntrospectionHandlers,
+  createSchemaIntrospector: () => createSchemaIntrospector,
+  exportFinalizedLeaves: () => exportFinalizedLeaves,
+  extractLeafSourceByAst: () => extractLeafSourceByAst,
+  flattenLeafSchemas: () => flattenLeafSchemas,
+  flattenSerializableSchema: () => flattenSerializableSchema,
+  introspectSchema: () => introspectSchema,
+  loadFinalizedLeavesInput: () => loadFinalizedLeavesInput,
+  parseFinalizedLeavesCliArgs: () => parseFinalizedLeavesCliArgs,
+  registerSchemaIntrospectionHandler: () => registerSchemaIntrospectionHandler,
+  runExportFinalizedLeavesCli: () => runExportFinalizedLeavesCli,
+  serializableSchemaKinds: () => serializableSchemaKinds,
+  serializeLeafContract: () => serializeLeafContract,
+  serializeLeavesContract: () => serializeLeavesContract,
+  writeFinalizedLeavesExport: () => writeFinalizedLeavesExport
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/schemaIntrospection.ts
+var z = __toESM(require("zod"), 1);
+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 = z;
+  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 = z.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 z.ZodOptional) {
+      optional = true;
+      const def = getDef(current);
+      current = def && def.innerType || current;
+      continue;
+    }
+    if (current instanceof z.ZodNullable) {
+      nullable = true;
+      const def = getDef(current);
+      current = def && def.innerType || current;
+      continue;
+    }
+    if (current instanceof z.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 z.ZodString) return "string";
+  if (schema instanceof z.ZodNumber) return "number";
+  if (schema instanceof z.ZodBoolean) return "boolean";
+  if (schema instanceof z.ZodBigInt) return "bigint";
+  if (schema instanceof z.ZodDate) return "date";
+  if (schema instanceof z.ZodArray) return "array";
+  if (schema instanceof z.ZodObject) return "object";
+  if (schema instanceof z.ZodUnion) return "union";
+  if (schema instanceof z.ZodLiteral) return "literal";
+  if (schema instanceof z.ZodEnum) return "enum";
+  if (schema instanceof z.ZodRecord) return "record";
+  if (schema instanceof z.ZodTuple) return "tuple";
+  if (schema instanceof z.ZodUnknown) return "unknown";
+  if (schema instanceof z.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 z.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: z,
+        introspect,
+        getDef,
+        unwrap,
+        getDescription
+      }
+    );
+  };
+  return introspect;
+}
+function introspectSchema(schema, options = {}) {
+  const introspect = createSchemaIntrospector(options);
+  return introspect(schema);
+}
+
+// src/serializeLeafContract.ts
+var import_rrroutes_contract = require("@emeryld/rrroutes-contract");
+function serializeContractSchema(schema, options) {
+  return schema ? introspectSchema((0, import_rrroutes_contract.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/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/exportFinalizedLeaves.ts
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+var import_node_child_process = require("child_process");
+
+// src/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;
+        --schema-accent: #fbbd23;
+      }
+      body {
+        margin: 0;
+        font-family: 'Iosevka Web', 'SFMono-Regular', Menlo, Consolas, monospace;
+        color: var(--text);
+        background: var(--bg);
+      }
+      a { color: var(--schema-accent); }
+      .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/extractLeafSourceByAst.ts
+var import_node_path = __toESM(require("path"), 1);
+var import_typescript = __toESM(require("typescript"), 1);
+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: import_node_path.default.resolve(sourceFile.fileName),
+    line: line + 1,
+    column: character + 1
+  };
+}
+function markFile(ctx, sourceFile) {
+  if (!sourceFile) return;
+  ctx.visitedFilePaths.add(import_node_path.default.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 (import_typescript.default.isParenthesizedExpression(current) || import_typescript.default.isAsExpression(current) || import_typescript.default.isTypeAssertionExpression(current) || import_typescript.default.isNonNullExpression(current) || import_typescript.default.isSatisfiesExpression(current)) {
+      current = current.expression;
+      continue;
+    }
+    break;
+  }
+  return current;
+}
+function getTextName(name) {
+  if (import_typescript.default.isIdentifier(name) || import_typescript.default.isStringLiteral(name) || import_typescript.default.isNumericLiteral(name)) {
+    return name.text;
+  }
+  return void 0;
+}
+function joinPaths(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 & import_typescript.default.SymbolFlags.Alias) !== 0) {
+    try {
+      return checker.getAliasedSymbol(symbol);
+    } catch {
+      return symbol;
+    }
+  }
+  return symbol;
+}
+function findSourceFile(program, filePath) {
+  const wanted = import_node_path.default.resolve(filePath);
+  const normalizedWanted = import_node_path.default.normalize(wanted);
+  return program.getSourceFiles().find((file) => import_node_path.default.normalize(import_node_path.default.resolve(file.fileName)) === normalizedWanted);
+}
+function declarationToExpression(declaration) {
+  if (!declaration) return void 0;
+  if (import_typescript.default.isVariableDeclaration(declaration)) {
+    return declaration.initializer;
+  }
+  if (import_typescript.default.isExportAssignment(declaration)) {
+    return declaration.expression;
+  }
+  if (import_typescript.default.isPropertyAssignment(declaration)) {
+    return declaration.initializer;
+  }
+  if (import_typescript.default.isShorthandPropertyAssignment(declaration)) {
+    return declaration.name;
+  }
+  if (import_typescript.default.isBindingElement(declaration)) {
+    return declaration.initializer;
+  }
+  if (import_typescript.default.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 = import_node_path.default.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 && import_typescript.default.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 (import_typescript.default.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 = import_typescript.default.isPropertyAccessExpression(expression) ? expression.name.text : expression.argumentExpression && import_typescript.default.isStringLiteralLike(expression.argumentExpression) ? expression.argumentExpression.text : void 0;
+  if (!propName) return void 0;
+  for (const property of owner.properties) {
+    if (import_typescript.default.isPropertyAssignment(property) && getTextName(property.name) === propName) {
+      return property.initializer;
+    }
+    if (import_typescript.default.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 (import_typescript.default.isIdentifier(resolved)) {
+    return resolveIdentifierExpression(resolved, ctx, depth + 1);
+  }
+  if (import_typescript.default.isPropertyAccessExpression(resolved) || import_typescript.default.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 exports2 = checker.getExportsOfModule(moduleSymbol);
+  const explicit = exports2.find((entry) => entry.getName() === exportName);
+  if (explicit) {
+    const declaration = getAliasedSymbolIfNeeded(checker, explicit).declarations?.[0];
+    return declarationToExpression(declaration);
+  }
+  const defaultExport = exports2.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 (!import_typescript.default.isObjectLiteralExpression(resolved)) return void 0;
+  for (const property of resolved.properties) {
+    if (!import_typescript.default.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 (import_typescript.default.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 (import_typescript.default.isSpreadAssignment(property)) {
+      const spreadObject = maybeObjectLiteral(property.expression, ctx, depth + 1);
+      if (!spreadObject) continue;
+      Object.assign(
+        schemas,
+        collectSchemaExpressionsFromObject(spreadObject, ctx, depth + 1)
+      );
+      continue;
+    }
+    if (import_typescript.default.isPropertyAssignment(property)) {
+      const key = getTextName(property.name);
+      if (!key || !SCHEMA_KEYS.includes(key)) continue;
+      schemas[key] = property.initializer;
+      continue;
+    }
+    if (import_typescript.default.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 (import_typescript.default.isVariableDeclaration(current) && import_typescript.default.isIdentifier(current.name)) {
+      return current.name.text;
+    }
+    current = current.parent;
+  }
+  return void 0;
+}
+function isAllAccess(expression) {
+  if (import_typescript.default.isPropertyAccessExpression(expression)) {
+    return expression.name.text === "all";
+  }
+  return Boolean(
+    expression.argumentExpression && import_typescript.default.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 (import_typescript.default.isIdentifier(resolved)) {
+    const valueExpr = resolveIdentifierExpression(resolved, ctx, depth + 1);
+    if (!valueExpr) return void 0;
+    return evaluateBranchExpression(valueExpr, ctx, depth + 1);
+  }
+  if (!import_typescript.default.isCallExpression(resolved)) return void 0;
+  const call = resolved;
+  if (import_typescript.default.isIdentifier(call.expression) && call.expression.text === "resource") {
+    const firstArg = call.arguments[0];
+    if (!firstArg || !import_typescript.default.isStringLiteralLike(firstArg)) {
+      ctx.unsupportedShapeSeen = true;
+      return void 0;
+    }
+    return { base: normalizeResourceBase(firstArg.text), leaves: [] };
+  }
+  if (!import_typescript.default.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: joinPaths(branch.base, leaf.path)
+    }));
+    return {
+      ...branch,
+      leaves: [...branch.leaves, ...prefixed]
+    };
+  }
+  ctx.unsupportedShapeSeen = true;
+  return void 0;
+}
+function expressionKey(expression) {
+  const source = expression.getSourceFile();
+  return `${import_node_path.default.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 (import_typescript.default.isIdentifier(resolved)) {
+      const valueExpr = resolveIdentifierExpression(resolved, ctx, depth + 1);
+      if (!valueExpr) return [];
+      return evaluateLeavesFromExpression(valueExpr, ctx, depth + 1);
+    }
+    if (import_typescript.default.isPropertyAccessExpression(resolved) || import_typescript.default.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 (import_typescript.default.isArrayLiteralExpression(resolved)) {
+      const leaves = [];
+      for (const element of resolved.elements) {
+        if (import_typescript.default.isSpreadElement(element)) {
+          leaves.push(...evaluateLeavesFromExpression(element.expression, ctx, depth + 1));
+          continue;
+        }
+        leaves.push(...evaluateLeavesFromExpression(element, ctx, depth + 1));
+      }
+      return leaves;
+    }
+    if (import_typescript.default.isCallExpression(resolved)) {
+      if (import_typescript.default.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 (import_typescript.default.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 (import_typescript.default.isIdentifier(resolved)) {
+    const symbol = resolveSymbolFromNode(resolved, ctx);
+    const declaration = symbol?.declarations?.[0];
+    const locationNode = declaration ? import_typescript.default.isVariableDeclaration(declaration) ? declaration.name : declaration : resolved;
+    const sourceName = declaration && import_typescript.default.isVariableDeclaration(declaration) && import_typescript.default.isIdentifier(declaration.name) ? declaration.name.text : resolved.text;
+    return {
+      ...toLocation(locationNode),
+      sourceName,
+      tag: declaration ? void 0 : "<anonymous>"
+    };
+  }
+  if (import_typescript.default.isPropertyAccessExpression(resolved) || import_typescript.default.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 ? import_node_path.default.resolve(cwd, tsconfigPath) : import_typescript.default.findConfigFile(cwd, import_typescript.default.sys.fileExists, "tsconfig.json");
+  if (!resolvedTsconfig) {
+    return void 0;
+  }
+  const read = import_typescript.default.readConfigFile(resolvedTsconfig, import_typescript.default.sys.readFile);
+  if (read.error) {
+    throw new Error(import_typescript.default.flattenDiagnosticMessageText(read.error.messageText, "\n"));
+  }
+  const parsed = import_typescript.default.parseJsonConfigFileContent(
+    read.config,
+    import_typescript.default.sys,
+    import_node_path.default.dirname(resolvedTsconfig),
+    void 0,
+    resolvedTsconfig
+  );
+  const nonEmptyInputErrors = parsed.errors.filter((entry) => entry.code !== 18003);
+  if (nonEmptyInputErrors.length > 0) {
+    throw new Error(
+      nonEmptyInputErrors.map((entry) => import_typescript.default.flattenDiagnosticMessageText(entry.messageText, "\n")).join("\n")
+    );
+  }
+  return { resolvedTsconfig, parsed };
+}
+function createProgramWithFallback(parsed, moduleFileAbs) {
+  const base = import_typescript.default.createProgram({
+    rootNames: parsed.fileNames,
+    options: parsed.options
+  });
+  if (findSourceFile(base, moduleFileAbs)) {
+    return base;
+  }
+  const rootNames = Array.from(/* @__PURE__ */ new Set([...parsed.fileNames, moduleFileAbs]));
+  return import_typescript.default.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 = import_node_path.default.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([import_node_path.default.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/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 = import_node_path2.default.resolve(viewerTemplateFile);
+    await import_promises.default.access(resolved);
+    return resolved;
+  }
+  const candidates = [
+    import_node_path2.default.resolve(
+      process.cwd(),
+      "node_modules/@emeryld/rrroutes-export/tools/finalized-leaves-viewer.html"
+    ),
+    import_node_path2.default.resolve(
+      process.cwd(),
+      "tools/finalized-leaves-viewer.html"
+    ),
+    import_node_path2.default.resolve(
+      process.cwd(),
+      "packages/export/tools/finalized-leaves-viewer.html"
+    )
+  ];
+  for (const candidate of candidates) {
+    try {
+      await import_promises.default.access(candidate);
+      return candidate;
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function writeJsonExport(payload, outFile) {
+  const resolved = import_node_path2.default.resolve(outFile);
+  await import_promises.default.mkdir(import_node_path2.default.dirname(resolved), { recursive: true });
+  await import_promises.default.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 import_promises.default.readFile(templatePath, "utf8") : DEFAULT_VIEWER_TEMPLATE;
+  const baked = injectPayloadIntoViewerHtml(template, payload);
+  const resolved = import_node_path2.default.resolve(htmlFile);
+  await import_promises.default.mkdir(import_node_path2.default.dirname(resolved), { recursive: true });
+  await import_promises.default.writeFile(resolved, baked, "utf8");
+  return resolved;
+}
+async function openHtmlInBrowser(filePath) {
+  const resolved = import_node_path2.default.resolve(filePath);
+  const platform = process.platform;
+  if (platform === "darwin") {
+    (0, import_node_child_process.spawn)("open", [resolved], { detached: true, stdio: "ignore" }).unref();
+    return;
+  }
+  if (platform === "win32") {
+    (0, import_node_child_process.spawn)("cmd", ["/c", "start", "", resolved], {
+      detached: true,
+      stdio: "ignore"
+    }).unref();
+    return;
+  }
+  (0, import_node_child_process.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: import_node_path2.default.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 ? import_node_path2.default.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/exportFinalizedLeaves.cli.ts
+var import_node_path3 = __toESM(require("path"), 1);
+var import_node_url = require("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 = import_node_path3.default.resolve(process.cwd(), modulePath);
+  const mod = await import((0, import_node_url.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: import_node_path3.default.resolve(args.outFile)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_VIEWER_TEMPLATE,
+  clearSchemaIntrospectionHandlers,
+  createSchemaIntrospector,
+  exportFinalizedLeaves,
+  extractLeafSourceByAst,
+  flattenLeafSchemas,
+  flattenSerializableSchema,
+  introspectSchema,
+  loadFinalizedLeavesInput,
+  parseFinalizedLeavesCliArgs,
+  registerSchemaIntrospectionHandler,
+  runExportFinalizedLeavesCli,
+  serializableSchemaKinds,
+  serializeLeafContract,
+  serializeLeavesContract,
+  writeFinalizedLeavesExport
+});
+//# sourceMappingURL=index.cjs.map