@openpkg-ts/extract 0.21.0 → 0.22.1

package/dist/bin/tspec.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   extract
-} from "../shared/chunk-yh8v9dbt.js";
+} from "../shared/chunk-7fp2zqf8.js";
 
 // src/cli/spec.ts
 import * as fs from "node:fs";
@@ -452,8 +452,9 @@ function createProgram() {
     fs.writeFileSync(options.output, JSON.stringify(normalized, null, 2));
     spin.success(`Extracted to ${options.output}`);
     if (result.runtimeSchemas) {
-      const { extracted, merged, vendors } = result.runtimeSchemas;
-      console.log(`ℹ Runtime schemas: ${merged}/${extracted} merged (${vendors.join(", ")})`);
+      const { extracted, merged, vendors, method } = result.runtimeSchemas;
+      const via = method ? ` via ${method}` : "";
+      console.log(`ℹ Runtime schemas: ${merged}/${extracted} merged (${vendors.join(", ")})${via}`);
     }
     for (const diag of result.diagnostics) {
       if (diag.severity === "info" && !options.verbose)

package/dist/shared/{chunk-yh8v9dbt.js → chunk-7fp2zqf8.js}

@@ -125,9 +125,15 @@ function buildSchema(type, checker, ctx, _depth = 0) {
       return buildFunctionSchema(callSignatures, checker, ctx);
     }
     const symbol2 = type.getSymbol() || type.aliasSymbol;
-    if (symbol2) {
+    if (symbol2 && !isAnonymous(type)) {
       return { $ref: `#/types/${symbol2.getName()}` };
     }
+    if (type.flags & ts.TypeFlags.Object) {
+      const properties = type.getProperties();
+      if (properties.length > 0) {
+        return buildObjectSchema(properties, checker, ctx);
+      }
+    }
     return { type: checker.typeToString(type) };
   }
   if (ctx && type.flags & ts.TypeFlags.Object) {
@@ -1498,6 +1504,169 @@ function serializeTypeAlias(node, ctx) {
   };
 }
 
+// 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) ?? undefined;
+  return {
+    adapter,
+    outputType,
+    inputType
+  };
+}
+
+// src/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/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/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/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/schema/adapters/index.ts
+registerAdapter(zodAdapter);
+registerAdapter(valibotAdapter);
+registerAdapter(arktypeAdapter);
+registerAdapter(typeboxAdapter);
+
 // src/serializers/variables.ts
 function serializeVariable(node, statement, ctx) {
   const symbol = ctx.typeChecker.getSymbolAtLocation(node.name);
@@ -1508,8 +1677,14 @@ function serializeVariable(node, statement, ctx) {
   const { description, tags, examples } = getJSDocComment(statement);
   const source = getSourceLocation(node, declSourceFile);
   const type = ctx.typeChecker.getTypeAtLocation(node);
-  registerReferencedTypes(type, ctx);
-  const schema = buildSchema(type, ctx.typeChecker, ctx);
+  const schemaExtraction = extractSchemaType(type, ctx.typeChecker);
+  const typeToSerialize = schemaExtraction?.outputType ?? type;
+  registerReferencedTypes(typeToSerialize, ctx);
+  const schema = buildSchema(typeToSerialize, ctx.typeChecker, ctx);
+  const flags = schemaExtraction ? {
+    schemaLibrary: schemaExtraction.adapter.id,
+    ...schemaExtraction.inputType && schemaExtraction.inputType !== schemaExtraction.outputType ? { hasTransform: true } : {}
+  } : undefined;
   return {
     id: name,
     name,
@@ -1518,13 +1693,15 @@ function serializeVariable(node, statement, ctx) {
     tags,
     source,
     schema,
+    ...flags ? { flags } : {},
     ...examples.length > 0 ? { examples } : {}
   };
 }
 
 // src/schema/standard-schema.ts
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path2 from "node:path";
 function isStandardJSONSchema(obj) {
   if (typeof obj !== "object" || obj === null)
@@ -1543,6 +1720,57 @@ function isStandardJSONSchema(obj) {
   const jsObj = jsonSchema;
   return typeof jsObj.output === "function" && typeof jsObj.input === "function";
 }
+var cachedRuntime;
+function commandExists(cmd) {
+  try {
+    const result = spawnSync(process.platform === "win32" ? "where" : "which", [cmd], {
+      stdio: "ignore"
+    });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
+function detectTsRuntime() {
+  if (cachedRuntime !== undefined) {
+    return cachedRuntime;
+  }
+  const nodeVersion = parseInt(process.versions.node.split(".")[0], 10);
+  if (nodeVersion >= 22) {
+    cachedRuntime = {
+      cmd: "node",
+      args: ["--experimental-strip-types", "--no-warnings"],
+      name: "node (native)"
+    };
+    return cachedRuntime;
+  }
+  if (commandExists("bun")) {
+    cachedRuntime = {
+      cmd: "bun",
+      args: ["run"],
+      name: "bun"
+    };
+    return cachedRuntime;
+  }
+  if (commandExists("tsx")) {
+    cachedRuntime = {
+      cmd: "tsx",
+      args: [],
+      name: "tsx"
+    };
+    return cachedRuntime;
+  }
+  if (commandExists("ts-node")) {
+    cachedRuntime = {
+      cmd: "ts-node",
+      args: ["--transpile-only"],
+      name: "ts-node"
+    };
+    return cachedRuntime;
+  }
+  cachedRuntime = null;
+  return null;
+}
 var WORKER_SCRIPT = `
 const path = require('path');
 const { pathToFileURL } = require('url');
@@ -1634,6 +1862,161 @@ async function extract() {
 
 extract();
 `;
+var TS_WORKER_SCRIPT = `
+import * as path from 'path';
+import { pathToFileURL } from 'url';
+
+// TypeBox detection
+const TYPEBOX_KIND = Symbol.for('TypeBox.Kind');
+
+function isTypeBoxSchema(obj: unknown): boolean {
+  if (!obj || typeof obj !== 'object') return false;
+  const o = obj as Record<string | symbol, unknown>;
+  if (!o[TYPEBOX_KIND]) return false;
+  return typeof o.type === 'string' || 'anyOf' in o || 'oneOf' in o || 'allOf' in o;
+}
+
+function sanitizeTypeBoxSchema(schema: unknown): unknown {
+  return JSON.parse(JSON.stringify(schema));
+}
+
+async function extract() {
+  const [,, modulePath, optionsJson] = process.argv;
+  const { target, libraryOptions } = JSON.parse(optionsJson || '{}');
+
+  try {
+    const absPath = path.resolve(modulePath);
+    const mod = await import(pathToFileURL(absPath).href);
+    const results: Array<{exportName: string; vendor: string; outputSchema: unknown; inputSchema?: unknown}> = [];
+
+    // Build exports map
+    const exports: Record<string, unknown> = {};
+    for (const [name, value] of Object.entries(mod)) {
+      if (name === 'default' && typeof value === 'object' && value !== null) {
+        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;
+
+      const v = value as Record<string, unknown>;
+      const std = v['~standard'] as Record<string, unknown> | undefined;
+
+      // Standard JSON Schema
+      if (std && typeof std === 'object' && std.version === 1 && typeof std.vendor === 'string') {
+        const jsonSchema = std.jsonSchema as Record<string, unknown> | undefined;
+        if (jsonSchema && typeof jsonSchema.output === 'function') {
+          try {
+            const options = { target: target || 'draft-2020-12', ...(libraryOptions && { libraryOptions }) };
+            const outputSchema = (jsonSchema.output as Function)(options);
+            const inputSchema = typeof jsonSchema.input === 'function' ? (jsonSchema.input as Function)(options) : undefined;
+            results.push({ exportName: name, vendor: std.vendor as string, outputSchema, inputSchema });
+          } catch {}
+          continue;
+        }
+      }
+
+      // TypeBox
+      if (isTypeBoxSchema(value)) {
+        try {
+          results.push({ exportName: name, vendor: 'typebox', outputSchema: sanitizeTypeBoxSchema(value) });
+        } catch {}
+      }
+    }
+
+    console.log(JSON.stringify({ success: true, results }));
+  } catch (e) {
+    console.log(JSON.stringify({ success: false, error: (e as Error).message }));
+  }
+}
+
+extract();
+`;
+async function extractStandardSchemasFromTs(tsFilePath, options = {}) {
+  const { timeout = 1e4, target = "draft-2020-12", libraryOptions } = options;
+  const result = {
+    schemas: new Map,
+    errors: []
+  };
+  const runtime = detectTsRuntime();
+  if (!runtime) {
+    result.errors.push("No TypeScript runtime available. Install bun, tsx, or ts-node, or use Node 22+.");
+    return result;
+  }
+  if (!fs.existsSync(tsFilePath)) {
+    result.errors.push(`TypeScript file not found: ${tsFilePath}`);
+    return result;
+  }
+  const tempDir = os.tmpdir();
+  const workerPath = path2.join(tempDir, `openpkg-extract-worker-${Date.now()}.ts`);
+  try {
+    fs.writeFileSync(workerPath, TS_WORKER_SCRIPT);
+    const optionsJson = JSON.stringify({ target, libraryOptions });
+    const args = [...runtime.args, workerPath, tsFilePath, optionsJson];
+    return await new Promise((resolve) => {
+      const child = spawn(runtime.cmd, args, {
+        timeout,
+        stdio: ["ignore", "pipe", "pipe"],
+        cwd: path2.dirname(tsFilePath)
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout.on("data", (data) => {
+        stdout += data.toString();
+      });
+      child.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      child.on("close", (code) => {
+        try {
+          fs.unlinkSync(workerPath);
+        } catch {}
+        if (code !== 0) {
+          result.errors.push(`Extraction failed (${runtime.name}): ${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) => {
+        try {
+          fs.unlinkSync(workerPath);
+        } catch {}
+        result.errors.push(`Subprocess error: ${err.message}`);
+        resolve(result);
+      });
+    });
+  } catch (e) {
+    try {
+      fs.unlinkSync(workerPath);
+    } catch {}
+    result.errors.push(`Failed to create worker script: ${e}`);
+    return result;
+  }
+}
 function readTsconfigOutDir(baseDir) {
   const tsconfigPath = path2.join(baseDir, "tsconfig.json");
   try {
@@ -1743,14 +2126,34 @@ async function extractStandardSchemas(compiledJsPath, options = {}) {
   });
 }
 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.`]
-    };
+  const { preferDirectTs, ...extractOptions } = options;
+  const isTypeScript = /\.tsx?$/.test(entryFile);
+  if (!preferDirectTs) {
+    const compiledPath = resolveCompiledPath(entryFile, baseDir);
+    if (compiledPath) {
+      const result = await extractStandardSchemas(compiledPath, extractOptions);
+      return {
+        ...result,
+        info: { method: "compiled", path: compiledPath }
+      };
+    }
   }
-  return extractStandardSchemas(compiledPath, options);
+  if (isTypeScript) {
+    const runtime2 = detectTsRuntime();
+    if (runtime2) {
+      const result = await extractStandardSchemasFromTs(entryFile, extractOptions);
+      return {
+        ...result,
+        info: { method: "direct-ts", runtime: runtime2.name, path: entryFile }
+      };
+    }
+  }
+  const runtime = detectTsRuntime();
+  const hint = isTypeScript && !runtime ? " Install bun, tsx, or ts-node for direct TS execution." : "";
+  return {
+    schemas: new Map,
+    errors: [`Could not find compiled JS for ${entryFile}.${hint}`]
+  };
 }
 
 // src/builder/spec-builder.ts
@@ -1980,35 +2383,27 @@ async function extract(options) {
   let runtimeMetadata;
   if (options.schemaExtraction === "hybrid") {
     const projectBaseDir = baseDir || path3.dirname(entryFile);
-    const compiledPath = resolveCompiledPath(entryFile, projectBaseDir);
-    if (compiledPath) {
-      const runtimeResult = await extractStandardSchemas(compiledPath, {
-        target: options.schemaTarget || "draft-2020-12",
-        timeout: 15000
-      });
-      if (runtimeResult.schemas.size > 0) {
-        const mergeResult = mergeRuntimeSchemas(exports, runtimeResult.schemas);
-        exports = mergeResult.exports;
-        runtimeMetadata = {
-          extracted: runtimeResult.schemas.size,
-          merged: mergeResult.merged,
-          vendors: [...new Set([...runtimeResult.schemas.values()].map((s) => s.vendor))],
-          errors: runtimeResult.errors
-        };
-      }
-      for (const error of runtimeResult.errors) {
-        diagnostics.push({
-          message: `Runtime schema extraction: ${error}`,
-          severity: "warning",
-          code: "RUNTIME_SCHEMA_ERROR"
-        });
-      }
-    } else {
+    const runtimeResult = await extractStandardSchemasFromProject(entryFile, projectBaseDir, {
+      target: options.schemaTarget || "draft-2020-12",
+      timeout: 15000
+    });
+    if (runtimeResult.schemas.size > 0) {
+      const mergeResult = mergeRuntimeSchemas(exports, runtimeResult.schemas);
+      exports = mergeResult.exports;
+      const method = runtimeResult.info?.method === "direct-ts" ? `direct-ts (${runtimeResult.info.runtime})` : "compiled";
+      runtimeMetadata = {
+        extracted: runtimeResult.schemas.size,
+        merged: mergeResult.merged,
+        vendors: [...new Set([...runtimeResult.schemas.values()].map((s) => s.vendor))],
+        errors: runtimeResult.errors,
+        method
+      };
+    }
+    for (const error of runtimeResult.errors) {
       diagnostics.push({
-        message: "Hybrid mode: Could not find compiled JS. Build the project first.",
+        message: `Runtime schema extraction: ${error}`,
         severity: "warning",
-        code: "NO_COMPILED_JS",
-        suggestion: "Run `npm run build` or `tsc` before extraction"
+        code: "RUNTIME_SCHEMA_ERROR"
       });
     }
   }
@@ -2358,4 +2753,4 @@ async function getPackageMeta(entryFile, baseDir) {
   } catch {}
   return { name: path3.basename(searchDir) };
 }
-export { BUILTIN_TYPE_SCHEMAS, isPrimitiveName, isBuiltinGeneric, isAnonymous, buildSchema, isPureRefSchema, withDescription, schemaIsAny, schemasAreEqual, deduplicateSchemas, findDiscriminatorProperty, TypeRegistry, getJSDocComment, getSourceLocation, getParamDescription, extractTypeParameters, isSymbolDeprecated, createProgram, extractParameters, registerReferencedTypes, serializeClass, serializeEnum, serializeFunctionExport, serializeInterface, serializeTypeAlias, serializeVariable, isStandardJSONSchema, resolveCompiledPath, extractStandardSchemas, extractStandardSchemasFromProject, extract };
+export { BUILTIN_TYPE_SCHEMAS, isPrimitiveName, isBuiltinGeneric, isAnonymous, buildSchema, isPureRefSchema, withDescription, schemaIsAny, schemasAreEqual, deduplicateSchemas, findDiscriminatorProperty, TypeRegistry, getJSDocComment, getSourceLocation, getParamDescription, extractTypeParameters, isSymbolDeprecated, createProgram, extractParameters, registerReferencedTypes, serializeClass, serializeEnum, serializeFunctionExport, serializeInterface, serializeTypeAlias, isTypeReference, getNonNullableType, registerAdapter, findAdapter, isSchemaType, extractSchemaType, arktypeAdapter, typeboxAdapter, valibotAdapter, zodAdapter, serializeVariable, isStandardJSONSchema, detectTsRuntime, extractStandardSchemasFromTs, resolveCompiledPath, extractStandardSchemas, extractStandardSchemasFromProject, extract };

package/dist/src/index.d.ts

@@ -96,6 +96,8 @@ interface ExtractResult {
 		vendors: string[];
 		/** Any errors encountered during runtime extraction */
 		errors: string[];
+		/** Extraction method used: 'compiled' or 'direct-ts (runtime)' */
+		method?: string;
 	};
 }
 interface Diagnostic {
@@ -199,6 +201,32 @@ interface StandardSchemaExtractionOutput {
 */
 declare function isStandardJSONSchema(obj: unknown): obj is StandardJSONSchemaV1;
 /**
+* TypeScript runtime configuration.
+*/
+interface TsRuntime {
+	/** Command to execute */
+	cmd: string;
+	/** Arguments to pass before the script path */
+	args: string[];
+	/** Human-readable name */
+	name: string;
+}
+/**
+* Detect available TypeScript runtime.
+* Checks in order: Node 22+ native, bun, tsx, ts-node.
+* Returns null if no TS runtime is available.
+*/
+declare function detectTsRuntime(): TsRuntime | null;
+/**
+* Extract Standard Schema from a TypeScript file directly.
+* Uses detected TS runtime (bun, tsx, ts-node, or node 22+).
+*
+* @param tsFilePath - Path to TypeScript file
+* @param options - Extraction options
+* @returns Extraction results
+*/
+declare function extractStandardSchemasFromTs(tsFilePath: string, options?: ExtractStandardSchemasOptions): Promise<StandardSchemaExtractionOutput>;
+/**
 * Resolve compiled JS path from TypeScript source.
 * Reads tsconfig.json for outDir and tries multiple output patterns.
 * Supports .js, .mjs, and .cjs extensions.
@@ -216,15 +244,42 @@ declare function resolveCompiledPath(tsPath: string, baseDir: string): string |
 */
 declare function extractStandardSchemas(compiledJsPath: string, options?: ExtractStandardSchemasOptions): Promise<StandardSchemaExtractionOutput>;
 /**
+* Result info from extractStandardSchemasFromProject
+*/
+interface ProjectExtractionInfo {
+	/** How schemas were extracted */
+	method: "compiled" | "direct-ts";
+	/** Runtime used (for direct-ts) */
+	runtime?: string;
+	/** Path that was used */
+	path: string;
+}
+/**
+* Extended options for project extraction
+*/
+interface ExtractFromProjectOptions extends ExtractStandardSchemasOptions {
+	/** Prefer direct TS execution even if compiled JS exists */
+	preferDirectTs?: boolean;
+}
+/**
+* Extended result for project extraction
+*/
+interface ProjectExtractionOutput extends StandardSchemaExtractionOutput {
+	/** Info about how extraction was performed */
+	info?: ProjectExtractionInfo;
+}
+/**
 * Extract Standard Schema from a TypeScript project.
 *
-* Convenience function that resolves compiled JS and extracts schemas.
+* Tries in order:
+* 1. Compiled JS (if found)
+* 2. Direct TypeScript execution (if TS runtime available)
 *
 * @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 extractStandardSchemasFromProject(entryFile: string, baseDir: string, options?: ExtractFromProjectOptions): Promise<ProjectExtractionOutput>;
 import ts4 from "typescript";
 interface ProgramOptions {
 	entryFile: string;
@@ -373,4 +428,4 @@ declare function findDiscriminatorProperty(unionTypes: ts12.Type[], checker: ts1
 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, TypeReference2 as TypeReference, StandardSchemaExtractionResult, StandardSchemaExtractionOutput, StandardJSONSchemaV1, StandardJSONSchemaTarget, StandardJSONSchemaOptions, SerializerContext, SchemaExtractionResult, SchemaAdapter, ProgramResult, ProgramOptions, ForgottenExport, ExtractStandardSchemasOptions, ExtractResult, ExtractOptions, Diagnostic, BUILTIN_TYPE_SCHEMAS };
+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, extractStandardSchemasFromTs, extractStandardSchemasFromProject, extractStandardSchemas, extractSchemaType, extractParameters, extract, detectTsRuntime, deduplicateSchemas, createProgram, buildSchema, arktypeAdapter, TypeRegistry, TypeReference2 as TypeReference, TsRuntime, StandardSchemaExtractionResult, StandardSchemaExtractionOutput, StandardJSONSchemaV1, StandardJSONSchemaTarget, StandardJSONSchemaOptions, SerializerContext, SchemaExtractionResult, SchemaAdapter, ProjectExtractionOutput, ProjectExtractionInfo, ProgramResult, ProgramOptions, ForgottenExport, ExtractStandardSchemasOptions, ExtractResult, ExtractOptions, ExtractFromProjectOptions, Diagnostic, BUILTIN_TYPE_SCHEMAS };

package/dist/src/index.js

@@ -1,24 +1,33 @@
 import {
   BUILTIN_TYPE_SCHEMAS,
   TypeRegistry,
+  arktypeAdapter,
   buildSchema,
   createProgram,
   deduplicateSchemas,
+  detectTsRuntime,
   extract,
   extractParameters,
+  extractSchemaType,
   extractStandardSchemas,
   extractStandardSchemasFromProject,
+  extractStandardSchemasFromTs,
   extractTypeParameters,
+  findAdapter,
   findDiscriminatorProperty,
   getJSDocComment,
+  getNonNullableType,
   getParamDescription,
   getSourceLocation,
   isAnonymous,
   isBuiltinGeneric,
   isPrimitiveName,
   isPureRefSchema,
+  isSchemaType,
   isStandardJSONSchema,
   isSymbolDeprecated,
+  isTypeReference,
+  registerAdapter,
   registerReferencedTypes,
   resolveCompiledPath,
   schemaIsAny,
@@ -29,170 +38,11 @@ import {
   serializeInterface,
   serializeTypeAlias,
   serializeVariable,
-  withDescription
-} from "../shared/chunk-yh8v9dbt.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) ?? undefined;
-  return {
-    adapter,
-    outputType,
-    inputType
-  };
-}
-
-// src/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/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/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/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/schema/adapters/index.ts
-registerAdapter(zodAdapter);
-registerAdapter(valibotAdapter);
-registerAdapter(arktypeAdapter);
-registerAdapter(typeboxAdapter);
+  typeboxAdapter,
+  valibotAdapter,
+  withDescription,
+  zodAdapter
+} from "../shared/chunk-7fp2zqf8.js";
 // src/types/utils.ts
 function isExported(node) {
   const modifiers = node.modifiers;
@@ -240,11 +90,13 @@ export {
   findDiscriminatorProperty,
   findAdapter,
   extractTypeParameters,
+  extractStandardSchemasFromTs,
   extractStandardSchemasFromProject,
   extractStandardSchemas,
   extractSchemaType,
   extractParameters,
   extract,
+  detectTsRuntime,
   deduplicateSchemas,
   createProgram,
   buildSchema,

package/package.json

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