@doccov/sdk 0.15.1 → 0.19.0

package/dist/index.js

@@ -15,8 +15,349 @@ var __toESM = (mod, isNodeMode, target) => {
       });
   return to;
 };
-var __require = createRequire(import.meta.url);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// src/analysis/schema-detection.ts
+async function detectRuntimeSchemas(_context) {
+  return {
+    schemas: new Map,
+    errors: []
+  };
+}
+function clearSchemaCache() {}
+// src/extract/schema/types.ts
+function isTypeReference(type) {
+  return !!(type.flags & 524288 && type.objectFlags && type.objectFlags & 4);
+}
+function getNonNullableType(type) {
+  if (type.isUnion()) {
+    const nonNullable = type.types.filter((t) => !(t.flags & 32768) && !(t.flags & 65536));
+    if (nonNullable.length === 1) {
+      return nonNullable[0];
+    }
+  }
+  return type;
+}
+// src/extract/schema/adapters/zod.ts
+var ZOD_TYPE_PATTERN = /^Zod[A-Z]/;
+var zodAdapter = {
+  id: "zod",
+  packages: ["zod"],
+  matches(type, checker) {
+    const typeName = checker.typeToString(type);
+    return ZOD_TYPE_PATTERN.test(typeName);
+  },
+  extractOutputType(type, checker) {
+    const outputSymbol = type.getProperty("_output");
+    if (outputSymbol) {
+      return checker.getTypeOfSymbol(outputSymbol);
+    }
+    const typeSymbol = type.getProperty("_type");
+    if (typeSymbol) {
+      return checker.getTypeOfSymbol(typeSymbol);
+    }
+    return null;
+  },
+  extractInputType(type, checker) {
+    const inputSymbol = type.getProperty("_input");
+    if (inputSymbol) {
+      return checker.getTypeOfSymbol(inputSymbol);
+    }
+    return null;
+  }
+};
+
+// src/extract/schema/adapters/valibot.ts
+var VALIBOT_TYPE_PATTERN = /Schema(<|$)/;
+var valibotAdapter = {
+  id: "valibot",
+  packages: ["valibot"],
+  matches(type, checker) {
+    const typeName = checker.typeToString(type);
+    return VALIBOT_TYPE_PATTERN.test(typeName) && !typeName.includes("Zod");
+  },
+  extractOutputType(type, checker) {
+    const typesSymbol = type.getProperty("~types");
+    if (!typesSymbol) {
+      return null;
+    }
+    let typesType = checker.getTypeOfSymbol(typesSymbol);
+    typesType = getNonNullableType(typesType);
+    const outputSymbol = typesType.getProperty("output");
+    if (!outputSymbol) {
+      return null;
+    }
+    return checker.getTypeOfSymbol(outputSymbol);
+  },
+  extractInputType(type, checker) {
+    const typesSymbol = type.getProperty("~types");
+    if (!typesSymbol) {
+      return null;
+    }
+    let typesType = checker.getTypeOfSymbol(typesSymbol);
+    typesType = getNonNullableType(typesType);
+    const inputSymbol = typesType.getProperty("input");
+    if (!inputSymbol) {
+      return null;
+    }
+    return checker.getTypeOfSymbol(inputSymbol);
+  }
+};
+
+// src/extract/schema/adapters/typebox.ts
+var TYPEBOX_TYPE_PATTERN = /^T[A-Z]/;
+var typeboxAdapter = {
+  id: "typebox",
+  packages: ["@sinclair/typebox"],
+  matches(type, checker) {
+    const typeName = checker.typeToString(type);
+    if (!TYPEBOX_TYPE_PATTERN.test(typeName)) {
+      return false;
+    }
+    const typeProperty = type.getProperty("type");
+    return typeProperty !== undefined;
+  },
+  extractOutputType(type, checker) {
+    const staticSymbol = type.getProperty("static");
+    if (staticSymbol) {
+      return checker.getTypeOfSymbol(staticSymbol);
+    }
+    return null;
+  }
+};
+
+// src/extract/schema/adapters/arktype.ts
+var ARKTYPE_TYPE_PATTERN = /^Type</;
+var arktypeAdapter = {
+  id: "arktype",
+  packages: ["arktype"],
+  matches(type, checker) {
+    const typeName = checker.typeToString(type);
+    return ARKTYPE_TYPE_PATTERN.test(typeName);
+  },
+  extractOutputType(type, checker) {
+    if (!isTypeReference(type)) {
+      return null;
+    }
+    const args = checker.getTypeArguments(type);
+    if (args.length < 1) {
+      return null;
+    }
+    return args[0];
+  },
+  extractInputType(type, checker) {
+    if (!isTypeReference(type)) {
+      return null;
+    }
+    const args = checker.getTypeArguments(type);
+    if (args.length < 2) {
+      return null;
+    }
+    return args[1];
+  }
+};
+
+// src/extract/schema/registry.ts
+var adapters = [
+  zodAdapter,
+  arktypeAdapter,
+  typeboxAdapter,
+  valibotAdapter
+];
+function findAdapter(type, checker) {
+  for (const adapter of adapters) {
+    if (adapter.matches(type, checker)) {
+      return adapter;
+    }
+  }
+  return null;
+}
+function isSchemaType(type, checker) {
+  return findAdapter(type, checker) !== null;
+}
+function extractSchemaOutputType(type, checker) {
+  const adapter = findAdapter(type, checker);
+  if (!adapter) {
+    return null;
+  }
+  return adapter.extractOutputType(type, checker);
+}
+function extractSchemaType(type, checker) {
+  const adapter = findAdapter(type, checker);
+  if (!adapter) {
+    return null;
+  }
+  const outputType = adapter.extractOutputType(type, checker);
+  if (!outputType) {
+    return null;
+  }
+  const result = {
+    adapter,
+    outputType
+  };
+  if (adapter.extractInputType) {
+    const inputType = adapter.extractInputType(type, checker);
+    if (inputType) {
+      result.inputType = inputType;
+    }
+  }
+  return result;
+}
+function getRegisteredAdapters() {
+  return adapters;
+}
+function getSupportedLibraries() {
+  return adapters.flatMap((a) => a.packages);
+}
+// 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');
+
+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
+    const mod = require(path.resolve(modulePath));
+    const results = [];
+
+    // Check each export
+    for (const [name, value] of Object.entries(mod)) {
+      if (name.startsWith('_')) continue;
+      if (typeof value !== 'object' || value === null) continue;
+
+      const std = value['~standard'];
+      if (!std || typeof std !== 'object') continue;
+      if (typeof std.version !== 'number') continue;
+      if (typeof std.vendor !== 'string') continue;
+      if (!std.jsonSchema || typeof std.jsonSchema.output !== 'function') continue;
+
+      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
+      }
+    }
+
+    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/docs-coverage.ts
 import {
   DRIFT_CATEGORIES
@@ -446,8 +787,8 @@ function categorizeDrifts(drifts) {
   return { fixable, nonFixable };
 }
 // src/fix/jsdoc-writer.ts
-import * as fs from "node:fs";
-import * as path from "node:path";
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
 
 // src/ts-module.ts
 import * as tsNamespace from "typescript";
@@ -786,7 +1127,7 @@ async function applyEdits(edits) {
   }
   for (const [filePath, fileEdits] of editsByFile) {
     try {
-      const content = fs.readFileSync(filePath, "utf-8");
+      const content = fs2.readFileSync(filePath, "utf-8");
       const lines = content.split(`
 `);
       const sortedEdits = [...fileEdits].sort((a, b) => b.startLine - a.startLine);
@@ -800,7 +1141,7 @@ async function applyEdits(edits) {
         }
         result.editsApplied++;
       }
-      fs.writeFileSync(filePath, lines.join(`
+      fs2.writeFileSync(filePath, lines.join(`
 `));
       result.filesModified++;
     } catch (error) {
@@ -813,8 +1154,8 @@ async function applyEdits(edits) {
   return result;
 }
 function createSourceFile(filePath) {
-  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);
+  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);
 }
 // src/utils/builtin-detection.ts
 function isBuiltInTypeName(name) {
@@ -2012,271 +2353,6 @@ function ensureSpecCoverage(spec) {
     }
   };
 }
-// src/quality/rules.ts
-var CORE_RULES = [
-  {
-    id: "has-description",
-    name: "Has Description",
-    description: "Export has a description comment",
-    affectsCoverage: true,
-    defaultSeverity: "warn",
-    check(ctx) {
-      return Boolean(ctx.export.description?.trim());
-    },
-    getViolation(ctx) {
-      return {
-        ruleId: "has-description",
-        severity: "warn",
-        message: `Export '${ctx.export.name}' is missing a description`,
-        fixable: false
-      };
-    }
-  },
-  {
-    id: "has-params",
-    name: "Has Parameters",
-    description: "All parameters are documented",
-    appliesTo: ["function"],
-    affectsCoverage: true,
-    defaultSeverity: "off",
-    check(ctx) {
-      const parameters = (ctx.export.signatures ?? []).flatMap((sig) => sig.parameters ?? []);
-      if (parameters.length === 0)
-        return true;
-      return parameters.every((p) => Boolean(p.description?.trim()));
-    },
-    getViolation(ctx) {
-      return {
-        ruleId: "has-params",
-        severity: "warn",
-        message: `Function '${ctx.export.name}' has undocumented parameters`,
-        fixable: true
-      };
-    }
-  },
-  {
-    id: "has-returns",
-    name: "Has Returns",
-    description: "Return value is documented",
-    appliesTo: ["function"],
-    affectsCoverage: true,
-    defaultSeverity: "off",
-    check(ctx) {
-      const signatures = ctx.export.signatures ?? [];
-      if (signatures.length === 0)
-        return true;
-      return signatures.every((sig) => {
-        const text = sig.returns?.description;
-        return Boolean(text?.trim());
-      });
-    },
-    getViolation(ctx) {
-      return {
-        ruleId: "has-returns",
-        severity: "warn",
-        message: `Function '${ctx.export.name}' has undocumented return value`,
-        fixable: true
-      };
-    }
-  },
-  {
-    id: "has-examples",
-    name: "Has Examples",
-    description: "Export has at least one @example",
-    appliesTo: ["function", "class"],
-    affectsCoverage: true,
-    defaultSeverity: "off",
-    check(ctx) {
-      return Boolean(ctx.export.examples?.length);
-    },
-    getViolation(ctx) {
-      return {
-        ruleId: "has-examples",
-        severity: "warn",
-        message: `Export '${ctx.export.name}' is missing an @example`,
-        fixable: false
-      };
-    }
-  }
-];
-var STYLE_RULES = [
-  {
-    id: "no-empty-returns",
-    name: "No Empty Returns",
-    description: "@returns tag must have a description",
-    appliesTo: ["function"],
-    affectsCoverage: false,
-    defaultSeverity: "warn",
-    check(ctx) {
-      if (!ctx.rawJSDoc)
-        return true;
-      const returnsMatch = ctx.rawJSDoc.match(/@returns?\s*(?:\{[^}]*\})?\s*$/m);
-      if (returnsMatch)
-        return false;
-      const returnsTypeOnly = ctx.rawJSDoc.match(/@returns?\s+\{[^}]+\}\s*$/m);
-      if (returnsTypeOnly)
-        return false;
-      return true;
-    },
-    getViolation(ctx) {
-      return {
-        ruleId: "no-empty-returns",
-        severity: "warn",
-        message: `Export '${ctx.export.name}' has @returns without a description`,
-        fixable: false
-      };
-    }
-  },
-  {
-    id: "consistent-param-style",
-    name: "Consistent Param Style",
-    description: "@param tags use dash separator",
-    appliesTo: ["function"],
-    affectsCoverage: false,
-    defaultSeverity: "off",
-    check(ctx) {
-      if (!ctx.rawJSDoc)
-        return true;
-      const paramRegex = /@param\s+(?:\{[^}]+\}\s+)?(\S+)\s+([^@\n]+)/g;
-      const matches = ctx.rawJSDoc.matchAll(paramRegex);
-      for (const match of matches) {
-        const rest = match[2]?.trim();
-        if (rest && !rest.startsWith("-") && !rest.startsWith("–")) {
-          return false;
-        }
-      }
-      return true;
-    },
-    getViolation(ctx) {
-      return {
-        ruleId: "consistent-param-style",
-        severity: "warn",
-        message: `Export '${ctx.export.name}' has @param without dash separator`,
-        fixable: true
-      };
-    },
-    fix(ctx) {
-      if (!ctx.rawJSDoc)
-        return null;
-      const patch = parseJSDocToPatch(ctx.rawJSDoc);
-      if (!patch.params || patch.params.length === 0)
-        return null;
-      return patch;
-    }
-  }
-];
-var BUILTIN_RULES = [...CORE_RULES, ...STYLE_RULES];
-function getCoverageRules() {
-  return BUILTIN_RULES.filter((r) => r.affectsCoverage);
-}
-function getRulesForKind(kind) {
-  return BUILTIN_RULES.filter((r) => {
-    if (!r.appliesTo)
-      return true;
-    return r.appliesTo.includes(kind);
-  });
-}
-function getRule(id) {
-  return BUILTIN_RULES.find((r) => r.id === id);
-}
-function getDefaultConfig() {
-  const config = {};
-  for (const rule of BUILTIN_RULES) {
-    config[rule.id] = rule.defaultSeverity;
-  }
-  return config;
-}
-
-// src/quality/engine.ts
-function evaluateExportQuality(exp, rawJSDoc, config = { rules: {} }) {
-  const kind = exp.kind ?? "variable";
-  const applicableRules = getRulesForKind(kind);
-  const defaults = getDefaultConfig();
-  const getSeverity = (ruleId, defaultSev) => config.rules[ruleId] ?? defaults[ruleId] ?? defaultSev;
-  const activeCoverageRules = applicableRules.filter((r) => {
-    if (!r.affectsCoverage)
-      return false;
-    const severity = getSeverity(r.id, r.defaultSeverity);
-    return severity !== "off";
-  });
-  const result = {
-    coverageScore: 0,
-    coverage: {
-      satisfied: [],
-      missing: [],
-      applicable: activeCoverageRules.map((r) => r.id)
-    },
-    violations: [],
-    summary: {
-      errorCount: 0,
-      warningCount: 0,
-      fixableCount: 0
-    }
-  };
-  const context = { export: exp, rawJSDoc };
-  for (const rule of applicableRules) {
-    const passed = rule.check(context);
-    const severity = getSeverity(rule.id, rule.defaultSeverity);
-    if (rule.affectsCoverage && severity !== "off") {
-      if (passed) {
-        result.coverage.satisfied.push(rule.id);
-      } else {
-        result.coverage.missing.push(rule.id);
-      }
-    }
-    if (!passed && severity !== "off" && rule.getViolation) {
-      const violation = {
-        ...rule.getViolation(context),
-        severity: severity === "error" ? "error" : "warn"
-      };
-      result.violations.push(violation);
-      if (violation.severity === "error") {
-        result.summary.errorCount++;
-      } else {
-        result.summary.warningCount++;
-      }
-      if (violation.fixable) {
-        result.summary.fixableCount++;
-      }
-    }
-  }
-  const { satisfied, applicable } = result.coverage;
-  result.coverageScore = applicable.length === 0 ? 100 : Math.round(satisfied.length / applicable.length * 100);
-  return result;
-}
-function evaluateQuality(exports, config = { rules: {} }) {
-  const byExport = new Map;
-  let totalCoverage = 0;
-  let totalErrors = 0;
-  let totalWarnings = 0;
-  for (const { export: exp, rawJSDoc } of exports) {
-    const result = evaluateExportQuality(exp, rawJSDoc, config);
-    byExport.set(exp.id ?? exp.name, result);
-    totalCoverage += result.coverageScore;
-    totalErrors += result.summary.errorCount;
-    totalWarnings += result.summary.warningCount;
-  }
-  const count = exports.length;
-  return {
-    byExport,
-    overall: {
-      coverageScore: count === 0 ? 100 : Math.round(totalCoverage / count),
-      totalViolations: totalErrors + totalWarnings,
-      errorCount: totalErrors,
-      warningCount: totalWarnings
-    }
-  };
-}
-function mergeConfig(userConfig) {
-  const defaults = getDefaultConfig();
-  return {
-    rules: {
-      ...defaults,
-      ...userConfig.rules
-    }
-  };
-}
-
 // src/analysis/enrich.ts
 function collectAllMissing(exports) {
   const allMissing = new Set;
@@ -2298,38 +2374,33 @@ function collectAllDrift(exports) {
   }
   return allDrift;
 }
-function collectAllViolations(exports) {
-  const allViolations = [];
-  for (const exp of exports) {
-    if (exp.docs?.violations) {
-      allViolations.push(...exp.docs.violations);
-    }
+function computeExportCoverage(exp) {
+  const missing = [];
+  if (!exp.description) {
+    missing.push("has-description");
+    return { score: 0, missing };
   }
-  return allViolations;
+  return { score: 100, missing: [] };
 }
 function enrichSpec(spec, options = {}) {
-  const { driftByExport, qualityConfig = { rules: {} }, rawJSDocByExport } = options;
+  const { driftByExport } = options;
   const exportRegistry = buildExportRegistry(spec);
   let totalCoverage = 0;
   const enrichedExports = spec.exports.map((exp) => {
-    const rawJSDoc = rawJSDocByExport?.get(exp.id);
-    const quality = evaluateExportQuality(exp, rawJSDoc, qualityConfig);
+    const coverage = computeExportCoverage(exp);
     const drift = computeExportDrift(exp, exportRegistry);
     const additionalDrift = driftByExport?.get(exp.id);
     const allDrift2 = additionalDrift ? [...drift, ...additionalDrift] : drift;
-    totalCoverage += quality.coverageScore;
+    totalCoverage += coverage.score;
     const docs2 = {
-      coverageScore: quality.coverageScore
+      coverageScore: coverage.score
     };
-    if (quality.coverage.missing.length > 0) {
-      docs2.missing = quality.coverage.missing;
+    if (coverage.missing.length > 0) {
+      docs2.missing = coverage.missing;
     }
     if (allDrift2.length > 0) {
       docs2.drift = allDrift2;
     }
-    if (quality.violations.length > 0) {
-      docs2.violations = quality.violations;
-    }
     return {
       ...exp,
       docs: docs2
@@ -2338,7 +2409,6 @@ function enrichSpec(spec, options = {}) {
   const count = enrichedExports.length;
   const allMissing = collectAllMissing(enrichedExports);
   const allDrift = collectAllDrift(enrichedExports);
-  const allViolations = collectAllViolations(enrichedExports);
   const docs = {
     coverageScore: count === 0 ? 100 : Math.round(totalCoverage / count)
   };
@@ -2348,9 +2418,6 @@ function enrichSpec(spec, options = {}) {
   if (allDrift.length > 0) {
     docs.drift = allDrift;
   }
-  if (allViolations.length > 0) {
-    docs.violations = allViolations;
-  }
   const driftSummary = allDrift.length > 0 ? getDriftSummary(allDrift) : undefined;
   return {
     ...spec,
@@ -2360,8 +2427,8 @@ function enrichSpec(spec, options = {}) {
   };
 }
 // src/analysis/report.ts
-import * as fs2 from "node:fs";
-import * as path2 from "node:path";
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
 
 // src/types/report.ts
 var REPORT_VERSION = "1.0.0";
@@ -2424,7 +2491,7 @@ function generateReportFromEnriched(enriched) {
     driftSummary
   };
   return {
-    $schema: "https://doccov.dev/schemas/v1.0.0/report.schema.json",
+    $schema: "https://doccov.com/schemas/v1.0.0/report.schema.json",
     version: REPORT_VERSION,
     generatedAt: new Date().toISOString(),
     spec: {
@@ -2437,23 +2504,23 @@ function generateReportFromEnriched(enriched) {
 }
 function loadCachedReport(reportPath = DEFAULT_REPORT_PATH) {
   try {
-    const fullPath = path2.resolve(reportPath);
-    if (!fs2.existsSync(fullPath)) {
+    const fullPath = path3.resolve(reportPath);
+    if (!fs3.existsSync(fullPath)) {
       return null;
     }
-    const content = fs2.readFileSync(fullPath, "utf-8");
+    const content = fs3.readFileSync(fullPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
 function saveReport(report, reportPath = DEFAULT_REPORT_PATH) {
-  const fullPath = path2.resolve(reportPath);
-  const dir = path2.dirname(fullPath);
-  if (!fs2.existsSync(dir)) {
-    fs2.mkdirSync(dir, { recursive: true });
+  const fullPath = path3.resolve(reportPath);
+  const dir = path3.dirname(fullPath);
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true });
   }
-  fs2.writeFileSync(fullPath, JSON.stringify(report, null, 2));
+  fs3.writeFileSync(fullPath, JSON.stringify(report, null, 2));
 }
 function isCachedReportValid(reportPath = DEFAULT_REPORT_PATH, sourceFiles = []) {
   const report = loadCachedReport(reportPath);
@@ -2463,7 +2530,7 @@ function isCachedReportValid(reportPath = DEFAULT_REPORT_PATH, sourceFiles = [])
   const reportTime = new Date(report.generatedAt).getTime();
   for (const file of sourceFiles) {
     try {
-      const stat = fs2.statSync(file);
+      const stat = fs3.statSync(file);
       if (stat.mtimeMs > reportTime) {
         return false;
       }
@@ -2473,16 +2540,418 @@ function isCachedReportValid(reportPath = DEFAULT_REPORT_PATH, sourceFiles = [])
   }
   return true;
 }
-// src/cache/hash.ts
-import * as crypto from "node:crypto";
-import * as fs3 from "node:fs";
-import * as path3 from "node:path";
-function hashFile(filePath) {
-  try {
-    const content = fs3.readFileSync(filePath);
-    return crypto.createHash("sha256").update(content).digest("hex").slice(0, 16);
-  } catch {
-    return null;
+function formatSignature(name, signature) {
+  const params = (signature.parameters ?? []).map((p) => {
+    const optional = p.required === false ? "?" : "";
+    const rest = p.rest ? "..." : "";
+    const typeStr = typeof p.schema === "string" ? p.schema : p.schema?.type ?? "unknown";
+    return `${rest}${p.name}${optional}: ${typeStr}`;
+  }).join(", ");
+  const returnType = signature.returns ? typeof signature.returns.schema === "string" ? signature.returns.schema : signature.returns.schema?.type ?? "unknown" : "void";
+  const typeParams = signature.typeParameters?.length ? `<${signature.typeParameters.map((tp) => tp.name).join(", ")}>` : "";
+  return `${name}${typeParams}(${params}): ${returnType}`;
+}
+function formatExportToApiSurface(exp) {
+  const lines = [];
+  lines.push(`### ${exp.name}`);
+  switch (exp.kind) {
+    case "function": {
+      const signatures = exp.signatures ?? [];
+      if (signatures.length === 0) {
+        lines.push(`\`\`\`typescript
+function ${exp.name}(): unknown
+\`\`\``);
+      } else {
+        for (const sig of signatures) {
+          lines.push(`\`\`\`typescript
+function ${formatSignature(exp.name, sig)}
+\`\`\``);
+        }
+      }
+      break;
+    }
+    case "class": {
+      const extendsClause = exp.extends ? ` extends ${exp.extends}` : "";
+      const implementsClause = exp.implements?.length ? ` implements ${exp.implements.join(", ")}` : "";
+      lines.push(`\`\`\`typescript
+class ${exp.name}${extendsClause}${implementsClause}
+\`\`\``);
+      break;
+    }
+    case "interface":
+    case "type": {
+      const typeStr = typeof exp.type === "string" ? exp.type : exp.type?.type ?? "{ ... }";
+      lines.push(`\`\`\`typescript
+type ${exp.name} = ${typeStr}
+\`\`\``);
+      break;
+    }
+    case "variable": {
+      const typeStr = typeof exp.type === "string" ? exp.type : exp.type?.type ?? "unknown";
+      lines.push(`\`\`\`typescript
+const ${exp.name}: ${typeStr}
+\`\`\``);
+      break;
+    }
+    case "enum": {
+      lines.push(`\`\`\`typescript
+enum ${exp.name} { ... }
+\`\`\``);
+      break;
+    }
+    default: {
+      lines.push(`\`\`\`typescript
+${exp.kind} ${exp.name}
+\`\`\``);
+    }
+  }
+  return lines.join(`
+`);
+}
+function formatTypeToApiSurface(type) {
+  const lines = [];
+  lines.push(`### ${type.name}`);
+  switch (type.kind) {
+    case "interface": {
+      const extendsClause = type.extends ? ` extends ${type.extends}` : "";
+      lines.push(`\`\`\`typescript
+interface ${type.name}${extendsClause} { ... }
+\`\`\``);
+      break;
+    }
+    case "type": {
+      const typeStr = typeof type.type === "string" ? type.type : type.type?.type ?? "{ ... }";
+      lines.push(`\`\`\`typescript
+type ${type.name} = ${typeStr}
+\`\`\``);
+      break;
+    }
+    case "class": {
+      const extendsClause = type.extends ? ` extends ${type.extends}` : "";
+      lines.push(`\`\`\`typescript
+class ${type.name}${extendsClause}
+\`\`\``);
+      break;
+    }
+    case "enum": {
+      lines.push(`\`\`\`typescript
+enum ${type.name} { ... }
+\`\`\``);
+      break;
+    }
+    default: {
+      lines.push(`\`\`\`typescript
+${type.kind} ${type.name}
+\`\`\``);
+    }
+  }
+  return lines.join(`
+`);
+}
+function renderApiSurface(spec) {
+  const lines = [];
+  const version = spec.meta.version ? ` v${spec.meta.version}` : "";
+  lines.push(`# API Surface: ${spec.meta.name}${version}`);
+  lines.push("");
+  lines.push("> This file is auto-generated. Do not edit manually.");
+  lines.push("> Run `doccov spec --format api-surface` to regenerate.");
+  lines.push("");
+  const exportsByKind = {};
+  for (const exp of spec.exports) {
+    const kind = exp.kind;
+    if (!exportsByKind[kind]) {
+      exportsByKind[kind] = [];
+    }
+    exportsByKind[kind].push(exp);
+  }
+  for (const kind of Object.keys(exportsByKind)) {
+    exportsByKind[kind].sort((a, b) => a.name.localeCompare(b.name));
+  }
+  const kindOrder = [
+    "function",
+    "class",
+    "interface",
+    "type",
+    "variable",
+    "enum",
+    "namespace",
+    "module"
+  ];
+  for (const kind of kindOrder) {
+    const exports = exportsByKind[kind];
+    if (!exports || exports.length === 0)
+      continue;
+    const kindTitle = kind.charAt(0).toUpperCase() + kind.slice(1) + "s";
+    lines.push(`## ${kindTitle}`);
+    lines.push("");
+    for (const exp of exports) {
+      lines.push(formatExportToApiSurface(exp));
+      lines.push("");
+    }
+  }
+  for (const kind of Object.keys(exportsByKind).sort()) {
+    if (kindOrder.includes(kind))
+      continue;
+    const exports = exportsByKind[kind];
+    if (!exports || exports.length === 0)
+      continue;
+    const kindTitle = kind.charAt(0).toUpperCase() + kind.slice(1) + "s";
+    lines.push(`## ${kindTitle}`);
+    lines.push("");
+    for (const exp of exports) {
+      lines.push(formatExportToApiSurface(exp));
+      lines.push("");
+    }
+  }
+  const types = spec.types ?? [];
+  if (types.length > 0) {
+    const sortedTypes = [...types].sort((a, b) => a.name.localeCompare(b.name));
+    lines.push("## Internal Types");
+    lines.push("");
+    for (const type of sortedTypes) {
+      lines.push(formatTypeToApiSurface(type));
+      lines.push("");
+    }
+  }
+  return lines.join(`
+`);
+}
+// src/analysis/history.ts
+import * as fs4 from "node:fs";
+import * as path4 from "node:path";
+var HISTORY_DIR = ".doccov/history";
+var RETENTION_DAYS = {
+  free: 7,
+  team: 30,
+  pro: 90
+};
+function getSnapshotFilename(timestamp) {
+  const pad = (n) => n.toString().padStart(2, "0");
+  const year = timestamp.getFullYear();
+  const month = pad(timestamp.getMonth() + 1);
+  const day = pad(timestamp.getDate());
+  const hours = pad(timestamp.getHours());
+  const minutes = pad(timestamp.getMinutes());
+  const seconds = pad(timestamp.getSeconds());
+  return `${year}-${month}-${day}-${hours}${minutes}${seconds}.json`;
+}
+function computeSnapshot(spec, options) {
+  const exports = spec.exports ?? [];
+  const documented = exports.filter((e) => e.description && e.description.trim().length > 0);
+  const driftCount = exports.reduce((sum, e) => {
+    const docs = e.docs;
+    return sum + (docs?.drift?.length ?? 0);
+  }, 0);
+  const coverageScore = exports.length > 0 ? Math.round(documented.length / exports.length * 100) : 100;
+  return {
+    timestamp: new Date().toISOString(),
+    package: spec.meta.name,
+    version: spec.meta.version,
+    coverageScore,
+    totalExports: exports.length,
+    documentedExports: documented.length,
+    driftCount,
+    commit: options?.commit,
+    branch: options?.branch
+  };
+}
+function saveSnapshot(snapshot, cwd) {
+  const historyDir = path4.resolve(cwd, HISTORY_DIR);
+  if (!fs4.existsSync(historyDir)) {
+    fs4.mkdirSync(historyDir, { recursive: true });
+  }
+  const filename = getSnapshotFilename(new Date(snapshot.timestamp));
+  const filepath = path4.join(historyDir, filename);
+  fs4.writeFileSync(filepath, JSON.stringify(snapshot, null, 2));
+}
+function loadSnapshots(cwd) {
+  const historyDir = path4.resolve(cwd, HISTORY_DIR);
+  if (!fs4.existsSync(historyDir)) {
+    return [];
+  }
+  const files = fs4.readdirSync(historyDir).filter((f) => f.endsWith(".json")).sort().reverse();
+  const snapshots = [];
+  for (const file of files) {
+    try {
+      const content = fs4.readFileSync(path4.join(historyDir, file), "utf-8");
+      snapshots.push(JSON.parse(content));
+    } catch {}
+  }
+  return snapshots;
+}
+function getTrend(spec, cwd, options) {
+  const current = computeSnapshot(spec, options);
+  const history = loadSnapshots(cwd);
+  const delta = history.length > 0 ? current.coverageScore - history[0].coverageScore : undefined;
+  const sparklineHistory = history.slice(0, 9).map((s) => s.coverageScore);
+  const sparkline = [current.coverageScore, ...sparklineHistory].reverse();
+  return {
+    current,
+    history,
+    delta,
+    sparkline
+  };
+}
+function renderSparkline(values) {
+  if (values.length === 0)
+    return "";
+  const chars = ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"];
+  const min = Math.min(...values);
+  const max = Math.max(...values);
+  const range = max - min || 1;
+  return values.map((v) => {
+    const normalized = (v - min) / range;
+    const index = Math.min(Math.floor(normalized * chars.length), chars.length - 1);
+    return chars[index];
+  }).join("");
+}
+function formatDelta(delta) {
+  if (delta > 0)
+    return `↑${delta}%`;
+  if (delta < 0)
+    return `↓${Math.abs(delta)}%`;
+  return "→0%";
+}
+function pruneHistory(cwd, keepCount = 100) {
+  const historyDir = path4.resolve(cwd, HISTORY_DIR);
+  if (!fs4.existsSync(historyDir)) {
+    return 0;
+  }
+  const files = fs4.readdirSync(historyDir).filter((f) => f.endsWith(".json")).sort().reverse();
+  const toDelete = files.slice(keepCount);
+  for (const file of toDelete) {
+    try {
+      fs4.unlinkSync(path4.join(historyDir, file));
+    } catch {}
+  }
+  return toDelete.length;
+}
+function pruneByTier(cwd, tier) {
+  const retentionDays = RETENTION_DAYS[tier];
+  const cutoffDate = new Date;
+  cutoffDate.setDate(cutoffDate.getDate() - retentionDays);
+  const historyDir = path4.resolve(cwd, HISTORY_DIR);
+  if (!fs4.existsSync(historyDir)) {
+    return 0;
+  }
+  const files = fs4.readdirSync(historyDir).filter((f) => f.endsWith(".json"));
+  let deleted = 0;
+  for (const file of files) {
+    try {
+      const filepath = path4.join(historyDir, file);
+      const content = fs4.readFileSync(filepath, "utf-8");
+      const snapshot = JSON.parse(content);
+      const snapshotDate = new Date(snapshot.timestamp);
+      if (snapshotDate < cutoffDate) {
+        fs4.unlinkSync(filepath);
+        deleted++;
+      }
+    } catch {}
+  }
+  return deleted;
+}
+function loadSnapshotsForDays(cwd, days) {
+  const cutoffDate = new Date;
+  cutoffDate.setDate(cutoffDate.getDate() - days);
+  const allSnapshots = loadSnapshots(cwd);
+  return allSnapshots.filter((s) => new Date(s.timestamp) >= cutoffDate);
+}
+function calculateVelocity(snapshots) {
+  if (snapshots.length < 2)
+    return 0;
+  const newest = snapshots[0];
+  const oldest = snapshots[snapshots.length - 1];
+  const newestDate = new Date(newest.timestamp);
+  const oldestDate = new Date(oldest.timestamp);
+  const daysDiff = (newestDate.getTime() - oldestDate.getTime()) / (1000 * 60 * 60 * 24);
+  if (daysDiff < 1)
+    return 0;
+  const coverageDiff = newest.coverageScore - oldest.coverageScore;
+  return Math.round(coverageDiff / daysDiff * 100) / 100;
+}
+function getWeekStart(date) {
+  const result = new Date(date);
+  result.setDate(result.getDate() - result.getDay());
+  result.setHours(0, 0, 0, 0);
+  return result;
+}
+function generateWeeklySummaries(snapshots) {
+  if (snapshots.length === 0)
+    return [];
+  const weeklyGroups = new Map;
+  for (const snapshot of snapshots) {
+    const weekStart = getWeekStart(new Date(snapshot.timestamp));
+    const weekKey = weekStart.toISOString().split("T")[0];
+    const group = weeklyGroups.get(weekKey) ?? [];
+    group.push(snapshot);
+    weeklyGroups.set(weekKey, group);
+  }
+  const summaries = [];
+  for (const [weekKey, weekSnapshots] of weeklyGroups) {
+    const sorted = [...weekSnapshots].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+    const weekStart = new Date(weekKey);
+    const weekEnd = new Date(weekStart);
+    weekEnd.setDate(weekEnd.getDate() + 6);
+    const scores = sorted.map((s) => s.coverageScore);
+    const avgCoverage = Math.round(scores.reduce((a, b) => a + b, 0) / scores.length);
+    const startCoverage = sorted[0].coverageScore;
+    const endCoverage = sorted[sorted.length - 1].coverageScore;
+    summaries.push({
+      weekStart: weekStart.toISOString(),
+      weekEnd: weekEnd.toISOString(),
+      avgCoverage,
+      startCoverage,
+      endCoverage,
+      delta: endCoverage - startCoverage,
+      snapshotCount: sorted.length
+    });
+  }
+  return summaries.sort((a, b) => new Date(b.weekStart).getTime() - new Date(a.weekStart).getTime());
+}
+function getExtendedTrend(spec, cwd, options) {
+  const tier = options?.tier ?? "pro";
+  const retentionDays = RETENTION_DAYS[tier];
+  const trend = getTrend(spec, cwd, options);
+  const periodSnapshots = loadSnapshotsForDays(cwd, retentionDays);
+  const snapshots7d = loadSnapshotsForDays(cwd, 7);
+  const snapshots30d = loadSnapshotsForDays(cwd, 30);
+  const snapshots90d = tier === "pro" ? loadSnapshotsForDays(cwd, 90) : [];
+  const velocity7d = calculateVelocity(snapshots7d);
+  const velocity30d = calculateVelocity(snapshots30d);
+  const velocity90d = tier === "pro" ? calculateVelocity(snapshots90d) : undefined;
+  const currentScore = trend.current.coverageScore;
+  const projected30d = Math.min(100, Math.max(0, Math.round(currentScore + velocity30d * 30)));
+  const allScores = [trend.current.coverageScore, ...trend.history.map((s) => s.coverageScore)];
+  const allTimeHigh = Math.max(...allScores);
+  const allTimeLow = Math.min(...allScores);
+  const dataRange = trend.history.length > 0 ? {
+    start: trend.history[trend.history.length - 1].timestamp,
+    end: trend.current.timestamp
+  } : null;
+  const allSnapshots = [trend.current, ...periodSnapshots];
+  const weeklySummaries = generateWeeklySummaries(allSnapshots);
+  return {
+    trend,
+    weeklySummaries,
+    velocity7d,
+    velocity30d,
+    velocity90d,
+    projected30d,
+    allTimeHigh,
+    allTimeLow,
+    dataRange
+  };
+}
+// src/cache/hash.ts
+import * as crypto from "node:crypto";
+import * as fs5 from "node:fs";
+import * as path5 from "node:path";
+function hashFile(filePath) {
+  try {
+    const content = fs5.readFileSync(filePath);
+    return crypto.createHash("sha256").update(content).digest("hex").slice(0, 16);
+  } catch {
+    return null;
   }
 }
 function hashString(content) {
@@ -2493,7 +2962,7 @@ function hashFiles(filePaths, cwd) {
   for (const filePath of filePaths) {
     const hash = hashFile(filePath);
     if (hash) {
-      const relativePath = path3.relative(cwd, filePath);
+      const relativePath = path5.relative(cwd, filePath);
       hashes[relativePath] = hash;
     }
   }
@@ -2514,17 +2983,17 @@ function diffHashes(cached, current) {
   return changed;
 }
 // src/cache/spec-cache.ts
-import * as fs4 from "node:fs";
-import * as path4 from "node:path";
+import * as fs6 from "node:fs";
+import * as path6 from "node:path";
 var CACHE_VERSION = "1.0.0";
 var SPEC_CACHE_FILE = ".doccov/spec.cache.json";
 function loadSpecCache(cwd) {
   try {
-    const cachePath = path4.resolve(cwd, SPEC_CACHE_FILE);
-    if (!fs4.existsSync(cachePath)) {
+    const cachePath = path6.resolve(cwd, SPEC_CACHE_FILE);
+    if (!fs6.existsSync(cachePath)) {
       return null;
     }
-    const content = fs4.readFileSync(cachePath, "utf-8");
+    const content = fs6.readFileSync(cachePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -2536,7 +3005,7 @@ function saveSpecCache(spec, context) {
     cacheVersion: CACHE_VERSION,
     generatedAt: new Date().toISOString(),
     specVersion: spec.openpkg,
-    entryFile: path4.relative(cwd, entryFile),
+    entryFile: path6.relative(cwd, entryFile),
     hashes: {
       tsconfig: tsconfigPath ? hashFile(tsconfigPath) : null,
       packageJson: hashFile(packageJsonPath) ?? "",
@@ -2545,19 +3014,19 @@ function saveSpecCache(spec, context) {
     config,
     spec
   };
-  const cachePath = path4.resolve(cwd, SPEC_CACHE_FILE);
-  const dir = path4.dirname(cachePath);
-  if (!fs4.existsSync(dir)) {
-    fs4.mkdirSync(dir, { recursive: true });
+  const cachePath = path6.resolve(cwd, SPEC_CACHE_FILE);
+  const dir = path6.dirname(cachePath);
+  if (!fs6.existsSync(dir)) {
+    fs6.mkdirSync(dir, { recursive: true });
   }
-  fs4.writeFileSync(cachePath, JSON.stringify(cache, null, 2));
+  fs6.writeFileSync(cachePath, JSON.stringify(cache, null, 2));
 }
 function validateSpecCache(cache, context) {
   const { entryFile, sourceFiles, tsconfigPath, packageJsonPath, config, cwd } = context;
   if (cache.cacheVersion !== CACHE_VERSION) {
     return { valid: false, reason: "cache-version-mismatch" };
   }
-  const relativeEntry = path4.relative(cwd, entryFile);
+  const relativeEntry = path6.relative(cwd, entryFile);
   if (cache.entryFile !== relativeEntry) {
     return { valid: false, reason: "entry-file-changed" };
   }
@@ -2580,34 +3049,34 @@ function validateSpecCache(cache, context) {
   return { valid: true };
 }
 function clearSpecCache(cwd) {
-  const cachePath = path4.resolve(cwd, SPEC_CACHE_FILE);
-  if (fs4.existsSync(cachePath)) {
-    fs4.unlinkSync(cachePath);
+  const cachePath = path6.resolve(cwd, SPEC_CACHE_FILE);
+  if (fs6.existsSync(cachePath)) {
+    fs6.unlinkSync(cachePath);
     return true;
   }
   return false;
 }
 function getSpecCachePath(cwd) {
-  return path4.resolve(cwd, SPEC_CACHE_FILE);
+  return path6.resolve(cwd, SPEC_CACHE_FILE);
 }
 // src/config/types.ts
 function defineConfig(config) {
   return config;
 }
 // src/detect/utils.ts
-async function safeParseJson(fs5, path5) {
+async function safeParseJson(fs7, path7) {
   try {
-    if (!await fs5.exists(path5))
+    if (!await fs7.exists(path7))
       return null;
-    const content = await fs5.readFile(path5);
+    const content = await fs7.readFile(path7);
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
-async function readPackageJson(fs5, dir) {
-  const path5 = dir === "." ? "package.json" : `${dir}/package.json`;
-  return safeParseJson(fs5, path5);
+async function readPackageJson(fs7, dir) {
+  const path7 = dir === "." ? "package.json" : `${dir}/package.json`;
+  return safeParseJson(fs7, path7);
 }
 
 // src/detect/build.ts
@@ -2637,8 +3106,8 @@ var BUILD_TOOL_PATTERNS = [
   "babel",
   "ncc build"
 ];
-async function detectBuildInfo(fs5, packagePath = ".") {
-  const pkgJson = await readPackageJson(fs5, packagePath);
+async function detectBuildInfo(fs7, packagePath = ".") {
+  const pkgJson = await readPackageJson(fs7, packagePath);
   const scripts = pkgJson?.scripts ?? {};
   const scriptNames = Object.keys(scripts);
   const buildScriptsByName = scriptNames.filter((name) => BUILD_SCRIPT_NAMES.has(name) || BUILD_SCRIPT_PREFIXES.some((prefix) => name.startsWith(prefix)));
@@ -2650,10 +3119,10 @@ async function detectBuildInfo(fs5, packagePath = ".") {
   });
   const buildScripts = [...new Set([...buildScriptsByName, ...buildScriptsByContent])];
   const tsconfigPath = packagePath === "." ? "tsconfig.json" : `${packagePath}/tsconfig.json`;
-  const hasTsConfig = await fs5.exists(tsconfigPath);
+  const hasTsConfig = await fs7.exists(tsconfigPath);
   const hasTsDep = pkgJson?.devDependencies?.typescript !== undefined || pkgJson?.dependencies?.typescript !== undefined;
   const hasTypeScript = hasTsConfig || hasTsDep;
-  const wasm = await detectWasmProject(fs5, packagePath, pkgJson);
+  const wasm = await detectWasmProject(fs7, packagePath, pkgJson);
   const napi = detectNapiProject(pkgJson);
   return {
     scripts: buildScripts,
@@ -2670,11 +3139,11 @@ var WASM_PACKAGES = new Set([
   "wasm-bindgen",
   "@aspect/aspect-cli"
 ]);
-async function detectWasmProject(fs5, packagePath, pkgJson) {
+async function detectWasmProject(fs7, packagePath, pkgJson) {
   const pkgCargoPath = packagePath === "." ? "Cargo.toml" : `${packagePath}/Cargo.toml`;
-  if (await fs5.exists(pkgCargoPath))
+  if (await fs7.exists(pkgCargoPath))
     return true;
-  if (packagePath !== "." && await fs5.exists("Cargo.toml"))
+  if (packagePath !== "." && await fs7.exists("Cargo.toml"))
     return true;
   if (pkgJson) {
     const deps = Object.keys({
@@ -2715,15 +3184,15 @@ function getPrimaryBuildScript(buildInfo) {
   return buildInfo.scripts[0] ?? null;
 }
 // src/detect/entry-point.ts
-async function detectEntryPoint(fs5, packagePath = ".") {
-  const pkgJson = await readPackageJson(fs5, packagePath);
+async function detectEntryPoint(fs7, packagePath = ".") {
+  const pkgJson = await readPackageJson(fs7, packagePath);
   if (!pkgJson) {
     throw new Error("No package.json found - not a valid npm package");
   }
-  const tsConfig = await parseTsConfig(fs5, packagePath);
+  const tsConfig = await parseTsConfig(fs7, packagePath);
   const typesField = pkgJson.types || pkgJson.typings;
   if (typesField && typeof typesField === "string") {
-    const resolved = await resolveToSource(fs5, packagePath, typesField, tsConfig);
+    const resolved = await resolveToSource(fs7, packagePath, typesField, tsConfig);
     if (resolved) {
       return { ...resolved, source: "types" };
     }
@@ -2733,7 +3202,7 @@ async function detectEntryPoint(fs5, packagePath = ".") {
     if (dotExport && typeof dotExport === "object" && "types" in dotExport) {
       const typesPath = dotExport.types;
       if (typesPath && typeof typesPath === "string") {
-        const resolved = await resolveToSource(fs5, packagePath, typesPath, tsConfig);
+        const resolved = await resolveToSource(fs7, packagePath, typesPath, tsConfig);
         if (resolved) {
           return { ...resolved, source: "exports" };
         }
@@ -2741,13 +3210,13 @@ async function detectEntryPoint(fs5, packagePath = ".") {
     }
   }
   if (pkgJson.main && typeof pkgJson.main === "string") {
-    const resolved = await resolveToSource(fs5, packagePath, pkgJson.main, tsConfig);
+    const resolved = await resolveToSource(fs7, packagePath, pkgJson.main, tsConfig);
     if (resolved) {
       return { ...resolved, source: "main" };
     }
   }
   if (pkgJson.module && typeof pkgJson.module === "string") {
-    const resolved = await resolveToSource(fs5, packagePath, pkgJson.module, tsConfig);
+    const resolved = await resolveToSource(fs7, packagePath, pkgJson.module, tsConfig);
     if (resolved) {
       return { ...resolved, source: "module" };
     }
@@ -2765,27 +3234,27 @@ async function detectEntryPoint(fs5, packagePath = ".") {
   ];
   for (const fallback of fallbacks) {
     const checkPath = packagePath === "." ? fallback : `${packagePath}/${fallback}`;
-    if (await fs5.exists(checkPath)) {
+    if (await fs7.exists(checkPath)) {
       return { path: fallback, source: "fallback", isDeclarationOnly: false };
     }
   }
   throw new Error("Could not detect TypeScript entry point. No types field in package.json and no common entry paths found.");
 }
-async function parseTsConfig(fs5, packagePath) {
+async function parseTsConfig(fs7, packagePath) {
   const tsconfigPath = packagePath === "." ? "tsconfig.json" : `${packagePath}/tsconfig.json`;
-  const tsconfig = await safeParseJson(fs5, tsconfigPath);
+  const tsconfig = await safeParseJson(fs7, tsconfigPath);
   if (!tsconfig?.compilerOptions) {
     return null;
   }
   const { outDir, rootDir, baseUrl, paths } = tsconfig.compilerOptions;
   return { outDir, rootDir, baseUrl, paths };
 }
-async function resolveToSource(fs5, basePath, filePath, tsConfig) {
+async function resolveToSource(fs7, basePath, filePath, tsConfig) {
   const normalized = filePath.replace(/^\.\//, "");
   const checkPath = (p) => basePath === "." ? p : `${basePath}/${p}`;
   const isSourceTs = normalized.endsWith(".ts") && !normalized.endsWith(".d.ts") || normalized.endsWith(".tsx");
   if (isSourceTs) {
-    if (await fs5.exists(checkPath(normalized))) {
+    if (await fs7.exists(checkPath(normalized))) {
       return { path: normalized, isDeclarationOnly: false };
     }
   }
@@ -2827,19 +3296,19 @@ async function resolveToSource(fs5, basePath, filePath, tsConfig) {
   for (const candidate of candidates) {
     if (candidate.endsWith(".d.ts"))
       continue;
-    if (await fs5.exists(checkPath(candidate))) {
+    if (await fs7.exists(checkPath(candidate))) {
       return { path: candidate, isDeclarationOnly: false };
     }
   }
   if (normalized.endsWith(".d.ts")) {
-    if (await fs5.exists(checkPath(normalized))) {
+    if (await fs7.exists(checkPath(normalized))) {
       return { path: normalized, isDeclarationOnly: true };
     }
   }
   return null;
 }
 // src/detect/filesystem.ts
-import * as fs5 from "node:fs";
+import * as fs7 from "node:fs";
 import * as nodePath from "node:path";
 import { Writable } from "node:stream";
 
@@ -2852,19 +3321,19 @@ class NodeFileSystem {
     return nodePath.join(this.basePath, relativePath);
   }
   async exists(relativePath) {
-    return fs5.existsSync(this.resolve(relativePath));
+    return fs7.existsSync(this.resolve(relativePath));
   }
   async readFile(relativePath) {
-    return fs5.readFileSync(this.resolve(relativePath), "utf-8");
+    return fs7.readFileSync(this.resolve(relativePath), "utf-8");
   }
   async readDir(relativePath) {
-    return fs5.readdirSync(this.resolve(relativePath));
+    return fs7.readdirSync(this.resolve(relativePath));
   }
   async isDirectory(relativePath) {
     const fullPath = this.resolve(relativePath);
-    if (!fs5.existsSync(fullPath))
+    if (!fs7.existsSync(fullPath))
       return false;
-    return fs5.statSync(fullPath).isDirectory();
+    return fs7.statSync(fullPath).isDirectory();
   }
 }
 function createCaptureStream() {
@@ -2880,9 +3349,9 @@ function createCaptureStream() {
 
 class FileNotFoundError extends Error {
   path;
-  constructor(path5, message) {
-    super(message ?? `File not found: ${path5}`);
-    this.path = path5;
+  constructor(path7, message) {
+    super(message ?? `File not found: ${path7}`);
+    this.path = path7;
     this.name = "FileNotFoundError";
   }
 }
@@ -2892,34 +3361,34 @@ class SandboxFileSystem {
   constructor(sandbox) {
     this.sandbox = sandbox;
   }
-  async exists(path5) {
+  async exists(path7) {
     const result = await this.sandbox.runCommand({
       cmd: "test",
-      args: ["-e", path5]
+      args: ["-e", path7]
     });
     return result.exitCode === 0;
   }
-  async readFile(path5) {
-    const exists = await this.exists(path5);
+  async readFile(path7) {
+    const exists = await this.exists(path7);
     if (!exists) {
-      throw new FileNotFoundError(path5);
+      throw new FileNotFoundError(path7);
     }
     const capture = createCaptureStream();
     const result = await this.sandbox.runCommand({
       cmd: "cat",
-      args: [path5],
+      args: [path7],
       stdout: capture.stream
     });
     if (result.exitCode !== 0) {
-      throw new FileNotFoundError(path5, `Failed to read file: ${path5}`);
+      throw new FileNotFoundError(path7, `Failed to read file: ${path7}`);
     }
     return capture.getOutput();
   }
-  async readDir(path5) {
+  async readDir(path7) {
     const capture = createCaptureStream();
     const result = await this.sandbox.runCommand({
       cmd: "ls",
-      args: ["-1", path5],
+      args: ["-1", path7],
       stdout: capture.stream
     });
     if (result.exitCode !== 0) {
@@ -2928,20 +3397,20 @@ class SandboxFileSystem {
     return capture.getOutput().split(`
 `).filter(Boolean);
   }
-  async isDirectory(path5) {
+  async isDirectory(path7) {
     const result = await this.sandbox.runCommand({
       cmd: "test",
-      args: ["-d", path5]
+      args: ["-d", path7]
     });
     return result.exitCode === 0;
   }
 }
 // src/detect/monorepo.ts
-async function detectMonorepo(fs6) {
-  const pkgJson = await readPackageJson(fs6, ".");
+async function detectMonorepo(fs8) {
+  const pkgJson = await readPackageJson(fs8, ".");
   if (pkgJson?.workspaces) {
     const patterns = extractWorkspacePatterns(pkgJson.workspaces);
-    const packages = await resolveWorkspacePackages(fs6, patterns, pkgJson.name, pkgJson.private);
+    const packages = await resolveWorkspacePackages(fs8, patterns, pkgJson.name, pkgJson.private);
     return {
       isMonorepo: packages.length > 0,
       type: "npm-workspaces",
@@ -2949,10 +3418,10 @@ async function detectMonorepo(fs6) {
       packages
     };
   }
-  if (await fs6.exists("pnpm-workspace.yaml")) {
-    const content = await fs6.readFile("pnpm-workspace.yaml");
+  if (await fs8.exists("pnpm-workspace.yaml")) {
+    const content = await fs8.readFile("pnpm-workspace.yaml");
     const patterns = parsePnpmWorkspace(content);
-    const packages = await resolveWorkspacePackages(fs6, patterns, pkgJson?.name, pkgJson?.private);
+    const packages = await resolveWorkspacePackages(fs8, patterns, pkgJson?.name, pkgJson?.private);
     return {
       isMonorepo: packages.length > 0,
       type: "pnpm-workspaces",
@@ -2960,10 +3429,10 @@ async function detectMonorepo(fs6) {
       packages
     };
   }
-  if (await fs6.exists("lerna.json")) {
-    const lerna = await safeParseJson(fs6, "lerna.json");
+  if (await fs8.exists("lerna.json")) {
+    const lerna = await safeParseJson(fs8, "lerna.json");
     const patterns = lerna?.packages ?? ["packages/*"];
-    const packages = await resolveWorkspacePackages(fs6, patterns, pkgJson?.name, pkgJson?.private);
+    const packages = await resolveWorkspacePackages(fs8, patterns, pkgJson?.name, pkgJson?.private);
     return {
       isMonorepo: packages.length > 0,
       type: "lerna",
@@ -3037,7 +3506,7 @@ function parsePnpmWorkspace(content) {
   }
   return patterns.length > 0 ? patterns : ["packages/*"];
 }
-async function resolveWorkspacePackages(fs6, patterns, rootPackageName, rootIsPrivate) {
+async function resolveWorkspacePackages(fs8, patterns, rootPackageName, rootIsPrivate) {
   const packages = [];
   const seen = new Set;
   if (rootPackageName && !rootIsPrivate && rootPackageName !== "root") {
@@ -3059,18 +3528,18 @@ async function resolveWorkspacePackages(fs6, patterns, rootPackageName, rootIsPr
   }
   dirsToScan.add("packages");
   for (const dir of dirsToScan) {
-    if (!await fs6.exists(dir))
+    if (!await fs8.exists(dir))
       continue;
-    if (!await fs6.isDirectory(dir))
+    if (!await fs8.isDirectory(dir))
       continue;
-    const subdirs = await fs6.readDir(dir);
+    const subdirs = await fs8.readDir(dir);
     for (const subdir of subdirs) {
       const pkgPath = `${dir}/${subdir}`;
       const pkgJsonPath = `${pkgPath}/package.json`;
-      if (!await fs6.exists(pkgJsonPath))
+      if (!await fs8.exists(pkgJsonPath))
         continue;
       try {
-        const content = await fs6.readFile(pkgJsonPath);
+        const content = await fs8.readFile(pkgJsonPath);
         const pkg = JSON.parse(content);
         if (pkg.name && !seen.has(pkg.name)) {
           seen.add(pkg.name);
@@ -3142,14 +3611,14 @@ var DEFAULT_PM = {
   installArgs: ["install", "--legacy-peer-deps"],
   runPrefix: ["npm", "run"]
 };
-async function detectPackageManager(fs6) {
-  const pkgJson = await safeParseJson(fs6, "package.json");
+async function detectPackageManager(fs8) {
+  const pkgJson = await safeParseJson(fs8, "package.json");
   if (pkgJson?.packageManager) {
     const pmName = parsePackageManagerField(pkgJson.packageManager);
     if (pmName && PM_CONFIGS[pmName]) {
       const config = PM_CONFIGS[pmName];
       for (const lockfile of config.lockfiles) {
-        if (await fs6.exists(lockfile)) {
+        if (await fs8.exists(lockfile)) {
           return { ...config.info, lockfile };
         }
       }
@@ -3159,7 +3628,7 @@ async function detectPackageManager(fs6) {
   const foundLockfiles = [];
   for (const [pmName, config] of Object.entries(PM_CONFIGS)) {
     for (const lockfile of config.lockfiles) {
-      if (await fs6.exists(lockfile)) {
+      if (await fs8.exists(lockfile)) {
         foundLockfiles.push({ lockfile, pm: pmName });
       }
     }
@@ -3191,10 +3660,10 @@ function getRunCommand(pm, script) {
   return [...pm.runPrefix, script];
 }
 // src/detect/index.ts
-async function analyzeProject(fs6, options = {}) {
+async function analyzeProject(fs8, options = {}) {
   const [packageManager, monorepo] = await Promise.all([
-    detectPackageManager(fs6),
-    detectMonorepo(fs6)
+    detectPackageManager(fs8),
+    detectMonorepo(fs8)
   ]);
   let targetPath = ".";
   if (monorepo.isMonorepo) {
@@ -3211,8 +3680,8 @@ async function analyzeProject(fs6, options = {}) {
     targetPath = pkg.path;
   }
   const [entryPoint, build] = await Promise.all([
-    detectEntryPoint(fs6, targetPath),
-    detectBuildInfo(fs6, targetPath)
+    detectEntryPoint(fs8, targetPath),
+    detectBuildInfo(fs8, targetPath)
   ]);
   return { packageManager, monorepo, entryPoint, build };
 }
@@ -3256,17 +3725,17 @@ function shouldValidate(validations, check) {
   return validations.includes(check);
 }
 // src/typecheck/example-typechecker.ts
-import * as fs6 from "node:fs";
-import * as path5 from "node:path";
+import * as fs8 from "node:fs";
+import * as path7 from "node:path";
 import ts3 from "typescript";
 function stripCodeBlockMarkers(code) {
   return code.replace(/^```(?:ts|typescript|js|javascript)?\n?/i, "").replace(/\n?```$/i, "").trim();
 }
 function getPackageName(packagePath) {
-  const pkgJsonPath = path5.join(packagePath, "package.json");
-  if (fs6.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path7.join(packagePath, "package.json");
+  if (fs8.existsSync(pkgJsonPath)) {
     try {
-      const pkgJson = JSON.parse(fs6.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
       return pkgJson.name;
     } catch {
       return;
@@ -3276,12 +3745,12 @@ function getPackageName(packagePath) {
 }
 function findTsConfig(packagePath) {
   let dir = packagePath;
-  while (dir !== path5.dirname(dir)) {
-    const tsConfigPath = path5.join(dir, "tsconfig.json");
-    if (fs6.existsSync(tsConfigPath)) {
+  while (dir !== path7.dirname(dir)) {
+    const tsConfigPath = path7.join(dir, "tsconfig.json");
+    if (fs8.existsSync(tsConfigPath)) {
       return tsConfigPath;
     }
-    dir = path5.dirname(dir);
+    dir = path7.dirname(dir);
   }
   return;
 }
@@ -3297,10 +3766,10 @@ function createVirtualSource(example, packageName, exportNames) {
 `);
 }
 function getCompilerOptions(tsconfigPath) {
-  if (tsconfigPath && fs6.existsSync(tsconfigPath)) {
+  if (tsconfigPath && fs8.existsSync(tsconfigPath)) {
     const configFile = ts3.readConfigFile(tsconfigPath, ts3.sys.readFile);
     if (!configFile.error) {
-      const parsed = ts3.parseJsonConfigFileContent(configFile.config, ts3.sys, path5.dirname(tsconfigPath));
+      const parsed = ts3.parseJsonConfigFileContent(configFile.config, ts3.sys, path7.dirname(tsconfigPath));
       return {
         ...parsed.options,
         noEmit: true,
@@ -3326,7 +3795,7 @@ function typecheckExample(example, packagePath, options = {}) {
   const tsconfigPath = options.tsconfig ?? findTsConfig(packagePath);
   const compilerOptions = getCompilerOptions(tsconfigPath);
   const virtualSource = createVirtualSource(cleanCode, packageName, exportNames);
-  const virtualFileName = path5.join(packagePath, "__doccov_example__.ts");
+  const virtualFileName = path7.join(packagePath, "__doccov_example__.ts");
   const hasImport = packageName !== undefined && exportNames && exportNames.length > 0;
   const lineOffset = hasImport ? 2 : 0;
   const sourceFile = ts3.createSourceFile(virtualFileName, virtualSource, ts3.ScriptTarget.ES2022, true);
@@ -3397,25 +3866,25 @@ function typecheckExamples(examples, packagePath, options = {}) {
 }
 
 // src/utils/example-runner.ts
-import { spawn } from "node:child_process";
-import * as fs7 from "node:fs";
+import { spawn as spawn2 } from "node:child_process";
+import * as fs9 from "node:fs";
 import * as os from "node:os";
-import * as path6 from "node:path";
+import * as path8 from "node:path";
 function stripCodeBlockMarkers2(code) {
   return code.replace(/^```(?:ts|typescript|js|javascript)?\n?/i, "").replace(/\n?```$/i, "").trim();
 }
 async function runExample(code, options = {}) {
   const { timeout = 5000, cwd = process.cwd() } = options;
   const cleanCode = stripCodeBlockMarkers2(code);
-  const tmpFile = path6.join(cwd, `doccov-example-${Date.now()}-${Math.random().toString(36).slice(2)}.ts`);
+  const tmpFile = path8.join(cwd, `doccov-example-${Date.now()}-${Math.random().toString(36).slice(2)}.ts`);
   try {
-    fs7.writeFileSync(tmpFile, cleanCode, "utf-8");
+    fs9.writeFileSync(tmpFile, cleanCode, "utf-8");
     const startTime = Date.now();
-    return await new Promise((resolve4) => {
+    return await new Promise((resolve5) => {
       let stdout = "";
       let stderr = "";
       let killed = false;
-      const proc = spawn("node", ["--experimental-strip-types", tmpFile], {
+      const proc = spawn2("node", ["--experimental-strip-types", tmpFile], {
         cwd,
         timeout,
         stdio: ["ignore", "pipe", "pipe"]
@@ -3434,7 +3903,7 @@ async function runExample(code, options = {}) {
         clearTimeout(timeoutId);
         const duration = Date.now() - startTime;
         if (killed) {
-          resolve4({
+          resolve5({
             success: false,
             stdout,
             stderr: stderr || `Example timed out after ${timeout}ms`,
@@ -3442,7 +3911,7 @@ async function runExample(code, options = {}) {
             duration
           });
         } else {
-          resolve4({
+          resolve5({
             success: exitCode === 0,
             stdout,
             stderr,
@@ -3453,7 +3922,7 @@ async function runExample(code, options = {}) {
       });
       proc.on("error", (error) => {
         clearTimeout(timeoutId);
-        resolve4({
+        resolve5({
           success: false,
           stdout,
           stderr: error.message,
@@ -3464,7 +3933,7 @@ async function runExample(code, options = {}) {
     });
   } finally {
     try {
-      fs7.unlinkSync(tmpFile);
+      fs9.unlinkSync(tmpFile);
     } catch {}
   }
 }
@@ -3479,15 +3948,15 @@ async function runExamples(examples, options = {}) {
   return results;
 }
 function detectPackageManager2(cwd) {
-  if (fs7.existsSync(path6.join(cwd, "bun.lockb")))
+  if (fs9.existsSync(path8.join(cwd, "bun.lockb")))
     return "bun";
-  if (fs7.existsSync(path6.join(cwd, "bun.lock")))
+  if (fs9.existsSync(path8.join(cwd, "bun.lock")))
     return "bun";
-  if (fs7.existsSync(path6.join(cwd, "pnpm-lock.yaml")))
+  if (fs9.existsSync(path8.join(cwd, "pnpm-lock.yaml")))
     return "pnpm";
-  if (fs7.existsSync(path6.join(cwd, "yarn.lock")))
+  if (fs9.existsSync(path8.join(cwd, "yarn.lock")))
     return "yarn";
-  if (fs7.existsSync(path6.join(cwd, "package-lock.json")))
+  if (fs9.existsSync(path8.join(cwd, "package-lock.json")))
     return "npm";
   return "npm";
 }
@@ -3504,11 +3973,11 @@ function getInstallCommand2(pm, packagePath) {
   }
 }
 async function runCommand(cmd, args, options) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     let stdout = "";
     let stderr = "";
     let killed = false;
-    const proc = spawn(cmd, args, {
+    const proc = spawn2(cmd, args, {
       cwd: options.cwd,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -3525,14 +3994,14 @@ async function runCommand(cmd, args, options) {
     proc.on("close", (exitCode) => {
       clearTimeout(timeoutId);
       if (killed) {
-        resolve4({
+        resolve5({
           success: false,
           stdout,
           stderr: stderr || `Command timed out after ${options.timeout}ms`,
           exitCode: exitCode ?? 1
         });
       } else {
-        resolve4({
+        resolve5({
           success: exitCode === 0,
           stdout,
           stderr,
@@ -3542,7 +4011,7 @@ async function runCommand(cmd, args, options) {
     });
     proc.on("error", (error) => {
       clearTimeout(timeoutId);
-      resolve4({
+      resolve5({
         success: false,
         stdout,
         stderr: error.message,
@@ -3555,12 +4024,12 @@ async function runExamplesWithPackage(examples, options) {
   const { packagePath, packageManager, installTimeout = 60000, timeout = 5000 } = options;
   const startTime = Date.now();
   const results = new Map;
-  const absolutePackagePath = path6.resolve(packagePath);
-  const workDir = path6.join(os.tmpdir(), `doccov-examples-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  const absolutePackagePath = path8.resolve(packagePath);
+  const workDir = path8.join(os.tmpdir(), `doccov-examples-${Date.now()}-${Math.random().toString(36).slice(2)}`);
   try {
-    fs7.mkdirSync(workDir, { recursive: true });
+    fs9.mkdirSync(workDir, { recursive: true });
     const pkgJson = { name: "doccov-example-runner", type: "module" };
-    fs7.writeFileSync(path6.join(workDir, "package.json"), JSON.stringify(pkgJson, null, 2));
+    fs9.writeFileSync(path8.join(workDir, "package.json"), JSON.stringify(pkgJson, null, 2));
     const pm = packageManager ?? detectPackageManager2(options.cwd ?? process.cwd());
     const { cmd, args } = getInstallCommand2(pm, absolutePackagePath);
     const installResult = await runCommand(cmd, args, {
@@ -3588,7 +4057,7 @@ async function runExamplesWithPackage(examples, options) {
     };
   } finally {
     try {
-      fs7.rmSync(workDir, { recursive: true, force: true });
+      fs9.rmSync(workDir, { recursive: true, force: true });
     } catch {}
   }
 }
@@ -3767,9 +4236,12 @@ async function validateExamples(exports, options) {
   }
   return result;
 }
+// src/extractor.ts
+import * as path13 from "node:path";
+
 // src/analysis/run-analysis.ts
-import * as fs9 from "node:fs";
-import * as path10 from "node:path";
+import * as fs11 from "node:fs";
+import * as path12 from "node:path";
 // src/utils/type-utils.ts
 function getTypeId(type, typeChecker) {
   const internalId = type.id;
@@ -3892,7 +4364,7 @@ function collectReferencedTypesFromNode(node, typeChecker, referencedTypes) {
 }
 
 // src/analysis/context.ts
-import * as path8 from "node:path";
+import * as path10 from "node:path";
 
 // src/options.ts
 var DEFAULT_MAX_TYPE_DEPTH = 20;
@@ -3913,7 +4385,7 @@ function normalizeDocCovOptions(options = {}) {
 }
 
 // src/analysis/program.ts
-import * as path7 from "node:path";
+import * as path9 from "node:path";
 var DEFAULT_COMPILER_OPTIONS = {
   target: ts.ScriptTarget.Latest,
   module: ts.ModuleKind.CommonJS,
@@ -3923,14 +4395,14 @@ var DEFAULT_COMPILER_OPTIONS = {
 };
 function createProgram({
   entryFile,
-  baseDir = path7.dirname(entryFile),
+  baseDir = path9.dirname(entryFile),
   content
 }) {
   const configPath = ts.findConfigFile(baseDir, ts.sys.fileExists, "tsconfig.json");
   let compilerOptions = { ...DEFAULT_COMPILER_OPTIONS };
   if (configPath) {
     const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
-    const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path7.dirname(configPath));
+    const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path9.dirname(configPath));
     compilerOptions = { ...compilerOptions, ...parsedConfig.options };
   }
   const allowJsVal = compilerOptions.allowJs;
@@ -3965,9 +4437,10 @@ function createAnalysisContext({
   entryFile,
   packageDir,
   content,
-  options
+  options,
+  detectedSchemas
 }) {
-  const baseDir = packageDir ?? path8.dirname(entryFile);
+  const baseDir = packageDir ?? path10.dirname(entryFile);
   const normalizedOptions = normalizeDocCovOptions(options);
   const programResult = createProgram({ entryFile, baseDir, content });
   if (!programResult.sourceFile) {
@@ -3982,13 +4455,14 @@ function createAnalysisContext({
     compilerOptions: programResult.compilerOptions,
     compilerHost: programResult.compilerHost,
     options: normalizedOptions,
-    configPath: programResult.configPath
+    configPath: programResult.configPath,
+    detectedSchemas
   };
 }
 
 // src/analysis/spec-builder.ts
-import * as fs8 from "node:fs";
-import * as path9 from "node:path";
+import * as fs10 from "node:fs";
+import * as path11 from "node:path";
 import { SCHEMA_URL, SCHEMA_VERSION } from "@openpkg-ts/spec";
 
 // src/analysis/decorator-utils.ts
@@ -4020,354 +4494,100 @@ function extractParameterDecorators(param) {
   return extractDecorators(param);
 }
 
-// src/utils/typebox-handler.ts
-var TYPEBOX_PRIMITIVE_MAP = {
-  TString: { type: "string" },
-  TNumber: { type: "number" },
-  TBoolean: { type: "boolean" },
-  TInteger: { type: "integer" },
-  TNull: { type: "null" },
-  TAny: {},
-  TUnknown: {},
-  TNever: { not: {} },
-  TVoid: { type: "null" },
-  TUndefined: { type: "null" }
+// src/utils/schema-builder.ts
+var BUILTIN_TYPE_SCHEMAS = {
+  Date: { type: "string", format: "date-time" },
+  RegExp: { type: "object", description: "RegExp" },
+  Error: { type: "object" },
+  Promise: { type: "object" },
+  Map: { type: "object" },
+  Set: { type: "object" },
+  WeakMap: { type: "object" },
+  WeakSet: { type: "object" },
+  Function: { type: "object" },
+  ArrayBuffer: { type: "string", format: "binary" },
+  ArrayBufferLike: { type: "string", format: "binary" },
+  DataView: { type: "string", format: "binary" },
+  Uint8Array: { type: "string", format: "byte" },
+  Uint16Array: { type: "string", format: "byte" },
+  Uint32Array: { type: "string", format: "byte" },
+  Int8Array: { type: "string", format: "byte" },
+  Int16Array: { type: "string", format: "byte" },
+  Int32Array: { type: "string", format: "byte" },
+  Float32Array: { type: "string", format: "byte" },
+  Float64Array: { type: "string", format: "byte" },
+  BigInt64Array: { type: "string", format: "byte" },
+  BigUint64Array: { type: "string", format: "byte" }
 };
-function isTypeBoxSchemaType(symbolName) {
-  return /^T[A-Z][a-zA-Z]*$/.test(symbolName);
-}
-function isInternalProperty(name) {
-  return name.startsWith("__@");
-}
-function isTypeBoxOptionalMarker(type) {
-  const props = type.getProperties();
-  if (props.length !== 1)
+function isObjectLiteralType(type) {
+  if (!(type.getFlags() & ts.TypeFlags.Object)) {
     return false;
-  return isInternalProperty(props[0].getName());
+  }
+  const objectFlags = type.objectFlags;
+  return (objectFlags & ts.ObjectFlags.ObjectLiteral) !== 0;
 }
-function unwrapTypeBoxOptional(type) {
-  if (!type.isIntersection()) {
-    return { innerTypes: [type], isOptional: false };
+function isPureRefSchema(value) {
+  return Object.keys(value).length === 1 && "$ref" in value;
+}
+function withDescription(schema, description) {
+  if (isPureRefSchema(schema)) {
+    return {
+      allOf: [schema],
+      description
+    };
   }
-  const intersectionType = type;
-  const filtered = intersectionType.types.filter((t) => !isTypeBoxOptionalMarker(t));
-  const hadMarker = filtered.length < intersectionType.types.length;
-  return { innerTypes: filtered, isOptional: hadMarker };
+  return {
+    ...schema,
+    description
+  };
 }
-function getPropertyType(prop, parentType, typeChecker) {
-  if (prop.valueDeclaration) {
-    return typeChecker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration);
+function propertiesToSchema(properties, description) {
+  const schema = {
+    type: "object",
+    properties: {}
+  };
+  const required = [];
+  for (const prop of properties) {
+    const propType = prop.type;
+    let propSchema;
+    if (typeof propType === "string") {
+      if (["string", "number", "boolean", "bigint", "null"].includes(propType)) {
+        propSchema = { type: propType === "bigint" ? "string" : propType };
+      } else {
+        propSchema = { type: propType };
+      }
+    } else if (propType && typeof propType === "object") {
+      propSchema = propType;
+    } else {
+      propSchema = { type: "any" };
+    }
+    if (prop.description && typeof propSchema === "object") {
+      propSchema = withDescription(propSchema, prop.description);
+    }
+    schema.properties[prop.name] = propSchema;
+    if (!prop.optional) {
+      required.push(prop.name);
+    }
   }
-  const propType = typeChecker.getTypeOfPropertyOfType(parentType, prop.getName());
-  if (propType) {
-    return propType;
+  if (required.length > 0) {
+    schema.required = required;
   }
-  const decl = prop.declarations?.[0];
-  if (decl) {
-    return typeChecker.getTypeOfSymbolAtLocation(prop, decl);
+  if (description) {
+    return withDescription(schema, description);
   }
-  return typeChecker.getAnyType();
+  return schema;
 }
 var _formatTypeReference = null;
-function setFormatTypeReference(fn) {
+function setSchemaBuilderFormatTypeReference(fn) {
   _formatTypeReference = fn;
 }
-function formatTypeReferenceInternal(type, typeChecker, typeRefs, referencedTypes, visited, depth, maxDepth, typeIds) {
-  if (_formatTypeReference) {
-    return _formatTypeReference(type, typeChecker, typeRefs, referencedTypes, visited, depth, maxDepth, typeIds);
+function buildSchemaFromTypeNode(node, typeChecker, typeRefs, referencedTypes, functionDoc, parentParamName) {
+  if (ts.isParenthesizedTypeNode(node)) {
+    return buildSchemaFromTypeNode(node.type, typeChecker, typeRefs, referencedTypes, functionDoc ?? null, parentParamName);
   }
-  return { type: "object" };
-}
-function formatTypeBoxSchema(type, typeChecker, typeRefs, referencedTypes, visited, depth = 0, maxDepth = DEFAULT_MAX_TYPE_DEPTH, typeIds) {
-  if (depth > maxDepth) {
-    return { type: "unknown" };
-  }
-  const symbol = type.getSymbol();
-  if (!symbol)
-    return null;
-  const symbolName = symbol.getName();
-  if (TYPEBOX_PRIMITIVE_MAP[symbolName]) {
-    return { ...TYPEBOX_PRIMITIVE_MAP[symbolName] };
-  }
-  const objectType = type;
-  if (!(objectType.objectFlags & ts.ObjectFlags.Reference)) {
-    return null;
-  }
-  const typeRef = type;
-  const typeArgs = typeRef.typeArguments;
-  switch (symbolName) {
-    case "TObject": {
-      if (!typeArgs || typeArgs.length === 0) {
-        return { type: "object" };
-      }
-      const propsType = typeArgs[0];
-      const properties = {};
-      const required = [];
-      for (const prop of propsType.getProperties()) {
-        const propName = prop.getName();
-        if (isInternalProperty(propName)) {
-          continue;
-        }
-        const propType = getPropertyType(prop, propsType, typeChecker);
-        const propSymbol = propType.getSymbol();
-        const propSymbolName = propSymbol?.getName();
-        if (propSymbolName && typeRefs.has(propSymbolName)) {
-          properties[propName] = { $ref: `#/types/${propSymbolName}` };
-        } else if (propSymbolName && isTypeBoxSchemaType(propSymbolName)) {
-          const nested = formatTypeBoxSchema(propType, typeChecker, typeRefs, referencedTypes, visited, depth + 1, maxDepth, typeIds);
-          properties[propName] = nested ?? { type: "object" };
-        } else {
-          properties[propName] = formatTypeReferenceInternal(propType, typeChecker, typeRefs, referencedTypes, visited, depth + 1, maxDepth, typeIds);
-        }
-        const { isOptional } = unwrapTypeBoxOptional(propType);
-        if (propSymbolName !== "TOptional" && !isOptional) {
-          required.push(propName);
-        }
-      }
-      const schema = { type: "object", properties };
-      if (required.length > 0) {
-        schema.required = required;
-      }
-      return schema;
-    }
-    case "TArray": {
-      if (!typeArgs || typeArgs.length === 0) {
-        return { type: "array" };
-      }
-      const itemType = typeArgs[0];
-      const itemSymbol = itemType.getSymbol();
-      const itemSymbolName = itemSymbol?.getName();
-      let items;
-      if (itemSymbolName && typeRefs.has(itemSymbolName)) {
-        items = { $ref: `#/types/${itemSymbolName}` };
-      } else if (itemSymbolName && isTypeBoxSchemaType(itemSymbolName)) {
-        items = formatTypeBoxSchema(itemType, typeChecker, typeRefs, referencedTypes, visited, depth + 1, maxDepth, typeIds) ?? {
-          type: "object"
-        };
-      } else {
-        items = formatTypeReferenceInternal(itemType, typeChecker, typeRefs, referencedTypes, visited, depth + 1, maxDepth, typeIds);
-      }
-      return { type: "array", items };
-    }
-    case "TUnion": {
-      if (!typeArgs || typeArgs.length === 0) {
-        return { anyOf: [] };
-      }
-      const tupleType = typeArgs[0];
-      const members = [];
-      if (tupleType.isUnion()) {
-        for (const memberType of tupleType.types) {
-          const memberSymbol = memberType.getSymbol();
-          const memberSymbolName = memberSymbol?.getName();
-          if (memberSymbolName && typeRefs.has(memberSymbolName)) {
-            members.push({ $ref: `#/types/${memberSymbolName}` });
-          } else if (memberSymbolName && isTypeBoxSchemaType(memberSymbolName)) {
-            members.push(formatTypeBoxSchema(memberType, typeChecker, typeRefs, referencedTypes, visited, depth + 1, maxDepth, typeIds) ?? {
-              type: "object"
-            });
-          } else {
-            members.push(formatTypeReferenceInternal(memberType, typeChecker, typeRefs, referencedTypes, visited, depth + 1, maxDepth, typeIds));
-          }
-        }
-      } else if (tupleType.typeArguments) {
-        for (const memberType of tupleType.typeArguments) {
-          const memberSymbol = memberType.getSymbol();
-          const memberSymbolName = memberSymbol?.getName();
-          if (memberSymbolName && typeRefs.has(memberSymbolName)) {
-            members.push({ $ref: `#/types/${memberSymbolName}` });
-          } else if (memberSymbolName && isTypeBoxSchemaType(memberSymbolName)) {
-            members.push(formatTypeBoxSchema(memberType, typeChecker, typeRefs, referencedTypes, visited, depth + 1, maxDepth, typeIds) ?? {
-              type: "object"
-            });
-          } else {
-            members.push(formatTypeReferenceInternal(memberType, typeChecker, typeRefs, referencedTypes, visited, depth + 1, maxDepth, typeIds));
-          }
-        }
-      }
-      return { anyOf: members };
-    }
-    case "TIntersect": {
-      if (!typeArgs || typeArgs.length === 0) {
-        return { allOf: [] };
-      }
-      const tupleType = typeArgs[0];
-      const members = [];
-      if (tupleType.typeArguments) {
-        for (const memberType of tupleType.typeArguments) {
-          const memberSymbol = memberType.getSymbol();
-          const memberSymbolName = memberSymbol?.getName();
-          if (memberSymbolName && typeRefs.has(memberSymbolName)) {
-            members.push({ $ref: `#/types/${memberSymbolName}` });
-          } else if (memberSymbolName && isTypeBoxSchemaType(memberSymbolName)) {
-            members.push(formatTypeBoxSchema(memberType, typeChecker, typeRefs, referencedTypes, visited, depth + 1, maxDepth, typeIds) ?? {
-              type: "object"
-            });
-          } else {
-            members.push(formatTypeReferenceInternal(memberType, typeChecker, typeRefs, referencedTypes, visited, depth + 1, maxDepth, typeIds));
-          }
-        }
-      }
-      return { allOf: members };
-    }
-    case "TOptional": {
-      if (!typeArgs || typeArgs.length === 0) {
-        return {};
-      }
-      const innerType = typeArgs[0];
-      const innerSymbol = innerType.getSymbol();
-      const innerSymbolName = innerSymbol?.getName();
-      if (innerSymbolName && typeRefs.has(innerSymbolName)) {
-        return { $ref: `#/types/${innerSymbolName}` };
-      } else if (innerSymbolName && isTypeBoxSchemaType(innerSymbolName)) {
-        return formatTypeBoxSchema(innerType, typeChecker, typeRefs, referencedTypes, visited, depth + 1, maxDepth, typeIds) ?? {
-          type: "object"
-        };
-      }
-      return formatTypeReferenceInternal(innerType, typeChecker, typeRefs, referencedTypes, visited, depth + 1, maxDepth, typeIds);
-    }
-    case "TLiteral": {
-      if (!typeArgs || typeArgs.length === 0) {
-        return { enum: [] };
-      }
-      const literalType = typeArgs[0];
-      if (literalType.isLiteral()) {
-        const value = literalType.value;
-        return { enum: [value] };
-      }
-      const literalStr = typeChecker.typeToString(literalType);
-      if (literalStr.startsWith('"') && literalStr.endsWith('"')) {
-        return { enum: [literalStr.slice(1, -1)] };
-      }
-      return { enum: [literalStr] };
-    }
-    case "TRecord": {
-      if (!typeArgs || typeArgs.length < 2) {
-        return { type: "object", additionalProperties: true };
-      }
-      const valueType = typeArgs[1];
-      const valueSymbol = valueType.getSymbol();
-      const valueSymbolName = valueSymbol?.getName();
-      let additionalProperties;
-      if (valueSymbolName && typeRefs.has(valueSymbolName)) {
-        additionalProperties = { $ref: `#/types/${valueSymbolName}` };
-      } else if (valueSymbolName && isTypeBoxSchemaType(valueSymbolName)) {
-        additionalProperties = formatTypeBoxSchema(valueType, typeChecker, typeRefs, referencedTypes, visited, depth + 1, maxDepth, typeIds) ?? true;
-      } else {
-        additionalProperties = formatTypeReferenceInternal(valueType, typeChecker, typeRefs, referencedTypes, visited, depth + 1, maxDepth, typeIds);
-      }
-      return { type: "object", additionalProperties };
-    }
-    case "TRef": {
-      if (!typeArgs || typeArgs.length === 0) {
-        return { $ref: "#/types/unknown" };
-      }
-      const refType = typeArgs[0];
-      const refSymbol = refType.getSymbol();
-      const refSymbolName = refSymbol?.getName();
-      if (refSymbolName) {
-        return { $ref: `#/types/${refSymbolName}` };
-      }
-      return { type: "object" };
-    }
-    default:
-      return null;
-  }
-}
-
-// src/utils/schema-builder.ts
-var BUILTIN_TYPE_SCHEMAS = {
-  Date: { type: "string", format: "date-time" },
-  RegExp: { type: "object", description: "RegExp" },
-  Error: { type: "object" },
-  Promise: { type: "object" },
-  Map: { type: "object" },
-  Set: { type: "object" },
-  WeakMap: { type: "object" },
-  WeakSet: { type: "object" },
-  Function: { type: "object" },
-  ArrayBuffer: { type: "string", format: "binary" },
-  ArrayBufferLike: { type: "string", format: "binary" },
-  DataView: { type: "string", format: "binary" },
-  Uint8Array: { type: "string", format: "byte" },
-  Uint16Array: { type: "string", format: "byte" },
-  Uint32Array: { type: "string", format: "byte" },
-  Int8Array: { type: "string", format: "byte" },
-  Int16Array: { type: "string", format: "byte" },
-  Int32Array: { type: "string", format: "byte" },
-  Float32Array: { type: "string", format: "byte" },
-  Float64Array: { type: "string", format: "byte" },
-  BigInt64Array: { type: "string", format: "byte" },
-  BigUint64Array: { type: "string", format: "byte" }
-};
-function isObjectLiteralType(type) {
-  if (!(type.getFlags() & ts.TypeFlags.Object)) {
-    return false;
-  }
-  const objectFlags = type.objectFlags;
-  return (objectFlags & ts.ObjectFlags.ObjectLiteral) !== 0;
-}
-function isPureRefSchema(value) {
-  return Object.keys(value).length === 1 && "$ref" in value;
-}
-function withDescription(schema, description) {
-  if (isPureRefSchema(schema)) {
-    return {
-      allOf: [schema],
-      description
-    };
-  }
-  return {
-    ...schema,
-    description
-  };
-}
-function propertiesToSchema(properties, description) {
-  const schema = {
-    type: "object",
-    properties: {}
-  };
-  const required = [];
-  for (const prop of properties) {
-    const propType = prop.type;
-    let propSchema;
-    if (typeof propType === "string") {
-      if (["string", "number", "boolean", "bigint", "null"].includes(propType)) {
-        propSchema = { type: propType === "bigint" ? "string" : propType };
-      } else {
-        propSchema = { type: propType };
-      }
-    } else if (propType && typeof propType === "object") {
-      propSchema = propType;
-    } else {
-      propSchema = { type: "any" };
-    }
-    if (prop.description && typeof propSchema === "object") {
-      propSchema = withDescription(propSchema, prop.description);
-    }
-    schema.properties[prop.name] = propSchema;
-    if (!prop.optional) {
-      required.push(prop.name);
-    }
-  }
-  if (required.length > 0) {
-    schema.required = required;
-  }
-  if (description) {
-    return withDescription(schema, description);
-  }
-  return schema;
-}
-var _formatTypeReference2 = null;
-function setSchemaBuilderFormatTypeReference(fn) {
-  _formatTypeReference2 = fn;
-}
-function buildSchemaFromTypeNode(node, typeChecker, typeRefs, referencedTypes, functionDoc, parentParamName) {
-  if (ts.isParenthesizedTypeNode(node)) {
-    return buildSchemaFromTypeNode(node.type, typeChecker, typeRefs, referencedTypes, functionDoc ?? null, parentParamName);
-  }
-  if (ts.isIntersectionTypeNode(node)) {
-    const schemas = node.types.map((type) => buildSchemaFromTypeNode(type, typeChecker, typeRefs, referencedTypes, functionDoc, parentParamName));
-    return { allOf: schemas };
+  if (ts.isIntersectionTypeNode(node)) {
+    const schemas = node.types.map((type) => buildSchemaFromTypeNode(type, typeChecker, typeRefs, referencedTypes, functionDoc, parentParamName));
+    return { allOf: schemas };
   }
   if (ts.isUnionTypeNode(node)) {
     const schemas = node.types.map((type) => buildSchemaFromTypeNode(type, typeChecker, typeRefs, referencedTypes, functionDoc, parentParamName));
@@ -4390,7 +4610,7 @@ function buildSchemaFromTypeNode(node, typeChecker, typeRefs, referencedTypes, f
       let schema2 = "any";
       if (member.type) {
         const memberType = typeChecker.getTypeFromTypeNode(member.type);
-        const formatted = _formatTypeReference2 ? _formatTypeReference2(memberType, typeChecker, typeRefs, referencedTypes) : { type: "any" };
+        const formatted = _formatTypeReference ? _formatTypeReference(memberType, typeChecker, typeRefs, referencedTypes) : { type: "any" };
         if (typeof formatted === "string") {
           if (formatted === "any") {
             schema2 = buildSchemaFromTypeNode(member.type, typeChecker, typeRefs, referencedTypes, functionDoc, parentParamName);
@@ -4501,75 +4721,328 @@ function findDiscriminatorProperty(unionTypes, typeChecker) {
         } else if (propType.isNumberLiteral()) {
           propValues.set(prop.getName(), propType.value);
         }
-      } catch {}
+      } catch {}
+    }
+    memberProps.push(propValues);
+  }
+  if (memberProps.length < 2) {
+    return;
+  }
+  const firstMember = memberProps[0];
+  for (const [propName, firstValue] of firstMember) {
+    const values = new Set([firstValue]);
+    let isDiscriminator = true;
+    for (let i = 1;i < memberProps.length; i++) {
+      const value = memberProps[i].get(propName);
+      if (value === undefined) {
+        isDiscriminator = false;
+        break;
+      }
+      if (values.has(value)) {
+        isDiscriminator = false;
+        break;
+      }
+      values.add(value);
+    }
+    if (isDiscriminator) {
+      return propName;
+    }
+  }
+  return;
+}
+function schemaIsAny(schema) {
+  if (typeof schema === "string") {
+    return schema === "any";
+  }
+  if ("type" in schema && schema.type === "any" && Object.keys(schema).length === 1) {
+    return true;
+  }
+  return false;
+}
+function schemasAreEqual(left, right) {
+  if (typeof left !== typeof right) {
+    return false;
+  }
+  if (typeof left === "string" && typeof right === "string") {
+    return left === right;
+  }
+  if (left == null || right == null) {
+    return left === right;
+  }
+  const normalize = (value) => {
+    if (Array.isArray(value)) {
+      return value.map((item) => normalize(item));
+    }
+    if (value && typeof value === "object") {
+      const sortedEntries = Object.entries(value).map(([key, val]) => [key, normalize(val)]).sort(([keyA], [keyB]) => keyA.localeCompare(keyB));
+      return Object.fromEntries(sortedEntries);
+    }
+    return value;
+  };
+  return JSON.stringify(normalize(left)) === JSON.stringify(normalize(right));
+}
+function deduplicateSchemas(schemas) {
+  const result = [];
+  for (const schema of schemas) {
+    const isDuplicate = result.some((existing) => schemasAreEqual(existing, schema));
+    if (!isDuplicate) {
+      result.push(schema);
+    }
+  }
+  return result;
+}
+// src/utils/typebox-handler.ts
+var TYPEBOX_PRIMITIVE_MAP = {
+  TString: { type: "string" },
+  TNumber: { type: "number" },
+  TBoolean: { type: "boolean" },
+  TInteger: { type: "integer" },
+  TNull: { type: "null" },
+  TAny: {},
+  TUnknown: {},
+  TNever: { not: {} },
+  TVoid: { type: "null" },
+  TUndefined: { type: "null" }
+};
+function isTypeBoxSchemaType(symbolName) {
+  return /^T[A-Z][a-zA-Z]*$/.test(symbolName);
+}
+function isInternalProperty(name) {
+  return name.startsWith("__@");
+}
+function isTypeBoxOptionalMarker(type) {
+  const props = type.getProperties();
+  if (props.length !== 1)
+    return false;
+  return isInternalProperty(props[0].getName());
+}
+function unwrapTypeBoxOptional(type) {
+  if (!type.isIntersection()) {
+    return { innerTypes: [type], isOptional: false };
+  }
+  const intersectionType = type;
+  const filtered = intersectionType.types.filter((t) => !isTypeBoxOptionalMarker(t));
+  const hadMarker = filtered.length < intersectionType.types.length;
+  return { innerTypes: filtered, isOptional: hadMarker };
+}
+function getPropertyType(prop, parentType, typeChecker) {
+  if (prop.valueDeclaration) {
+    return typeChecker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration);
+  }
+  const propType = typeChecker.getTypeOfPropertyOfType(parentType, prop.getName());
+  if (propType) {
+    return propType;
+  }
+  const decl = prop.declarations?.[0];
+  if (decl) {
+    return typeChecker.getTypeOfSymbolAtLocation(prop, decl);
+  }
+  return typeChecker.getAnyType();
+}
+var _formatTypeReference2 = null;
+function setFormatTypeReference(fn) {
+  _formatTypeReference2 = fn;
+}
+function formatTypeReferenceInternal(type, typeChecker, typeRefs, referencedTypes, visited, depth, maxDepth, typeIds) {
+  if (_formatTypeReference2) {
+    return _formatTypeReference2(type, typeChecker, typeRefs, referencedTypes, visited, depth, maxDepth, typeIds);
+  }
+  return { type: "object" };
+}
+function formatTypeBoxSchema(type, typeChecker, typeRefs, referencedTypes, visited, depth = 0, maxDepth = DEFAULT_MAX_TYPE_DEPTH, typeIds) {
+  if (depth > maxDepth) {
+    return { type: "unknown" };
+  }
+  const symbol = type.getSymbol();
+  if (!symbol)
+    return null;
+  const symbolName = symbol.getName();
+  if (TYPEBOX_PRIMITIVE_MAP[symbolName]) {
+    return { ...TYPEBOX_PRIMITIVE_MAP[symbolName] };
+  }
+  const objectType = type;
+  if (!(objectType.objectFlags & ts.ObjectFlags.Reference)) {
+    return null;
+  }
+  const typeRef = type;
+  const typeArgs = typeRef.typeArguments;
+  switch (symbolName) {
+    case "TObject": {
+      if (!typeArgs || typeArgs.length === 0) {
+        return { type: "object" };
+      }
+      const propsType = typeArgs[0];
+      const properties = {};
+      const required = [];
+      for (const prop of propsType.getProperties()) {
+        const propName = prop.getName();
+        if (isInternalProperty(propName)) {
+          continue;
+        }
+        const propType = getPropertyType(prop, propsType, typeChecker);
+        const propSymbol = propType.getSymbol();
+        const propSymbolName = propSymbol?.getName();
+        if (propSymbolName && typeRefs.has(propSymbolName)) {
+          properties[propName] = { $ref: `#/types/${propSymbolName}` };
+        } else if (propSymbolName && isTypeBoxSchemaType(propSymbolName)) {
+          const nested = formatTypeBoxSchema(propType, typeChecker, typeRefs, referencedTypes, visited, depth + 1, maxDepth, typeIds);
+          properties[propName] = nested ?? { type: "object" };
+        } else {
+          properties[propName] = formatTypeReferenceInternal(propType, typeChecker, typeRefs, referencedTypes, visited, depth + 1, maxDepth, typeIds);
+        }
+        const { isOptional } = unwrapTypeBoxOptional(propType);
+        if (propSymbolName !== "TOptional" && !isOptional) {
+          required.push(propName);
+        }
+      }
+      const schema = { type: "object", properties };
+      if (required.length > 0) {
+        schema.required = required;
+      }
+      return schema;
+    }
+    case "TArray": {
+      if (!typeArgs || typeArgs.length === 0) {
+        return { type: "array" };
+      }
+      const itemType = typeArgs[0];
+      const itemSymbol = itemType.getSymbol();
+      const itemSymbolName = itemSymbol?.getName();
+      let items;
+      if (itemSymbolName && typeRefs.has(itemSymbolName)) {
+        items = { $ref: `#/types/${itemSymbolName}` };
+      } else if (itemSymbolName && isTypeBoxSchemaType(itemSymbolName)) {
+        items = formatTypeBoxSchema(itemType, typeChecker, typeRefs, referencedTypes, visited, depth + 1, maxDepth, typeIds) ?? {
+          type: "object"
+        };
+      } else {
+        items = formatTypeReferenceInternal(itemType, typeChecker, typeRefs, referencedTypes, visited, depth + 1, maxDepth, typeIds);
+      }
+      return { type: "array", items };
+    }
+    case "TUnion": {
+      if (!typeArgs || typeArgs.length === 0) {
+        return { anyOf: [] };
+      }
+      const tupleType = typeArgs[0];
+      const members = [];
+      if (tupleType.isUnion()) {
+        for (const memberType of tupleType.types) {
+          const memberSymbol = memberType.getSymbol();
+          const memberSymbolName = memberSymbol?.getName();
+          if (memberSymbolName && typeRefs.has(memberSymbolName)) {
+            members.push({ $ref: `#/types/${memberSymbolName}` });
+          } else if (memberSymbolName && isTypeBoxSchemaType(memberSymbolName)) {
+            members.push(formatTypeBoxSchema(memberType, typeChecker, typeRefs, referencedTypes, visited, depth + 1, maxDepth, typeIds) ?? {
+              type: "object"
+            });
+          } else {
+            members.push(formatTypeReferenceInternal(memberType, typeChecker, typeRefs, referencedTypes, visited, depth + 1, maxDepth, typeIds));
+          }
+        }
+      } else if (tupleType.typeArguments) {
+        for (const memberType of tupleType.typeArguments) {
+          const memberSymbol = memberType.getSymbol();
+          const memberSymbolName = memberSymbol?.getName();
+          if (memberSymbolName && typeRefs.has(memberSymbolName)) {
+            members.push({ $ref: `#/types/${memberSymbolName}` });
+          } else if (memberSymbolName && isTypeBoxSchemaType(memberSymbolName)) {
+            members.push(formatTypeBoxSchema(memberType, typeChecker, typeRefs, referencedTypes, visited, depth + 1, maxDepth, typeIds) ?? {
+              type: "object"
+            });
+          } else {
+            members.push(formatTypeReferenceInternal(memberType, typeChecker, typeRefs, referencedTypes, visited, depth + 1, maxDepth, typeIds));
+          }
+        }
+      }
+      return { anyOf: members };
+    }
+    case "TIntersect": {
+      if (!typeArgs || typeArgs.length === 0) {
+        return { allOf: [] };
+      }
+      const tupleType = typeArgs[0];
+      const members = [];
+      if (tupleType.typeArguments) {
+        for (const memberType of tupleType.typeArguments) {
+          const memberSymbol = memberType.getSymbol();
+          const memberSymbolName = memberSymbol?.getName();
+          if (memberSymbolName && typeRefs.has(memberSymbolName)) {
+            members.push({ $ref: `#/types/${memberSymbolName}` });
+          } else if (memberSymbolName && isTypeBoxSchemaType(memberSymbolName)) {
+            members.push(formatTypeBoxSchema(memberType, typeChecker, typeRefs, referencedTypes, visited, depth + 1, maxDepth, typeIds) ?? {
+              type: "object"
+            });
+          } else {
+            members.push(formatTypeReferenceInternal(memberType, typeChecker, typeRefs, referencedTypes, visited, depth + 1, maxDepth, typeIds));
+          }
+        }
+      }
+      return { allOf: members };
     }
-    memberProps.push(propValues);
-  }
-  if (memberProps.length < 2) {
-    return;
-  }
-  const firstMember = memberProps[0];
-  for (const [propName, firstValue] of firstMember) {
-    const values = new Set([firstValue]);
-    let isDiscriminator = true;
-    for (let i = 1;i < memberProps.length; i++) {
-      const value = memberProps[i].get(propName);
-      if (value === undefined) {
-        isDiscriminator = false;
-        break;
+    case "TOptional": {
+      if (!typeArgs || typeArgs.length === 0) {
+        return {};
       }
-      if (values.has(value)) {
-        isDiscriminator = false;
-        break;
+      const innerType = typeArgs[0];
+      const innerSymbol = innerType.getSymbol();
+      const innerSymbolName = innerSymbol?.getName();
+      if (innerSymbolName && typeRefs.has(innerSymbolName)) {
+        return { $ref: `#/types/${innerSymbolName}` };
+      } else if (innerSymbolName && isTypeBoxSchemaType(innerSymbolName)) {
+        return formatTypeBoxSchema(innerType, typeChecker, typeRefs, referencedTypes, visited, depth + 1, maxDepth, typeIds) ?? {
+          type: "object"
+        };
       }
-      values.add(value);
-    }
-    if (isDiscriminator) {
-      return propName;
+      return formatTypeReferenceInternal(innerType, typeChecker, typeRefs, referencedTypes, visited, depth + 1, maxDepth, typeIds);
     }
-  }
-  return;
-}
-function schemaIsAny(schema) {
-  if (typeof schema === "string") {
-    return schema === "any";
-  }
-  if ("type" in schema && schema.type === "any" && Object.keys(schema).length === 1) {
-    return true;
-  }
-  return false;
-}
-function schemasAreEqual(left, right) {
-  if (typeof left !== typeof right) {
-    return false;
-  }
-  if (typeof left === "string" && typeof right === "string") {
-    return left === right;
-  }
-  if (left == null || right == null) {
-    return left === right;
-  }
-  const normalize = (value) => {
-    if (Array.isArray(value)) {
-      return value.map((item) => normalize(item));
+    case "TLiteral": {
+      if (!typeArgs || typeArgs.length === 0) {
+        return { enum: [] };
+      }
+      const literalType = typeArgs[0];
+      if (literalType.isLiteral()) {
+        const value = literalType.value;
+        return { enum: [value] };
+      }
+      const literalStr = typeChecker.typeToString(literalType);
+      if (literalStr.startsWith('"') && literalStr.endsWith('"')) {
+        return { enum: [literalStr.slice(1, -1)] };
+      }
+      return { enum: [literalStr] };
     }
-    if (value && typeof value === "object") {
-      const sortedEntries = Object.entries(value).map(([key, val]) => [key, normalize(val)]).sort(([keyA], [keyB]) => keyA.localeCompare(keyB));
-      return Object.fromEntries(sortedEntries);
+    case "TRecord": {
+      if (!typeArgs || typeArgs.length < 2) {
+        return { type: "object", additionalProperties: true };
+      }
+      const valueType = typeArgs[1];
+      const valueSymbol = valueType.getSymbol();
+      const valueSymbolName = valueSymbol?.getName();
+      let additionalProperties;
+      if (valueSymbolName && typeRefs.has(valueSymbolName)) {
+        additionalProperties = { $ref: `#/types/${valueSymbolName}` };
+      } else if (valueSymbolName && isTypeBoxSchemaType(valueSymbolName)) {
+        additionalProperties = formatTypeBoxSchema(valueType, typeChecker, typeRefs, referencedTypes, visited, depth + 1, maxDepth, typeIds) ?? true;
+      } else {
+        additionalProperties = formatTypeReferenceInternal(valueType, typeChecker, typeRefs, referencedTypes, visited, depth + 1, maxDepth, typeIds);
+      }
+      return { type: "object", additionalProperties };
     }
-    return value;
-  };
-  return JSON.stringify(normalize(left)) === JSON.stringify(normalize(right));
-}
-function deduplicateSchemas(schemas) {
-  const result = [];
-  for (const schema of schemas) {
-    const isDuplicate = result.some((existing) => schemasAreEqual(existing, schema));
-    if (!isDuplicate) {
-      result.push(schema);
+    case "TRef": {
+      if (!typeArgs || typeArgs.length === 0) {
+        return { $ref: "#/types/unknown" };
+      }
+      const refType = typeArgs[0];
+      const refSymbol = refType.getSymbol();
+      const refSymbolName = refSymbol?.getName();
+      if (refSymbolName) {
+        return { $ref: `#/types/${refSymbolName}` };
+      }
+      return { type: "object" };
     }
+    default:
+      return null;
   }
-  return result;
 }
 
 // src/utils/type-formatter.ts
@@ -6509,9 +6982,52 @@ function serializeVariable(declaration, symbol, context) {
   }
   const typeRefs = typeRegistry.getTypeRefs();
   const referencedTypes = typeRegistry.getReferencedTypes();
+  const symbolName = symbol.getName();
+  const standardSchema = context.detectedSchemas?.get(symbolName);
+  if (standardSchema) {
+    return {
+      id: symbolName,
+      name: symbolName,
+      ...metadata,
+      kind: "variable",
+      deprecated: isSymbolDeprecated(symbol),
+      schema: standardSchema.schema,
+      description,
+      source: getSourceLocation(declaration),
+      tags: [
+        ...parsedDoc?.tags ?? [],
+        { name: "schemaLibrary", text: standardSchema.vendor },
+        { name: "schemaSource", text: "standard-schema" }
+      ],
+      examples: parsedDoc?.examples
+    };
+  }
+  if (isSchemaType(variableType, checker)) {
+    const schemaResult = extractSchemaType(variableType, checker);
+    if (schemaResult?.outputType) {
+      collectReferencedTypes(schemaResult.outputType, checker, referencedTypes);
+      const outputTypeRef = formatTypeReference(schemaResult.outputType, checker, typeRefs, referencedTypes);
+      return {
+        id: symbolName,
+        name: symbolName,
+        ...metadata,
+        kind: "variable",
+        deprecated: isSymbolDeprecated(symbol),
+        type: outputTypeRef,
+        description,
+        source: getSourceLocation(declaration),
+        tags: [
+          ...parsedDoc?.tags ?? [],
+          { name: "schemaLibrary", text: schemaResult.adapter.id },
+          { name: "schemaSource", text: "static-ast" }
+        ],
+        examples: parsedDoc?.examples
+      };
+    }
+  }
   return {
-    id: symbol.getName(),
-    name: symbol.getName(),
+    id: symbolName,
+    name: symbolName,
     ...metadata,
     kind: "variable",
     deprecated: isSymbolDeprecated(symbol),
@@ -6597,9 +7113,9 @@ function createDefaultGenerationInfo(entryFile) {
 }
 function buildOpenPkgSpec(context, resolveExternalTypes, generation) {
   const { baseDir, checker: typeChecker, sourceFile, program, entryFile } = context;
-  const packageJsonPath = path9.join(baseDir, "package.json");
-  const packageJson = fs8.existsSync(packageJsonPath) ? JSON.parse(fs8.readFileSync(packageJsonPath, "utf-8")) : {};
-  const generationInfo = generation ?? createDefaultGenerationInfo(path9.relative(baseDir, entryFile));
+  const packageJsonPath = path11.join(baseDir, "package.json");
+  const packageJson = fs10.existsSync(packageJsonPath) ? JSON.parse(fs10.readFileSync(packageJsonPath, "utf-8")) : {};
+  const generationInfo = generation ?? createDefaultGenerationInfo(path11.relative(baseDir, entryFile));
   const spec = {
     $schema: SCHEMA_URL,
     openpkg: SCHEMA_VERSION,
@@ -6619,7 +7135,8 @@ function buildOpenPkgSpec(context, resolveExternalTypes, generation) {
   const serializerContext = {
     checker: typeChecker,
     typeRegistry,
-    maxTypeDepth: context.options.maxDepth
+    maxTypeDepth: context.options.maxDepth,
+    detectedSchemas: context.detectedSchemas
   };
   const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
   if (!moduleSymbol) {
@@ -6797,11 +7314,11 @@ function deriveImportPath(sourceFile, baseDir) {
   if (!sourceFile) {
     return;
   }
-  const relative4 = path9.relative(baseDir, sourceFile);
-  if (!relative4 || relative4.startsWith("..")) {
+  const relative5 = path11.relative(baseDir, sourceFile);
+  if (!relative5 || relative5.startsWith("..")) {
     return;
   }
-  const normalized = relative4.replace(/\\/g, "/");
+  const normalized = relative5.replace(/\\/g, "/");
   const withoutExt = stripExtensions(normalized);
   if (!withoutExt) {
     return;
@@ -6840,11 +7357,11 @@ function withExportName(entry, exportName) {
 function findNearestPackageJson(startDir) {
   let current = startDir;
   while (true) {
-    const candidate = path10.join(current, "package.json");
-    if (fs9.existsSync(candidate)) {
+    const candidate = path12.join(current, "package.json");
+    if (fs11.existsSync(candidate)) {
       return candidate;
     }
-    const parent = path10.dirname(current);
+    const parent = path12.dirname(current);
     if (parent === current) {
       return;
     }
@@ -6872,11 +7389,11 @@ function canResolveExternalModules(program, baseDir) {
 function hasNodeModulesDirectoryFallback(startDir) {
   let current = startDir;
   while (true) {
-    const candidate = path10.join(current, "node_modules");
-    if (fs9.existsSync(candidate)) {
+    const candidate = path12.join(current, "node_modules");
+    if (fs11.existsSync(candidate)) {
       return true;
     }
-    const parent = path10.dirname(current);
+    const parent = path12.dirname(current);
     if (parent === current) {
       break;
     }
@@ -6977,6 +7494,17 @@ function runAnalysis(input, generationInput) {
     issues: generationIssues
   } : undefined;
   const spec = buildOpenPkgSpec(context, resolveExternalTypes, generation);
+  if (input.detectedSchemas && input.detectedSchemas.size > 0 && generation) {
+    const vendors = new Set;
+    for (const entry of input.detectedSchemas.values()) {
+      vendors.add(entry.vendor);
+    }
+    generation.analysis.schemaExtraction = {
+      method: "hybrid",
+      runtimeCount: input.detectedSchemas.size,
+      vendors: Array.from(vendors)
+    };
+  }
   const danglingRefs = collectDanglingRefs(spec);
   for (const ref of danglingRefs) {
     const issue = {
@@ -7021,11 +7549,27 @@ function runAnalysis(input, generationInput) {
 
 // src/extractor.ts
 async function extractPackageSpec(entryFile, packageDir, content, options) {
+  const baseDir = packageDir ?? path13.dirname(entryFile);
+  const schemaMode = options?.schemaExtraction ?? "static";
+  let detectedSchemas;
+  if (schemaMode === "runtime" || schemaMode === "hybrid") {
+    const extraction = await extractStandardSchemasFromProject(entryFile, baseDir);
+    if (extraction.schemas.size > 0) {
+      detectedSchemas = new Map;
+      for (const [name, result2] of extraction.schemas) {
+        detectedSchemas.set(name, {
+          schema: result2.outputSchema,
+          vendor: result2.vendor
+        });
+      }
+    }
+  }
   const result = runAnalysis({
     entryFile,
     packageDir,
     content,
-    options
+    options,
+    detectedSchemas
   });
   return result.spec;
 }
@@ -7118,16 +7662,33 @@ async function fetchSpecFromGitHub(parsed) {
   }
   return null;
 }
-async function fetchSpec(owner, repo, branch = "main") {
-  return fetchSpecFromGitHub({ owner, repo, ref: branch });
+async function fetchSpec(owner, repo, branchOrOptions = "main") {
+  const options = typeof branchOrOptions === "string" ? { ref: branchOrOptions, path: "openpkg.json" } : { ref: branchOrOptions.ref ?? "main", path: branchOrOptions.path ?? "openpkg.json" };
+  const parsed = { owner, repo, ref: options.ref };
+  return fetchSpecFromGitHubWithPath(parsed, options.path);
+}
+async function fetchSpecFromGitHubWithPath(parsed, specPath = "openpkg.json") {
+  const urls = [
+    buildRawUrl(parsed, specPath),
+    `https://raw.githubusercontent.com/${parsed.owner}/${parsed.repo}/master/${specPath}`
+  ];
+  for (const url of urls) {
+    try {
+      const response = await fetch(url);
+      if (response.ok) {
+        return await response.json();
+      }
+    } catch {}
+  }
+  return null;
 }
 // src/install/index.ts
 var DEFAULT_FALLBACK_ORDER = ["bun", "npm"];
-async function installDependencies(fs10, cwd, runCommand2, options = {}) {
+async function installDependencies(fs12, cwd, runCommand2, options = {}) {
   const { timeout = 180000, fallbackOrder = DEFAULT_FALLBACK_ORDER, onProgress } = options;
   const errors = [];
   onProgress?.({ stage: "installing", message: "Detecting package manager..." });
-  const pmInfo = await detectPackageManager(fs10);
+  const pmInfo = await detectPackageManager(fs12);
   if (pmInfo.lockfile) {
     onProgress?.({
       stage: "installing",
@@ -7782,7 +8343,7 @@ function diffMemberChanges(oldSpec, newSpec, changedClassNames) {
           memberName,
           memberKind: getMemberKind(newMember),
           changeType: "added",
-          newSignature: formatSignature(newMember)
+          newSignature: formatSignature2(newMember)
         });
       }
     }
@@ -7794,7 +8355,7 @@ function diffMemberChanges(oldSpec, newSpec, changedClassNames) {
           memberName,
           memberKind: getMemberKind(oldMember),
           changeType: "removed",
-          oldSignature: formatSignature(oldMember),
+          oldSignature: formatSignature2(oldMember),
           suggestion
         });
       }
@@ -7807,8 +8368,8 @@ function diffMemberChanges(oldSpec, newSpec, changedClassNames) {
           memberName,
           memberKind: getMemberKind(newMember),
           changeType: "signature-changed",
-          oldSignature: formatSignature(oldMember),
-          newSignature: formatSignature(newMember)
+          oldSignature: formatSignature2(oldMember),
+          newSignature: formatSignature2(newMember)
         });
       }
     }
@@ -7857,7 +8418,7 @@ function getMemberKind(member) {
       return "method";
   }
 }
-function formatSignature(member) {
+function formatSignature2(member) {
   if (!member.signatures?.length) {
     return member.name ?? "";
   }
@@ -8032,11 +8593,34 @@ function getDocsImpactSummary(diff) {
 }
 // src/openpkg.ts
 import * as fsSync from "node:fs";
-import * as fs10 from "node:fs/promises";
-import * as path11 from "node:path";
+import * as fs12 from "node:fs/promises";
+import * as path14 from "node:path";
 
 // src/filtering/apply-filters.ts
 var TYPE_REF_PREFIX = "#/types/";
+var getExportReleaseTag = (exp) => {
+  const tags = exp.tags ?? [];
+  for (const tag of tags) {
+    const tagName = tag.name?.toLowerCase();
+    if (tagName === "public")
+      return "public";
+    if (tagName === "beta")
+      return "beta";
+    if (tagName === "alpha")
+      return "alpha";
+    if (tagName === "internal")
+      return "internal";
+  }
+  return;
+};
+var matchesVisibility = (exp, visibility) => {
+  if (!visibility || visibility.length === 0) {
+    return true;
+  }
+  const tag = getExportReleaseTag(exp);
+  const effectiveTag = tag ?? "public";
+  return visibility.includes(effectiveTag);
+};
 var toLowerKey = (value) => value.trim().toLowerCase();
 var buildLookupMap = (values) => {
   const map = new Map;
@@ -8098,7 +8682,8 @@ var collectTypeRefs = (value, refs, seen = new Set) => {
 var applyFilters = (spec, options) => {
   const includeLookup = buildLookupMap(options.include);
   const excludeLookup = buildLookupMap(options.exclude);
-  if (includeLookup.size === 0 && excludeLookup.size === 0) {
+  const visibility = options.visibility;
+  if (includeLookup.size === 0 && excludeLookup.size === 0 && (!visibility || visibility.length === 0)) {
     return { spec, diagnostics: [], changed: false };
   }
   const includeMatches = new Set;
@@ -8111,10 +8696,11 @@ var applyFilters = (spec, options) => {
     const excludeMatch = matches(entry, excludeLookup);
     const allowedByInclude = includeLookup.size === 0 || Boolean(includeMatch);
     const allowedByExclude = !excludeMatch;
+    const allowedByVisibility = matchesVisibility(entry, visibility);
     if (includeMatch) {
       includeMatches.add(includeMatch);
     }
-    if (allowedByInclude && allowedByExclude) {
+    if (allowedByInclude && allowedByExclude && allowedByVisibility) {
       keptExports.push(entry);
     }
   }
@@ -8216,14 +8802,14 @@ class DocCov {
     this.options = normalizeDocCovOptions(options);
   }
   async analyze(code, fileName = "temp.ts", analyzeOptions = {}) {
-    const resolvedFileName = path11.resolve(fileName);
-    const tempDir = path11.dirname(resolvedFileName);
+    const resolvedFileName = path14.resolve(fileName);
+    const tempDir = path14.dirname(resolvedFileName);
     const spec = await extractPackageSpec(resolvedFileName, tempDir, code, this.options);
     return this.applySpecFilters(spec, analyzeOptions.filters).spec;
   }
   async analyzeFile(filePath, analyzeOptions = {}) {
-    const resolvedPath = path11.resolve(filePath);
-    const content = await fs10.readFile(resolvedPath, "utf-8");
+    const resolvedPath = path14.resolve(filePath);
+    const content = await fs12.readFile(resolvedPath, "utf-8");
     const packageDir = resolvePackageDir(resolvedPath);
     const spec = await extractPackageSpec(resolvedPath, packageDir, content, this.options);
     return this.applySpecFilters(spec, analyzeOptions.filters).spec;
@@ -8232,13 +8818,16 @@ class DocCov {
     return this.analyzeFile(entryPath, analyzeOptions);
   }
   async analyzeWithDiagnostics(code, fileName, analyzeOptions = {}) {
-    const resolvedFileName = path11.resolve(fileName ?? "temp.ts");
+    const resolvedFileName = path14.resolve(fileName ?? "temp.ts");
     const packageDir = resolvePackageDir(resolvedFileName);
+    const isRealFile = fileName && !fileName.includes("temp.ts");
+    const detectedSchemas = isRealFile ? await this.detectSchemas(resolvedFileName, packageDir) : undefined;
     const analysis = runAnalysis({
       entryFile: resolvedFileName,
       packageDir,
       content: code,
-      options: this.options
+      options: this.options,
+      detectedSchemas
     }, analyzeOptions.generationInput);
     const filterOutcome = this.applySpecFilters(analysis.spec, analyzeOptions.filters);
     return {
@@ -8252,7 +8841,7 @@ class DocCov {
     };
   }
   async analyzeFileWithDiagnostics(filePath, analyzeOptions = {}) {
-    const resolvedPath = path11.resolve(filePath);
+    const resolvedPath = path14.resolve(filePath);
     const packageDir = resolvePackageDir(resolvedPath);
     const { useCache, resolveExternalTypes } = this.options;
     if (useCache) {
@@ -8268,12 +8857,14 @@ class DocCov {
         };
       }
     }
-    const content = await fs10.readFile(resolvedPath, "utf-8");
+    const content = await fs12.readFile(resolvedPath, "utf-8");
+    const detectedSchemas = await this.detectSchemas(resolvedPath, packageDir);
     const analysis = runAnalysis({
       entryFile: resolvedPath,
       packageDir,
       content,
-      options: this.options
+      options: this.options,
+      detectedSchemas
     }, analyzeOptions.generationInput);
     const filterOutcome = this.applySpecFilters(analysis.spec, analyzeOptions.filters);
     const metadata = this.normalizeMetadata(analysis.metadata);
@@ -8303,10 +8894,10 @@ class DocCov {
     if (!packageJsonPath) {
       return null;
     }
-    const sourceFiles = Object.keys(cache.hashes.sourceFiles).map((relativePath) => path11.resolve(cwd, relativePath));
+    const currentSourceFiles = this.getCurrentSourceFiles(entryFile, packageDir);
     const cacheContext = {
       entryFile,
-      sourceFiles,
+      sourceFiles: currentSourceFiles,
       tsconfigPath,
       packageJsonPath,
       config: {
@@ -8318,6 +8909,7 @@ class DocCov {
     if (!validation.valid) {
       return null;
     }
+    const cachedSourceFiles = Object.keys(cache.hashes.sourceFiles).map((relativePath) => path14.resolve(cwd, relativePath));
     return {
       spec: cache.spec,
       metadata: {
@@ -8326,10 +8918,18 @@ class DocCov {
         packageJsonPath,
         hasNodeModules: true,
         resolveExternalTypes: cache.config.resolveExternalTypes,
-        sourceFiles
+        sourceFiles: cachedSourceFiles
       }
     };
   }
+  getCurrentSourceFiles(entryFile, baseDir) {
+    try {
+      const { program } = createProgram({ entryFile, baseDir });
+      return program.getSourceFiles().filter((sf) => !sf.isDeclarationFile && sf.fileName.startsWith(baseDir)).map((sf) => sf.fileName);
+    } catch {
+      return [];
+    }
+  }
   saveToCache(result, entryFile, metadata) {
     const { cwd } = this.options;
     if (!metadata.packageJsonPath) {
@@ -8352,11 +8952,11 @@ class DocCov {
   findTsConfig(startDir) {
     let current = startDir;
     while (true) {
-      const candidate = path11.join(current, "tsconfig.json");
+      const candidate = path14.join(current, "tsconfig.json");
       if (fsSync.existsSync(candidate)) {
         return candidate;
       }
-      const parent = path11.dirname(current);
+      const parent = path14.dirname(current);
       if (parent === current) {
         return null;
       }
@@ -8366,17 +8966,38 @@ class DocCov {
   findPackageJson(startDir) {
     let current = startDir;
     while (true) {
-      const candidate = path11.join(current, "package.json");
+      const candidate = path14.join(current, "package.json");
       if (fsSync.existsSync(candidate)) {
         return candidate;
       }
-      const parent = path11.dirname(current);
+      const parent = path14.dirname(current);
       if (parent === current) {
         return null;
       }
       current = parent;
     }
   }
+  async detectSchemas(entryFile, packageDir) {
+    try {
+      const result = await detectRuntimeSchemas({
+        baseDir: packageDir,
+        entryFile
+      });
+      if (result.schemas.size === 0) {
+        return;
+      }
+      const detected = new Map;
+      for (const [name, schema] of result.schemas) {
+        detected.set(name, {
+          schema: schema.schema,
+          vendor: schema.vendor
+        });
+      }
+      return detected;
+    } catch {
+      return;
+    }
+  }
   normalizeDiagnostic(tsDiagnostic) {
     const message = ts.flattenDiagnosticMessageText(tsDiagnostic.messageText, `
 `);
@@ -8438,14 +9059,14 @@ async function analyzeFile(filePath, options = {}) {
   return new DocCov().analyzeFile(filePath, options);
 }
 function resolvePackageDir(entryFile) {
-  const fallbackDir = path11.dirname(entryFile);
+  const fallbackDir = path14.dirname(entryFile);
   let currentDir = fallbackDir;
   while (true) {
-    const candidate = path11.join(currentDir, "package.json");
+    const candidate = path14.join(currentDir, "package.json");
     if (fsSync.existsSync(candidate)) {
       return currentDir;
     }
-    const parentDir = path11.dirname(currentDir);
+    const parentDir = path14.dirname(currentDir);
     if (parentDir === currentDir) {
       return fallbackDir;
     }
@@ -8453,12 +9074,12 @@ function resolvePackageDir(entryFile) {
   }
 }
 // src/resolve/index.ts
-import * as path12 from "node:path";
-async function resolveTarget(fs11, options) {
+import * as path15 from "node:path";
+async function resolveTarget(fs13, options) {
   let targetDir = options.cwd;
   let packageInfo;
   if (options.package) {
-    const mono = await detectMonorepo(fs11);
+    const mono = await detectMonorepo(fs13);
     if (!mono.isMonorepo) {
       throw new Error("Not a monorepo. Remove --package flag for single-package repos.");
     }
@@ -8467,21 +9088,21 @@ async function resolveTarget(fs11, options) {
       const available = mono.packages.map((p) => p.name).join(", ");
       throw new Error(`Package "${options.package}" not found. Available: ${available}`);
     }
-    targetDir = path12.join(options.cwd, pkg.path);
+    targetDir = path15.join(options.cwd, pkg.path);
     packageInfo = pkg;
   }
   let entryFile;
   let entryPointInfo;
   if (!options.entry) {
-    entryPointInfo = await detectEntryPoint(fs11, getRelativePath(options.cwd, targetDir));
-    entryFile = path12.join(targetDir, entryPointInfo.path);
+    entryPointInfo = await detectEntryPoint(fs13, getRelativePath(options.cwd, targetDir));
+    entryFile = path15.join(targetDir, entryPointInfo.path);
   } else {
-    const explicitPath = path12.resolve(targetDir, options.entry);
-    const isDirectory = await isDir(fs11, getRelativePath(options.cwd, explicitPath));
+    const explicitPath = path15.resolve(targetDir, options.entry);
+    const isDirectory = await isDir(fs13, getRelativePath(options.cwd, explicitPath));
     if (isDirectory) {
       targetDir = explicitPath;
-      entryPointInfo = await detectEntryPoint(fs11, getRelativePath(options.cwd, explicitPath));
-      entryFile = path12.join(explicitPath, entryPointInfo.path);
+      entryPointInfo = await detectEntryPoint(fs13, getRelativePath(options.cwd, explicitPath));
+      entryFile = path15.join(explicitPath, entryPointInfo.path);
     } else {
       entryFile = explicitPath;
       entryPointInfo = {
@@ -8501,52 +9122,20 @@ async function resolveTarget(fs11, options) {
 function getRelativePath(base, target) {
   if (base === target)
     return ".";
-  const rel = path12.relative(base, target);
+  const rel = path15.relative(base, target);
   return rel || ".";
 }
-async function isDir(fs11, relativePath) {
-  const hasPackageJson = await fs11.exists(path12.join(relativePath, "package.json"));
+async function isDir(fs13, relativePath) {
+  const hasPackageJson = await fs13.exists(path15.join(relativePath, "package.json"));
   if (hasPackageJson)
     return true;
   const commonEntryFiles = ["index.ts", "index.tsx", "src/index.ts", "main.ts"];
   for (const entry of commonEntryFiles) {
-    if (await fs11.exists(path12.join(relativePath, entry))) {
+    if (await fs13.exists(path15.join(relativePath, entry))) {
       return true;
     }
   }
-  return !path12.extname(relativePath);
-}
-// src/scan/summary.ts
-function extractSpecSummary(spec) {
-  const exports = spec.exports ?? [];
-  const undocumented = [];
-  const drift = [];
-  for (const exp of exports) {
-    const docs = exp.docs;
-    if (!docs)
-      continue;
-    const hasMissing = (docs.missing?.length ?? 0) > 0;
-    const isPartial = (docs.coverageScore ?? 0) < 100;
-    if (hasMissing || isPartial) {
-      undocumented.push(exp.name);
-    }
-    for (const d of docs.drift ?? []) {
-      drift.push({
-        export: exp.name,
-        type: d.type,
-        issue: d.issue,
-        suggestion: d.suggestion
-      });
-    }
-  }
-  return {
-    coverage: spec.docs?.coverageScore ?? 0,
-    exportCount: exports.length,
-    typeCount: spec.types?.length ?? 0,
-    driftCount: drift.length,
-    undocumented,
-    drift
-  };
+  return !path15.extname(relativePath);
 }
 // src/scan/github-context.ts
 function parseGitHubUrl2(url) {
@@ -8557,10 +9146,14 @@ function parseGitHubUrl2(url) {
     return null;
   }
 }
-async function fetchRawFile(owner, repo, ref, path13) {
-  const url = `https://raw.githubusercontent.com/${owner}/${repo}/${ref}/${path13}`;
+async function fetchRawFile(owner, repo, ref, path16, authToken) {
+  const url = `https://raw.githubusercontent.com/${owner}/${repo}/${ref}/${path16}`;
   try {
-    const response = await fetch(url);
+    const headers = {};
+    if (authToken) {
+      headers.Authorization = `Bearer ${authToken}`;
+    }
+    const response = await fetch(url, { headers });
     if (response.ok) {
       return await response.text();
     }
@@ -8569,14 +9162,16 @@ async function fetchRawFile(owner, repo, ref, path13) {
     return null;
   }
 }
-async function fetchRepoMetadata(owner, repo) {
+async function fetchRepoMetadata(owner, repo, authToken) {
   const url = `https://api.github.com/repos/${owner}/${repo}`;
-  const response = await fetch(url, {
-    headers: {
-      Accept: "application/vnd.github.v3+json",
-      "User-Agent": "DocCov-Scanner"
-    }
-  });
+  const headers = {
+    Accept: "application/vnd.github.v3+json",
+    "User-Agent": "DocCov-Scanner"
+  };
+  if (authToken) {
+    headers.Authorization = `Bearer ${authToken}`;
+  }
+  const response = await fetch(url, { headers });
   if (!response.ok) {
     throw new Error(`Failed to fetch repository: ${response.status} ${response.statusText}`);
   }
@@ -8591,7 +9186,7 @@ async function fetchRepoMetadata(owner, repo) {
     isPrivate: data.private
   };
 }
-async function detectPackageManager3(owner, repo, ref) {
+async function detectPackageManager3(owner, repo, ref, authToken) {
   const lockfiles = [
     { name: "bun.lockb", manager: "bun" },
     { name: "pnpm-lock.yaml", manager: "pnpm" },
@@ -8599,15 +9194,15 @@ async function detectPackageManager3(owner, repo, ref) {
     { name: "package-lock.json", manager: "npm" }
   ];
   for (const { name, manager } of lockfiles) {
-    const content = await fetchRawFile(owner, repo, ref, name);
+    const content = await fetchRawFile(owner, repo, ref, name, authToken);
     if (content !== null) {
       return { manager, lockfile: { name, content: content.slice(0, 1e4) } };
     }
   }
   return { manager: "unknown" };
 }
-async function detectWorkspace(packageJson, owner, repo, ref) {
-  const pnpmWorkspace = await fetchRawFile(owner, repo, ref, "pnpm-workspace.yaml");
+async function detectWorkspace(packageJson, owner, repo, ref, authToken) {
+  const pnpmWorkspace = await fetchRawFile(owner, repo, ref, "pnpm-workspace.yaml", authToken);
   if (pnpmWorkspace) {
     const packagesMatch = pnpmWorkspace.match(/packages:\s*\n((?:\s+-\s+['"]?[^\n]+['"]?\n?)+)/);
     const packages = packagesMatch ? packagesMatch[1].split(`
@@ -8618,7 +9213,7 @@ async function detectWorkspace(packageJson, owner, repo, ref) {
       packages
     };
   }
-  const lernaJson = await fetchRawFile(owner, repo, ref, "lerna.json");
+  const lernaJson = await fetchRawFile(owner, repo, ref, "lerna.json", authToken);
   if (lernaJson) {
     return { isMonorepo: true, tool: "lerna" };
   }
@@ -8678,18 +9273,20 @@ function detectBuildHints(packageJson, tsconfigJson) {
   }
   return hints;
 }
-async function fetchGitHubContext(repoUrl, ref) {
+async function fetchGitHubContext(repoUrl, refOrOptions) {
   const parsed = parseGitHubUrl2(repoUrl);
   if (!parsed) {
     throw new Error(`Invalid GitHub URL: ${repoUrl}`);
   }
+  const options = typeof refOrOptions === "string" ? { ref: refOrOptions } : refOrOptions ?? {};
+  const { authToken } = options;
   const { owner, repo } = parsed;
-  const metadata = await fetchRepoMetadata(owner, repo);
-  const targetRef = ref ?? metadata.defaultBranch;
+  const metadata = await fetchRepoMetadata(owner, repo, authToken);
+  const targetRef = options.ref ?? metadata.defaultBranch;
   const [packageJsonRaw, tsconfigJsonRaw, pmResult] = await Promise.all([
-    fetchRawFile(owner, repo, targetRef, "package.json"),
-    fetchRawFile(owner, repo, targetRef, "tsconfig.json"),
-    detectPackageManager3(owner, repo, targetRef)
+    fetchRawFile(owner, repo, targetRef, "package.json", authToken),
+    fetchRawFile(owner, repo, targetRef, "tsconfig.json", authToken),
+    detectPackageManager3(owner, repo, targetRef, authToken)
   ]);
   let packageJson = null;
   let tsconfigJson = null;
@@ -8703,7 +9300,7 @@ async function fetchGitHubContext(repoUrl, ref) {
       tsconfigJson = JSON.parse(tsconfigJsonRaw);
     } catch {}
   }
-  const workspace = await detectWorkspace(packageJson, owner, repo, targetRef);
+  const workspace = await detectWorkspace(packageJson, owner, repo, targetRef, authToken);
   const buildHints = detectBuildHints(packageJson, tsconfigJson);
   return {
     metadata,
@@ -8718,18 +9315,20 @@ async function fetchGitHubContext(repoUrl, ref) {
     }
   };
 }
-async function listWorkspacePackages(owner, repo, ref, patterns) {
+async function listWorkspacePackages(owner, repo, ref, patterns, authToken) {
   const packages = [];
   for (const pattern of patterns) {
     const baseDir = pattern.replace(/\/\*.*$/, "");
     try {
       const url = `https://api.github.com/repos/${owner}/${repo}/contents/${baseDir}?ref=${ref}`;
-      const response = await fetch(url, {
-        headers: {
-          Accept: "application/vnd.github.v3+json",
-          "User-Agent": "DocCov-Scanner"
-        }
-      });
+      const headers = {
+        Accept: "application/vnd.github.v3+json",
+        "User-Agent": "DocCov-Scanner"
+      };
+      if (authToken) {
+        headers.Authorization = `Bearer ${authToken}`;
+      }
+      const response = await fetch(url, { headers });
       if (response.ok) {
         const contents = await response.json();
         for (const item of contents) {
@@ -8742,6 +9341,38 @@ async function listWorkspacePackages(owner, repo, ref, patterns) {
   }
   return packages;
 }
+// src/scan/summary.ts
+function extractSpecSummary(spec) {
+  const exports = spec.exports ?? [];
+  const undocumented = [];
+  const drift = [];
+  for (const exp of exports) {
+    const docs = exp.docs;
+    if (!docs)
+      continue;
+    const hasMissing = (docs.missing?.length ?? 0) > 0;
+    const isPartial = (docs.coverageScore ?? 0) < 100;
+    if (hasMissing || isPartial) {
+      undocumented.push(exp.name);
+    }
+    for (const d of docs.drift ?? []) {
+      drift.push({
+        export: exp.name,
+        type: d.type,
+        issue: d.issue,
+        suggestion: d.suggestion
+      });
+    }
+  }
+  return {
+    coverage: spec.docs?.coverageScore ?? 0,
+    exportCount: exports.length,
+    typeCount: spec.types?.length ?? 0,
+    driftCount: drift.length,
+    undocumented,
+    drift
+  };
+}
 export {
   validateSpecCache,
   validateExamples,
@@ -8750,13 +9381,19 @@ export {
   shouldValidate,
   serializeJSDoc,
   saveSpecCache,
+  saveSnapshot,
   saveReport,
   safeParseJson,
   runExamplesWithPackage,
   runExamples,
   runExample,
   resolveTarget,
+  resolveCompiledPath,
+  renderSparkline,
+  renderApiSurface,
   readPackageJson,
+  pruneHistory,
+  pruneByTier,
   parseGitHubUrl2 as parseScanGitHubUrl,
   parseMarkdownFiles,
   parseMarkdownFile,
@@ -8767,10 +9404,13 @@ export {
   parseAssertions,
   mergeFixes,
   mergeFilters,
-  mergeConfig,
   loadSpecCache,
+  loadSnapshotsForDays,
+  loadSnapshots,
   loadCachedReport,
   listWorkspacePackages,
+  isStandardJSONSchema,
+  isSchemaType,
   isFixableDrift,
   isExecutableLang,
   isCachedReportValid,
@@ -8783,43 +9423,49 @@ export {
   hasDocsForExport,
   groupDriftsByCategory,
   getUndocumentedExports,
+  getTrend,
+  getSupportedLibraries,
   getSpecCachePath,
   getRunCommand,
-  getRulesForKind,
-  getRule,
   getReportPath,
+  getRegisteredAdapters,
   getPrimaryBuildScript,
   getInstallCommand,
+  getExtendedTrend,
   getDriftSummary,
   getDocumentedExports,
   getDocsImpactSummary,
   getDiffReportPath,
-  getDefaultConfig,
-  getCoverageRules,
+  generateWeeklySummaries,
   generateReportFromEnriched,
   generateReport,
   generateFixesForExport,
   generateFix,
   formatPackageList,
   formatDriftSummaryLine,
+  formatDelta,
   findRemovedReferences,
   findPackageByName,
   findJSDocLocation,
   findExportReferences,
   findDeprecatedReferences,
+  findAdapter,
   fetchSpecFromGitHub,
   fetchSpec,
   fetchGitHubContext,
+  extractStandardSchemasFromProject,
+  extractStandardSchemas,
   extractSpecSummary,
+  extractSchemaType,
+  extractSchemaOutputType,
   extractPackageSpec,
   extractImports,
   extractFunctionCalls,
-  evaluateQuality,
-  evaluateExportQuality,
   ensureSpecCoverage,
   enrichSpec,
   diffSpecWithDocs,
   diffHashes,
+  detectRuntimeSchemas,
   detectPackageManager,
   detectMonorepo,
   detectExampleRuntimeErrors,
@@ -8829,9 +9475,11 @@ export {
   defineConfig,
   createSourceFile,
   createNodeCommandRunner,
+  computeSnapshot,
   computeExportDrift,
   computeDrift,
   clearSpecCache,
+  clearSchemaCache,
   categorizeDrifts,
   categorizeDrift,
   calculateAggregateCoverage,
@@ -8848,16 +9496,15 @@ export {
   analyze,
   VALIDATION_INFO,
   SandboxFileSystem,
-  STYLE_RULES,
   SPEC_CACHE_FILE,
+  RETENTION_DAYS,
   REPORT_VERSION,
   REPORT_EXTENSIONS,
   NodeFileSystem,
+  HISTORY_DIR,
   DocCov,
   DEFAULT_REPORT_PATH,
   DEFAULT_REPORT_DIR,
-  CORE_RULES,
   CACHE_VERSION,
-  BUILTIN_RULES,
   ALL_VALIDATIONS
 };