@doccov/sdk 0.24.0 → 0.24.1

package/dist/shared/{chunk-c1f9mytc.js → chunk-p1stkhse.js}

@@ -3,250 +3,6 @@ import {
   REPORT_VERSION
 } from "./chunk-esptwrfq.js";
 
-// src/extract/schema/standard-schema.ts
-import { spawn } from "node:child_process";
-import * as fs from "node:fs";
-import * as path from "node:path";
-function isStandardJSONSchema(obj) {
-  if (typeof obj !== "object" || obj === null)
-    return false;
-  const std = obj["~standard"];
-  if (typeof std !== "object" || std === null)
-    return false;
-  const stdObj = std;
-  if (typeof stdObj.version !== "number")
-    return false;
-  if (typeof stdObj.vendor !== "string")
-    return false;
-  const jsonSchema = stdObj.jsonSchema;
-  if (typeof jsonSchema !== "object" || jsonSchema === null)
-    return false;
-  const jsObj = jsonSchema;
-  return typeof jsObj.output === "function";
-}
-var WORKER_SCRIPT = `
-const path = require('path');
-const { pathToFileURL } = require('url');
-
-// TypeBox detection: schemas have Symbol.for('TypeBox.Kind') and are JSON Schema
-const TYPEBOX_KIND = Symbol.for('TypeBox.Kind');
-
-function isTypeBoxSchema(obj) {
-  if (!obj || typeof obj !== 'object') return false;
-  // TypeBox schemas always have Kind symbol (Union, Object, String, etc.)
-  // Also check for common JSON Schema props to avoid false positives
-  if (!obj[TYPEBOX_KIND]) return false;
-  return typeof obj.type === 'string' || 'anyOf' in obj || 'oneOf' in obj || 'allOf' in obj;
-}
-
-function sanitizeTypeBoxSchema(schema) {
-  // JSON.stringify removes symbol keys, keeping only JSON Schema props
-  return JSON.parse(JSON.stringify(schema));
-}
-
-async function extract() {
-  // With node -e, argv is: [node, arg1, arg2, ...]
-  // (the -e script is NOT in argv)
-  const [modulePath, target] = process.argv.slice(1);
-
-  try {
-    // Import the module using dynamic import (works with ESM and CJS)
-    const absPath = path.resolve(modulePath);
-    const mod = await import(pathToFileURL(absPath).href);
-    const results = [];
-
-    // Build exports map - handle both ESM and CJS (where exports are in mod.default)
-    const exports = {};
-    for (const [name, value] of Object.entries(mod)) {
-      if (name === 'default' && typeof value === 'object' && value !== null) {
-        // CJS module: spread default exports
-        Object.assign(exports, value);
-      } else if (name !== 'default') {
-        exports[name] = value;
-      }
-    }
-
-    // Check each export
-    for (const [name, value] of Object.entries(exports)) {
-      if (name.startsWith('_')) continue;
-      if (typeof value !== 'object' || value === null) continue;
-
-      // Priority 1: Standard Schema (Zod 4.2+, ArkType, etc.)
-      const std = value['~standard'];
-      if (std && typeof std === 'object' && typeof std.version === 'number' && typeof std.vendor === 'string' && std.jsonSchema && typeof std.jsonSchema.output === 'function') {
-        try {
-          const outputSchema = std.jsonSchema.output(target);
-          const inputSchema = std.jsonSchema.input ? std.jsonSchema.input(target) : undefined;
-          results.push({
-            exportName: name,
-            vendor: std.vendor,
-            outputSchema,
-            inputSchema
-          });
-        } catch (e) {
-          // Skip schemas that fail to extract
-        }
-        continue;
-      }
-
-      // Priority 2: TypeBox (schema IS JSON Schema)
-      if (isTypeBoxSchema(value)) {
-        try {
-          results.push({
-            exportName: name,
-            vendor: 'typebox',
-            outputSchema: sanitizeTypeBoxSchema(value)
-          });
-        } catch (e) {
-          // Skip schemas that fail to extract
-        }
-        continue;
-      }
-    }
-
-    console.log(JSON.stringify({ success: true, results }));
-  } catch (e) {
-    console.log(JSON.stringify({ success: false, error: e.message }));
-  }
-}
-
-extract();
-`;
-function resolveCompiledPath(tsPath, baseDir) {
-  const relativePath = path.relative(baseDir, tsPath);
-  const withoutExt = relativePath.replace(/\.tsx?$/, "");
-  const candidates = [
-    path.join(baseDir, `${withoutExt}.js`),
-    path.join(baseDir, "dist", `${withoutExt.replace(/^src\//, "")}.js`),
-    path.join(baseDir, "build", `${withoutExt.replace(/^src\//, "")}.js`),
-    path.join(baseDir, "lib", `${withoutExt.replace(/^src\//, "")}.js`)
-  ];
-  for (const candidate of candidates) {
-    if (fs.existsSync(candidate)) {
-      return candidate;
-    }
-  }
-  return null;
-}
-async function extractStandardSchemas(compiledJsPath, options = {}) {
-  const { timeout = 1e4, target = "draft-2020-12" } = options;
-  const result = {
-    schemas: new Map,
-    errors: []
-  };
-  if (!fs.existsSync(compiledJsPath)) {
-    result.errors.push(`Compiled JS not found: ${compiledJsPath}`);
-    return result;
-  }
-  return new Promise((resolve) => {
-    const child = spawn("node", ["-e", WORKER_SCRIPT, compiledJsPath, target], {
-      timeout,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-    child.stderr.on("data", (data) => {
-      stderr += data.toString();
-    });
-    child.on("close", (code) => {
-      if (code !== 0) {
-        result.errors.push(`Extraction process failed: ${stderr || `exit code ${code}`}`);
-        resolve(result);
-        return;
-      }
-      try {
-        const parsed = JSON.parse(stdout);
-        if (!parsed.success) {
-          result.errors.push(`Extraction failed: ${parsed.error}`);
-          resolve(result);
-          return;
-        }
-        for (const item of parsed.results) {
-          result.schemas.set(item.exportName, {
-            exportName: item.exportName,
-            vendor: item.vendor,
-            outputSchema: item.outputSchema,
-            inputSchema: item.inputSchema
-          });
-        }
-      } catch (e) {
-        result.errors.push(`Failed to parse extraction output: ${e}`);
-      }
-      resolve(result);
-    });
-    child.on("error", (err) => {
-      result.errors.push(`Subprocess error: ${err.message}`);
-      resolve(result);
-    });
-  });
-}
-async function extractStandardSchemasFromProject(entryFile, baseDir, options = {}) {
-  const compiledPath = resolveCompiledPath(entryFile, baseDir);
-  if (!compiledPath) {
-    return {
-      schemas: new Map,
-      errors: [`Could not find compiled JS for ${entryFile}. Build the project first.`]
-    };
-  }
-  return extractStandardSchemas(compiledPath, options);
-}
-
-// src/analysis/schema-detection.ts
-async function detectRuntimeSchemas(context) {
-  const { baseDir, entryFile } = context;
-  const compiledPath = resolveCompiledPath(entryFile, baseDir);
-  if (!compiledPath) {
-    return {
-      schemas: new Map,
-      errors: [],
-      noCompiledJsWarning: true
-    };
-  }
-  const extraction = await extractStandardSchemasFromProject(entryFile, baseDir);
-  const schemas = new Map;
-  for (const [name, result] of extraction.schemas) {
-    schemas.set(name, {
-      schema: result.outputSchema,
-      vendor: result.vendor
-    });
-  }
-  return {
-    schemas,
-    errors: extraction.errors
-  };
-}
-
-// src/analysis/drift/types.ts
-var DRIFT_CATEGORIES = {
-  "param-mismatch": "structural",
-  "param-type-mismatch": "structural",
-  "return-type-mismatch": "structural",
-  "optionality-mismatch": "structural",
-  "generic-constraint-mismatch": "structural",
-  "property-type-drift": "structural",
-  "async-mismatch": "structural",
-  "deprecated-mismatch": "semantic",
-  "visibility-mismatch": "semantic",
-  "broken-link": "semantic",
-  "example-drift": "example",
-  "example-syntax-error": "example",
-  "example-runtime-error": "example",
-  "example-assertion-failed": "example"
-};
-var DRIFT_CATEGORY_LABELS = {
-  structural: "Signature mismatches",
-  semantic: "Metadata issues",
-  example: "Example problems"
-};
-var DRIFT_CATEGORY_DESCRIPTIONS = {
-  structural: "JSDoc types or parameters don't match the actual code signature",
-  semantic: "Deprecation, visibility, or reference issues",
-  example: "@example code has errors or doesn't work correctly"
-};
-
 // src/fix/deterministic-fixes.ts
 var FIXABLE_DRIFT_TYPES = new Set([
   "param-mismatch",
@@ -671,8 +427,8 @@ function categorizeDrifts(drifts) {
 }
 
 // src/fix/jsdoc-writer.ts
-import * as fs2 from "node:fs";
-import * as path2 from "node:path";
+import * as fs from "node:fs";
+import * as path from "node:path";
 
 // src/ts-module.ts
 import * as tsNamespace from "typescript";
@@ -1011,7 +767,7 @@ async function applyEdits(edits) {
   }
   for (const [filePath, fileEdits] of editsByFile) {
     try {
-      const content = fs2.readFileSync(filePath, "utf-8");
+      const content = fs.readFileSync(filePath, "utf-8");
       const lines = content.split(`
 `);
       const sortedEdits = [...fileEdits].sort((a, b) => b.startLine - a.startLine);
@@ -1025,7 +781,7 @@ async function applyEdits(edits) {
         }
         result.editsApplied++;
       }
-      fs2.writeFileSync(filePath, lines.join(`
+      fs.writeFileSync(filePath, lines.join(`
 `));
       result.filesModified++;
     } catch (error) {
@@ -1038,71 +794,21 @@ async function applyEdits(edits) {
   return result;
 }
 function createSourceFile(filePath) {
-  const content = fs2.readFileSync(filePath, "utf-8");
-  return ts.createSourceFile(path2.basename(filePath), content, ts.ScriptTarget.Latest, true, filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+  const content = fs.readFileSync(filePath, "utf-8");
+  return ts.createSourceFile(path.basename(filePath), content, ts.ScriptTarget.Latest, true, filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
 }
-// src/analysis/drift/categorize.ts
-function categorizeDrift(drift) {
-  return {
-    ...drift,
-    category: DRIFT_CATEGORIES[drift.type],
-    fixable: isFixableDrift(drift)
-  };
-}
-function groupDriftsByCategory(drifts) {
-  const grouped = {
-    structural: [],
-    semantic: [],
-    example: []
-  };
-  for (const drift of drifts) {
-    const categorized = categorizeDrift(drift);
-    grouped[categorized.category].push(categorized);
-  }
-  return grouped;
-}
-function getDriftSummary(drifts) {
-  const grouped = groupDriftsByCategory(drifts);
-  return {
-    total: drifts.length,
-    byCategory: {
-      structural: grouped.structural.length,
-      semantic: grouped.semantic.length,
-      example: grouped.example.length
-    },
-    fixable: drifts.filter((d) => isFixableDrift(d)).length
-  };
-}
-function formatDriftSummaryLine(summary) {
-  if (summary.total === 0) {
-    return "No drift detected";
-  }
-  const parts = [];
-  if (summary.byCategory.structural > 0) {
-    parts.push(`${summary.byCategory.structural} structural`);
-  }
-  if (summary.byCategory.semantic > 0) {
-    parts.push(`${summary.byCategory.semantic} semantic`);
-  }
-  if (summary.byCategory.example > 0) {
-    parts.push(`${summary.byCategory.example} example`);
-  }
-  const fixableNote = summary.fixable > 0 ? ` (${summary.fixable} auto-fixable)` : "";
-  return `${summary.total} issues (${parts.join(", ")})${fixableNote}`;
-}
-
-// src/analysis/drift/example-drift.ts
-import ts2 from "typescript";
-
-// src/utils/builtin-detection.ts
-function isBuiltInTypeName(name) {
-  if (name.length === 1 && /^[A-Z]$/.test(name)) {
-    return true;
-  }
-  if (name.startsWith("__")) {
-    return true;
-  }
-  return BUILTIN_TYPE_NAMES.has(name) || LIBRARY_INTERNAL_PATTERNS.some((re) => re.test(name));
+// src/analysis/drift/example-drift.ts
+import ts2 from "typescript";
+
+// src/utils/builtin-detection.ts
+function isBuiltInTypeName(name) {
+  if (name.length === 1 && /^[A-Z]$/.test(name)) {
+    return true;
+  }
+  if (name.startsWith("__")) {
+    return true;
+  }
+  return BUILTIN_TYPE_NAMES.has(name) || LIBRARY_INTERNAL_PATTERNS.some((re) => re.test(name));
 }
 function isBuiltInIdentifier(identifier) {
   return BUILTIN_GLOBALS.has(identifier);
@@ -2310,6 +2016,84 @@ function computeExportDrift(entry, registry) {
   ];
 }
 
+// src/analysis/drift/types.ts
+var DRIFT_CATEGORIES = {
+  "param-mismatch": "structural",
+  "param-type-mismatch": "structural",
+  "return-type-mismatch": "structural",
+  "optionality-mismatch": "structural",
+  "generic-constraint-mismatch": "structural",
+  "property-type-drift": "structural",
+  "async-mismatch": "structural",
+  "deprecated-mismatch": "semantic",
+  "visibility-mismatch": "semantic",
+  "broken-link": "semantic",
+  "example-drift": "example",
+  "example-syntax-error": "example",
+  "example-runtime-error": "example",
+  "example-assertion-failed": "example"
+};
+var DRIFT_CATEGORY_LABELS = {
+  structural: "Signature mismatches",
+  semantic: "Metadata issues",
+  example: "Example problems"
+};
+var DRIFT_CATEGORY_DESCRIPTIONS = {
+  structural: "JSDoc types or parameters don't match the actual code signature",
+  semantic: "Deprecation, visibility, or reference issues",
+  example: "@example code has errors or doesn't work correctly"
+};
+
+// src/analysis/drift/categorize.ts
+function categorizeDrift(drift) {
+  return {
+    ...drift,
+    category: DRIFT_CATEGORIES[drift.type],
+    fixable: isFixableDrift(drift)
+  };
+}
+function groupDriftsByCategory(drifts) {
+  const grouped = {
+    structural: [],
+    semantic: [],
+    example: []
+  };
+  for (const drift of drifts) {
+    const categorized = categorizeDrift(drift);
+    grouped[categorized.category].push(categorized);
+  }
+  return grouped;
+}
+function getDriftSummary(drifts) {
+  const grouped = groupDriftsByCategory(drifts);
+  return {
+    total: drifts.length,
+    byCategory: {
+      structural: grouped.structural.length,
+      semantic: grouped.semantic.length,
+      example: grouped.example.length
+    },
+    fixable: drifts.filter((d) => isFixableDrift(d)).length
+  };
+}
+function formatDriftSummaryLine(summary) {
+  if (summary.total === 0) {
+    return "No drift detected";
+  }
+  const parts = [];
+  if (summary.byCategory.structural > 0) {
+    parts.push(`${summary.byCategory.structural} structural`);
+  }
+  if (summary.byCategory.semantic > 0) {
+    parts.push(`${summary.byCategory.semantic} semantic`);
+  }
+  if (summary.byCategory.example > 0) {
+    parts.push(`${summary.byCategory.example} example`);
+  }
+  const fixableNote = summary.fixable > 0 ? ` (${summary.fixable} auto-fixable)` : "";
+  return `${summary.total} issues (${parts.join(", ")})${fixableNote}`;
+}
+
 // src/analysis/drift/coverage.ts
 function calculateAggregateCoverage(spec) {
   const exports = spec.exports ?? [];
@@ -2416,8 +2200,8 @@ function enrichSpec(spec, options = {}) {
 }
 
 // src/analysis/report.ts
-import * as fs3 from "node:fs";
-import * as path3 from "node:path";
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
 function generateReport(spec) {
   const enriched = enrichSpec(spec);
   return generateReportFromEnriched(enriched);
@@ -2471,23 +2255,23 @@ function generateReportFromEnriched(enriched) {
 }
 function loadCachedReport(reportPath = DEFAULT_REPORT_PATH) {
   try {
-    const fullPath = path3.resolve(reportPath);
-    if (!fs3.existsSync(fullPath)) {
+    const fullPath = path2.resolve(reportPath);
+    if (!fs2.existsSync(fullPath)) {
       return null;
     }
-    const content = fs3.readFileSync(fullPath, "utf-8");
+    const content = fs2.readFileSync(fullPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
 function saveReport(report, reportPath = DEFAULT_REPORT_PATH) {
-  const fullPath = path3.resolve(reportPath);
-  const dir = path3.dirname(fullPath);
-  if (!fs3.existsSync(dir)) {
-    fs3.mkdirSync(dir, { recursive: true });
+  const fullPath = path2.resolve(reportPath);
+  const dir = path2.dirname(fullPath);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
   }
-  fs3.writeFileSync(fullPath, JSON.stringify(report, null, 2));
+  fs2.writeFileSync(fullPath, JSON.stringify(report, null, 2));
 }
 function isCachedReportValid(reportPath = DEFAULT_REPORT_PATH, sourceFiles = []) {
   const report = loadCachedReport(reportPath);
@@ -2497,7 +2281,7 @@ function isCachedReportValid(reportPath = DEFAULT_REPORT_PATH, sourceFiles = [])
   const reportTime = new Date(report.generatedAt).getTime();
   for (const file of sourceFiles) {
     try {
-      const stat = fs3.statSync(file);
+      const stat = fs2.statSync(file);
       if (stat.mtimeMs > reportTime) {
         return false;
       }
@@ -2684,6 +2468,222 @@ function renderApiSurface(spec) {
 `);
 }
 
+// src/extract/schema/standard-schema.ts
+import { spawn } from "node:child_process";
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
+function isStandardJSONSchema(obj) {
+  if (typeof obj !== "object" || obj === null)
+    return false;
+  const std = obj["~standard"];
+  if (typeof std !== "object" || std === null)
+    return false;
+  const stdObj = std;
+  if (typeof stdObj.version !== "number")
+    return false;
+  if (typeof stdObj.vendor !== "string")
+    return false;
+  const jsonSchema = stdObj.jsonSchema;
+  if (typeof jsonSchema !== "object" || jsonSchema === null)
+    return false;
+  const jsObj = jsonSchema;
+  return typeof jsObj.output === "function";
+}
+var WORKER_SCRIPT = `
+const path = require('path');
+const { pathToFileURL } = require('url');
+
+// TypeBox detection: schemas have Symbol.for('TypeBox.Kind') and are JSON Schema
+const TYPEBOX_KIND = Symbol.for('TypeBox.Kind');
+
+function isTypeBoxSchema(obj) {
+  if (!obj || typeof obj !== 'object') return false;
+  // TypeBox schemas always have Kind symbol (Union, Object, String, etc.)
+  // Also check for common JSON Schema props to avoid false positives
+  if (!obj[TYPEBOX_KIND]) return false;
+  return typeof obj.type === 'string' || 'anyOf' in obj || 'oneOf' in obj || 'allOf' in obj;
+}
+
+function sanitizeTypeBoxSchema(schema) {
+  // JSON.stringify removes symbol keys, keeping only JSON Schema props
+  return JSON.parse(JSON.stringify(schema));
+}
+
+async function extract() {
+  // With node -e, argv is: [node, arg1, arg2, ...]
+  // (the -e script is NOT in argv)
+  const [modulePath, target] = process.argv.slice(1);
+
+  try {
+    // Import the module using dynamic import (works with ESM and CJS)
+    const absPath = path.resolve(modulePath);
+    const mod = await import(pathToFileURL(absPath).href);
+    const results = [];
+
+    // Build exports map - handle both ESM and CJS (where exports are in mod.default)
+    const exports = {};
+    for (const [name, value] of Object.entries(mod)) {
+      if (name === 'default' && typeof value === 'object' && value !== null) {
+        // CJS module: spread default exports
+        Object.assign(exports, value);
+      } else if (name !== 'default') {
+        exports[name] = value;
+      }
+    }
+
+    // Check each export
+    for (const [name, value] of Object.entries(exports)) {
+      if (name.startsWith('_')) continue;
+      if (typeof value !== 'object' || value === null) continue;
+
+      // Priority 1: Standard Schema (Zod 4.2+, ArkType, etc.)
+      const std = value['~standard'];
+      if (std && typeof std === 'object' && typeof std.version === 'number' && typeof std.vendor === 'string' && std.jsonSchema && typeof std.jsonSchema.output === 'function') {
+        try {
+          const outputSchema = std.jsonSchema.output(target);
+          const inputSchema = std.jsonSchema.input ? std.jsonSchema.input(target) : undefined;
+          results.push({
+            exportName: name,
+            vendor: std.vendor,
+            outputSchema,
+            inputSchema
+          });
+        } catch (e) {
+          // Skip schemas that fail to extract
+        }
+        continue;
+      }
+
+      // Priority 2: TypeBox (schema IS JSON Schema)
+      if (isTypeBoxSchema(value)) {
+        try {
+          results.push({
+            exportName: name,
+            vendor: 'typebox',
+            outputSchema: sanitizeTypeBoxSchema(value)
+          });
+        } catch (e) {
+          // Skip schemas that fail to extract
+        }
+        continue;
+      }
+    }
+
+    console.log(JSON.stringify({ success: true, results }));
+  } catch (e) {
+    console.log(JSON.stringify({ success: false, error: e.message }));
+  }
+}
+
+extract();
+`;
+function resolveCompiledPath(tsPath, baseDir) {
+  const relativePath = path3.relative(baseDir, tsPath);
+  const withoutExt = relativePath.replace(/\.tsx?$/, "");
+  const candidates = [
+    path3.join(baseDir, `${withoutExt}.js`),
+    path3.join(baseDir, "dist", `${withoutExt.replace(/^src\//, "")}.js`),
+    path3.join(baseDir, "build", `${withoutExt.replace(/^src\//, "")}.js`),
+    path3.join(baseDir, "lib", `${withoutExt.replace(/^src\//, "")}.js`)
+  ];
+  for (const candidate of candidates) {
+    if (fs3.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+async function extractStandardSchemas(compiledJsPath, options = {}) {
+  const { timeout = 1e4, target = "draft-2020-12" } = options;
+  const result = {
+    schemas: new Map,
+    errors: []
+  };
+  if (!fs3.existsSync(compiledJsPath)) {
+    result.errors.push(`Compiled JS not found: ${compiledJsPath}`);
+    return result;
+  }
+  return new Promise((resolve2) => {
+    const child = spawn("node", ["-e", WORKER_SCRIPT, compiledJsPath, target], {
+      timeout,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("close", (code) => {
+      if (code !== 0) {
+        result.errors.push(`Extraction process failed: ${stderr || `exit code ${code}`}`);
+        resolve2(result);
+        return;
+      }
+      try {
+        const parsed = JSON.parse(stdout);
+        if (!parsed.success) {
+          result.errors.push(`Extraction failed: ${parsed.error}`);
+          resolve2(result);
+          return;
+        }
+        for (const item of parsed.results) {
+          result.schemas.set(item.exportName, {
+            exportName: item.exportName,
+            vendor: item.vendor,
+            outputSchema: item.outputSchema,
+            inputSchema: item.inputSchema
+          });
+        }
+      } catch (e) {
+        result.errors.push(`Failed to parse extraction output: ${e}`);
+      }
+      resolve2(result);
+    });
+    child.on("error", (err) => {
+      result.errors.push(`Subprocess error: ${err.message}`);
+      resolve2(result);
+    });
+  });
+}
+async function extractStandardSchemasFromProject(entryFile, baseDir, options = {}) {
+  const compiledPath = resolveCompiledPath(entryFile, baseDir);
+  if (!compiledPath) {
+    return {
+      schemas: new Map,
+      errors: [`Could not find compiled JS for ${entryFile}. Build the project first.`]
+    };
+  }
+  return extractStandardSchemas(compiledPath, options);
+}
+
+// src/analysis/schema-detection.ts
+async function detectRuntimeSchemas(context) {
+  const { baseDir, entryFile } = context;
+  const compiledPath = resolveCompiledPath(entryFile, baseDir);
+  if (!compiledPath) {
+    return {
+      schemas: new Map,
+      errors: [],
+      noCompiledJsWarning: true
+    };
+  }
+  const extraction = await extractStandardSchemasFromProject(entryFile, baseDir);
+  const schemas = new Map;
+  for (const [name, result] of extraction.schemas) {
+    schemas.set(name, {
+      schema: result.outputSchema,
+      vendor: result.vendor
+    });
+  }
+  return {
+    schemas,
+    errors: extraction.errors
+  };
+}
+
 // src/analysis/history.ts
 import * as fs4 from "node:fs";
 import * as path4 from "node:path";
@@ -2911,4 +2911,4 @@ function getExtendedTrend(spec, cwd, options) {
   };
 }
 
-export { ts, isBuiltInTypeName, isBuiltInIdentifier, isStandardJSONSchema, resolveCompiledPath, extractStandardSchemas, extractStandardSchemasFromProject, detectRuntimeSchemas, DRIFT_CATEGORIES, DRIFT_CATEGORY_LABELS, DRIFT_CATEGORY_DESCRIPTIONS, isFixableDrift, generateFix, generateFixesForExport, mergeFixes, categorizeDrifts, parseJSDocToPatch, applyPatchToJSDoc, serializeJSDoc, findJSDocLocation, applyEdits, createSourceFile, categorizeDrift, groupDriftsByCategory, getDriftSummary, formatDriftSummaryLine, detectExampleRuntimeErrors, parseAssertions, hasNonAssertionComments, detectExampleAssertionFailures, buildExportRegistry, computeDrift, computeExportDrift, calculateAggregateCoverage, ensureSpecCoverage, enrichSpec, generateReport, generateReportFromEnriched, loadCachedReport, saveReport, isCachedReportValid, renderApiSurface, HISTORY_DIR, RETENTION_DAYS, computeSnapshot, saveSnapshot, loadSnapshots, getTrend, renderSparkline, formatDelta, pruneHistory, pruneByTier, loadSnapshotsForDays, generateWeeklySummaries, getExtendedTrend };
+export { isFixableDrift, generateFix, generateFixesForExport, mergeFixes, categorizeDrifts, ts, parseJSDocToPatch, applyPatchToJSDoc, serializeJSDoc, findJSDocLocation, applyEdits, createSourceFile, isBuiltInTypeName, isBuiltInIdentifier, detectExampleRuntimeErrors, parseAssertions, hasNonAssertionComments, detectExampleAssertionFailures, buildExportRegistry, computeDrift, computeExportDrift, DRIFT_CATEGORIES, DRIFT_CATEGORY_LABELS, DRIFT_CATEGORY_DESCRIPTIONS, categorizeDrift, groupDriftsByCategory, getDriftSummary, formatDriftSummaryLine, calculateAggregateCoverage, ensureSpecCoverage, enrichSpec, generateReport, generateReportFromEnriched, loadCachedReport, saveReport, isCachedReportValid, renderApiSurface, isStandardJSONSchema, resolveCompiledPath, extractStandardSchemas, extractStandardSchemasFromProject, detectRuntimeSchemas, HISTORY_DIR, RETENTION_DAYS, computeSnapshot, saveSnapshot, loadSnapshots, getTrend, renderSparkline, formatDelta, pruneHistory, pruneByTier, loadSnapshotsForDays, generateWeeklySummaries, getExtendedTrend };