npm - @emeryld/rrroutes-contract - Versions diffs - 2.7.6 → 2.7.7 - Mend

@emeryld/rrroutes-contract 2.7.6 → 2.7.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/README.md +1 -0
package/dist/export/defaultViewerTemplate.d.ts +1 -1
package/dist/export/exportFinalizedLeaves.d.ts +7 -1
package/dist/export/extractLeafSourceByAst.d.ts +8 -0
package/dist/index.cjs +247 -82
package/dist/index.cjs.map +1 -1
package/dist/index.mjs +247 -82
package/dist/index.mjs.map +1 -1
package/package.json +1 -1
package/tools/finalized-leaves-viewer.html +18 -7

package/dist/index.mjs CHANGED Viewed

@@ -759,14 +759,18 @@ var DEFAULT_VIEWER_TEMPLATE = `<!doctype html>
               link.href = definitionHref
               link.target = '_blank'
               link.rel = 'noopener noreferrer'
-              link.textContent =
-                'definition: ' +
+              link.textContent = 'definition'
+              label.appendChild(link)
+              const location = document.createElement('span')
+              location.textContent =
+                ' (' +
                 source.definition.file +
                 ':' +
                 source.definition.line +
                 ':' +
-                source.definition.column
-              label.appendChild(link)
+                source.definition.column +
+                ')'
+              label.appendChild(location)
               sourceWrap.appendChild(label)
             }
@@ -781,17 +785,12 @@ var DEFAULT_VIEWER_TEMPLATE = `<!doctype html>
                   link.target = '_blank'
                   link.rel = 'noopener noreferrer'
                   link.textContent =
-                    name +
-                    ': ' +
-                    (schema.sourceName || schema.tag || '<anonymous>') +
-                    ' (' +
-                    schema.file +
-                    ':' +
-                    schema.line +
-                    ':' +
-                    schema.column +
-                    ')'
+                    name + ': ' + (schema.sourceName || schema.tag || '<anonymous>')
                   row.appendChild(link)
+                  const location = document.createElement('span')
+                  location.textContent =
+                    ' (' + schema.file + ':' + schema.line + ':' + schema.column + ')'
+                  row.appendChild(location)
                 } else {
                   row.textContent = name + ': ' + (schema.sourceName || schema.tag || '<anonymous>')
                 }
@@ -824,6 +823,7 @@ var SCHEMA_KEYS = [
   "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(
@@ -835,6 +835,10 @@ function toLocation(node) {
     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;
@@ -892,7 +896,7 @@ function findSourceFile(program, filePath) {
   const normalizedWanted = path.normalize(wanted);
   return program.getSourceFiles().find((file) => path.normalize(path.resolve(file.fileName)) === normalizedWanted);
 }
-function expressionFromDeclaration(declaration) {
+function declarationToExpression(declaration) {
   if (!declaration) return void 0;
   if (ts.isVariableDeclaration(declaration)) {
     return declaration.initializer;
@@ -909,14 +913,95 @@ function expressionFromDeclaration(declaration) {
   if (ts.isBindingElement(declaration)) {
     return declaration.initializer;
   }
+  if (ts.isEnumMember(declaration)) {
+    return declaration.initializer;
+  }
   return void 0;
 }
-function resolveIdentifierExpression(identifier, ctx) {
-  const symbol = ctx.checker.getSymbolAtLocation(identifier);
-  if (!symbol) 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 declaration = target.declarations?.[0];
-  return expressionFromDeclaration(declaration);
+  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);
@@ -925,12 +1010,12 @@ function resolveExportExpression(sourceFile, exportName, checker) {
   const explicit = exports.find((entry) => entry.getName() === exportName);
   if (explicit) {
     const declaration = getAliasedSymbolIfNeeded(checker, explicit).declarations?.[0];
-    return expressionFromDeclaration(declaration);
+    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 = expressionFromDeclaration(defaultDecl);
+  const defaultExpr = declarationToExpression(defaultDecl);
   if (!defaultExpr) return void 0;
   const resolved = unwrapExpression(defaultExpr);
   if (!ts.isObjectLiteralExpression(resolved)) return void 0;
@@ -942,24 +1027,25 @@ function resolveExportExpression(sourceFile, exportName, checker) {
   }
   return void 0;
 }
-function maybeObjectLiteral(expression, ctx) {
-  if (!expression) 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;
-  if (ts.isIdentifier(resolved)) {
-    const target = resolveIdentifierExpression(resolved, ctx);
-    if (!target) return void 0;
-    return maybeObjectLiteral(target, ctx);
-  }
-  return void 0;
+  const referenced = evaluateExpressionReference(resolved, ctx, depth + 1);
+  if (!referenced) return void 0;
+  return maybeObjectLiteral(referenced, ctx, depth + 1);
 }
-function collectSchemaExpressionsFromObject(objectLiteral, ctx) {
+function collectSchemaExpressionsFromObject(objectLiteral, ctx, depth) {
   const schemas = {};
   for (const property of objectLiteral.properties) {
     if (ts.isSpreadAssignment(property)) {
-      const spreadObject = maybeObjectLiteral(property.expression, ctx);
+      const spreadObject = maybeObjectLiteral(property.expression, ctx, depth + 1);
       if (!spreadObject) continue;
-      Object.assign(schemas, collectSchemaExpressionsFromObject(spreadObject, ctx));
+      Object.assign(
+        schemas,
+        collectSchemaExpressionsFromObject(spreadObject, ctx, depth + 1)
+      );
       continue;
     }
     if (ts.isPropertyAssignment(property)) {
@@ -976,10 +1062,10 @@ function collectSchemaExpressionsFromObject(objectLiteral, ctx) {
   }
   return schemas;
 }
-function extractSchemaExpressions(cfgExpression, ctx) {
-  const objectLiteral = maybeObjectLiteral(cfgExpression, ctx);
+function extractSchemaExpressions(cfgExpression, ctx, depth) {
+  const objectLiteral = maybeObjectLiteral(cfgExpression, ctx, depth);
   if (!objectLiteral) return {};
-  return collectSchemaExpressionsFromObject(objectLiteral, ctx);
+  return collectSchemaExpressionsFromObject(objectLiteral, ctx, depth);
 }
 function getNearestVariableName(node) {
   let current = node;
@@ -991,31 +1077,45 @@ function getNearestVariableName(node) {
   }
   return void 0;
 }
-function evaluateBranchExpression(expression, ctx) {
+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);
+    const valueExpr = resolveIdentifierExpression(resolved, ctx, depth + 1);
     if (!valueExpr) return void 0;
-    return evaluateBranchExpression(valueExpr, ctx);
+    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)) return void 0;
+    if (!firstArg || !ts.isStringLiteralLike(firstArg)) {
+      ctx.unsupportedShapeSeen = true;
+      return void 0;
+    }
     return { base: normalizeResourceBase(firstArg.text), leaves: [] };
   }
-  if (!ts.isPropertyAccessExpression(call.expression)) return void 0;
+  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);
+  const branch = evaluateBranchExpression(owner, ctx, depth + 1);
   if (!branch) return void 0;
-  if (method === "with") {
-    return branch;
-  }
+  if (method === "with") return branch;
   if (HTTP_METHODS.has(method)) {
     const cfgExpression = call.arguments[0];
-    const schemas = extractSchemaExpressions(cfgExpression, ctx);
+    const schemas = extractSchemaExpressions(cfgExpression, ctx, depth + 1);
     const nextLeaf = {
       method,
       path: branch.base,
@@ -1029,7 +1129,7 @@ function evaluateBranchExpression(expression, ctx) {
   }
   if (method === "sub") {
     const mountedLeaves = call.arguments.flatMap(
-      (arg) => evaluateLeavesFromExpression(arg, ctx)
+      (arg) => evaluateLeavesFromExpression(arg, ctx, depth + 1)
     );
     const prefixed = mountedLeaves.map((leaf) => ({
       ...leaf,
@@ -1040,29 +1140,44 @@ function evaluateBranchExpression(expression, ctx) {
       leaves: [...branch.leaves, ...prefixed]
     };
   }
+  ctx.unsupportedShapeSeen = true;
   return void 0;
 }
-function evaluateLeavesFromExpression(expression, ctx) {
+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);
-  const key = resolved.getStart(resolved.getSourceFile());
-  if (ctx.visitedExpressionStarts.has(key)) {
-    return [];
-  }
-  ctx.visitedExpressionStarts.add(key);
+  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);
+      const valueExpr = resolveIdentifierExpression(resolved, ctx, depth + 1);
       if (!valueExpr) return [];
-      return evaluateLeavesFromExpression(valueExpr, ctx);
+      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));
+          leaves.push(...evaluateLeavesFromExpression(element.expression, ctx, depth + 1));
           continue;
         }
-        leaves.push(...evaluateLeavesFromExpression(element, ctx));
+        leaves.push(...evaluateLeavesFromExpression(element, ctx, depth + 1));
       }
       return leaves;
     }
@@ -1072,34 +1187,43 @@ function evaluateLeavesFromExpression(expression, ctx) {
         if (callName === "finalize") {
           const arg = resolved.arguments[0];
           if (!arg) return [];
-          return evaluateLeavesFromExpression(arg, ctx);
+          return evaluateLeavesFromExpression(arg, ctx, depth + 1);
         }
         if (callName === "mergeArrays") {
           return resolved.arguments.flatMap(
-            (arg) => evaluateLeavesFromExpression(arg, ctx)
+            (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);
+          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);
-    return branch?.leaves ?? [];
+    const branch = evaluateBranchExpression(resolved, ctx, depth + 1);
+    if (branch) return branch.leaves;
+    ctx.unsupportedShapeSeen = true;
+    return [];
   } finally {
-    ctx.visitedExpressionStarts.delete(key);
+    ctx.activeExpressionKeys.delete(key);
   }
 }
 function resolveSchemaMetadata(expression, ctx) {
   const resolved = unwrapExpression(expression);
   if (ts.isIdentifier(resolved)) {
-    const symbol = ctx.checker.getSymbolAtLocation(resolved);
-    const target = symbol ? getAliasedSymbolIfNeeded(ctx.checker, symbol) : void 0;
-    const declaration = target?.declarations?.[0];
+    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 {
@@ -1137,13 +1261,25 @@ function parseTsConfig(cwd, tsconfigPath) {
     void 0,
     resolvedTsconfig
   );
-  if (parsed.errors.length > 0) {
+  const nonEmptyInputErrors = parsed.errors.filter((entry) => entry.code !== 18003);
+  if (nonEmptyInputErrors.length > 0) {
     throw new Error(
-      parsed.errors.map((entry) => ts.flattenDiagnosticMessageText(entry.messageText, "\n")).join("\n")
+      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,
@@ -1152,32 +1288,43 @@ function extractLeafSourceByAst({
 }) {
   const parsedConfig = parseTsConfig(cwd, tsconfigPath);
   if (!parsedConfig) {
-    return { sourceByLeaf: {} };
+    return {
+      sourceByLeaf: {},
+      reason: "module_not_in_program",
+      stats: { visitedSymbols: 0, visitedFiles: 0, unresolvedReferences: 0 }
+    };
   }
-  const program = ts.createProgram({
-    rootNames: parsedConfig.parsed.fileNames,
-    options: parsedConfig.parsed.options
-  });
+  const moduleAbs = path.resolve(cwd, modulePath);
+  const program = createProgramWithFallback(parsedConfig.parsed, moduleAbs);
   const checker = program.getTypeChecker();
-  const moduleFile = findSourceFile(program, path.resolve(cwd, modulePath));
+  const moduleFile = findSourceFile(program, moduleAbs);
   if (!moduleFile) {
     return {
       sourceByLeaf: {},
-      tsconfigPath: parsedConfig.resolvedTsconfig
+      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
+      tsconfigPath: parsedConfig.resolvedTsconfig,
+      reason: "export_not_found",
+      stats: { visitedSymbols: 0, visitedFiles: 1, unresolvedReferences: 0 }
     };
   }
   const ctx = {
     checker,
-    visitedExpressionStarts: /* @__PURE__ */ new Set()
+    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);
+  const evaluatedLeaves = evaluateLeavesFromExpression(exportedExpression, ctx, 0);
   const sourceByLeaf = {};
   for (const leaf of evaluatedLeaves) {
     const key = buildLeafKey(leaf.method, leaf.path);
@@ -1185,17 +1332,27 @@ function extractLeafSourceByAst({
       ...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;
-      schemas[schemaKey] = resolveSchemaMetadata(schemaExpression, ctx);
+      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
+    tsconfigPath: parsedConfig.resolvedTsconfig,
+    reason,
+    stats: {
+      visitedSymbols: ctx.visitedSymbolKeys.size,
+      visitedFiles: ctx.visitedFilePaths.size,
+      unresolvedReferences: ctx.unresolvedReferences
+    }
   };
 }
@@ -1378,7 +1535,9 @@ async function exportFinalizedLeaves(input, options = {}) {
         modulePath: path2.resolve(modulePath),
         exportName,
         tsconfigPath: extracted.tsconfigPath,
-        resolvedLeafCount: Object.keys(sourceByLeaf).length
+        resolvedLeafCount: Object.keys(sourceByLeaf).length,
+        reason: extracted.reason,
+        stats: extracted.stats
       };
     } else {
       sourceExtraction = {
@@ -1386,7 +1545,13 @@ async function exportFinalizedLeaves(input, options = {}) {
         enabled: false,
         exportName,
         tsconfigPath: options.tsconfigPath ? path2.resolve(options.tsconfigPath) : void 0,
-        resolvedLeafCount: 0
+        resolvedLeafCount: 0,
+        reason: "resolved_zero_leaves",
+        stats: {
+          visitedSymbols: 0,
+          visitedFiles: 0,
+          unresolvedReferences: 0
+        }
       };
     }
   }