@doccov/sdk 0.27.0 → 0.27.3

package/dist/analysis/index.js

@@ -38,7 +38,7 @@ import {
   renderSparkline,
   saveReport,
   saveSnapshot
-} from "../shared/chunk-v62zsv8j.js";
+} from "../shared/chunk-v1vce2mg.js";
 import"../shared/chunk-esptwrfq.js";
 export {
   saveSnapshot,

package/dist/index.d.ts

@@ -1498,10 +1498,18 @@ interface JSDocTag {
 /**
 * A patchable representation of a JSDoc comment
 */
+/**
+* Represents a @throws tag in a JSDoc patch
+*/
+interface JSDocThrows {
+	type?: string;
+	description?: string;
+}
 interface JSDocPatch {
 	description?: string;
 	params?: JSDocParam[];
 	returns?: JSDocReturn;
+	throws?: JSDocThrows[];
 	examples?: string[];
 	deprecated?: string | false;
 	async?: boolean;
@@ -2131,143 +2139,21 @@ interface SchemaDetectionResult {
 }
 declare function detectRuntimeSchemas(context: SchemaDetectionContext): Promise<SchemaDetectionResult>;
 import * as TS2 from "typescript";
-/**
-* A schema adapter can detect and extract output types from a specific
-* schema validation library.
-*/
-interface SchemaAdapter {
-	/** Unique identifier for this adapter */
-	readonly id: string;
-	/** npm package name(s) this adapter handles */
-	readonly packages: readonly string[];
-	/**
-	* Check if a type matches this adapter's schema library.
-	* Should be fast - called for every export.
-	*/
-	matches(type: TS2.Type, checker: TS2.TypeChecker): boolean;
-	/**
-	* Extract the output type from a schema type.
-	* Returns null if extraction fails.
-	*/
-	extractOutputType(type: TS2.Type, checker: TS2.TypeChecker): TS2.Type | null;
-	/**
-	* Extract the input type from a schema type (optional).
-	* Useful for transforms where input differs from output.
-	*/
-	extractInputType?(type: TS2.Type, checker: TS2.TypeChecker): TS2.Type | null;
-}
-/**
-* Result of schema type extraction
-*/
-interface SchemaExtractionResult {
-	/** The adapter that matched */
-	adapter: SchemaAdapter;
-	/** The extracted output type */
-	outputType: TS2.Type;
-	/** The extracted input type (if different from output) */
-	inputType?: TS2.Type;
-}
-import * as TS3 from "typescript";
-/**
-* Find an adapter that matches the given type.
-* Returns null if no adapter matches.
-*/
-declare function findAdapter(type: TS3.Type, checker: TS3.TypeChecker): SchemaAdapter | null;
-/**
-* Check if a type is from a recognized schema library.
-*/
-declare function isSchemaType(type: TS3.Type, checker: TS3.TypeChecker): boolean;
+import { extractSchemaType, findAdapter, isSchemaType, extractStandardSchemas, extractStandardSchemasFromProject, isStandardJSONSchema, resolveCompiledPath, ExtractStandardSchemasOptions, SchemaAdapter, SchemaExtractionResult, StandardJSONSchemaV1, StandardSchemaExtractionOutput, StandardSchemaExtractionResult } from "@openpkg-ts/extract";
+import { SchemaAdapter as SchemaAdapter2 } from "@openpkg-ts/extract";
 /**
 * Extract the output type from a schema type.
-* Returns null if:
-* - The type is not from a recognized schema library
-* - The adapter fails to extract the output type
+* Convenience wrapper that returns just the type.
 */
-declare function extractSchemaOutputType(type: TS3.Type, checker: TS3.TypeChecker): TS3.Type | null;
-/**
-* Full extraction with adapter info.
-* Useful when you need to know which library was detected.
-*/
-declare function extractSchemaType(type: TS3.Type, checker: TS3.TypeChecker): SchemaExtractionResult | null;
+declare function extractSchemaOutputType(type: TS2.Type, checker: TS2.TypeChecker): TS2.Type | null;
 /**
 * Get all registered adapters.
-* Useful for logging/debugging.
 */
-declare function getRegisteredAdapters(): readonly SchemaAdapter[];
+declare function getRegisteredAdapters(): readonly SchemaAdapter2[];
 /**
 * Get supported library names.
-* Useful for documentation/help output.
 */
 declare function getSupportedLibraries(): readonly string[];
-/**
-* Standard JSON Schema v1 interface (minimal for detection).
-*/
-interface StandardJSONSchemaV1 {
-	"~standard": {
-		version: number;
-		vendor: string;
-		jsonSchema?: {
-			output: (target?: string) => Record<string, unknown>;
-			input?: (target?: string) => Record<string, unknown>;
-		};
-	};
-}
-/**
-* Result of extracting Standard Schema from an export.
-*/
-interface StandardSchemaExtractionResult {
-	exportName: string;
-	vendor: string;
-	outputSchema: Record<string, unknown>;
-	inputSchema?: Record<string, unknown>;
-}
-/**
-* Options for runtime Standard Schema extraction.
-*/
-interface ExtractStandardSchemasOptions {
-	/** Timeout in milliseconds (default: 10000) */
-	timeout?: number;
-	/** JSON Schema target version (default: 'draft-2020-12') */
-	target?: "draft-2020-12" | "draft-07" | "openapi-3.0";
-}
-/**
-* Result of Standard Schema extraction.
-*/
-interface StandardSchemaExtractionOutput {
-	schemas: Map<string, StandardSchemaExtractionResult>;
-	errors: string[];
-}
-/**
-* Check if an object implements StandardJSONSchemaV1.
-* This is a static type guard - doesn't require runtime.
-*/
-declare function isStandardJSONSchema(obj: unknown): obj is StandardJSONSchemaV1;
-/**
-* Resolve compiled JS path from TypeScript source.
-* Tries common output locations: dist/, build/, lib/, same dir.
-*/
-declare function resolveCompiledPath(tsPath: string, baseDir: string): string | null;
-/**
-* Extract Standard Schema JSON Schemas from a compiled JS module.
-*
-* **Security Note**: This executes the module in a subprocess.
-* Only use with trusted code (user's own packages).
-*
-* @param compiledJsPath - Path to compiled .js file
-* @param options - Extraction options
-* @returns Extraction results with schemas and any errors
-*/
-declare function extractStandardSchemas(compiledJsPath: string, options?: ExtractStandardSchemasOptions): Promise<StandardSchemaExtractionOutput>;
-/**
-* Extract Standard Schema from a TypeScript project.
-*
-* Convenience function that resolves compiled JS and extracts schemas.
-*
-* @param entryFile - TypeScript entry file path
-* @param baseDir - Project base directory
-* @param options - Extraction options
-*/
-declare function extractStandardSchemasFromProject(entryFile: string, baseDir: string, options?: ExtractStandardSchemasOptions): Promise<StandardSchemaExtractionOutput>;
 declare function extractPackageSpec(entryFile: string, packageDir?: string, content?: string, options?: DocCovOptions): Promise<OpenPkgSpec>;
 /**
 * Source of filter options.
@@ -2679,7 +2565,7 @@ interface SpecSummary {
 * ```
 */
 declare function extractSpecSummary(openpkg: OpenPkg8, doccov: DocCovSpec4): SpecSummary;
-import { OpenPkg as OpenPkg_tgtzybcxvb } from "@openpkg-ts/spec";
+import { OpenPkg as OpenPkg_jkmegcwtaf } from "@openpkg-ts/spec";
 /**
 * Build Plan types for AI-powered repository scanning.
 */
@@ -2776,7 +2662,7 @@ interface BuildPlanExecutionResult {
 	/** Whether all required steps succeeded */
 	success: boolean;
 	/** Generated OpenPkg spec (if successful) */
-	spec?: OpenPkg_tgtzybcxvb;
+	spec?: OpenPkg_jkmegcwtaf;
 	/** Results for each step */
 	stepResults: BuildPlanStepResult[];
 	/** Total execution time in milliseconds */

package/dist/index.js

@@ -21,8 +21,11 @@ import {
   detectExampleRuntimeErrors,
   detectRuntimeSchemas,
   ensureSpecCoverage,
+  extractSchemaOutputType,
+  extractSchemaType,
   extractStandardSchemas,
   extractStandardSchemasFromProject,
+  findAdapter,
   findJSDocLocation,
   formatDelta,
   formatDriftSummaryLine,
@@ -37,6 +40,8 @@ import {
   getExportMissing,
   getExportScore,
   getExtendedTrend,
+  getRegisteredAdapters,
+  getSupportedLibraries,
   getTrend,
   groupDriftsByCategory,
   groupFixesByFile,
@@ -44,6 +49,7 @@ import {
   isBuiltInIdentifier,
   isExportFullyDocumented,
   isFixableDrift,
+  isSchemaType,
   isStandardJSONSchema,
   loadCachedReport,
   loadSnapshots,
@@ -60,7 +66,7 @@ import {
   saveSnapshot,
   serializeJSDoc,
   ts
-} from "./shared/chunk-v62zsv8j.js";
+} from "./shared/chunk-v1vce2mg.js";
 import {
   mergeFilters,
   parseListFlag
@@ -419,189 +425,6 @@ function getSpecCachePath(cwd) {
 }
 // src/extractor.ts
 import * as path6 from "node:path";
-
-// src/extract/schema/types.ts
-function isTypeReference(type) {
-  return !!(type.flags & 524288 && type.objectFlags && type.objectFlags & 4);
-}
-function getNonNullableType(type) {
-  if (type.isUnion()) {
-    const nonNullable = type.types.filter((t) => !(t.flags & 32768) && !(t.flags & 65536));
-    if (nonNullable.length === 1) {
-      return nonNullable[0];
-    }
-  }
-  return type;
-}
-
-// src/extract/schema/adapters/arktype.ts
-var ARKTYPE_TYPE_PATTERN = /^Type</;
-var arktypeAdapter = {
-  id: "arktype",
-  packages: ["arktype"],
-  matches(type, checker) {
-    const typeName = checker.typeToString(type);
-    return ARKTYPE_TYPE_PATTERN.test(typeName);
-  },
-  extractOutputType(type, checker) {
-    if (!isTypeReference(type)) {
-      return null;
-    }
-    const args = checker.getTypeArguments(type);
-    if (args.length < 1) {
-      return null;
-    }
-    return args[0];
-  },
-  extractInputType(type, checker) {
-    if (!isTypeReference(type)) {
-      return null;
-    }
-    const args = checker.getTypeArguments(type);
-    if (args.length < 2) {
-      return null;
-    }
-    return args[1];
-  }
-};
-// src/extract/schema/adapters/typebox.ts
-var TYPEBOX_TYPE_PATTERN = /^T[A-Z]/;
-var typeboxAdapter = {
-  id: "typebox",
-  packages: ["@sinclair/typebox"],
-  matches(type, checker) {
-    const typeName = checker.typeToString(type);
-    if (!TYPEBOX_TYPE_PATTERN.test(typeName)) {
-      return false;
-    }
-    const typeProperty = type.getProperty("type");
-    return typeProperty !== undefined;
-  },
-  extractOutputType(type, checker) {
-    const staticSymbol = type.getProperty("static");
-    if (staticSymbol) {
-      return checker.getTypeOfSymbol(staticSymbol);
-    }
-    return null;
-  }
-};
-// src/extract/schema/adapters/valibot.ts
-var VALIBOT_TYPE_PATTERN = /Schema(<|$)/;
-var valibotAdapter = {
-  id: "valibot",
-  packages: ["valibot"],
-  matches(type, checker) {
-    const typeName = checker.typeToString(type);
-    return VALIBOT_TYPE_PATTERN.test(typeName) && !typeName.includes("Zod");
-  },
-  extractOutputType(type, checker) {
-    const typesSymbol = type.getProperty("~types");
-    if (!typesSymbol) {
-      return null;
-    }
-    let typesType = checker.getTypeOfSymbol(typesSymbol);
-    typesType = getNonNullableType(typesType);
-    const outputSymbol = typesType.getProperty("output");
-    if (!outputSymbol) {
-      return null;
-    }
-    return checker.getTypeOfSymbol(outputSymbol);
-  },
-  extractInputType(type, checker) {
-    const typesSymbol = type.getProperty("~types");
-    if (!typesSymbol) {
-      return null;
-    }
-    let typesType = checker.getTypeOfSymbol(typesSymbol);
-    typesType = getNonNullableType(typesType);
-    const inputSymbol = typesType.getProperty("input");
-    if (!inputSymbol) {
-      return null;
-    }
-    return checker.getTypeOfSymbol(inputSymbol);
-  }
-};
-// src/extract/schema/adapters/zod.ts
-var ZOD_TYPE_PATTERN = /^Zod[A-Z]/;
-var zodAdapter = {
-  id: "zod",
-  packages: ["zod"],
-  matches(type, checker) {
-    const typeName = checker.typeToString(type);
-    return ZOD_TYPE_PATTERN.test(typeName);
-  },
-  extractOutputType(type, checker) {
-    const outputSymbol = type.getProperty("_output");
-    if (outputSymbol) {
-      return checker.getTypeOfSymbol(outputSymbol);
-    }
-    const typeSymbol = type.getProperty("_type");
-    if (typeSymbol) {
-      return checker.getTypeOfSymbol(typeSymbol);
-    }
-    return null;
-  },
-  extractInputType(type, checker) {
-    const inputSymbol = type.getProperty("_input");
-    if (inputSymbol) {
-      return checker.getTypeOfSymbol(inputSymbol);
-    }
-    return null;
-  }
-};
-// src/extract/schema/registry.ts
-var adapters = [
-  zodAdapter,
-  arktypeAdapter,
-  typeboxAdapter,
-  valibotAdapter
-];
-function findAdapter(type, checker) {
-  for (const adapter of adapters) {
-    if (adapter.matches(type, checker)) {
-      return adapter;
-    }
-  }
-  return null;
-}
-function isSchemaType(type, checker) {
-  return findAdapter(type, checker) !== null;
-}
-function extractSchemaOutputType(type, checker) {
-  const adapter = findAdapter(type, checker);
-  if (!adapter) {
-    return null;
-  }
-  return adapter.extractOutputType(type, checker);
-}
-function extractSchemaType(type, checker) {
-  const adapter = findAdapter(type, checker);
-  if (!adapter) {
-    return null;
-  }
-  const outputType = adapter.extractOutputType(type, checker);
-  if (!outputType) {
-    return null;
-  }
-  const result = {
-    adapter,
-    outputType
-  };
-  if (adapter.extractInputType) {
-    const inputType = adapter.extractInputType(type, checker);
-    if (inputType) {
-      result.inputType = inputType;
-    }
-  }
-  return result;
-}
-function getRegisteredAdapters() {
-  return adapters;
-}
-function getSupportedLibraries() {
-  return adapters.flatMap((a) => a.packages);
-}
-// src/extractor.ts
 async function extractPackageSpec(entryFile, packageDir, content, options) {
   const baseDir = packageDir ?? path6.dirname(entryFile);
   const schemaMode = options?.schemaExtraction ?? "static";

package/dist/shared/{chunk-v62zsv8j.js → chunk-v1vce2mg.js}

@@ -546,6 +546,21 @@ function parseJSDocToPatch(jsDocText) {
         patch.deprecated = content || "Deprecated";
         break;
       }
+      case "throws":
+      case "throw": {
+        if (!patch.throws)
+          patch.throws = [];
+        const throwsMatch = content.match(/^(?:\{@?link\s+([^}]+)\}|\{([^}]+)\})?\s*(.*)$/s);
+        if (throwsMatch) {
+          patch.throws.push({
+            type: (throwsMatch[1] || throwsMatch[2])?.trim(),
+            description: throwsMatch[3]?.trim()
+          });
+        } else {
+          patch.throws.push({ description: content.trim() });
+        }
+        break;
+      }
       case "async": {
         patch.async = true;
         break;
@@ -620,6 +635,9 @@ function applyPatchToJSDoc(existing, updates) {
       ...updates.returns
     };
   }
+  if (updates.throws !== undefined) {
+    result.throws = updates.throws;
+  }
   if (updates.examples !== undefined) {
     result.examples = updates.examples;
   }
@@ -643,7 +661,7 @@ function serializeJSDoc(patch, indent = "") {
       lines.push(line);
     }
   }
-  const hasTags = patch.params?.length || patch.returns || patch.examples?.length || patch.deprecated || patch.async || patch.type || patch.typeParams?.length || patch.otherTags?.length;
+  const hasTags = patch.params?.length || patch.returns || patch.throws?.length || patch.examples?.length || patch.deprecated || patch.async || patch.type || patch.typeParams?.length || patch.otherTags?.length;
   if (patch.description && hasTags) {
     lines.push("");
   }
@@ -689,6 +707,18 @@ function serializeJSDoc(patch, indent = "") {
     }
     lines.push(tagLine);
   }
+  if (patch.throws) {
+    for (const t of patch.throws) {
+      let tagLine = "@throws";
+      if (t.type) {
+        tagLine += ` {${t.type}}`;
+      }
+      if (t.description) {
+        tagLine += ` ${t.description}`;
+      }
+      lines.push(tagLine);
+    }
+  }
   if (patch.deprecated && typeof patch.deprecated === "string") {
     lines.push(`@deprecated ${patch.deprecated}`);
   }
@@ -2765,195 +2795,47 @@ function renderApiSurface(spec) {
 `);
 }
 
-// src/extract/schema/standard-schema.ts
-import { spawn } from "node:child_process";
-import * as fs4 from "node:fs";
-import * as path4 from "node:path";
-function isStandardJSONSchema(obj) {
-  if (typeof obj !== "object" || obj === null)
-    return false;
-  const std = obj["~standard"];
-  if (typeof std !== "object" || std === null)
-    return false;
-  const stdObj = std;
-  if (typeof stdObj.version !== "number")
-    return false;
-  if (typeof stdObj.vendor !== "string")
-    return false;
-  const jsonSchema = stdObj.jsonSchema;
-  if (typeof jsonSchema !== "object" || jsonSchema === null)
-    return false;
-  const jsObj = jsonSchema;
-  return typeof jsObj.output === "function";
-}
-var WORKER_SCRIPT = `
-const path = require('path');
-const { pathToFileURL } = require('url');
-
-// TypeBox detection: schemas have Symbol.for('TypeBox.Kind') and are JSON Schema
-const TYPEBOX_KIND = Symbol.for('TypeBox.Kind');
-
-function isTypeBoxSchema(obj) {
-  if (!obj || typeof obj !== 'object') return false;
-  // TypeBox schemas always have Kind symbol (Union, Object, String, etc.)
-  // Also check for common JSON Schema props to avoid false positives
-  if (!obj[TYPEBOX_KIND]) return false;
-  return typeof obj.type === 'string' || 'anyOf' in obj || 'oneOf' in obj || 'allOf' in obj;
-}
-
-function sanitizeTypeBoxSchema(schema) {
-  // JSON.stringify removes symbol keys, keeping only JSON Schema props
-  return JSON.parse(JSON.stringify(schema));
-}
-
-async function extract() {
-  // With node -e, argv is: [node, arg1, arg2, ...]
-  // (the -e script is NOT in argv)
-  const [modulePath, target] = process.argv.slice(1);
-
-  try {
-    // Import the module using dynamic import (works with ESM and CJS)
-    const absPath = path.resolve(modulePath);
-    const mod = await import(pathToFileURL(absPath).href);
-    const results = [];
-
-    // Build exports map - handle both ESM and CJS (where exports are in mod.default)
-    const exports = {};
-    for (const [name, value] of Object.entries(mod)) {
-      if (name === 'default' && typeof value === 'object' && value !== null) {
-        // CJS module: spread default exports
-        Object.assign(exports, value);
-      } else if (name !== 'default') {
-        exports[name] = value;
-      }
-    }
-
-    // Check each export
-    for (const [name, value] of Object.entries(exports)) {
-      if (name.startsWith('_')) continue;
-      if (typeof value !== 'object' || value === null) continue;
-
-      // Priority 1: Standard Schema (Zod 4.2+, ArkType, etc.)
-      const std = value['~standard'];
-      if (std && typeof std === 'object' && typeof std.version === 'number' && typeof std.vendor === 'string' && std.jsonSchema && typeof std.jsonSchema.output === 'function') {
-        try {
-          const outputSchema = std.jsonSchema.output(target);
-          const inputSchema = std.jsonSchema.input ? std.jsonSchema.input(target) : undefined;
-          results.push({
-            exportName: name,
-            vendor: std.vendor,
-            outputSchema,
-            inputSchema
-          });
-        } catch (e) {
-          // Skip schemas that fail to extract
-        }
-        continue;
-      }
-
-      // Priority 2: TypeBox (schema IS JSON Schema)
-      if (isTypeBoxSchema(value)) {
-        try {
-          results.push({
-            exportName: name,
-            vendor: 'typebox',
-            outputSchema: sanitizeTypeBoxSchema(value)
-          });
-        } catch (e) {
-          // Skip schemas that fail to extract
-        }
-        continue;
-      }
-    }
-
-    console.log(JSON.stringify({ success: true, results }));
-  } catch (e) {
-    console.log(JSON.stringify({ success: false, error: e.message }));
-  }
-}
-
-extract();
-`;
-function resolveCompiledPath(tsPath, baseDir) {
-  const relativePath = path4.relative(baseDir, tsPath);
-  const withoutExt = relativePath.replace(/\.tsx?$/, "");
-  const candidates = [
-    path4.join(baseDir, `${withoutExt}.js`),
-    path4.join(baseDir, "dist", `${withoutExt.replace(/^src\//, "")}.js`),
-    path4.join(baseDir, "build", `${withoutExt.replace(/^src\//, "")}.js`),
-    path4.join(baseDir, "lib", `${withoutExt.replace(/^src\//, "")}.js`)
-  ];
-  for (const candidate of candidates) {
-    if (fs4.existsSync(candidate)) {
-      return candidate;
-    }
+// src/extract/schema/index.ts
+import {
+  arktypeAdapter,
+  typeboxAdapter,
+  valibotAdapter,
+  zodAdapter,
+  extractSchemaType,
+  findAdapter,
+  isSchemaType,
+  extractStandardSchemas,
+  extractStandardSchemasFromProject,
+  isStandardJSONSchema,
+  resolveCompiledPath,
+  getNonNullableType,
+  isTypeReference
+} from "@openpkg-ts/extract";
+import {
+  arktypeAdapter as arktypeAdapter2,
+  findAdapter as findAdapter2,
+  typeboxAdapter as typeboxAdapter2,
+  valibotAdapter as valibotAdapter2,
+  zodAdapter as zodAdapter2
+} from "@openpkg-ts/extract";
+var adapters = [
+  zodAdapter2,
+  arktypeAdapter2,
+  typeboxAdapter2,
+  valibotAdapter2
+];
+function extractSchemaOutputType(type, checker) {
+  const adapter = findAdapter2(type, checker);
+  if (!adapter) {
+    return null;
   }
-  return null;
+  return adapter.extractOutputType(type, checker);
 }
-async function extractStandardSchemas(compiledJsPath, options = {}) {
-  const { timeout = 1e4, target = "draft-2020-12" } = options;
-  const result = {
-    schemas: new Map,
-    errors: []
-  };
-  if (!fs4.existsSync(compiledJsPath)) {
-    result.errors.push(`Compiled JS not found: ${compiledJsPath}`);
-    return result;
-  }
-  return new Promise((resolve3) => {
-    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}`}`);
-        resolve3(result);
-        return;
-      }
-      try {
-        const parsed = JSON.parse(stdout);
-        if (!parsed.success) {
-          result.errors.push(`Extraction failed: ${parsed.error}`);
-          resolve3(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}`);
-      }
-      resolve3(result);
-    });
-    child.on("error", (err) => {
-      result.errors.push(`Subprocess error: ${err.message}`);
-      resolve3(result);
-    });
-  });
+function getRegisteredAdapters() {
+  return adapters;
 }
-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);
+function getSupportedLibraries() {
+  return adapters.flatMap((a) => a.packages);
 }
 
 // src/analysis/schema-detection.ts
@@ -2982,8 +2864,8 @@ async function detectRuntimeSchemas(context) {
 }
 
 // src/analysis/history.ts
-import * as fs5 from "node:fs";
-import * as path5 from "node:path";
+import * as fs4 from "node:fs";
+import * as path4 from "node:path";
 var HISTORY_DIR = ".doccov/history";
 var RETENTION_DAYS = {
   free: 7,
@@ -3021,24 +2903,24 @@ function computeSnapshot(spec, options) {
   };
 }
 function saveSnapshot(snapshot, cwd) {
-  const historyDir = path5.resolve(cwd, HISTORY_DIR);
-  if (!fs5.existsSync(historyDir)) {
-    fs5.mkdirSync(historyDir, { recursive: true });
+  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 = path5.join(historyDir, filename);
-  fs5.writeFileSync(filepath, JSON.stringify(snapshot, null, 2));
+  const filepath = path4.join(historyDir, filename);
+  fs4.writeFileSync(filepath, JSON.stringify(snapshot, null, 2));
 }
 function loadSnapshots(cwd) {
-  const historyDir = path5.resolve(cwd, HISTORY_DIR);
-  if (!fs5.existsSync(historyDir)) {
+  const historyDir = path4.resolve(cwd, HISTORY_DIR);
+  if (!fs4.existsSync(historyDir)) {
     return [];
   }
-  const files = fs5.readdirSync(historyDir).filter((f) => f.endsWith(".json")).sort().reverse();
+  const files = fs4.readdirSync(historyDir).filter((f) => f.endsWith(".json")).sort().reverse();
   const snapshots = [];
   for (const file of files) {
     try {
-      const content = fs5.readFileSync(path5.join(historyDir, file), "utf-8");
+      const content = fs4.readFileSync(path4.join(historyDir, file), "utf-8");
       snapshots.push(JSON.parse(content));
     } catch {}
   }
@@ -3078,15 +2960,15 @@ function formatDelta(delta) {
   return "→0%";
 }
 function pruneHistory(cwd, keepCount = 100) {
-  const historyDir = path5.resolve(cwd, HISTORY_DIR);
-  if (!fs5.existsSync(historyDir)) {
+  const historyDir = path4.resolve(cwd, HISTORY_DIR);
+  if (!fs4.existsSync(historyDir)) {
     return 0;
   }
-  const files = fs5.readdirSync(historyDir).filter((f) => f.endsWith(".json")).sort().reverse();
+  const files = fs4.readdirSync(historyDir).filter((f) => f.endsWith(".json")).sort().reverse();
   const toDelete = files.slice(keepCount);
   for (const file of toDelete) {
     try {
-      fs5.unlinkSync(path5.join(historyDir, file));
+      fs4.unlinkSync(path4.join(historyDir, file));
     } catch {}
   }
   return toDelete.length;
@@ -3095,20 +2977,20 @@ function pruneByTier(cwd, tier) {
   const retentionDays = RETENTION_DAYS[tier];
   const cutoffDate = new Date;
   cutoffDate.setDate(cutoffDate.getDate() - retentionDays);
-  const historyDir = path5.resolve(cwd, HISTORY_DIR);
-  if (!fs5.existsSync(historyDir)) {
+  const historyDir = path4.resolve(cwd, HISTORY_DIR);
+  if (!fs4.existsSync(historyDir)) {
     return 0;
   }
-  const files = fs5.readdirSync(historyDir).filter((f) => f.endsWith(".json"));
+  const files = fs4.readdirSync(historyDir).filter((f) => f.endsWith(".json"));
   let deleted = 0;
   for (const file of files) {
     try {
-      const filepath = path5.join(historyDir, file);
-      const content = fs5.readFileSync(filepath, "utf-8");
+      const filepath = path4.join(historyDir, file);
+      const content = fs4.readFileSync(filepath, "utf-8");
       const snapshot = JSON.parse(content);
       const snapshotDate = new Date(snapshot.timestamp);
       if (snapshotDate < cutoffDate) {
-        fs5.unlinkSync(filepath);
+        fs4.unlinkSync(filepath);
         deleted++;
       }
     } catch {}
@@ -3208,4 +3090,4 @@ function getExtendedTrend(spec, cwd, options) {
   };
 }
 
-export { computeHealth, isFixableDrift, generateFix, generateFixesForExport, mergeFixes, categorizeDrifts, ts, parseJSDocToPatch, applyPatchToJSDoc, serializeJSDoc, findJSDocLocation, applyEdits, createSourceFile, generateForgottenExportFixes, groupFixesByFile, applyForgottenExportFixes, previewForgottenExportFixes, isBuiltInIdentifier, detectExampleRuntimeErrors, parseAssertions, hasNonAssertionComments, detectExampleAssertionFailures, buildExportRegistry, computeDrift, computeExportDrift, buildDocCovSpec, DRIFT_CATEGORIES2 as DRIFT_CATEGORIES, DRIFT_CATEGORY_LABELS, DRIFT_CATEGORY_DESCRIPTIONS, categorizeDrift, groupDriftsByCategory, getDriftSummary, formatDriftSummaryLine, calculateAggregateCoverage, ensureSpecCoverage, getExportAnalysis, getExportScore, getExportDrift, getExportMissing, isExportFullyDocumented, generateReport, generateReportFromDocCov, loadCachedReport, saveReport, isCachedReportValid, renderApiSurface, isStandardJSONSchema, resolveCompiledPath, extractStandardSchemas, extractStandardSchemasFromProject, detectRuntimeSchemas, HISTORY_DIR, RETENTION_DAYS, computeSnapshot, saveSnapshot, loadSnapshots, getTrend, renderSparkline, formatDelta, pruneHistory, pruneByTier, loadSnapshotsForDays, generateWeeklySummaries, getExtendedTrend };
+export { computeHealth, isFixableDrift, generateFix, generateFixesForExport, mergeFixes, categorizeDrifts, ts, parseJSDocToPatch, applyPatchToJSDoc, serializeJSDoc, findJSDocLocation, applyEdits, createSourceFile, generateForgottenExportFixes, groupFixesByFile, applyForgottenExportFixes, previewForgottenExportFixes, isBuiltInIdentifier, detectExampleRuntimeErrors, parseAssertions, hasNonAssertionComments, detectExampleAssertionFailures, buildExportRegistry, computeDrift, computeExportDrift, buildDocCovSpec, DRIFT_CATEGORIES2 as DRIFT_CATEGORIES, DRIFT_CATEGORY_LABELS, DRIFT_CATEGORY_DESCRIPTIONS, categorizeDrift, groupDriftsByCategory, getDriftSummary, formatDriftSummaryLine, calculateAggregateCoverage, ensureSpecCoverage, getExportAnalysis, getExportScore, getExportDrift, getExportMissing, isExportFullyDocumented, generateReport, generateReportFromDocCov, loadCachedReport, saveReport, isCachedReportValid, renderApiSurface, extractSchemaOutputType, getRegisteredAdapters, getSupportedLibraries, extractSchemaType, findAdapter, isSchemaType, extractStandardSchemas, extractStandardSchemasFromProject, isStandardJSONSchema, resolveCompiledPath, detectRuntimeSchemas, HISTORY_DIR, RETENTION_DAYS, computeSnapshot, saveSnapshot, loadSnapshots, getTrend, renderSparkline, formatDelta, pruneHistory, pruneByTier, loadSnapshotsForDays, generateWeeklySummaries, getExtendedTrend };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doccov/sdk",
-  "version": "0.27.0",
+  "version": "0.27.3",
   "description": "DocCov SDK - Documentation coverage and drift detection for TypeScript",
   "keywords": [
     "typescript",
@@ -48,7 +48,7 @@
   ],
   "dependencies": {
     "@doccov/spec": "^0.27.0",
-    "@openpkg-ts/extract": "^0.16.0",
+    "@openpkg-ts/extract": "^0.16.1",
     "@openpkg-ts/spec": "^0.12.0",
     "@vercel/sandbox": "^1.0.3",
     "mdast": "^3.0.0",