@doccov/sdk 0.18.0 → 0.20.0

package/dist/index.js

@@ -4,168 +4,378 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod2, isNodeMode, target) => {
-  target = mod2 != null ? __create(__getProtoOf(mod2)) : {};
-  const to = isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod2))
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod2[key],
+        get: () => mod[key],
         enumerable: true
       });
   return to;
 };
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// src/analysis/schema-detection.ts
+// src/extract/schema/standard-schema.ts
+import { spawn } from "node:child_process";
 import * as fs from "node:fs";
-
-// src/extraction/standard-schema.ts
-function isStandardJSONSchema(value) {
-  if (typeof value !== "object" || value === null) {
+import * as path from "node:path";
+function isStandardJSONSchema(obj) {
+  if (typeof obj !== "object" || obj === null)
     return false;
-  }
-  const obj = value;
-  const standard = obj["~standard"];
-  if (typeof standard !== "object" || standard === null) {
+  const std = obj["~standard"];
+  if (typeof std !== "object" || std === null)
     return false;
-  }
-  const stdObj = standard;
-  if (typeof stdObj.version !== "number") {
+  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) {
+  if (typeof jsonSchema !== "object" || jsonSchema === null)
     return false;
+  const jsObj = jsonSchema;
+  return typeof jsObj.output === "function";
+}
+var WORKER_SCRIPT = `
+const path = require('path');
+const { pathToFileURL } = require('url');
+
+async function extract() {
+  // With node -e, argv is: [node, arg1, arg2, ...]
+  // (the -e script is NOT in argv)
+  const [modulePath, target] = process.argv.slice(1);
+
+  try {
+    // Import the module using dynamic import (works with ESM and CJS)
+    const absPath = path.resolve(modulePath);
+    const mod = await import(pathToFileURL(absPath).href);
+    const results = [];
+
+    // 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;
   }
-  const jsonSchemaObj = jsonSchema;
-  return typeof jsonSchemaObj.output === "function";
+  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);
+    });
+  });
 }
-function extractViaStandardSchema(schema, options = {}) {
-  const standard = schema["~standard"];
-  const target = options.target ?? "draft-2020-12";
-  const extractedSchema = standard.jsonSchema.output({ target });
+async function extractStandardSchemasFromProject(entryFile, baseDir, options = {}) {
+  const compiledPath = resolveCompiledPath(entryFile, baseDir);
+  if (!compiledPath) {
+    return {
+      schemas: new Map,
+      errors: [`Could not find compiled JS for ${entryFile}. Build the project first.`]
+    };
+  }
+  return extractStandardSchemas(compiledPath, options);
+}
+
+// src/analysis/schema-detection.ts
+async function detectRuntimeSchemas(context) {
+  const { baseDir, entryFile } = context;
+  const compiledPath = resolveCompiledPath(entryFile, baseDir);
+  if (!compiledPath) {
+    return {
+      schemas: new Map,
+      errors: []
+    };
+  }
+  const extraction = await extractStandardSchemasFromProject(entryFile, baseDir);
+  const schemas = new Map;
+  for (const [name, result] of extraction.schemas) {
+    schemas.set(name, {
+      schema: result.outputSchema,
+      vendor: result.vendor
+    });
+  }
   return {
-    schema: extractedSchema,
-    vendor: standard.vendor,
-    version: standard.version
+    schemas,
+    errors: extraction.errors
   };
 }
-function tryExtractStandardSchema(value, options = {}) {
-  if (!isStandardJSONSchema(value)) {
-    return null;
+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];
+    }
   }
-  try {
-    return extractViaStandardSchema(value, options);
-  } catch {
+  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;
   }
-}
-var KNOWN_VENDORS = {
-  zod: { minVersion: "4.2.0", homepage: "https://zod.dev" },
-  arktype: { minVersion: "2.0.0", homepage: "https://arktype.io" },
-  valibot: { minVersion: "1.0.0", homepage: "https://valibot.dev" }
 };
-// src/analysis/schema-detection.ts
-var moduleCache = new Map;
-function getFileMtime(filePath) {
-  try {
-    return fs.statSync(filePath).mtimeMs;
-  } catch {
-    return 0;
+
+// 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);
   }
-}
-async function loadModule(modulePath) {
-  const currentMtime = getFileMtime(modulePath);
-  const cached = moduleCache.get(modulePath);
-  if (cached && cached.mtime === currentMtime && currentMtime > 0) {
-    return cached.module;
+};
+
+// 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;
   }
-  try {
-    const requireCache = eval("require").cache;
-    if (requireCache && requireCache[modulePath]) {
-      delete requireCache[modulePath];
+};
+
+// 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;
     }
-  } catch {}
-  let mod;
-  try {
-    mod = eval("require")(modulePath);
-  } catch (err) {
-    const nodeErr = err;
-    if (nodeErr.code === "ERR_REQUIRE_ESM") {
-      const cacheBuster = currentMtime > 0 ? `?t=${currentMtime}` : "";
-      mod = await import(`${modulePath}${cacheBuster}`);
-    } else {
-      throw err;
+    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;
   }
-  moduleCache.set(modulePath, { module: mod, mtime: currentMtime });
-  return mod;
+  return adapter.extractOutputType(type, checker);
 }
-async function detectRuntimeSchemas(context) {
+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 = {
-    schemas: new Map,
-    errors: []
+    adapter,
+    outputType
   };
-  try {
-    const modulePath2 = resolveModulePath(context.entryFile, context.baseDir);
-    if (!modulePath2) {
-      result.errors.push("Could not resolve compiled module path");
-      return result;
-    }
-    const mod2 = await loadModule(modulePath2);
-    if (!mod2 || typeof mod2 !== "object") {
-      result.errors.push("Module did not export an object");
-      return result;
-    }
-    const exports = mod2;
-    for (const [name, value] of Object.entries(exports)) {
-      if (name.startsWith("_") || name === "default") {
-        continue;
-      }
-      const schemaResult = tryExtractStandardSchema(value);
-      if (schemaResult) {
-        result.schemas.set(name, schemaResult);
-      }
+  if (adapter.extractInputType) {
+    const inputType = adapter.extractInputType(type, checker);
+    if (inputType) {
+      result.inputType = inputType;
     }
-    if ("default" in exports && exports.default && typeof exports.default === "object") {
-      const defaultExports = exports.default;
-      for (const [name, value] of Object.entries(defaultExports)) {
-        if (name.startsWith("_"))
-          continue;
-        const schemaResult = tryExtractStandardSchema(value);
-        if (schemaResult && !result.schemas.has(name)) {
-          result.schemas.set(name, schemaResult);
-        }
-      }
-    }
-  } catch (err) {
-    result.errors.push(`Runtime detection failed: ${err instanceof Error ? err.message : String(err)}`);
   }
   return result;
 }
-function resolveModulePath(entryFile, baseDir) {
-  if (entryFile.endsWith(".js") || entryFile.endsWith(".mjs") || entryFile.endsWith(".cjs")) {
-    return entryFile;
-  }
-  const tsFile = entryFile;
-  const possiblePaths = [
-    tsFile.replace(/\.tsx?$/, ".js"),
-    tsFile.replace(/\.tsx?$/, ".mjs"),
-    tsFile.replace(/\/src\//, "/dist/").replace(/\.tsx?$/, ".js"),
-    tsFile.replace(/\/src\//, "/build/").replace(/\.tsx?$/, ".js"),
-    tsFile.replace(/\/src\//, "/lib/").replace(/\.tsx?$/, ".js")
-  ];
-  for (const testPath of possiblePaths) {
-    try {
-      __require.resolve(testPath, { paths: [baseDir] });
-      return testPath;
-    } catch {}
-  }
-  return null;
+function getRegisteredAdapters() {
+  return adapters;
 }
-function clearSchemaCache() {
-  moduleCache.clear();
+function getSupportedLibraries() {
+  return adapters.flatMap((a) => a.packages);
 }
 // src/analysis/docs-coverage.ts
 import {
@@ -597,7 +807,7 @@ function categorizeDrifts(drifts) {
 }
 // src/fix/jsdoc-writer.ts
 import * as fs2 from "node:fs";
-import * as path from "node:path";
+import * as path2 from "node:path";
 
 // src/ts-module.ts
 import * as tsNamespace from "typescript";
@@ -964,7 +1174,7 @@ async function applyEdits(edits) {
 }
 function createSourceFile(filePath) {
   const content = fs2.readFileSync(filePath, "utf-8");
-  return ts.createSourceFile(path.basename(filePath), content, ts.ScriptTarget.Latest, true, filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+  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) {
@@ -2162,480 +2372,6 @@ function ensureSpecCoverage(spec) {
     }
   };
 }
-// src/quality/rules.ts
-var BUILTIN_TYPES = new Set([
-  "string",
-  "number",
-  "boolean",
-  "object",
-  "any",
-  "unknown",
-  "void",
-  "never",
-  "null",
-  "undefined",
-  "symbol",
-  "bigint",
-  "Array",
-  "Promise",
-  "Map",
-  "Set",
-  "Record",
-  "Partial",
-  "Required",
-  "Readonly",
-  "Pick",
-  "Omit",
-  "Exclude",
-  "Extract",
-  "NonNullable",
-  "ReturnType",
-  "Parameters",
-  "InstanceType",
-  "ConstructorParameters",
-  "Awaited"
-]);
-function extractTypeReferences(exp) {
-  const refs = new Set;
-  function collectFromSchema(schema) {
-    if (!schema)
-      return;
-    if (typeof schema === "string") {
-      if (!BUILTIN_TYPES.has(schema)) {
-        refs.add(schema);
-      }
-      return;
-    }
-    if (typeof schema === "object") {
-      const obj = schema;
-      if (typeof obj.$ref === "string") {
-        const ref = obj.$ref;
-        const name = ref.startsWith("#/types/") ? ref.slice("#/types/".length) : ref;
-        if (!BUILTIN_TYPES.has(name)) {
-          refs.add(name);
-        }
-      }
-      if (typeof obj.type === "string" && !BUILTIN_TYPES.has(obj.type)) {
-        refs.add(obj.type);
-      }
-      if (obj.items) {
-        collectFromSchema(obj.items);
-      }
-      if (obj.properties && typeof obj.properties === "object") {
-        for (const prop of Object.values(obj.properties)) {
-          collectFromSchema(prop);
-        }
-      }
-      if (Array.isArray(obj.anyOf)) {
-        for (const item of obj.anyOf) {
-          collectFromSchema(item);
-        }
-      }
-      if (Array.isArray(obj.oneOf)) {
-        for (const item of obj.oneOf) {
-          collectFromSchema(item);
-        }
-      }
-      if (Array.isArray(obj.allOf)) {
-        for (const item of obj.allOf) {
-          collectFromSchema(item);
-        }
-      }
-      if (obj.additionalProperties && typeof obj.additionalProperties === "object") {
-        collectFromSchema(obj.additionalProperties);
-      }
-    }
-  }
-  for (const sig of exp.signatures ?? []) {
-    for (const param of sig.parameters ?? []) {
-      collectFromSchema(param.schema);
-    }
-    if (sig.returns?.schema) {
-      collectFromSchema(sig.returns.schema);
-    }
-  }
-  for (const member of exp.members ?? []) {
-    collectFromSchema(member.schema);
-    for (const sig of member.signatures ?? []) {
-      for (const param of sig.parameters ?? []) {
-        collectFromSchema(param.schema);
-      }
-      if (sig.returns?.schema) {
-        collectFromSchema(sig.returns.schema);
-      }
-    }
-  }
-  collectFromSchema(exp.schema);
-  if (typeof exp.type === "string" && !BUILTIN_TYPES.has(exp.type)) {
-    refs.add(exp.type);
-  }
-  if (exp.extends && !BUILTIN_TYPES.has(exp.extends)) {
-    refs.add(exp.extends);
-  }
-  for (const impl of exp.implements ?? []) {
-    if (!BUILTIN_TYPES.has(impl)) {
-      refs.add(impl);
-    }
-  }
-  return refs;
-}
-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 TSDOC_RULES = [
-  {
-    id: "require-release-tag",
-    name: "Require Release Tag",
-    description: "All exports must have @public, @beta, @alpha, or @internal",
-    affectsCoverage: false,
-    defaultSeverity: "off",
-    check(ctx) {
-      const tags = ctx.export.tags ?? [];
-      return tags.some((t) => ["public", "beta", "alpha", "internal"].includes(t.name.toLowerCase()));
-    },
-    getViolation(ctx) {
-      return {
-        ruleId: "require-release-tag",
-        severity: "warn",
-        message: `Export '${ctx.export.name}' is missing a release tag (@public, @beta, @alpha, or @internal)`,
-        fixable: true
-      };
-    }
-  },
-  {
-    id: "internal-underscore",
-    name: "Internal Underscore Prefix",
-    description: "@internal exports should have underscore prefix",
-    affectsCoverage: false,
-    defaultSeverity: "off",
-    check(ctx) {
-      const tags = ctx.export.tags ?? [];
-      const isInternal = tags.some((t) => t.name.toLowerCase() === "internal");
-      if (!isInternal)
-        return true;
-      return ctx.export.name.startsWith("_");
-    },
-    getViolation(ctx) {
-      return {
-        ruleId: "internal-underscore",
-        severity: "warn",
-        message: `Internal export '${ctx.export.name}' should have underscore prefix (_${ctx.export.name})`,
-        fixable: false
-      };
-    }
-  },
-  {
-    id: "no-conflicting-tags",
-    name: "No Conflicting Tags",
-    description: "Cannot have both @internal and @public/@beta/@alpha",
-    affectsCoverage: false,
-    defaultSeverity: "warn",
-    check(ctx) {
-      const tags = ctx.export.tags ?? [];
-      const tagNames = tags.map((t) => t.name.toLowerCase());
-      const hasInternal = tagNames.includes("internal");
-      const hasPublicish = tagNames.some((n) => ["public", "beta", "alpha"].includes(n));
-      return !(hasInternal && hasPublicish);
-    },
-    getViolation(ctx) {
-      return {
-        ruleId: "no-conflicting-tags",
-        severity: "error",
-        message: `Export '${ctx.export.name}' has conflicting release tags (@internal with @public/@beta/@alpha)`,
-        fixable: false
-      };
-    }
-  },
-  {
-    id: "no-forgotten-export",
-    name: "No Forgotten Export",
-    description: "All referenced types must be exported",
-    affectsCoverage: false,
-    defaultSeverity: "off",
-    check(ctx) {
-      if (!ctx.exportRegistry)
-        return true;
-      const refs = extractTypeReferences(ctx.export);
-      for (const ref of refs) {
-        if (!ctx.exportRegistry.has(ref)) {
-          return false;
-        }
-      }
-      return true;
-    },
-    getViolation(ctx) {
-      const refs = extractTypeReferences(ctx.export);
-      const missing = ctx.exportRegistry ? [...refs].filter((r) => !ctx.exportRegistry.has(r)) : [];
-      return {
-        ruleId: "no-forgotten-export",
-        severity: "warn",
-        message: missing.length > 0 ? `Export '${ctx.export.name}' references unexported types: ${missing.join(", ")}` : `Export '${ctx.export.name}' references types that are not exported`,
-        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, ...TSDOC_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: {} }, exportRegistry) {
-  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, exportRegistry };
-  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;
@@ -2657,38 +2393,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, exportRegistry);
+    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
@@ -2697,7 +2428,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)
   };
@@ -2707,9 +2437,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,
@@ -2720,7 +2447,7 @@ function enrichSpec(spec, options = {}) {
 }
 // src/analysis/report.ts
 import * as fs3 from "node:fs";
-import * as path2 from "node:path";
+import * as path3 from "node:path";
 
 // src/types/report.ts
 var REPORT_VERSION = "1.0.0";
@@ -2796,7 +2523,7 @@ function generateReportFromEnriched(enriched) {
 }
 function loadCachedReport(reportPath = DEFAULT_REPORT_PATH) {
   try {
-    const fullPath = path2.resolve(reportPath);
+    const fullPath = path3.resolve(reportPath);
     if (!fs3.existsSync(fullPath)) {
       return null;
     }
@@ -2807,8 +2534,8 @@ function loadCachedReport(reportPath = DEFAULT_REPORT_PATH) {
   }
 }
 function saveReport(report, reportPath = DEFAULT_REPORT_PATH) {
-  const fullPath = path2.resolve(reportPath);
-  const dir = path2.dirname(fullPath);
+  const fullPath = path3.resolve(reportPath);
+  const dir = path3.dirname(fullPath);
   if (!fs3.existsSync(dir)) {
     fs3.mkdirSync(dir, { recursive: true });
   }
@@ -3010,7 +2737,7 @@ function renderApiSurface(spec) {
 }
 // src/analysis/history.ts
 import * as fs4 from "node:fs";
-import * as path3 from "node:path";
+import * as path4 from "node:path";
 var HISTORY_DIR = ".doccov/history";
 var RETENTION_DAYS = {
   free: 7,
@@ -3048,16 +2775,16 @@ function computeSnapshot(spec, options) {
   };
 }
 function saveSnapshot(snapshot, cwd) {
-  const historyDir = path3.resolve(cwd, HISTORY_DIR);
+  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 = path3.join(historyDir, filename);
+  const filepath = path4.join(historyDir, filename);
   fs4.writeFileSync(filepath, JSON.stringify(snapshot, null, 2));
 }
 function loadSnapshots(cwd) {
-  const historyDir = path3.resolve(cwd, HISTORY_DIR);
+  const historyDir = path4.resolve(cwd, HISTORY_DIR);
   if (!fs4.existsSync(historyDir)) {
     return [];
   }
@@ -3065,7 +2792,7 @@ function loadSnapshots(cwd) {
   const snapshots = [];
   for (const file of files) {
     try {
-      const content = fs4.readFileSync(path3.join(historyDir, file), "utf-8");
+      const content = fs4.readFileSync(path4.join(historyDir, file), "utf-8");
       snapshots.push(JSON.parse(content));
     } catch {}
   }
@@ -3105,7 +2832,7 @@ function formatDelta(delta) {
   return "→0%";
 }
 function pruneHistory(cwd, keepCount = 100) {
-  const historyDir = path3.resolve(cwd, HISTORY_DIR);
+  const historyDir = path4.resolve(cwd, HISTORY_DIR);
   if (!fs4.existsSync(historyDir)) {
     return 0;
   }
@@ -3113,7 +2840,7 @@ function pruneHistory(cwd, keepCount = 100) {
   const toDelete = files.slice(keepCount);
   for (const file of toDelete) {
     try {
-      fs4.unlinkSync(path3.join(historyDir, file));
+      fs4.unlinkSync(path4.join(historyDir, file));
     } catch {}
   }
   return toDelete.length;
@@ -3122,7 +2849,7 @@ function pruneByTier(cwd, tier) {
   const retentionDays = RETENTION_DAYS[tier];
   const cutoffDate = new Date;
   cutoffDate.setDate(cutoffDate.getDate() - retentionDays);
-  const historyDir = path3.resolve(cwd, HISTORY_DIR);
+  const historyDir = path4.resolve(cwd, HISTORY_DIR);
   if (!fs4.existsSync(historyDir)) {
     return 0;
   }
@@ -3130,7 +2857,7 @@ function pruneByTier(cwd, tier) {
   let deleted = 0;
   for (const file of files) {
     try {
-      const filepath = path3.join(historyDir, file);
+      const filepath = path4.join(historyDir, file);
       const content = fs4.readFileSync(filepath, "utf-8");
       const snapshot = JSON.parse(content);
       const snapshotDate = new Date(snapshot.timestamp);
@@ -3237,7 +2964,7 @@ function getExtendedTrend(spec, cwd, options) {
 // src/cache/hash.ts
 import * as crypto from "node:crypto";
 import * as fs5 from "node:fs";
-import * as path4 from "node:path";
+import * as path5 from "node:path";
 function hashFile(filePath) {
   try {
     const content = fs5.readFileSync(filePath);
@@ -3254,21 +2981,21 @@ function hashFiles(filePaths, cwd) {
   for (const filePath of filePaths) {
     const hash = hashFile(filePath);
     if (hash) {
-      const relativePath = path4.relative(cwd, filePath);
+      const relativePath = path5.relative(cwd, filePath);
       hashes[relativePath] = hash;
     }
   }
   return hashes;
 }
-function diffHashes(cached2, current) {
+function diffHashes(cached, current) {
   const changed = [];
-  for (const [file, hash] of Object.entries(cached2)) {
+  for (const [file, hash] of Object.entries(cached)) {
     if (current[file] !== hash) {
       changed.push(file);
     }
   }
   for (const file of Object.keys(current)) {
-    if (!(file in cached2)) {
+    if (!(file in cached)) {
       changed.push(file);
     }
   }
@@ -3276,12 +3003,12 @@ function diffHashes(cached2, current) {
 }
 // src/cache/spec-cache.ts
 import * as fs6 from "node:fs";
-import * as path5 from "node:path";
+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 = path5.resolve(cwd, SPEC_CACHE_FILE);
+    const cachePath = path6.resolve(cwd, SPEC_CACHE_FILE);
     if (!fs6.existsSync(cachePath)) {
       return null;
     }
@@ -3297,7 +3024,7 @@ function saveSpecCache(spec, context) {
     cacheVersion: CACHE_VERSION,
     generatedAt: new Date().toISOString(),
     specVersion: spec.openpkg,
-    entryFile: path5.relative(cwd, entryFile),
+    entryFile: path6.relative(cwd, entryFile),
     hashes: {
       tsconfig: tsconfigPath ? hashFile(tsconfigPath) : null,
       packageJson: hashFile(packageJsonPath) ?? "",
@@ -3306,8 +3033,8 @@ function saveSpecCache(spec, context) {
     config,
     spec
   };
-  const cachePath = path5.resolve(cwd, SPEC_CACHE_FILE);
-  const dir = path5.dirname(cachePath);
+  const cachePath = path6.resolve(cwd, SPEC_CACHE_FILE);
+  const dir = path6.dirname(cachePath);
   if (!fs6.existsSync(dir)) {
     fs6.mkdirSync(dir, { recursive: true });
   }
@@ -3318,7 +3045,7 @@ function validateSpecCache(cache, context) {
   if (cache.cacheVersion !== CACHE_VERSION) {
     return { valid: false, reason: "cache-version-mismatch" };
   }
-  const relativeEntry = path5.relative(cwd, entryFile);
+  const relativeEntry = path6.relative(cwd, entryFile);
   if (cache.entryFile !== relativeEntry) {
     return { valid: false, reason: "entry-file-changed" };
   }
@@ -3341,7 +3068,7 @@ function validateSpecCache(cache, context) {
   return { valid: true };
 }
 function clearSpecCache(cwd) {
-  const cachePath = path5.resolve(cwd, SPEC_CACHE_FILE);
+  const cachePath = path6.resolve(cwd, SPEC_CACHE_FILE);
   if (fs6.existsSync(cachePath)) {
     fs6.unlinkSync(cachePath);
     return true;
@@ -3349,325 +3076,26 @@ function clearSpecCache(cwd) {
   return false;
 }
 function getSpecCachePath(cwd) {
-  return path5.resolve(cwd, SPEC_CACHE_FILE);
-}
-// src/codeowners/index.ts
-import * as fs7 from "node:fs";
-import * as path6 from "node:path";
-import { minimatch } from "minimatch";
-var CODEOWNERS_LOCATIONS = [
-  "CODEOWNERS",
-  ".github/CODEOWNERS",
-  "docs/CODEOWNERS"
-];
-function parseCodeOwners(content) {
-  const rules = [];
-  const lines = content.split(`
-`);
-  for (let i = 0;i < lines.length; i++) {
-    const line = lines[i].trim();
-    if (!line || line.startsWith("#"))
-      continue;
-    const parts = line.split(/\s+/);
-    if (parts.length < 2)
-      continue;
-    const pattern = parts[0];
-    const owners = parts.slice(1).filter((o) => o.startsWith("@") || o.includes("@"));
-    if (owners.length > 0) {
-      rules.push({
-        line: i + 1,
-        pattern,
-        owners
-      });
-    }
-  }
-  return rules;
-}
-function loadCodeOwners(baseDir) {
-  for (const location of CODEOWNERS_LOCATIONS) {
-    const filePath = path6.join(baseDir, location);
-    if (fs7.existsSync(filePath)) {
-      const content = fs7.readFileSync(filePath, "utf-8");
-      return {
-        filePath,
-        rules: parseCodeOwners(content)
-      };
-    }
-  }
-  return null;
-}
-function findOwners(filePath, rules) {
-  const normalizedPath = filePath.replace(/^\.\//, "");
-  let matchingOwners = [];
-  for (const rule of rules) {
-    let pattern = rule.pattern;
-    if (pattern.endsWith("/")) {
-      pattern = pattern + "**";
-    }
-    if (pattern.startsWith("/")) {
-      pattern = pattern.slice(1);
-    } else if (!pattern.startsWith("*")) {
-      pattern = "**/" + pattern;
-    }
-    if (minimatch(normalizedPath, pattern, { matchBase: true, dot: true })) {
-      matchingOwners = rule.owners;
-    }
-  }
-  return matchingOwners;
-}
-function attributeOwners(exports, rules, baseDir) {
-  const ownershipMap = new Map;
-  for (const exp of exports) {
-    const filePath = exp.source?.file;
-    if (!filePath) {
-      ownershipMap.set(exp, []);
-      continue;
-    }
-    let relativePath = filePath;
-    if (path6.isAbsolute(filePath)) {
-      relativePath = path6.relative(baseDir, filePath);
-    }
-    const owners = findOwners(relativePath, rules);
-    ownershipMap.set(exp, owners);
-  }
-  return ownershipMap;
-}
-function analyzeOwnership(spec, codeowners, baseDir) {
-  const exports = spec.exports ?? [];
-  const ownershipMap = attributeOwners(exports, codeowners.rules, baseDir);
-  const byOwnerExports = new Map;
-  const unowned = [];
-  for (const [exp, owners] of ownershipMap) {
-    if (owners.length === 0) {
-      unowned.push(exp);
-    } else {
-      for (const owner of owners) {
-        const existing = byOwnerExports.get(owner) ?? [];
-        existing.push(exp);
-        byOwnerExports.set(owner, existing);
-      }
-    }
-  }
-  const byOwner = new Map;
-  for (const [owner, ownerExports] of byOwnerExports) {
-    const documented = ownerExports.filter((e) => e.description);
-    const withDrift = ownerExports.filter((e) => e.docs?.drift && e.docs.drift.length > 0);
-    const withExamples = ownerExports.filter((e) => e.examples && e.examples.length > 0);
-    const undocumented = ownerExports.filter((e) => !e.description);
-    const coverageScore = ownerExports.length === 0 ? 100 : Math.round(documented.length / ownerExports.length * 100);
-    const driftScore = ownerExports.length === 0 ? 0 : Math.round(withDrift.length / ownerExports.length * 100);
-    byOwner.set(owner, {
-      owner,
-      totalExports: ownerExports.length,
-      documentedExports: documented.length,
-      coverageScore,
-      exportsWithDrift: withDrift.length,
-      driftScore,
-      missingExamples: ownerExports.length - withExamples.length,
-      undocumentedExports: undocumented.map((e) => e.name)
-    });
-  }
-  return {
-    codeownersPath: codeowners.filePath,
-    byOwner,
-    unowned,
-    totalExports: exports.length
-  };
-}
-function analyzeSpecOwnership(spec, options) {
-  const codeowners = loadCodeOwners(options.baseDir);
-  if (!codeowners)
-    return null;
-  return analyzeOwnership(spec, codeowners, options.baseDir);
-}
-// src/contributors/index.ts
-import { execSync } from "node:child_process";
-import * as path7 from "node:path";
-function parseBlameOutput(output) {
-  const results = [];
-  const lines = output.split(`
-`);
-  let currentCommit = "";
-  let currentAuthor = "";
-  let currentEmail = "";
-  let currentTime = 0;
-  let lineNumber = 0;
-  for (const line of lines) {
-    if (line.match(/^[0-9a-f]{40}/)) {
-      const parts = line.split(" ");
-      currentCommit = parts[0];
-      lineNumber = parseInt(parts[2], 10);
-    } else if (line.startsWith("author ")) {
-      currentAuthor = line.slice(7);
-    } else if (line.startsWith("author-mail ")) {
-      currentEmail = line.slice(12).replace(/[<>]/g, "");
-    } else if (line.startsWith("author-time ")) {
-      currentTime = parseInt(line.slice(12), 10);
-    } else if (line.startsWith("\t")) {
-      results.push({
-        commit: currentCommit,
-        author: currentAuthor,
-        email: currentEmail,
-        line: lineNumber,
-        timestamp: currentTime
-      });
-    }
-  }
-  return results;
-}
-function getFileBlame(filePath, cwd) {
-  try {
-    const relativePath = path7.isAbsolute(filePath) ? path7.relative(cwd, filePath) : filePath;
-    const output = execSync(`git blame --porcelain "${relativePath}"`, {
-      cwd,
-      encoding: "utf-8",
-      maxBuffer: 10 * 1024 * 1024,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    return parseBlameOutput(output);
-  } catch {
-    return null;
-  }
-}
-function getBlameForLines(filePath, startLine, endLine, cwd) {
-  try {
-    const relativePath = path7.isAbsolute(filePath) ? path7.relative(cwd, filePath) : filePath;
-    const output = execSync(`git blame --porcelain -L ${startLine},${endLine} "${relativePath}"`, {
-      cwd,
-      encoding: "utf-8",
-      maxBuffer: 10 * 1024 * 1024,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    return parseBlameOutput(output);
-  } catch {
-    return null;
-  }
-}
-function findPrimaryAuthor(blameLines) {
-  if (blameLines.length === 0)
-    return null;
-  const authorCounts = new Map;
-  for (const line of blameLines) {
-    const key = line.email;
-    const existing = authorCounts.get(key);
-    if (existing) {
-      existing.count++;
-      if (line.timestamp > existing.info.timestamp) {
-        existing.info = line;
-      }
-    } else {
-      authorCounts.set(key, { count: 1, info: line });
-    }
-  }
-  let maxCount = 0;
-  let primaryAuthor = null;
-  for (const { count, info } of authorCounts.values()) {
-    if (count > maxCount) {
-      maxCount = count;
-      primaryAuthor = info;
-    }
-  }
-  return primaryAuthor;
-}
-function analyzeContributors(spec, baseDir) {
-  const exports = spec.exports ?? [];
-  const byContributor = new Map;
-  const unattributed = [];
-  let totalDocumented = 0;
-  const fileBlameCache = new Map;
-  for (const exp of exports) {
-    if (!exp.description)
-      continue;
-    const filePath = exp.source?.file;
-    const line = exp.source?.line;
-    if (!filePath || !line) {
-      unattributed.push(exp.name);
-      continue;
-    }
-    let fileBlame = fileBlameCache.get(filePath);
-    if (fileBlame === undefined) {
-      fileBlame = getFileBlame(filePath, baseDir);
-      fileBlameCache.set(filePath, fileBlame);
-    }
-    if (!fileBlame) {
-      unattributed.push(exp.name);
-      continue;
-    }
-    const jsDocStartLine = Math.max(1, line - 20);
-    const declarationLine = line;
-    const jsDocBlame = fileBlame.filter((b) => b.line >= jsDocStartLine && b.line < declarationLine);
-    const primaryAuthor = findPrimaryAuthor(jsDocBlame);
-    if (!primaryAuthor) {
-      const declBlame = fileBlame.find((b) => b.line === declarationLine);
-      if (declBlame) {
-        attributeToContributor(byContributor, declBlame, exp.name, 1);
-        totalDocumented++;
-      } else {
-        unattributed.push(exp.name);
-      }
-      continue;
-    }
-    const linesAuthored = jsDocBlame.filter((b) => b.email === primaryAuthor.email).length;
-    attributeToContributor(byContributor, primaryAuthor, exp.name, linesAuthored);
-    totalDocumented++;
-  }
-  return {
-    byContributor,
-    totalDocumented,
-    unattributed
-  };
-}
-function attributeToContributor(byContributor, blame, exportName, lines) {
-  const key = blame.email;
-  const existing = byContributor.get(key);
-  if (existing) {
-    existing.documentedExports++;
-    existing.exports.push(exportName);
-    existing.linesAuthored += lines;
-    const blameDate = new Date(blame.timestamp * 1000);
-    if (!existing.lastContribution || blameDate > existing.lastContribution) {
-      existing.lastContribution = blameDate;
-    }
-  } else {
-    byContributor.set(key, {
-      name: blame.author,
-      email: blame.email,
-      documentedExports: 1,
-      exports: [exportName],
-      linesAuthored: lines,
-      lastContribution: new Date(blame.timestamp * 1000)
-    });
-  }
-}
-function analyzeSpecContributors(spec, options) {
-  try {
-    execSync("git rev-parse --git-dir", {
-      cwd: options.baseDir,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-  } catch {
-    return null;
-  }
-  return analyzeContributors(spec, options.baseDir);
+  return path6.resolve(cwd, SPEC_CACHE_FILE);
 }
 // src/config/types.ts
 function defineConfig(config) {
   return config;
 }
 // src/detect/utils.ts
-async function safeParseJson(fs8, path8) {
+async function safeParseJson(fs7, path7) {
   try {
-    if (!await fs8.exists(path8))
+    if (!await fs7.exists(path7))
       return null;
-    const content = await fs8.readFile(path8);
+    const content = await fs7.readFile(path7);
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
-async function readPackageJson(fs8, dir) {
-  const path8 = dir === "." ? "package.json" : `${dir}/package.json`;
-  return safeParseJson(fs8, path8);
+async function readPackageJson(fs7, dir) {
+  const path7 = dir === "." ? "package.json" : `${dir}/package.json`;
+  return safeParseJson(fs7, path7);
 }
 
 // src/detect/build.ts
@@ -3697,8 +3125,8 @@ var BUILD_TOOL_PATTERNS = [
   "babel",
   "ncc build"
 ];
-async function detectBuildInfo(fs8, packagePath = ".") {
-  const pkgJson = await readPackageJson(fs8, 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)));
@@ -3710,10 +3138,10 @@ async function detectBuildInfo(fs8, packagePath = ".") {
   });
   const buildScripts = [...new Set([...buildScriptsByName, ...buildScriptsByContent])];
   const tsconfigPath = packagePath === "." ? "tsconfig.json" : `${packagePath}/tsconfig.json`;
-  const hasTsConfig = await fs8.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(fs8, packagePath, pkgJson);
+  const wasm = await detectWasmProject(fs7, packagePath, pkgJson);
   const napi = detectNapiProject(pkgJson);
   return {
     scripts: buildScripts,
@@ -3730,11 +3158,11 @@ var WASM_PACKAGES = new Set([
   "wasm-bindgen",
   "@aspect/aspect-cli"
 ]);
-async function detectWasmProject(fs8, packagePath, pkgJson) {
+async function detectWasmProject(fs7, packagePath, pkgJson) {
   const pkgCargoPath = packagePath === "." ? "Cargo.toml" : `${packagePath}/Cargo.toml`;
-  if (await fs8.exists(pkgCargoPath))
+  if (await fs7.exists(pkgCargoPath))
     return true;
-  if (packagePath !== "." && await fs8.exists("Cargo.toml"))
+  if (packagePath !== "." && await fs7.exists("Cargo.toml"))
     return true;
   if (pkgJson) {
     const deps = Object.keys({
@@ -3775,15 +3203,15 @@ function getPrimaryBuildScript(buildInfo) {
   return buildInfo.scripts[0] ?? null;
 }
 // src/detect/entry-point.ts
-async function detectEntryPoint(fs8, packagePath = ".") {
-  const pkgJson = await readPackageJson(fs8, 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(fs8, packagePath);
+  const tsConfig = await parseTsConfig(fs7, packagePath);
   const typesField = pkgJson.types || pkgJson.typings;
   if (typesField && typeof typesField === "string") {
-    const resolved = await resolveToSource(fs8, packagePath, typesField, tsConfig);
+    const resolved = await resolveToSource(fs7, packagePath, typesField, tsConfig);
     if (resolved) {
       return { ...resolved, source: "types" };
     }
@@ -3793,7 +3221,7 @@ async function detectEntryPoint(fs8, packagePath = ".") {
     if (dotExport && typeof dotExport === "object" && "types" in dotExport) {
       const typesPath = dotExport.types;
       if (typesPath && typeof typesPath === "string") {
-        const resolved = await resolveToSource(fs8, packagePath, typesPath, tsConfig);
+        const resolved = await resolveToSource(fs7, packagePath, typesPath, tsConfig);
         if (resolved) {
           return { ...resolved, source: "exports" };
         }
@@ -3801,13 +3229,13 @@ async function detectEntryPoint(fs8, packagePath = ".") {
     }
   }
   if (pkgJson.main && typeof pkgJson.main === "string") {
-    const resolved = await resolveToSource(fs8, 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(fs8, packagePath, pkgJson.module, tsConfig);
+    const resolved = await resolveToSource(fs7, packagePath, pkgJson.module, tsConfig);
     if (resolved) {
       return { ...resolved, source: "module" };
     }
@@ -3825,27 +3253,27 @@ async function detectEntryPoint(fs8, packagePath = ".") {
   ];
   for (const fallback of fallbacks) {
     const checkPath = packagePath === "." ? fallback : `${packagePath}/${fallback}`;
-    if (await fs8.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(fs8, packagePath) {
+async function parseTsConfig(fs7, packagePath) {
   const tsconfigPath = packagePath === "." ? "tsconfig.json" : `${packagePath}/tsconfig.json`;
-  const tsconfig = await safeParseJson(fs8, 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(fs8, 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 fs8.exists(checkPath(normalized))) {
+    if (await fs7.exists(checkPath(normalized))) {
       return { path: normalized, isDeclarationOnly: false };
     }
   }
@@ -3887,19 +3315,19 @@ async function resolveToSource(fs8, basePath, filePath, tsConfig) {
   for (const candidate of candidates) {
     if (candidate.endsWith(".d.ts"))
       continue;
-    if (await fs8.exists(checkPath(candidate))) {
+    if (await fs7.exists(checkPath(candidate))) {
       return { path: candidate, isDeclarationOnly: false };
     }
   }
   if (normalized.endsWith(".d.ts")) {
-    if (await fs8.exists(checkPath(normalized))) {
+    if (await fs7.exists(checkPath(normalized))) {
       return { path: normalized, isDeclarationOnly: true };
     }
   }
   return null;
 }
 // src/detect/filesystem.ts
-import * as fs8 from "node:fs";
+import * as fs7 from "node:fs";
 import * as nodePath from "node:path";
 import { Writable } from "node:stream";
 
@@ -3912,19 +3340,19 @@ class NodeFileSystem {
     return nodePath.join(this.basePath, relativePath);
   }
   async exists(relativePath) {
-    return fs8.existsSync(this.resolve(relativePath));
+    return fs7.existsSync(this.resolve(relativePath));
   }
   async readFile(relativePath) {
-    return fs8.readFileSync(this.resolve(relativePath), "utf-8");
+    return fs7.readFileSync(this.resolve(relativePath), "utf-8");
   }
   async readDir(relativePath) {
-    return fs8.readdirSync(this.resolve(relativePath));
+    return fs7.readdirSync(this.resolve(relativePath));
   }
   async isDirectory(relativePath) {
     const fullPath = this.resolve(relativePath);
-    if (!fs8.existsSync(fullPath))
+    if (!fs7.existsSync(fullPath))
       return false;
-    return fs8.statSync(fullPath).isDirectory();
+    return fs7.statSync(fullPath).isDirectory();
   }
 }
 function createCaptureStream() {
@@ -3940,9 +3368,9 @@ function createCaptureStream() {
 
 class FileNotFoundError extends Error {
   path;
-  constructor(path8, message) {
-    super(message ?? `File not found: ${path8}`);
-    this.path = path8;
+  constructor(path7, message) {
+    super(message ?? `File not found: ${path7}`);
+    this.path = path7;
     this.name = "FileNotFoundError";
   }
 }
@@ -3952,34 +3380,34 @@ class SandboxFileSystem {
   constructor(sandbox) {
     this.sandbox = sandbox;
   }
-  async exists(path8) {
+  async exists(path7) {
     const result = await this.sandbox.runCommand({
       cmd: "test",
-      args: ["-e", path8]
+      args: ["-e", path7]
     });
     return result.exitCode === 0;
   }
-  async readFile(path8) {
-    const exists = await this.exists(path8);
+  async readFile(path7) {
+    const exists = await this.exists(path7);
     if (!exists) {
-      throw new FileNotFoundError(path8);
+      throw new FileNotFoundError(path7);
     }
     const capture = createCaptureStream();
     const result = await this.sandbox.runCommand({
       cmd: "cat",
-      args: [path8],
+      args: [path7],
       stdout: capture.stream
     });
     if (result.exitCode !== 0) {
-      throw new FileNotFoundError(path8, `Failed to read file: ${path8}`);
+      throw new FileNotFoundError(path7, `Failed to read file: ${path7}`);
     }
     return capture.getOutput();
   }
-  async readDir(path8) {
+  async readDir(path7) {
     const capture = createCaptureStream();
     const result = await this.sandbox.runCommand({
       cmd: "ls",
-      args: ["-1", path8],
+      args: ["-1", path7],
       stdout: capture.stream
     });
     if (result.exitCode !== 0) {
@@ -3988,20 +3416,20 @@ class SandboxFileSystem {
     return capture.getOutput().split(`
 `).filter(Boolean);
   }
-  async isDirectory(path8) {
+  async isDirectory(path7) {
     const result = await this.sandbox.runCommand({
       cmd: "test",
-      args: ["-d", path8]
+      args: ["-d", path7]
     });
     return result.exitCode === 0;
   }
 }
 // src/detect/monorepo.ts
-async function detectMonorepo(fs9) {
-  const pkgJson = await readPackageJson(fs9, ".");
+async function detectMonorepo(fs8) {
+  const pkgJson = await readPackageJson(fs8, ".");
   if (pkgJson?.workspaces) {
     const patterns = extractWorkspacePatterns(pkgJson.workspaces);
-    const packages = await resolveWorkspacePackages(fs9, patterns, pkgJson.name, pkgJson.private);
+    const packages = await resolveWorkspacePackages(fs8, patterns, pkgJson.name, pkgJson.private);
     return {
       isMonorepo: packages.length > 0,
       type: "npm-workspaces",
@@ -4009,10 +3437,10 @@ async function detectMonorepo(fs9) {
       packages
     };
   }
-  if (await fs9.exists("pnpm-workspace.yaml")) {
-    const content = await fs9.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(fs9, patterns, pkgJson?.name, pkgJson?.private);
+    const packages = await resolveWorkspacePackages(fs8, patterns, pkgJson?.name, pkgJson?.private);
     return {
       isMonorepo: packages.length > 0,
       type: "pnpm-workspaces",
@@ -4020,10 +3448,10 @@ async function detectMonorepo(fs9) {
       packages
     };
   }
-  if (await fs9.exists("lerna.json")) {
-    const lerna = await safeParseJson(fs9, "lerna.json");
+  if (await fs8.exists("lerna.json")) {
+    const lerna = await safeParseJson(fs8, "lerna.json");
     const patterns = lerna?.packages ?? ["packages/*"];
-    const packages = await resolveWorkspacePackages(fs9, patterns, pkgJson?.name, pkgJson?.private);
+    const packages = await resolveWorkspacePackages(fs8, patterns, pkgJson?.name, pkgJson?.private);
     return {
       isMonorepo: packages.length > 0,
       type: "lerna",
@@ -4097,7 +3525,7 @@ function parsePnpmWorkspace(content) {
   }
   return patterns.length > 0 ? patterns : ["packages/*"];
 }
-async function resolveWorkspacePackages(fs9, patterns, rootPackageName, rootIsPrivate) {
+async function resolveWorkspacePackages(fs8, patterns, rootPackageName, rootIsPrivate) {
   const packages = [];
   const seen = new Set;
   if (rootPackageName && !rootIsPrivate && rootPackageName !== "root") {
@@ -4119,18 +3547,18 @@ async function resolveWorkspacePackages(fs9, patterns, rootPackageName, rootIsPr
   }
   dirsToScan.add("packages");
   for (const dir of dirsToScan) {
-    if (!await fs9.exists(dir))
+    if (!await fs8.exists(dir))
       continue;
-    if (!await fs9.isDirectory(dir))
+    if (!await fs8.isDirectory(dir))
       continue;
-    const subdirs = await fs9.readDir(dir);
+    const subdirs = await fs8.readDir(dir);
     for (const subdir of subdirs) {
       const pkgPath = `${dir}/${subdir}`;
       const pkgJsonPath = `${pkgPath}/package.json`;
-      if (!await fs9.exists(pkgJsonPath))
+      if (!await fs8.exists(pkgJsonPath))
         continue;
       try {
-        const content = await fs9.readFile(pkgJsonPath);
+        const content = await fs8.readFile(pkgJsonPath);
         const pkg = JSON.parse(content);
         if (pkg.name && !seen.has(pkg.name)) {
           seen.add(pkg.name);
@@ -4202,14 +3630,14 @@ var DEFAULT_PM = {
   installArgs: ["install", "--legacy-peer-deps"],
   runPrefix: ["npm", "run"]
 };
-async function detectPackageManager(fs9) {
-  const pkgJson = await safeParseJson(fs9, "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 fs9.exists(lockfile)) {
+        if (await fs8.exists(lockfile)) {
           return { ...config.info, lockfile };
         }
       }
@@ -4219,7 +3647,7 @@ async function detectPackageManager(fs9) {
   const foundLockfiles = [];
   for (const [pmName, config] of Object.entries(PM_CONFIGS)) {
     for (const lockfile of config.lockfiles) {
-      if (await fs9.exists(lockfile)) {
+      if (await fs8.exists(lockfile)) {
         foundLockfiles.push({ lockfile, pm: pmName });
       }
     }
@@ -4251,10 +3679,10 @@ function getRunCommand(pm, script) {
   return [...pm.runPrefix, script];
 }
 // src/detect/index.ts
-async function analyzeProject(fs9, options = {}) {
+async function analyzeProject(fs8, options = {}) {
   const [packageManager, monorepo] = await Promise.all([
-    detectPackageManager(fs9),
-    detectMonorepo(fs9)
+    detectPackageManager(fs8),
+    detectMonorepo(fs8)
   ]);
   let targetPath = ".";
   if (monorepo.isMonorepo) {
@@ -4271,8 +3699,8 @@ async function analyzeProject(fs9, options = {}) {
     targetPath = pkg.path;
   }
   const [entryPoint, build] = await Promise.all([
-    detectEntryPoint(fs9, targetPath),
-    detectBuildInfo(fs9, targetPath)
+    detectEntryPoint(fs8, targetPath),
+    detectBuildInfo(fs8, targetPath)
   ]);
   return { packageManager, monorepo, entryPoint, build };
 }
@@ -4316,17 +3744,17 @@ function shouldValidate(validations, check) {
   return validations.includes(check);
 }
 // src/typecheck/example-typechecker.ts
-import * as fs9 from "node:fs";
-import * as path8 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 = path8.join(packagePath, "package.json");
-  if (fs9.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path7.join(packagePath, "package.json");
+  if (fs8.existsSync(pkgJsonPath)) {
     try {
-      const pkgJson = JSON.parse(fs9.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
       return pkgJson.name;
     } catch {
       return;
@@ -4336,12 +3764,12 @@ function getPackageName(packagePath) {
 }
 function findTsConfig(packagePath) {
   let dir = packagePath;
-  while (dir !== path8.dirname(dir)) {
-    const tsConfigPath = path8.join(dir, "tsconfig.json");
-    if (fs9.existsSync(tsConfigPath)) {
+  while (dir !== path7.dirname(dir)) {
+    const tsConfigPath = path7.join(dir, "tsconfig.json");
+    if (fs8.existsSync(tsConfigPath)) {
       return tsConfigPath;
     }
-    dir = path8.dirname(dir);
+    dir = path7.dirname(dir);
   }
   return;
 }
@@ -4357,10 +3785,10 @@ function createVirtualSource(example, packageName, exportNames) {
 `);
 }
 function getCompilerOptions(tsconfigPath) {
-  if (tsconfigPath && fs9.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, path8.dirname(tsconfigPath));
+      const parsed = ts3.parseJsonConfigFileContent(configFile.config, ts3.sys, path7.dirname(tsconfigPath));
       return {
         ...parsed.options,
         noEmit: true,
@@ -4386,7 +3814,7 @@ function typecheckExample(example, packagePath, options = {}) {
   const tsconfigPath = options.tsconfig ?? findTsConfig(packagePath);
   const compilerOptions = getCompilerOptions(tsconfigPath);
   const virtualSource = createVirtualSource(cleanCode, packageName, exportNames);
-  const virtualFileName = path8.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);
@@ -4457,25 +3885,25 @@ function typecheckExamples(examples, packagePath, options = {}) {
 }
 
 // src/utils/example-runner.ts
-import { spawn } from "node:child_process";
-import * as fs10 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 path9 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 = path9.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 {
-    fs10.writeFileSync(tmpFile, cleanCode, "utf-8");
+    fs9.writeFileSync(tmpFile, cleanCode, "utf-8");
     const startTime = Date.now();
     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"]
@@ -4524,7 +3952,7 @@ async function runExample(code, options = {}) {
     });
   } finally {
     try {
-      fs10.unlinkSync(tmpFile);
+      fs9.unlinkSync(tmpFile);
     } catch {}
   }
 }
@@ -4539,15 +3967,15 @@ async function runExamples(examples, options = {}) {
   return results;
 }
 function detectPackageManager2(cwd) {
-  if (fs10.existsSync(path9.join(cwd, "bun.lockb")))
+  if (fs9.existsSync(path8.join(cwd, "bun.lockb")))
     return "bun";
-  if (fs10.existsSync(path9.join(cwd, "bun.lock")))
+  if (fs9.existsSync(path8.join(cwd, "bun.lock")))
     return "bun";
-  if (fs10.existsSync(path9.join(cwd, "pnpm-lock.yaml")))
+  if (fs9.existsSync(path8.join(cwd, "pnpm-lock.yaml")))
     return "pnpm";
-  if (fs10.existsSync(path9.join(cwd, "yarn.lock")))
+  if (fs9.existsSync(path8.join(cwd, "yarn.lock")))
     return "yarn";
-  if (fs10.existsSync(path9.join(cwd, "package-lock.json")))
+  if (fs9.existsSync(path8.join(cwd, "package-lock.json")))
     return "npm";
   return "npm";
 }
@@ -4568,7 +3996,7 @@ async function runCommand(cmd, args, options) {
     let stdout = "";
     let stderr = "";
     let killed = false;
-    const proc = spawn(cmd, args, {
+    const proc = spawn2(cmd, args, {
       cwd: options.cwd,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -4615,12 +4043,12 @@ async function runExamplesWithPackage(examples, options) {
   const { packagePath, packageManager, installTimeout = 60000, timeout = 5000 } = options;
   const startTime = Date.now();
   const results = new Map;
-  const absolutePackagePath = path9.resolve(packagePath);
-  const workDir = path9.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 {
-    fs10.mkdirSync(workDir, { recursive: true });
+    fs9.mkdirSync(workDir, { recursive: true });
     const pkgJson = { name: "doccov-example-runner", type: "module" };
-    fs10.writeFileSync(path9.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, {
@@ -4648,7 +4076,7 @@ async function runExamplesWithPackage(examples, options) {
     };
   } finally {
     try {
-      fs10.rmSync(workDir, { recursive: true, force: true });
+      fs9.rmSync(workDir, { recursive: true, force: true });
     } catch {}
   }
 }
@@ -4827,9 +4255,12 @@ async function validateExamples(exports, options) {
   }
   return result;
 }
-// src/analysis/run-analysis.ts
-import * as fs12 from "node:fs";
+// src/extractor.ts
 import * as path13 from "node:path";
+
+// src/analysis/run-analysis.ts
+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;
@@ -4952,7 +4383,7 @@ function collectReferencedTypesFromNode(node, typeChecker, referencedTypes) {
 }
 
 // src/analysis/context.ts
-import * as path11 from "node:path";
+import * as path10 from "node:path";
 
 // src/options.ts
 var DEFAULT_MAX_TYPE_DEPTH = 20;
@@ -4973,7 +4404,7 @@ function normalizeDocCovOptions(options = {}) {
 }
 
 // src/analysis/program.ts
-import * as path10 from "node:path";
+import * as path9 from "node:path";
 var DEFAULT_COMPILER_OPTIONS = {
   target: ts.ScriptTarget.Latest,
   module: ts.ModuleKind.CommonJS,
@@ -4983,14 +4414,14 @@ var DEFAULT_COMPILER_OPTIONS = {
 };
 function createProgram({
   entryFile,
-  baseDir = path10.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, path10.dirname(configPath));
+    const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path9.dirname(configPath));
     compilerOptions = { ...compilerOptions, ...parsedConfig.options };
   }
   const allowJsVal = compilerOptions.allowJs;
@@ -5028,7 +4459,7 @@ function createAnalysisContext({
   options,
   detectedSchemas
 }) {
-  const baseDir = packageDir ?? path11.dirname(entryFile);
+  const baseDir = packageDir ?? path10.dirname(entryFile);
   const normalizedOptions = normalizeDocCovOptions(options);
   const programResult = createProgram({ entryFile, baseDir, content });
   if (!programResult.sourceFile) {
@@ -5049,8 +4480,8 @@ function createAnalysisContext({
 }
 
 // src/analysis/spec-builder.ts
-import * as fs11 from "node:fs";
-import * as path12 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
@@ -6740,10 +6171,10 @@ function serializeClassMembers(declaration, checker, typeRefs, referencedTypes)
       if (member.questionToken || isOptionalSymbol) {
         flags.optional = true;
       }
-      if (member.modifiers?.some((mod2) => mod2.kind === ts.SyntaxKind.ReadonlyKeyword)) {
+      if (member.modifiers?.some((mod) => mod.kind === ts.SyntaxKind.ReadonlyKeyword)) {
         flags.readonly = true;
       }
-      if (member.modifiers?.some((mod2) => mod2.kind === ts.SyntaxKind.StaticKeyword)) {
+      if (member.modifiers?.some((mod) => mod.kind === ts.SyntaxKind.StaticKeyword)) {
         flags.static = true;
       }
       members.push({
@@ -6865,20 +6296,20 @@ function serializeSignature(signature, checker, typeRefs, referencedTypes, doc,
 function getMemberVisibility(modifiers) {
   if (!modifiers)
     return;
-  if (modifiers.some((mod2) => mod2.kind === ts.SyntaxKind.PrivateKeyword)) {
+  if (modifiers.some((mod) => mod.kind === ts.SyntaxKind.PrivateKeyword)) {
     return "private";
   }
-  if (modifiers.some((mod2) => mod2.kind === ts.SyntaxKind.ProtectedKeyword)) {
+  if (modifiers.some((mod) => mod.kind === ts.SyntaxKind.ProtectedKeyword)) {
     return "protected";
   }
-  if (modifiers.some((mod2) => mod2.kind === ts.SyntaxKind.PublicKeyword)) {
+  if (modifiers.some((mod) => mod.kind === ts.SyntaxKind.PublicKeyword)) {
     return "public";
   }
   return;
 }
 function getMethodFlags(member) {
   const flags = {};
-  if (member.modifiers?.some((mod2) => mod2.kind === ts.SyntaxKind.StaticKeyword)) {
+  if (member.modifiers?.some((mod) => mod.kind === ts.SyntaxKind.StaticKeyword)) {
     flags.static = true;
   }
   if (member.asteriskToken) {
@@ -7063,7 +6494,7 @@ function serializeInterfaceMembers(declaration, checker, typeRefs, referencedTyp
       if (member.questionToken) {
         flags.optional = true;
       }
-      if (member.modifiers?.some((mod2) => mod2.kind === ts.SyntaxKind.ReadonlyKeyword)) {
+      if (member.modifiers?.some((mod) => mod.kind === ts.SyntaxKind.ReadonlyKeyword)) {
         flags.readonly = true;
       }
       members.push({
@@ -7361,7 +6792,7 @@ function extractNamespaceMembers(declaration, checker) {
     return members;
   }
   for (const statement of body.statements) {
-    const hasExportModifier = ts.canHaveModifiers(statement) && ts.getModifiers(statement)?.some((mod2) => mod2.kind === ts.SyntaxKind.ExportKeyword);
+    const hasExportModifier = ts.canHaveModifiers(statement) && ts.getModifiers(statement)?.some((mod) => mod.kind === ts.SyntaxKind.ExportKeyword);
     if (!hasExportModifier) {
       continue;
     }
@@ -7571,27 +7002,51 @@ function serializeVariable(declaration, symbol, context) {
   const typeRefs = typeRegistry.getTypeRefs();
   const referencedTypes = typeRegistry.getReferencedTypes();
   const symbolName = symbol.getName();
-  const detectedSchema = context.detectedSchemas?.get(symbolName);
-  if (detectedSchema) {
+  const standardSchema = context.detectedSchemas?.get(symbolName);
+  if (standardSchema) {
     return {
       id: symbolName,
       name: symbolName,
       ...metadata,
       kind: "variable",
       deprecated: isSymbolDeprecated(symbol),
-      schema: detectedSchema.schema,
+      schema: standardSchema.schema,
       description,
       source: getSourceLocation(declaration),
       tags: [
         ...parsedDoc?.tags ?? [],
-        { name: "standardSchema", text: detectedSchema.vendor }
+        { 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),
@@ -7677,9 +7132,9 @@ function createDefaultGenerationInfo(entryFile) {
 }
 function buildOpenPkgSpec(context, resolveExternalTypes, generation) {
   const { baseDir, checker: typeChecker, sourceFile, program, entryFile } = context;
-  const packageJsonPath = path12.join(baseDir, "package.json");
-  const packageJson = fs11.existsSync(packageJsonPath) ? JSON.parse(fs11.readFileSync(packageJsonPath, "utf-8")) : {};
-  const generationInfo = generation ?? createDefaultGenerationInfo(path12.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,
@@ -7878,11 +7333,11 @@ function deriveImportPath(sourceFile, baseDir) {
   if (!sourceFile) {
     return;
   }
-  const relative6 = path12.relative(baseDir, sourceFile);
-  if (!relative6 || relative6.startsWith("..")) {
+  const relative5 = path11.relative(baseDir, sourceFile);
+  if (!relative5 || relative5.startsWith("..")) {
     return;
   }
-  const normalized = relative6.replace(/\\/g, "/");
+  const normalized = relative5.replace(/\\/g, "/");
   const withoutExt = stripExtensions(normalized);
   if (!withoutExt) {
     return;
@@ -7921,11 +7376,11 @@ function withExportName(entry, exportName) {
 function findNearestPackageJson(startDir) {
   let current = startDir;
   while (true) {
-    const candidate = path13.join(current, "package.json");
-    if (fs12.existsSync(candidate)) {
+    const candidate = path12.join(current, "package.json");
+    if (fs11.existsSync(candidate)) {
       return candidate;
     }
-    const parent = path13.dirname(current);
+    const parent = path12.dirname(current);
     if (parent === current) {
       return;
     }
@@ -7953,11 +7408,11 @@ function canResolveExternalModules(program, baseDir) {
 function hasNodeModulesDirectoryFallback(startDir) {
   let current = startDir;
   while (true) {
-    const candidate = path13.join(current, "node_modules");
-    if (fs12.existsSync(candidate)) {
+    const candidate = path12.join(current, "node_modules");
+    if (fs11.existsSync(candidate)) {
       return true;
     }
-    const parent = path13.dirname(current);
+    const parent = path12.dirname(current);
     if (parent === current) {
       break;
     }
@@ -8002,8 +7457,8 @@ function hasExternalImports(sourceFile) {
     if (ts.isImportDeclaration(node) && node.moduleSpecifier) {
       const specifier = node.moduleSpecifier;
       if (ts.isStringLiteral(specifier)) {
-        const modulePath2 = specifier.text;
-        if (!modulePath2.startsWith(".") && !modulePath2.startsWith("/")) {
+        const modulePath = specifier.text;
+        if (!modulePath.startsWith(".") && !modulePath.startsWith("/")) {
           found = true;
         }
       }
@@ -8113,11 +7568,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;
 }
@@ -8232,11 +7703,11 @@ async function fetchSpecFromGitHubWithPath(parsed, specPath = "openpkg.json") {
 }
 // src/install/index.ts
 var DEFAULT_FALLBACK_ORDER = ["bun", "npm"];
-async function installDependencies(fs13, 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(fs13);
+  const pmInfo = await detectPackageManager(fs12);
   if (pmInfo.lockfile) {
     onProgress?.({
       stage: "installing",
@@ -8311,10 +7782,10 @@ function getFallbackInstallCommand(pm) {
 }
 function createNodeCommandRunner() {
   return async (cmd, args, options) => {
-    const { execSync: execSync2 } = await import("node:child_process");
+    const { execSync } = await import("node:child_process");
     const fullCmd = [cmd, ...args].join(" ");
     try {
-      const stdout = execSync2(fullCmd, {
+      const stdout = execSync(fullCmd, {
         cwd: options.cwd,
         stdio: "pipe",
         timeout: options.timeout ?? 180000
@@ -9141,7 +8612,7 @@ function getDocsImpactSummary(diff) {
 }
 // src/openpkg.ts
 import * as fsSync from "node:fs";
-import * as fs13 from "node:fs/promises";
+import * as fs12 from "node:fs/promises";
 import * as path14 from "node:path";
 
 // src/filtering/apply-filters.ts
@@ -9357,7 +8828,7 @@ class DocCov {
   }
   async analyzeFile(filePath, analyzeOptions = {}) {
     const resolvedPath = path14.resolve(filePath);
-    const content = await fs13.readFile(resolvedPath, "utf-8");
+    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;
@@ -9405,7 +8876,7 @@ class DocCov {
         };
       }
     }
-    const content = await fs13.readFile(resolvedPath, "utf-8");
+    const content = await fs12.readFile(resolvedPath, "utf-8");
     const detectedSchemas = await this.detectSchemas(resolvedPath, packageDir);
     const analysis = runAnalysis({
       entryFile: resolvedPath,
@@ -9526,6 +8997,10 @@ class DocCov {
     }
   }
   async detectSchemas(entryFile, packageDir) {
+    const mode = this.options.schemaExtraction ?? "static";
+    if (mode === "static") {
+      return;
+    }
     try {
       const result = await detectRuntimeSchemas({
         baseDir: packageDir,
@@ -9621,113 +9096,13 @@ function resolvePackageDir(entryFile) {
     currentDir = parentDir;
   }
 }
-// src/policies/index.ts
-import * as path15 from "node:path";
-import { minimatch as minimatch2 } from "minimatch";
-function matchesPolicy(exp, policy, baseDir) {
-  const filePath = exp.source?.file;
-  if (!filePath)
-    return false;
-  let normalizedPath = filePath;
-  if (baseDir && path15.isAbsolute(filePath)) {
-    normalizedPath = path15.relative(baseDir, filePath);
-  }
-  normalizedPath = normalizedPath.replace(/^\.\//, "");
-  return minimatch2(normalizedPath, policy.path, { matchBase: true });
-}
-function calculateCoverage(exports) {
-  if (exports.length === 0)
-    return 100;
-  let documented = 0;
-  for (const exp of exports) {
-    if (exp.description) {
-      documented++;
-    }
-  }
-  return Math.round(documented / exports.length * 100);
-}
-function calculateDrift(exports) {
-  if (exports.length === 0)
-    return 0;
-  let withDrift = 0;
-  for (const exp of exports) {
-    if (exp.docs?.drift && exp.docs.drift.length > 0) {
-      withDrift++;
-    }
-  }
-  return Math.round(withDrift / exports.length * 100);
-}
-function countMissingExamples(exports) {
-  let missing = 0;
-  for (const exp of exports) {
-    const hasExample = exp.examples && exp.examples.length > 0;
-    if (!hasExample) {
-      missing++;
-    }
-  }
-  return missing;
-}
-function evaluatePolicy(policy, allExports, baseDir) {
-  const matchedExports = allExports.filter((exp) => matchesPolicy(exp, policy, baseDir));
-  const coverageScore = calculateCoverage(matchedExports);
-  const driftScore = calculateDrift(matchedExports);
-  const missingExamples = countMissingExamples(matchedExports);
-  const failures = [];
-  if (policy.minCoverage !== undefined && coverageScore < policy.minCoverage) {
-    failures.push({
-      type: "coverage",
-      message: `Coverage ${coverageScore}% below minimum ${policy.minCoverage}%`,
-      actual: coverageScore,
-      threshold: policy.minCoverage
-    });
-  }
-  if (policy.maxDrift !== undefined && driftScore > policy.maxDrift) {
-    failures.push({
-      type: "drift",
-      message: `Drift ${driftScore}% exceeds maximum ${policy.maxDrift}%`,
-      actual: driftScore,
-      threshold: policy.maxDrift
-    });
-  }
-  if (policy.requireExamples && missingExamples > 0) {
-    failures.push({
-      type: "examples",
-      message: `${missingExamples} exports missing @example`,
-      actual: missingExamples,
-      threshold: 0
-    });
-  }
-  return {
-    policy,
-    matchedExports,
-    coverageScore,
-    driftScore,
-    missingExamples,
-    passed: failures.length === 0,
-    failures
-  };
-}
-function evaluatePolicies(policies, spec, options = {}) {
-  const { baseDir } = options;
-  const exports = spec.exports ?? [];
-  const results = policies.map((policy) => evaluatePolicy(policy, exports, baseDir));
-  const passedCount = results.filter((r) => r.passed).length;
-  const failedCount = results.length - passedCount;
-  return {
-    results,
-    allPassed: failedCount === 0,
-    totalPolicies: policies.length,
-    passedCount,
-    failedCount
-  };
-}
 // src/resolve/index.ts
-import * as path16 from "node:path";
-async function resolveTarget(fs14, 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(fs14);
+    const mono = await detectMonorepo(fs13);
     if (!mono.isMonorepo) {
       throw new Error("Not a monorepo. Remove --package flag for single-package repos.");
     }
@@ -9736,21 +9111,21 @@ async function resolveTarget(fs14, options) {
       const available = mono.packages.map((p) => p.name).join(", ");
       throw new Error(`Package "${options.package}" not found. Available: ${available}`);
     }
-    targetDir = path16.join(options.cwd, pkg.path);
+    targetDir = path15.join(options.cwd, pkg.path);
     packageInfo = pkg;
   }
   let entryFile;
   let entryPointInfo;
   if (!options.entry) {
-    entryPointInfo = await detectEntryPoint(fs14, getRelativePath(options.cwd, targetDir));
-    entryFile = path16.join(targetDir, entryPointInfo.path);
+    entryPointInfo = await detectEntryPoint(fs13, getRelativePath(options.cwd, targetDir));
+    entryFile = path15.join(targetDir, entryPointInfo.path);
   } else {
-    const explicitPath = path16.resolve(targetDir, options.entry);
-    const isDirectory = await isDir(fs14, 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(fs14, getRelativePath(options.cwd, explicitPath));
-      entryFile = path16.join(explicitPath, entryPointInfo.path);
+      entryPointInfo = await detectEntryPoint(fs13, getRelativePath(options.cwd, explicitPath));
+      entryFile = path15.join(explicitPath, entryPointInfo.path);
     } else {
       entryFile = explicitPath;
       entryPointInfo = {
@@ -9770,20 +9145,20 @@ async function resolveTarget(fs14, options) {
 function getRelativePath(base, target) {
   if (base === target)
     return ".";
-  const rel = path16.relative(base, target);
+  const rel = path15.relative(base, target);
   return rel || ".";
 }
-async function isDir(fs14, relativePath) {
-  const hasPackageJson = await fs14.exists(path16.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 fs14.exists(path16.join(relativePath, entry))) {
+    if (await fs13.exists(path15.join(relativePath, entry))) {
       return true;
     }
   }
-  return !path16.extname(relativePath);
+  return !path15.extname(relativePath);
 }
 // src/scan/github-context.ts
 function parseGitHubUrl2(url) {
@@ -9794,8 +9169,8 @@ function parseGitHubUrl2(url) {
     return null;
   }
 }
-async function fetchRawFile(owner, repo, ref, path17, authToken) {
-  const url = `https://raw.githubusercontent.com/${owner}/${repo}/${ref}/${path17}`;
+async function fetchRawFile(owner, repo, ref, path16, authToken) {
+  const url = `https://raw.githubusercontent.com/${owner}/${repo}/${ref}/${path16}`;
   try {
     const headers = {};
     if (authToken) {
@@ -10026,7 +9401,6 @@ export {
   validateExamples,
   typecheckExamples,
   typecheckExample,
-  tryExtractStandardSchema,
   shouldValidate,
   serializeJSDoc,
   saveSpecCache,
@@ -10037,6 +9411,7 @@ export {
   runExamples,
   runExample,
   resolveTarget,
+  resolveCompiledPath,
   renderSparkline,
   renderApiSurface,
   readPackageJson,
@@ -10049,18 +9424,16 @@ export {
   parseJSDocToPatch,
   parseGitHubUrl,
   parseExamplesFlag,
-  parseCodeOwners,
   parseAssertions,
   mergeFixes,
   mergeFilters,
-  mergeConfig,
   loadSpecCache,
   loadSnapshotsForDays,
   loadSnapshots,
-  loadCodeOwners,
   loadCachedReport,
   listWorkspacePackages,
   isStandardJSONSchema,
+  isSchemaType,
   isFixableDrift,
   isExecutableLang,
   isCachedReportValid,
@@ -10074,22 +9447,18 @@ export {
   groupDriftsByCategory,
   getUndocumentedExports,
   getTrend,
+  getSupportedLibraries,
   getSpecCachePath,
   getRunCommand,
-  getRulesForKind,
-  getRule,
   getReportPath,
+  getRegisteredAdapters,
   getPrimaryBuildScript,
   getInstallCommand,
-  getFileBlame,
   getExtendedTrend,
   getDriftSummary,
   getDocumentedExports,
   getDocsImpactSummary,
   getDiffReportPath,
-  getDefaultConfig,
-  getCoverageRules,
-  getBlameForLines,
   generateWeeklySummaries,
   generateReportFromEnriched,
   generateReport,
@@ -10100,22 +9469,21 @@ export {
   formatDelta,
   findRemovedReferences,
   findPackageByName,
-  findOwners,
   findJSDocLocation,
   findExportReferences,
   findDeprecatedReferences,
+  findAdapter,
   fetchSpecFromGitHub,
   fetchSpec,
   fetchGitHubContext,
-  extractViaStandardSchema,
+  extractStandardSchemasFromProject,
+  extractStandardSchemas,
   extractSpecSummary,
+  extractSchemaType,
+  extractSchemaOutputType,
   extractPackageSpec,
   extractImports,
   extractFunctionCalls,
-  evaluateQuality,
-  evaluatePolicy,
-  evaluatePolicies,
-  evaluateExportQuality,
   ensureSpecCoverage,
   enrichSpec,
   diffSpecWithDocs,
@@ -10143,33 +9511,23 @@ export {
   buildDisplayUrl,
   buildCloneUrl,
   blockReferencesExport,
-  attributeOwners,
   applyPatchToJSDoc,
   applyEdits,
-  analyzeSpecOwnership,
-  analyzeSpecContributors,
   analyzeProject,
-  analyzeOwnership,
   analyzeFile,
   analyzeDocsImpact,
-  analyzeContributors,
   analyze,
   VALIDATION_INFO,
-  TSDOC_RULES,
   SandboxFileSystem,
-  STYLE_RULES,
   SPEC_CACHE_FILE,
   RETENTION_DAYS,
   REPORT_VERSION,
   REPORT_EXTENSIONS,
   NodeFileSystem,
-  KNOWN_VENDORS,
   HISTORY_DIR,
   DocCov,
   DEFAULT_REPORT_PATH,
   DEFAULT_REPORT_DIR,
-  CORE_RULES,
   CACHE_VERSION,
-  BUILTIN_RULES,
   ALL_VALIDATIONS
 };