@openpkg-ts/extract 0.13.0 → 0.14.0

package/dist/bin/tspec.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   extract
-} from "../shared/chunk-ksf9k654.js";
+} from "../shared/chunk-v4cnenxs.js";
 
 // src/cli/spec.ts
 import * as fs from "node:fs";

package/dist/shared/{chunk-ksf9k654.js → chunk-v4cnenxs.js}

@@ -248,7 +248,7 @@ class TypeRegistry {
             return { type: checker.typeToString(t) };
           }
           if (sym && !sym.getName().startsWith("__")) {
-            return { $ref: sym.getName() };
+            return { $ref: `#/types/${sym.getName()}` };
           }
           if (t.flags & ts.TypeFlags.StringLiteral) {
             return { type: "string", enum: [t.value] };
@@ -265,7 +265,7 @@ class TypeRegistry {
         allOf: type.types.map((t) => {
           const sym = t.getSymbol() || t.aliasSymbol;
           if (sym && !sym.getName().startsWith("__")) {
-            return { $ref: sym.getName() };
+            return { $ref: `#/types/${sym.getName()}` };
           }
           return { type: checker.typeToString(t) };
         })
@@ -287,7 +287,7 @@ class TypeRegistry {
           const propSym = propType.getSymbol() || propType.aliasSymbol;
           const symName = propSym?.getName();
           if (propSym && symName && !symName.startsWith("__") && symName !== propName) {
-            properties[propName] = { $ref: symName };
+            properties[propName] = { $ref: `#/types/${symName}` };
           } else {
             properties[propName] = { type: checker.typeToString(propType) };
           }
@@ -316,7 +316,7 @@ class TypeRegistry {
         members.push({
           name,
           kind: "property",
-          schema: sym && !sym.getName().startsWith("__") ? { $ref: sym.getName() } : { type: checker.typeToString(type) }
+          schema: sym && !sym.getName().startsWith("__") ? { $ref: `#/types/${sym.getName()}` } : { type: checker.typeToString(type) }
         });
       } else if (ts.isMethodDeclaration(member) || ts.isMethodSignature(member)) {
         const name = member.name?.getText();
@@ -428,6 +428,21 @@ function extractTypeParameters(node, checker) {
     };
   });
 }
+function isSymbolDeprecated(symbol) {
+  if (!symbol) {
+    return false;
+  }
+  const jsDocTags = symbol.getJsDocTags();
+  if (jsDocTags.some((tag) => tag.name.toLowerCase() === "deprecated")) {
+    return true;
+  }
+  for (const declaration of symbol.getDeclarations() ?? []) {
+    if (ts2.getJSDocDeprecatedTag(declaration)) {
+      return true;
+    }
+  }
+  return false;
+}
 
 // src/compiler/program.ts
 import * as path2 from "node:path";
@@ -480,6 +495,30 @@ function createProgram({
 
 // src/types/schema-builder.ts
 import ts4 from "typescript";
+var BUILTIN_TYPE_SCHEMAS = {
+  Date: { type: "string", format: "date-time" },
+  RegExp: { type: "object", description: "RegExp" },
+  Error: { type: "object" },
+  Promise: { type: "object" },
+  Map: { type: "object" },
+  Set: { type: "object" },
+  WeakMap: { type: "object" },
+  WeakSet: { type: "object" },
+  Function: { type: "object" },
+  ArrayBuffer: { type: "string", format: "binary" },
+  ArrayBufferLike: { type: "string", format: "binary" },
+  DataView: { type: "string", format: "binary" },
+  Uint8Array: { type: "string", format: "byte" },
+  Uint16Array: { type: "string", format: "byte" },
+  Uint32Array: { type: "string", format: "byte" },
+  Int8Array: { type: "string", format: "byte" },
+  Int16Array: { type: "string", format: "byte" },
+  Int32Array: { type: "string", format: "byte" },
+  Float32Array: { type: "string", format: "byte" },
+  Float64Array: { type: "string", format: "byte" },
+  BigInt64Array: { type: "string", format: "byte" },
+  BigUint64Array: { type: "string", format: "byte" }
+};
 var PRIMITIVES2 = new Set([
   "string",
   "number",
@@ -575,10 +614,10 @@ function buildSchema(type, checker, ctx, _depth = 0) {
   if (isAtMaxDepth(ctx)) {
     return { type: checker.typeToString(type) };
   }
-  if (ctx && ctx.visitedTypes.has(type)) {
+  if (ctx?.visitedTypes.has(type)) {
     const symbol2 = type.getSymbol() || type.aliasSymbol;
     if (symbol2) {
-      return { $ref: symbol2.getName() };
+      return { $ref: `#/types/${symbol2.getName()}` };
     }
     return { type: checker.typeToString(type) };
   }
@@ -680,17 +719,17 @@ function buildSchema(type, checker, ctx, _depth = 0) {
     const symbol2 = typeRef.target.getSymbol();
     const name = symbol2?.getName();
     if (name && BUILTIN_TYPES.has(name)) {
-      return { $ref: name };
+      return { $ref: `#/types/${name}` };
     }
     if (name && (isBuiltinGeneric(name) || !isAnonymous(typeRef.target))) {
       if (ctx) {
         return withDepth(ctx, () => ({
-          $ref: name,
+          $ref: `#/types/${name}`,
           typeArguments: typeRef.typeArguments.map((t) => buildSchema(t, checker, ctx))
         }));
       }
       return {
-        $ref: name,
+        $ref: `#/types/${name}`,
         typeArguments: typeRef.typeArguments.map((t) => buildSchema(t, checker, ctx))
       };
     }
@@ -702,10 +741,10 @@ function buildSchema(type, checker, ctx, _depth = 0) {
       return { type: name };
     }
     if (BUILTIN_TYPES.has(name)) {
-      return { $ref: name };
+      return { $ref: `#/types/${name}` };
     }
     if (!name.startsWith("__")) {
-      return { $ref: name };
+      return { $ref: `#/types/${name}` };
     }
   }
   if (type.flags & ts4.TypeFlags.Object) {
@@ -772,6 +811,110 @@ function buildObjectSchema(properties, checker, ctx) {
   }
   return buildProps();
 }
+function isPureRefSchema(schema) {
+  return typeof schema === "object" && Object.keys(schema).length === 1 && "$ref" in schema;
+}
+function withDescription(schema, description) {
+  if (isPureRefSchema(schema)) {
+    return {
+      allOf: [schema],
+      description
+    };
+  }
+  return { ...schema, description };
+}
+function schemaIsAny(schema) {
+  if (typeof schema === "string") {
+    return schema === "any";
+  }
+  if ("type" in schema && schema.type === "any" && Object.keys(schema).length === 1) {
+    return true;
+  }
+  return false;
+}
+function schemasAreEqual(left, right) {
+  if (typeof left !== typeof right) {
+    return false;
+  }
+  if (typeof left === "string" && typeof right === "string") {
+    return left === right;
+  }
+  if (left == null || right == null) {
+    return left === right;
+  }
+  const normalize = (value) => {
+    if (Array.isArray(value)) {
+      return value.map((item) => normalize(item));
+    }
+    if (value && typeof value === "object") {
+      const sortedEntries = Object.entries(value).map(([key, val]) => [key, normalize(val)]).sort(([keyA], [keyB]) => keyA.localeCompare(keyB));
+      return Object.fromEntries(sortedEntries);
+    }
+    return value;
+  };
+  return JSON.stringify(normalize(left)) === JSON.stringify(normalize(right));
+}
+function deduplicateSchemas(schemas) {
+  const result = [];
+  for (const schema of schemas) {
+    const isDuplicate = result.some((existing) => schemasAreEqual(existing, schema));
+    if (!isDuplicate) {
+      result.push(schema);
+    }
+  }
+  return result;
+}
+function findDiscriminatorProperty(unionTypes, checker) {
+  const memberProps = [];
+  for (const t of unionTypes) {
+    if (t.flags & (ts4.TypeFlags.Null | ts4.TypeFlags.Undefined)) {
+      continue;
+    }
+    const props = t.getProperties();
+    if (!props || props.length === 0) {
+      return;
+    }
+    const propValues = new Map;
+    for (const prop of props) {
+      const declaration = prop.valueDeclaration ?? prop.declarations?.[0];
+      if (!declaration)
+        continue;
+      try {
+        const propType = checker.getTypeOfSymbolAtLocation(prop, declaration);
+        if (propType.isStringLiteral()) {
+          propValues.set(prop.getName(), propType.value);
+        } else if (propType.isNumberLiteral()) {
+          propValues.set(prop.getName(), propType.value);
+        }
+      } catch {}
+    }
+    memberProps.push(propValues);
+  }
+  if (memberProps.length < 2) {
+    return;
+  }
+  const firstMember = memberProps[0];
+  for (const [propName, firstValue] of firstMember) {
+    const values = new Set([firstValue]);
+    let isDiscriminator = true;
+    for (let i = 1;i < memberProps.length; i++) {
+      const value = memberProps[i].get(propName);
+      if (value === undefined) {
+        isDiscriminator = false;
+        break;
+      }
+      if (values.has(value)) {
+        isDiscriminator = false;
+        break;
+      }
+      values.add(value);
+    }
+    if (isDiscriminator) {
+      return propName;
+    }
+  }
+  return;
+}
 
 // src/types/parameters.ts
 import ts5 from "typescript";
@@ -941,7 +1084,7 @@ function serializeClass(node, ctx) {
         members.push(propMember);
     } else if (ts6.isMethodDeclaration(member)) {
       const methodMember = serializeMethod(member, ctx);
-      if (methodMember && methodMember.name) {
+      if (methodMember?.name) {
         if (!methodsByName.has(methodMember.name)) {
           methodsByName.set(methodMember.name, methodMember);
         } else {
@@ -1247,7 +1390,7 @@ function serializeInterface(node, ctx) {
         members.push(propMember);
     } else if (ts7.isMethodSignature(member)) {
       const methodMember = serializeMethodSignature(member, ctx);
-      if (methodMember && methodMember.name) {
+      if (methodMember?.name) {
         if (!methodsByName.has(methodMember.name)) {
           methodsByName.set(methodMember.name, methodMember);
         }
@@ -1440,7 +1583,7 @@ function serializeVariable(node, statement, ctx) {
 // src/builder/spec-builder.ts
 import * as fs2 from "node:fs";
 import * as path3 from "node:path";
-import { SCHEMA_VERSION } from "@openpkg-ts/spec";
+import { SCHEMA_URL, SCHEMA_VERSION } from "@openpkg-ts/spec";
 import ts8 from "typescript";
 
 // src/serializers/context.ts
@@ -1460,15 +1603,52 @@ function createContext(program, sourceFile, options = {}) {
 }
 
 // src/builder/spec-builder.ts
+var BUILTIN_TYPES2 = new Set([
+  "Array",
+  "Promise",
+  "Map",
+  "Set",
+  "Record",
+  "Partial",
+  "Required",
+  "Pick",
+  "Omit",
+  "Exclude",
+  "Extract",
+  "NonNullable",
+  "Parameters",
+  "ReturnType",
+  "Readonly",
+  "ReadonlyArray",
+  "Awaited",
+  "Date",
+  "RegExp",
+  "Error",
+  "Function",
+  "Object",
+  "String",
+  "Number",
+  "Boolean",
+  "Symbol",
+  "BigInt"
+]);
 async function extract(options) {
-  const { entryFile, baseDir, content, maxTypeDepth, maxExternalTypeDepth, resolveExternalTypes } = options;
+  const {
+    entryFile,
+    baseDir,
+    content,
+    maxTypeDepth,
+    maxExternalTypeDepth,
+    resolveExternalTypes,
+    includeSchema
+  } = options;
   const diagnostics = [];
   const exports = [];
   const result = createProgram({ entryFile, baseDir, content });
   const { program, sourceFile } = result;
   if (!sourceFile) {
     return {
-      spec: createEmptySpec(entryFile),
+      spec: createEmptySpec(entryFile, includeSchema),
       diagnostics: [{ message: `Could not load source file: ${entryFile}`, severity: "error" }]
     };
   }
@@ -1476,7 +1656,7 @@ async function extract(options) {
   const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
   if (!moduleSymbol) {
     return {
-      spec: createEmptySpec(entryFile),
+      spec: createEmptySpec(entryFile, includeSchema),
       diagnostics: [{ message: "Could not get module symbol", severity: "warning" }]
     };
   }
@@ -1485,7 +1665,11 @@ async function extract(options) {
   for (const symbol of exportedSymbols) {
     exportedIds.add(symbol.getName());
   }
-  const ctx = createContext(program, sourceFile, { maxTypeDepth, maxExternalTypeDepth, resolveExternalTypes });
+  const ctx = createContext(program, sourceFile, {
+    maxTypeDepth,
+    maxExternalTypeDepth,
+    resolveExternalTypes
+  });
   ctx.exportedIds = exportedIds;
   for (const symbol of exportedSymbols) {
     try {
@@ -1504,11 +1688,31 @@ async function extract(options) {
     }
   }
   const meta = await getPackageMeta(entryFile, baseDir);
+  const types = ctx.typeRegistry.getAll();
+  const danglingRefs = collectDanglingRefs(exports, types);
+  for (const ref of danglingRefs) {
+    diagnostics.push({
+      message: `Type '${ref}' is referenced but not defined in types[].`,
+      severity: "warning",
+      code: "DANGLING_REF",
+      suggestion: "The type may be from an external package. Check import paths."
+    });
+  }
+  const externalTypes = types.filter((t) => t.kind === "external");
+  if (externalTypes.length > 0) {
+    diagnostics.push({
+      message: `${externalTypes.length} external type(s) could not be fully resolved: ${externalTypes.slice(0, 5).map((t) => t.id).join(", ")}${externalTypes.length > 5 ? "..." : ""}`,
+      severity: "warning",
+      code: "EXTERNAL_TYPE_STUBS",
+      suggestion: "Types are from external packages. Full resolution requires type declarations."
+    });
+  }
   const spec = {
+    ...includeSchema ? { $schema: SCHEMA_URL } : {},
     openpkg: SCHEMA_VERSION,
     meta,
     exports,
-    types: ctx.typeRegistry.getAll(),
+    types,
     generation: {
       generator: "@openpkg-ts/extract",
       timestamp: new Date().toISOString()
@@ -1516,6 +1720,32 @@ async function extract(options) {
   };
   return { spec, diagnostics };
 }
+function collectAllRefs(obj, refs) {
+  if (obj === null || obj === undefined)
+    return;
+  if (Array.isArray(obj)) {
+    for (const item of obj) {
+      collectAllRefs(item, refs);
+    }
+    return;
+  }
+  if (typeof obj === "object") {
+    const record = obj;
+    if (typeof record.$ref === "string" && record.$ref.startsWith("#/types/")) {
+      refs.add(record.$ref.slice("#/types/".length));
+    }
+    for (const value of Object.values(record)) {
+      collectAllRefs(value, refs);
+    }
+  }
+}
+function collectDanglingRefs(exports, types) {
+  const definedTypes = new Set(types.map((t) => t.id));
+  const referencedTypes = new Set;
+  collectAllRefs(exports, referencedTypes);
+  collectAllRefs(types, referencedTypes);
+  return Array.from(referencedTypes).filter((ref) => !definedTypes.has(ref) && !BUILTIN_TYPES2.has(ref));
+}
 function resolveExportTarget(symbol, checker) {
   let targetSymbol = symbol;
   if (symbol.flags & ts8.SymbolFlags.Alias) {
@@ -1528,7 +1758,7 @@ function resolveExportTarget(symbol, checker) {
   const declaration = targetSymbol.valueDeclaration || declarations.find((decl) => decl.kind !== ts8.SyntaxKind.ExportSpecifier) || declarations[0];
   return { declaration, targetSymbol };
 }
-function serializeDeclaration(declaration, exportSymbol, targetSymbol, exportName, ctx) {
+function serializeDeclaration(declaration, exportSymbol, _targetSymbol, exportName, ctx) {
   let result = null;
   if (ts8.isFunctionDeclaration(declaration)) {
     result = serializeFunctionExport(declaration, ctx);
@@ -1546,16 +1776,16 @@ function serializeDeclaration(declaration, exportSymbol, targetSymbol, exportNam
       result = serializeVariable(declaration, varStatement, ctx);
     }
   } else if (ts8.isNamespaceExport(declaration) || ts8.isModuleDeclaration(declaration)) {
-    result = serializeNamespaceExport(exportSymbol, exportName, ctx);
+    result = serializeNamespaceExport(exportSymbol, exportName);
   } else if (ts8.isSourceFile(declaration)) {
-    result = serializeNamespaceExport(exportSymbol, exportName, ctx);
+    result = serializeNamespaceExport(exportSymbol, exportName);
   }
   if (result) {
     result = withExportName(result, exportName);
   }
   return result;
 }
-function serializeNamespaceExport(symbol, exportName, ctx) {
+function serializeNamespaceExport(symbol, exportName) {
   const { description, tags, examples } = getJSDocFromExportSymbol(symbol);
   return {
     id: exportName,
@@ -1633,8 +1863,9 @@ function withExportName(entry, exportName) {
     name: entry.name
   };
 }
-function createEmptySpec(entryFile) {
+function createEmptySpec(entryFile, includeSchema) {
   return {
+    ...includeSchema ? { $schema: SCHEMA_URL } : {},
     openpkg: SCHEMA_VERSION,
     meta: { name: path3.basename(entryFile, path3.extname(entryFile)) },
     exports: [],
@@ -1659,4 +1890,4 @@ async function getPackageMeta(entryFile, baseDir) {
   } catch {}
   return { name: path3.basename(searchDir) };
 }
-export { TypeRegistry, getJSDocComment, getSourceLocation, createProgram, isPrimitiveName, isBuiltinGeneric, isAnonymous, buildSchema, extractParameters, registerReferencedTypes, serializeClass, serializeEnum, serializeFunctionExport, serializeInterface, serializeTypeAlias, serializeVariable, extract };
+export { TypeRegistry, getJSDocComment, getSourceLocation, getParamDescription, extractTypeParameters, isSymbolDeprecated, createProgram, BUILTIN_TYPE_SCHEMAS, isPrimitiveName, isBuiltinGeneric, isAnonymous, buildSchema, isPureRefSchema, withDescription, schemaIsAny, schemasAreEqual, deduplicateSchemas, findDiscriminatorProperty, extractParameters, registerReferencedTypes, serializeClass, serializeEnum, serializeFunctionExport, serializeInterface, serializeTypeAlias, serializeVariable, extract };

package/dist/src/index.d.ts

@@ -25,7 +25,7 @@ declare class TypeRegistry {
 	private extractShallowMembers;
 	registerFromSymbol(symbol: ts.Symbol, checker: ts.TypeChecker): SpecType | undefined;
 }
-import { SpecExample, SpecSource, SpecTag } from "@openpkg-ts/spec";
+import { SpecExample, SpecSource, SpecTag, SpecTypeParameter } from "@openpkg-ts/spec";
 import ts2 from "typescript";
 declare function getJSDocComment(node: ts2.Node): {
 	description?: string;
@@ -33,6 +33,23 @@ declare function getJSDocComment(node: ts2.Node): {
 	examples: SpecExample[];
 };
 declare function getSourceLocation(node: ts2.Node, sourceFile: ts2.SourceFile): SpecSource;
+/**
+* Get description for a destructured parameter property from JSDoc @param tags.
+* Matches patterns like:
+* - @param paramName - exact match
+* - @param opts.paramName - dotted notation with alias
+* - @param {type} paramName - type annotation format
+*/
+declare function getParamDescription(propertyName: string, jsdocTags: readonly ts2.JSDocTag[], inferredAlias?: string): string | undefined;
+type DeclarationWithTypeParams = ts2.FunctionDeclaration | ts2.ClassDeclaration | ts2.InterfaceDeclaration | ts2.TypeAliasDeclaration | ts2.MethodDeclaration | ts2.ArrowFunction;
+/**
+* Extract type parameters from declarations like `<T extends Base, K = Default>`
+*/
+declare function extractTypeParameters(node: DeclarationWithTypeParams, checker: ts2.TypeChecker): SpecTypeParameter[] | undefined;
+/**
+* Check if a symbol is marked as deprecated via @deprecated JSDoc tag.
+*/
+declare function isSymbolDeprecated(symbol: ts2.Symbol | undefined): boolean;
 import { OpenPkg } from "@openpkg-ts/spec";
 interface ExtractOptions {
 	entryFile: string;
@@ -42,6 +59,8 @@ interface ExtractOptions {
 	maxExternalTypeDepth?: number;
 	resolveExternalTypes?: boolean;
 	schemaExtraction?: "static" | "hybrid";
+	/** Include $schema URL in output */
+	includeSchema?: boolean;
 }
 interface ExtractResult {
 	spec: OpenPkg;
@@ -50,6 +69,8 @@ interface ExtractResult {
 interface Diagnostic {
 	message: string;
 	severity: "error" | "warning" | "info";
+	code?: string;
+	suggestion?: string;
 	location?: {
 		file?: string;
 		line?: number;
@@ -71,35 +92,135 @@ interface ProgramResult {
 	configPath?: string;
 }
 declare function createProgram({ entryFile, baseDir, content }: ProgramOptions): ProgramResult;
-import { SpecSchema } from "@openpkg-ts/spec";
-import ts4 from "typescript";
-type SchemaAdapter = {
-	name: string;
-	detect: (node: ts4.Node, checker: ts4.TypeChecker) => boolean;
-	extract: (node: ts4.Node, checker: ts4.TypeChecker) => SpecSchema | null;
-};
+import * as TS 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: TS.Type, checker: TS.TypeChecker): boolean;
+	/**
+	* Extract the output type from a schema type.
+	* Returns null if extraction fails.
+	*/
+	extractOutputType(type: TS.Type, checker: TS.TypeChecker): TS.Type | null;
+	/**
+	* Extract the input type from a schema type (optional).
+	* Useful for transforms where input differs from output.
+	*/
+	extractInputType?(type: TS.Type, checker: TS.TypeChecker): TS.Type | null;
+}
+/**
+* Result of schema type extraction
+*/
+interface SchemaExtractionResult {
+	/** The adapter that matched */
+	adapter: SchemaAdapter;
+	/** The extracted output type */
+	outputType: TS.Type;
+	/** The extracted input type (if different from output) */
+	inputType?: TS.Type;
+}
+/**
+* Utility: Check if type is an object type reference (has type arguments)
+*/
+declare function isTypeReference(type: TS.Type): type is TS.TypeReference;
+/**
+* Utility: Remove undefined/null from a union type
+*/
+declare function getNonNullableType(type: TS.Type): TS.Type;
 declare function registerAdapter(adapter: SchemaAdapter): void;
-declare function findAdapter(node: ts4.Node, checker: ts4.TypeChecker): SchemaAdapter | undefined;
-declare function isSchemaType(node: ts4.Node, checker: ts4.TypeChecker): boolean;
-declare function extractSchemaType(node: ts4.Node, checker: ts4.TypeChecker): SpecSchema | null;
+declare function findAdapter(type: TS.Type, checker: TS.TypeChecker): SchemaAdapter | undefined;
+declare function isSchemaType(type: TS.Type, checker: TS.TypeChecker): boolean;
+declare function extractSchemaType(type: TS.Type, checker: TS.TypeChecker): SchemaExtractionResult | null;
 declare const arktypeAdapter: SchemaAdapter;
 declare const typeboxAdapter: SchemaAdapter;
 declare const valibotAdapter: SchemaAdapter;
 declare const zodAdapter: SchemaAdapter;
-import { SpecSchema as SpecSchema2 } from "@openpkg-ts/spec";
-import ts5 from "typescript";
-interface StandardSchemaResult {
-	schema: SpecSchema2;
+/**
+* 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";
 }
-declare function extractStandardSchemas(_program: ts5.Program, _entryFile: string): StandardSchemaResult[];
+/**
+* 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>;
 import { SpecExport } from "@openpkg-ts/spec";
-import ts7 from "typescript";
-import ts6 from "typescript";
+import ts5 from "typescript";
+import ts4 from "typescript";
 interface SerializerContext {
-	typeChecker: ts6.TypeChecker;
-	program: ts6.Program;
-	sourceFile: ts6.SourceFile;
+	typeChecker: ts4.TypeChecker;
+	program: ts4.Program;
+	sourceFile: ts4.SourceFile;
 	maxTypeDepth: number;
 	maxExternalTypeDepth: number;
 	currentDepth: number;
@@ -107,37 +228,39 @@ interface SerializerContext {
 	typeRegistry: TypeRegistry;
 	exportedIds: Set<string>;
 	/** Track visited types to prevent infinite recursion */
-	visitedTypes: Set<ts6.Type>;
+	visitedTypes: Set<ts4.Type>;
 }
-declare function serializeClass(node: ts7.ClassDeclaration, ctx: SerializerContext): SpecExport | null;
+declare function serializeClass(node: ts5.ClassDeclaration, ctx: SerializerContext): SpecExport | null;
 import { SpecExport as SpecExport2 } from "@openpkg-ts/spec";
-import ts8 from "typescript";
-declare function serializeEnum(node: ts8.EnumDeclaration, ctx: SerializerContext): SpecExport2 | null;
+import ts6 from "typescript";
+declare function serializeEnum(node: ts6.EnumDeclaration, ctx: SerializerContext): SpecExport2 | null;
 import { SpecExport as SpecExport3 } from "@openpkg-ts/spec";
-import ts9 from "typescript";
-declare function serializeFunctionExport(node: ts9.FunctionDeclaration | ts9.ArrowFunction, ctx: SerializerContext): SpecExport3 | null;
+import ts7 from "typescript";
+declare function serializeFunctionExport(node: ts7.FunctionDeclaration | ts7.ArrowFunction, ctx: SerializerContext): SpecExport3 | null;
 import { SpecExport as SpecExport4 } from "@openpkg-ts/spec";
-import ts10 from "typescript";
-declare function serializeInterface(node: ts10.InterfaceDeclaration, ctx: SerializerContext): SpecExport4 | null;
+import ts8 from "typescript";
+declare function serializeInterface(node: ts8.InterfaceDeclaration, ctx: SerializerContext): SpecExport4 | null;
 import { SpecExport as SpecExport5 } from "@openpkg-ts/spec";
-import ts11 from "typescript";
-declare function serializeTypeAlias(node: ts11.TypeAliasDeclaration, ctx: SerializerContext): SpecExport5 | null;
+import ts9 from "typescript";
+declare function serializeTypeAlias(node: ts9.TypeAliasDeclaration, ctx: SerializerContext): SpecExport5 | null;
 import { SpecExport as SpecExport6 } from "@openpkg-ts/spec";
-import ts12 from "typescript";
-declare function serializeVariable(node: ts12.VariableDeclaration, statement: ts12.VariableStatement, ctx: SerializerContext): SpecExport6 | null;
-import ts13 from "typescript";
-declare function formatTypeReference(type: ts13.Type, checker: ts13.TypeChecker): string;
-declare function collectReferencedTypes(type: ts13.Type, checker: ts13.TypeChecker, visited?: Set<string>): string[];
+import ts10 from "typescript";
+declare function serializeVariable(node: ts10.VariableDeclaration, statement: ts10.VariableStatement, ctx: SerializerContext): SpecExport6 | null;
 import { SpecSignatureParameter } from "@openpkg-ts/spec";
-import ts14 from "typescript";
-declare function extractParameters(signature: ts14.Signature, ctx: SerializerContext): SpecSignatureParameter[];
+import ts11 from "typescript";
+declare function extractParameters(signature: ts11.Signature, ctx: SerializerContext): SpecSignatureParameter[];
 /**
 * Recursively register types referenced by a ts.Type.
 * Uses ctx.visitedTypes to prevent infinite recursion on circular types.
 */
-declare function registerReferencedTypes(type: ts14.Type, ctx: SerializerContext): void;
-import { SpecSchema as SpecSchema3 } from "@openpkg-ts/spec";
-import ts15 from "typescript";
+declare function registerReferencedTypes(type: ts11.Type, ctx: SerializerContext): void;
+import { SpecSchema } from "@openpkg-ts/spec";
+import ts12 from "typescript";
+/**
+* Built-in type schemas with JSON Schema format hints.
+* Used for types that have specific serialization formats.
+*/
+declare const BUILTIN_TYPE_SCHEMAS: Record<string, SpecSchema>;
 /**
 * Check if a name is a primitive type
 */
@@ -149,13 +272,41 @@ declare function isBuiltinGeneric(name: string): boolean;
 /**
 * Check if a type is anonymous (no meaningful symbol name)
 */
-declare function isAnonymous(type: ts15.Type): boolean;
+declare function isAnonymous(type: ts12.Type): boolean;
 /**
 * Build a structured SpecSchema from a TypeScript type.
 * Uses $ref for named types and typeArguments for generics.
 */
-declare function buildSchema(type: ts15.Type, checker: ts15.TypeChecker, ctx?: SerializerContext, _depth?: number): SpecSchema3;
-import ts16 from "typescript";
-declare function isExported(node: ts16.Node): boolean;
-declare function getNodeName(node: ts16.Node): string | undefined;
-export { zodAdapter, valibotAdapter, typeboxAdapter, serializeVariable, serializeTypeAlias, serializeInterface, serializeFunctionExport, serializeEnum, serializeClass, registerReferencedTypes, registerAdapter, isSchemaType, isPrimitiveName, isExported, isBuiltinGeneric, isAnonymous, getSourceLocation, getNodeName, getJSDocComment, formatTypeReference, findAdapter, extractStandardSchemas, extractSchemaType, extractParameters, extract, createProgram, collectReferencedTypes, buildSchema, arktypeAdapter, TypeRegistry, StandardSchemaResult, SerializerContext, SchemaAdapter, ProgramResult, ProgramOptions, ExtractResult, ExtractOptions, Diagnostic };
+declare function buildSchema(type: ts12.Type, checker: ts12.TypeChecker, ctx?: SerializerContext, _depth?: number): SpecSchema;
+/**
+* Check if a schema is a pure $ref (only has $ref property)
+*/
+declare function isPureRefSchema(schema: SpecSchema): schema is {
+	$ref: string;
+};
+/**
+* Add description to a schema, handling $ref properly.
+* For pure $ref schemas, wraps in allOf to preserve the reference.
+*/
+declare function withDescription(schema: SpecSchema, description: string): SpecSchema;
+/**
+* Check if a schema represents the 'any' type
+*/
+declare function schemaIsAny(schema: SpecSchema): boolean;
+/**
+* Deep equality comparison for schemas
+*/
+declare function schemasAreEqual(left: SpecSchema, right: SpecSchema): boolean;
+/**
+* Remove duplicate schemas from an array while preserving order.
+*/
+declare function deduplicateSchemas(schemas: SpecSchema[]): SpecSchema[];
+/**
+* Find a discriminator property in a union of object types (tagged union pattern).
+* A valid discriminator has a unique literal value in each union member.
+*/
+declare function findDiscriminatorProperty(unionTypes: ts12.Type[], checker: ts12.TypeChecker): string | undefined;
+import ts13 from "typescript";
+declare function isExported(node: ts13.Node): boolean;
+declare function getNodeName(node: ts13.Node): string | undefined;
+export { zodAdapter, withDescription, valibotAdapter, typeboxAdapter, serializeVariable, serializeTypeAlias, serializeInterface, serializeFunctionExport, serializeEnum, serializeClass, schemasAreEqual, schemaIsAny, resolveCompiledPath, registerReferencedTypes, registerAdapter, isTypeReference, isSymbolDeprecated, isStandardJSONSchema, isSchemaType, isPureRefSchema, isPrimitiveName, isExported, isBuiltinGeneric, isAnonymous, getSourceLocation, getParamDescription, getNonNullableType, getNodeName, getJSDocComment, findDiscriminatorProperty, findAdapter, extractTypeParameters, extractStandardSchemasFromProject, extractStandardSchemas, extractSchemaType, extractParameters, extract, deduplicateSchemas, createProgram, buildSchema, arktypeAdapter, TypeRegistry, StandardSchemaExtractionResult, StandardSchemaExtractionOutput, StandardJSONSchemaV1, SerializerContext, SchemaExtractionResult, SchemaAdapter, ProgramResult, ProgramOptions, ExtractStandardSchemasOptions, ExtractResult, ExtractOptions, Diagnostic, BUILTIN_TYPE_SCHEMAS };

package/dist/src/index.js

@@ -1,78 +1,383 @@
 import {
+  BUILTIN_TYPE_SCHEMAS,
   TypeRegistry,
   buildSchema,
   createProgram,
+  deduplicateSchemas,
   extract,
   extractParameters,
+  extractTypeParameters,
+  findDiscriminatorProperty,
   getJSDocComment,
+  getParamDescription,
   getSourceLocation,
   isAnonymous,
   isBuiltinGeneric,
   isPrimitiveName,
+  isPureRefSchema,
+  isSymbolDeprecated,
   registerReferencedTypes,
+  schemaIsAny,
+  schemasAreEqual,
   serializeClass,
   serializeEnum,
   serializeFunctionExport,
   serializeInterface,
   serializeTypeAlias,
-  serializeVariable
-} from "../shared/chunk-ksf9k654.js";
+  serializeVariable,
+  withDescription
+} from "../shared/chunk-v4cnenxs.js";
+// src/schema/registry.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;
+}
+var adapters = [];
+function registerAdapter(adapter) {
+  adapters.push(adapter);
+}
+function findAdapter(type, checker) {
+  return adapters.find((a) => a.matches(type, checker));
+}
+function isSchemaType(type, checker) {
+  return adapters.some((a) => a.matches(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 inputType = adapter.extractInputType?.(type, checker);
+  return {
+    adapter,
+    outputType,
+    inputType
+  };
+}
+
 // src/schema/adapters/arktype.ts
+var ARKTYPE_TYPE_PATTERN = /^Type</;
 var arktypeAdapter = {
-  name: "arktype",
-  detect: () => false,
-  extract: () => null
+  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/schema/adapters/typebox.ts
+var TYPEBOX_TYPE_PATTERN = /^T[A-Z]/;
 var typeboxAdapter = {
-  name: "typebox",
-  detect: () => false,
-  extract: () => null
+  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/schema/adapters/valibot.ts
+var VALIBOT_TYPE_PATTERN = /Schema(<|$)/;
 var valibotAdapter = {
-  name: "valibot",
-  detect: () => false,
-  extract: () => null
+  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/schema/adapters/zod.ts
+var ZOD_TYPE_PATTERN = /^Zod[A-Z]/;
 var zodAdapter = {
-  name: "zod",
-  detect: () => false,
-  extract: () => null
+  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/schema/registry.ts
-var adapters = [];
-function registerAdapter(adapter) {
-  adapters.push(adapter);
+
+// src/schema/adapters/index.ts
+registerAdapter(zodAdapter);
+registerAdapter(valibotAdapter);
+registerAdapter(arktypeAdapter);
+registerAdapter(typeboxAdapter);
+// src/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";
 }
-function findAdapter(node, checker) {
-  return adapters.find((a) => a.detect(node, checker));
+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 isSchemaType(node, checker) {
-  return adapters.some((a) => a.detect(node, checker));
+
+function sanitizeTypeBoxSchema(schema) {
+  // JSON.stringify removes symbol keys, keeping only JSON Schema props
+  return JSON.parse(JSON.stringify(schema));
 }
-function extractSchemaType(node, checker) {
-  const adapter = findAdapter(node, checker);
-  return adapter?.extract(node, checker) ?? null;
+
+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 }));
+  }
 }
-// src/schema/standard-schema.ts
-function extractStandardSchemas(_program, _entryFile) {
-  return [];
+
+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;
 }
-// src/types/formatter.ts
-function formatTypeReference(type, checker) {
-  return checker.typeToString(type);
+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);
+    });
+  });
 }
-function collectReferencedTypes(type, checker, visited = new Set) {
-  const symbol = type.getSymbol();
-  if (!symbol)
-    return [];
-  const name = symbol.getName();
-  if (visited.has(name))
-    return [];
-  visited.add(name);
-  return [name];
+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/types/utils.ts
 function isExported(node) {
@@ -90,6 +395,7 @@ function getNodeName(node) {
 }
 export {
   zodAdapter,
+  withDescription,
   valibotAdapter,
   typeboxAdapter,
   serializeVariable,
@@ -98,25 +404,37 @@ export {
   serializeFunctionExport,
   serializeEnum,
   serializeClass,
+  schemasAreEqual,
+  schemaIsAny,
+  resolveCompiledPath,
   registerReferencedTypes,
   registerAdapter,
+  isTypeReference,
+  isSymbolDeprecated,
+  isStandardJSONSchema,
   isSchemaType,
+  isPureRefSchema,
   isPrimitiveName,
   isExported,
   isBuiltinGeneric,
   isAnonymous,
   getSourceLocation,
+  getParamDescription,
+  getNonNullableType,
   getNodeName,
   getJSDocComment,
-  formatTypeReference,
+  findDiscriminatorProperty,
   findAdapter,
+  extractTypeParameters,
+  extractStandardSchemasFromProject,
   extractStandardSchemas,
   extractSchemaType,
   extractParameters,
   extract,
+  deduplicateSchemas,
   createProgram,
-  collectReferencedTypes,
   buildSchema,
   arktypeAdapter,
-  TypeRegistry
+  TypeRegistry,
+  BUILTIN_TYPE_SCHEMAS
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpkg-ts/extract",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "TypeScript export extraction to OpenPkg spec",
   "keywords": [
     "openpkg",