@doccov/sdk 0.19.0 → 0.21.0

package/dist/index.d.ts

@@ -114,21 +114,19 @@ interface DetectedSchemaEntry {
 	schema: Record<string, unknown>;
 	vendor: string;
 }
-/**
-* Runtime Schema Detection (Stubbed)
-*
-* Standard Schema extraction has been removed. This module provides
-* empty stubs to maintain API compatibility.
-*/
 interface SchemaDetectionContext {
 	baseDir: string;
 	entryFile: string;
 }
+interface DetectedSchema {
+	schema: Record<string, unknown>;
+	vendor: string;
+}
 interface SchemaDetectionResult {
-	schemas: Map<string, never>;
+	schemas: Map<string, DetectedSchema>;
 	errors: string[];
 }
-declare function detectRuntimeSchemas(_context: SchemaDetectionContext): Promise<SchemaDetectionResult>;
+declare function detectRuntimeSchemas(context: SchemaDetectionContext): Promise<SchemaDetectionResult>;
 declare function clearSchemaCache(): void;
 import * as TS from "typescript";
 /**
@@ -2298,8 +2296,9 @@ declare class DocCov {
 	*/
 	private findPackageJson;
 	/**
-	* Opportunistically detect Standard Schema exports from compiled modules.
-	* Returns undefined if detection fails or no schemas found (fallback to AST).
+	* Detect Standard Schema exports from compiled modules.
+	* Only runs when schemaExtraction is 'runtime' or 'hybrid'.
+	* Returns undefined if detection is disabled, fails, or no schemas found.
 	*/
 	private detectSchemas;
 	private normalizeDiagnostic;

package/dist/index.js

@@ -17,12 +17,208 @@ var __toESM = (mod, isNodeMode, target) => {
 };
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// src/analysis/schema-detection.ts
-async function detectRuntimeSchemas(_context) {
-  return {
+// src/extract/schema/standard-schema.ts
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+function isStandardJSONSchema(obj) {
+  if (typeof obj !== "object" || obj === null)
+    return false;
+  const std = obj["~standard"];
+  if (typeof std !== "object" || std === null)
+    return false;
+  const stdObj = std;
+  if (typeof stdObj.version !== "number")
+    return false;
+  if (typeof stdObj.vendor !== "string")
+    return false;
+  const jsonSchema = stdObj.jsonSchema;
+  if (typeof jsonSchema !== "object" || jsonSchema === null)
+    return false;
+  const jsObj = jsonSchema;
+  return typeof jsObj.output === "function";
+}
+var WORKER_SCRIPT = `
+const path = require('path');
+const { pathToFileURL } = require('url');
+
+// TypeBox detection: schemas have Symbol.for('TypeBox.Kind') and are JSON Schema
+const TYPEBOX_KIND = Symbol.for('TypeBox.Kind');
+
+function isTypeBoxSchema(obj) {
+  if (!obj || typeof obj !== 'object') return false;
+  // TypeBox schemas always have Kind symbol (Union, Object, String, etc.)
+  // Also check for common JSON Schema props to avoid false positives
+  if (!obj[TYPEBOX_KIND]) return false;
+  return typeof obj.type === 'string' || 'anyOf' in obj || 'oneOf' in obj || 'allOf' in obj;
+}
+
+function sanitizeTypeBoxSchema(schema) {
+  // JSON.stringify removes symbol keys, keeping only JSON Schema props
+  return JSON.parse(JSON.stringify(schema));
+}
+
+async function extract() {
+  // With node -e, argv is: [node, arg1, arg2, ...]
+  // (the -e script is NOT in argv)
+  const [modulePath, target] = process.argv.slice(1);
+
+  try {
+    // Import the module using dynamic import (works with ESM and CJS)
+    const absPath = path.resolve(modulePath);
+    const mod = await import(pathToFileURL(absPath).href);
+    const results = [];
+
+    // Check each export
+    for (const [name, value] of Object.entries(mod)) {
+      if (name.startsWith('_')) continue;
+      if (typeof value !== 'object' || value === null) continue;
+
+      // Priority 1: Standard Schema (Zod 4.2+, ArkType, etc.)
+      const std = value['~standard'];
+      if (std && typeof std === 'object' && typeof std.version === 'number' && typeof std.vendor === 'string' && std.jsonSchema && typeof std.jsonSchema.output === 'function') {
+        try {
+          const outputSchema = std.jsonSchema.output(target);
+          const inputSchema = std.jsonSchema.input ? std.jsonSchema.input(target) : undefined;
+          results.push({
+            exportName: name,
+            vendor: std.vendor,
+            outputSchema,
+            inputSchema
+          });
+        } catch (e) {
+          // Skip schemas that fail to extract
+        }
+        continue;
+      }
+
+      // Priority 2: TypeBox (schema IS JSON Schema)
+      if (isTypeBoxSchema(value)) {
+        try {
+          results.push({
+            exportName: name,
+            vendor: 'typebox',
+            outputSchema: sanitizeTypeBoxSchema(value)
+          });
+        } catch (e) {
+          // Skip schemas that fail to extract
+        }
+        continue;
+      }
+    }
+
+    console.log(JSON.stringify({ success: true, results }));
+  } catch (e) {
+    console.log(JSON.stringify({ success: false, error: e.message }));
+  }
+}
+
+extract();
+`;
+function resolveCompiledPath(tsPath, baseDir) {
+  const relativePath = path.relative(baseDir, tsPath);
+  const withoutExt = relativePath.replace(/\.tsx?$/, "");
+  const candidates = [
+    path.join(baseDir, `${withoutExt}.js`),
+    path.join(baseDir, "dist", `${withoutExt.replace(/^src\//, "")}.js`),
+    path.join(baseDir, "build", `${withoutExt.replace(/^src\//, "")}.js`),
+    path.join(baseDir, "lib", `${withoutExt.replace(/^src\//, "")}.js`)
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+async function extractStandardSchemas(compiledJsPath, options = {}) {
+  const { timeout = 1e4, target = "draft-2020-12" } = options;
+  const result = {
     schemas: new Map,
     errors: []
   };
+  if (!fs.existsSync(compiledJsPath)) {
+    result.errors.push(`Compiled JS not found: ${compiledJsPath}`);
+    return result;
+  }
+  return new Promise((resolve) => {
+    const child = spawn("node", ["-e", WORKER_SCRIPT, compiledJsPath, target], {
+      timeout,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("close", (code) => {
+      if (code !== 0) {
+        result.errors.push(`Extraction process failed: ${stderr || `exit code ${code}`}`);
+        resolve(result);
+        return;
+      }
+      try {
+        const parsed = JSON.parse(stdout);
+        if (!parsed.success) {
+          result.errors.push(`Extraction failed: ${parsed.error}`);
+          resolve(result);
+          return;
+        }
+        for (const item of parsed.results) {
+          result.schemas.set(item.exportName, {
+            exportName: item.exportName,
+            vendor: item.vendor,
+            outputSchema: item.outputSchema,
+            inputSchema: item.inputSchema
+          });
+        }
+      } catch (e) {
+        result.errors.push(`Failed to parse extraction output: ${e}`);
+      }
+      resolve(result);
+    });
+    child.on("error", (err) => {
+      result.errors.push(`Subprocess error: ${err.message}`);
+      resolve(result);
+    });
+  });
+}
+async function extractStandardSchemasFromProject(entryFile, baseDir, options = {}) {
+  const compiledPath = resolveCompiledPath(entryFile, baseDir);
+  if (!compiledPath) {
+    return {
+      schemas: new Map,
+      errors: [`Could not find compiled JS for ${entryFile}. Build the project first.`]
+    };
+  }
+  return extractStandardSchemas(compiledPath, options);
+}
+
+// src/analysis/schema-detection.ts
+async function detectRuntimeSchemas(context) {
+  const { baseDir, entryFile } = context;
+  const compiledPath = resolveCompiledPath(entryFile, baseDir);
+  if (!compiledPath) {
+    return {
+      schemas: new Map,
+      errors: []
+    };
+  }
+  const extraction = await extractStandardSchemasFromProject(entryFile, baseDir);
+  const schemas = new Map;
+  for (const [name, result] of extraction.schemas) {
+    schemas.set(name, {
+      schema: result.outputSchema,
+      vendor: result.vendor
+    });
+  }
+  return {
+    schemas,
+    errors: extraction.errors
+  };
 }
 function clearSchemaCache() {}
 // src/extract/schema/types.ts
@@ -209,155 +405,6 @@ function getRegisteredAdapters() {
 function getSupportedLibraries() {
   return adapters.flatMap((a) => a.packages);
 }
-// src/extract/schema/standard-schema.ts
-import { spawn } from "node:child_process";
-import * as fs from "node:fs";
-import * as path from "node:path";
-function isStandardJSONSchema(obj) {
-  if (typeof obj !== "object" || obj === null)
-    return false;
-  const std = obj["~standard"];
-  if (typeof std !== "object" || std === null)
-    return false;
-  const stdObj = std;
-  if (typeof stdObj.version !== "number")
-    return false;
-  if (typeof stdObj.vendor !== "string")
-    return false;
-  const jsonSchema = stdObj.jsonSchema;
-  if (typeof jsonSchema !== "object" || jsonSchema === null)
-    return false;
-  const jsObj = jsonSchema;
-  return typeof jsObj.output === "function";
-}
-var WORKER_SCRIPT = `
-const path = require('path');
-
-async function extract() {
-  // With node -e, argv is: [node, arg1, arg2, ...]
-  // (the -e script is NOT in argv)
-  const [modulePath, target] = process.argv.slice(1);
-
-  try {
-    // Import the module
-    const mod = require(path.resolve(modulePath));
-    const results = [];
-
-    // Check each export
-    for (const [name, value] of Object.entries(mod)) {
-      if (name.startsWith('_')) continue;
-      if (typeof value !== 'object' || value === null) continue;
-
-      const std = value['~standard'];
-      if (!std || typeof std !== 'object') continue;
-      if (typeof std.version !== 'number') continue;
-      if (typeof std.vendor !== 'string') continue;
-      if (!std.jsonSchema || typeof std.jsonSchema.output !== 'function') continue;
-
-      try {
-        const outputSchema = std.jsonSchema.output(target);
-        const inputSchema = std.jsonSchema.input ? std.jsonSchema.input(target) : undefined;
-
-        results.push({
-          exportName: name,
-          vendor: std.vendor,
-          outputSchema,
-          inputSchema
-        });
-      } catch (e) {
-        // Skip schemas that fail to extract
-      }
-    }
-
-    console.log(JSON.stringify({ success: true, results }));
-  } catch (e) {
-    console.log(JSON.stringify({ success: false, error: e.message }));
-  }
-}
-
-extract();
-`;
-function resolveCompiledPath(tsPath, baseDir) {
-  const relativePath = path.relative(baseDir, tsPath);
-  const withoutExt = relativePath.replace(/\.tsx?$/, "");
-  const candidates = [
-    path.join(baseDir, `${withoutExt}.js`),
-    path.join(baseDir, "dist", `${withoutExt.replace(/^src\//, "")}.js`),
-    path.join(baseDir, "build", `${withoutExt.replace(/^src\//, "")}.js`),
-    path.join(baseDir, "lib", `${withoutExt.replace(/^src\//, "")}.js`)
-  ];
-  for (const candidate of candidates) {
-    if (fs.existsSync(candidate)) {
-      return candidate;
-    }
-  }
-  return null;
-}
-async function extractStandardSchemas(compiledJsPath, options = {}) {
-  const { timeout = 1e4, target = "draft-2020-12" } = options;
-  const result = {
-    schemas: new Map,
-    errors: []
-  };
-  if (!fs.existsSync(compiledJsPath)) {
-    result.errors.push(`Compiled JS not found: ${compiledJsPath}`);
-    return result;
-  }
-  return new Promise((resolve) => {
-    const child = spawn("node", ["-e", WORKER_SCRIPT, compiledJsPath, target], {
-      timeout,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-    child.stderr.on("data", (data) => {
-      stderr += data.toString();
-    });
-    child.on("close", (code) => {
-      if (code !== 0) {
-        result.errors.push(`Extraction process failed: ${stderr || `exit code ${code}`}`);
-        resolve(result);
-        return;
-      }
-      try {
-        const parsed = JSON.parse(stdout);
-        if (!parsed.success) {
-          result.errors.push(`Extraction failed: ${parsed.error}`);
-          resolve(result);
-          return;
-        }
-        for (const item of parsed.results) {
-          result.schemas.set(item.exportName, {
-            exportName: item.exportName,
-            vendor: item.vendor,
-            outputSchema: item.outputSchema,
-            inputSchema: item.inputSchema
-          });
-        }
-      } catch (e) {
-        result.errors.push(`Failed to parse extraction output: ${e}`);
-      }
-      resolve(result);
-    });
-    child.on("error", (err) => {
-      result.errors.push(`Subprocess error: ${err.message}`);
-      resolve(result);
-    });
-  });
-}
-async function extractStandardSchemasFromProject(entryFile, baseDir, options = {}) {
-  const compiledPath = resolveCompiledPath(entryFile, baseDir);
-  if (!compiledPath) {
-    return {
-      schemas: new Map,
-      errors: [`Could not find compiled JS for ${entryFile}. Build the project first.`]
-    };
-  }
-  return extractStandardSchemas(compiledPath, options);
-}
 // src/analysis/docs-coverage.ts
 import {
   DRIFT_CATEGORIES
@@ -6983,21 +7030,22 @@ function serializeVariable(declaration, symbol, context) {
   const typeRefs = typeRegistry.getTypeRefs();
   const referencedTypes = typeRegistry.getReferencedTypes();
   const symbolName = symbol.getName();
-  const standardSchema = context.detectedSchemas?.get(symbolName);
-  if (standardSchema) {
+  const runtimeSchema = context.detectedSchemas?.get(symbolName);
+  if (runtimeSchema) {
+    const schemaSource = runtimeSchema.vendor === "typebox" ? "typebox-native" : "standard-schema";
     return {
       id: symbolName,
       name: symbolName,
       ...metadata,
       kind: "variable",
       deprecated: isSymbolDeprecated(symbol),
-      schema: standardSchema.schema,
+      schema: runtimeSchema.schema,
       description,
       source: getSourceLocation(declaration),
       tags: [
         ...parsedDoc?.tags ?? [],
-        { name: "schemaLibrary", text: standardSchema.vendor },
-        { name: "schemaSource", text: "standard-schema" }
+        { name: "schemaLibrary", text: runtimeSchema.vendor },
+        { name: "schemaSource", text: schemaSource }
       ],
       examples: parsedDoc?.examples
     };
@@ -8978,6 +9026,10 @@ class DocCov {
     }
   }
   async detectSchemas(entryFile, packageDir) {
+    const mode = this.options.schemaExtraction ?? "static";
+    if (mode === "static") {
+      return;
+    }
     try {
       const result = await detectRuntimeSchemas({
         baseDir: packageDir,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doccov/sdk",
-  "version": "0.19.0",
+  "version": "0.21.0",
   "description": "DocCov SDK - Documentation coverage and drift detection for TypeScript",
   "keywords": [
     "typescript",