@doccov/sdk 0.20.0 → 0.22.0

package/dist/index.d.ts

@@ -125,6 +125,8 @@ interface DetectedSchema {
 interface SchemaDetectionResult {
 	schemas: Map<string, DetectedSchema>;
 	errors: string[];
+	/** Warning when runtime was requested but compiled JS not found */
+	noCompiledJsWarning?: boolean;
 }
 declare function detectRuntimeSchemas(context: SchemaDetectionContext): Promise<SchemaDetectionResult>;
 declare function clearSchemaCache(): void;

package/dist/index.js

@@ -42,6 +42,22 @@ 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)
@@ -58,24 +74,36 @@ async function extract() {
       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') 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;
+      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;
+      }
 
-        results.push({
-          exportName: name,
-          vendor: std.vendor,
-          outputSchema,
-          inputSchema
-        });
-      } catch (e) {
-        // Skip schemas that fail to extract
+      // 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;
       }
     }
 
@@ -176,7 +204,8 @@ async function detectRuntimeSchemas(context) {
   if (!compiledPath) {
     return {
       schemas: new Map,
-      errors: []
+      errors: [],
+      noCompiledJsWarning: true
     };
   }
   const extraction = await extractStandardSchemasFromProject(entryFile, baseDir);
@@ -618,7 +647,7 @@ function generateReturnTypeFix(drift, exportEntry, existingPatch) {
   const actualReturn = signature?.returns;
   if (!actualReturn)
     return null;
-  const correctType = actualReturn.tsType ?? stringifySchema(actualReturn.schema);
+  const correctType = stringifySchema(actualReturn.schema);
   const updatedReturn = {
     ...existingPatch?.returns,
     type: correctType
@@ -1568,7 +1597,7 @@ function detectReturnTypeDrift(entry) {
   if (!signatureReturn) {
     return [];
   }
-  const declaredRaw = signatureReturn.tsType ?? extractTypeFromSchema(signatureReturn.schema);
+  const declaredRaw = extractTypeFromSchema(signatureReturn.schema);
   const declaredType = normalizeType(declaredRaw) ?? undefined;
   if (!declaredType) {
     return [];
@@ -2170,7 +2199,7 @@ function detectAsyncMismatch(entry) {
   }
   const drifts = [];
   const returnsPromise = signatures.some((sig) => {
-    const returnType = sig.returns?.tsType ?? extractTypeFromSchema(sig.returns?.schema) ?? "";
+    const returnType = extractTypeFromSchema(sig.returns?.schema) ?? "";
     return returnType.startsWith("Promise<") || returnType === "Promise";
   });
   const returnsTag = entry.tags?.find((tag) => tag.name === "returns" || tag.name === "return");
@@ -5133,11 +5162,11 @@ function formatTypeReference(type, typeChecker, typeRefs, referencedTypes, visit
     if (type.getFlags() & ts.TypeFlags.Object) {
       const objectType = type;
       if (objectType.objectFlags & ts.ObjectFlags.Mapped) {
-        return { type: "object", tsType: typeString };
+        return { type: "object" };
       }
     }
     if (type.flags & ts.TypeFlags.Conditional) {
-      return { type: "object", tsType: typeString };
+      return { type: "object" };
     }
     if (type.isUnion()) {
       const unionType = type;
@@ -6391,7 +6420,6 @@ function serializeCallSignatures(signatures, symbol, context, parsedDoc) {
       };
     });
     const returnType = signature.getReturnType();
-    const returnTypeText = returnType ? checker.typeToString(returnType) : undefined;
     if (returnType) {
       collectReferencedTypes(returnType, checker, referencedTypes);
     }
@@ -6417,7 +6445,6 @@ function serializeCallSignatures(signatures, symbol, context, parsedDoc) {
       returns: {
         schema: returnType ? formatTypeReference(returnType, checker, typeRefs, referencedTypes) : { type: "void" },
         description: functionDoc?.returns || "",
-        tsType: returnTypeText,
         ...typePredicateInfo ? { typePredicate: typePredicateInfo } : {}
       },
       description: functionDoc?.description || undefined,
@@ -7002,21 +7029,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
     };
@@ -8461,13 +8489,6 @@ function extractTypeName(schema) {
   if (typeof s.type === "string") {
     return s.type;
   }
-  if (typeof s.tsType === "string") {
-    const tsType = s.tsType;
-    if (tsType.length > 30) {
-      return `${tsType.slice(0, 27)}...`;
-    }
-    return tsType;
-  }
   return;
 }
 function hasSignatureChanged(oldMember, newMember) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doccov/sdk",
-  "version": "0.20.0",
+  "version": "0.22.0",
   "description": "DocCov SDK - Documentation coverage and drift detection for TypeScript",
   "keywords": [
     "typescript",
@@ -39,7 +39,7 @@
     "dist"
   ],
   "dependencies": {
-    "@openpkg-ts/spec": "^0.10.0",
+    "@openpkg-ts/spec": "^0.11.0",
     "@vercel/sandbox": "^1.0.3",
     "mdast": "^3.0.0",
     "minimatch": "^10.1.1",