@openpkg-ts/extract 0.20.0 → 0.22.0

package/dist/bin/tspec.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   extract
-} from "../shared/chunk-rej3ws8m.js";
+} from "../shared/chunk-nymjpc96.js";
 
 // src/cli/spec.ts
 import * as fs from "node:fs";
@@ -451,13 +451,22 @@ function createProgram() {
     }
     fs.writeFileSync(options.output, JSON.stringify(normalized, null, 2));
     spin.success(`Extracted to ${options.output}`);
+    if (result.runtimeSchemas) {
+      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)
         continue;
       const prefix2 = diag.severity === "error" ? "✗" : diag.severity === "warning" ? "⚠" : "ℹ";
       console.log(`${prefix2} ${diag.message}`);
     }
-    summary().addKeyValue("Exports", normalized.exports.length).addKeyValue("Types", normalized.types?.length || 0).print();
+    const sum = summary().addKeyValue("Exports", normalized.exports.length).addKeyValue("Types", normalized.types?.length || 0);
+    if (result.runtimeSchemas) {
+      sum.addKeyValue("Runtime Schemas", result.runtimeSchemas.merged);
+    }
+    sum.print();
   });
   return program;
 }

package/dist/shared/{chunk-rej3ws8m.js → chunk-nymjpc96.js}

@@ -164,8 +164,8 @@ function buildSchema(type, checker, ctx, _depth = 0) {
     return { type: "number", enum: [literal] };
   }
   if (type.flags & ts.TypeFlags.BooleanLiteral) {
-    const intrinsicName = type.intrinsicName;
-    return { type: "boolean", enum: [intrinsicName === "true"] };
+    const typeString = checker.typeToString(type);
+    return { type: "boolean", enum: [typeString === "true"] };
   }
   if (type.isUnion()) {
     const types = type.types;
@@ -329,6 +329,9 @@ function isPureRefSchema(schema) {
   return typeof schema === "object" && Object.keys(schema).length === 1 && "$ref" in schema;
 }
 function withDescription(schema, description) {
+  if (typeof schema === "string") {
+    return { type: schema, description };
+  }
   if (isPureRefSchema(schema)) {
     return {
       allOf: [schema],
@@ -702,9 +705,9 @@ function getJSDocComment(node) {
     }
     return { name: tag.tagName.text, text: rawText };
   });
-  const jsDocComments = node.jsDoc;
+  const jsDocComments = ts3.getJSDocCommentsAndTags(node).filter(ts3.isJSDoc);
   let description;
-  if (jsDocComments && jsDocComments.length > 0) {
+  if (jsDocComments.length > 0) {
     const firstDoc = jsDocComments[0];
     if (firstDoc.comment) {
       description = typeof firstDoc.comment === "string" ? firstDoc.comment : ts3.getTextOfJSDocComment(firstDoc.comment);
@@ -1076,7 +1079,7 @@ function getMemberName(member) {
   return member.name.getText();
 }
 function getVisibility(member) {
-  const modifiers = ts6.getModifiers(member);
+  const modifiers = ts6.canHaveModifiers(member) ? ts6.getModifiers(member) : undefined;
   if (!modifiers)
     return;
   for (const mod of modifiers) {
@@ -1090,11 +1093,11 @@ function getVisibility(member) {
   return;
 }
 function isStatic(member) {
-  const modifiers = ts6.getModifiers(member);
+  const modifiers = ts6.canHaveModifiers(member) ? ts6.getModifiers(member) : undefined;
   return modifiers?.some((m) => m.kind === ts6.SyntaxKind.StaticKeyword) ?? false;
 }
 function isReadonly(member) {
-  const modifiers = ts6.getModifiers(member);
+  const modifiers = ts6.canHaveModifiers(member) ? ts6.getModifiers(member) : undefined;
   return modifiers?.some((m) => m.kind === ts6.SyntaxKind.ReadonlyKeyword) ?? false;
 }
 function serializeProperty(node, ctx) {
@@ -1463,7 +1466,7 @@ function getInterfaceExtends(node, checker) {
         const type = checker.getTypeAtLocation(expr);
         return type.getSymbol()?.getName() ?? expr.expression.getText();
       });
-      return names.length === 1 ? names[0] : names;
+      return names.join(" & ");
     }
   }
   return;
@@ -1519,9 +1522,467 @@ function serializeVariable(node, statement, ctx) {
   };
 }
 
-// src/builder/spec-builder.ts
+// src/schema/standard-schema.ts
+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)
+    return false;
+  const std = obj["~standard"];
+  if (typeof std !== "object" || std === null)
+    return false;
+  const stdObj = std;
+  if (stdObj.version !== 1)
+    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" && 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');
+
+// 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, optionsJson] = process.argv.slice(1);
+  const { target, libraryOptions } = JSON.parse(optionsJson || '{}');
+
+  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 JSON Schema (Zod 4.2+, ArkType 2.1.28+, Valibot 1.2+)
+      const std = value['~standard'];
+      if (std && typeof std === 'object' && std.version === 1 && typeof std.vendor === 'string' && std.jsonSchema && typeof std.jsonSchema.output === 'function') {
+        try {
+          // Per spec: pass options object with target and optional libraryOptions
+          const options = { target: target || 'draft-2020-12', ...(libraryOptions && { libraryOptions }) };
+          const outputSchema = std.jsonSchema.output(options);
+          const inputSchema = typeof std.jsonSchema.input === 'function' ? std.jsonSchema.input(options) : 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();
+`;
+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 {
+    if (!fs.existsSync(tsconfigPath)) {
+      return null;
+    }
+    const content = fs.readFileSync(tsconfigPath, "utf-8");
+    const stripped = content.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "");
+    const tsconfig = JSON.parse(stripped);
+    if (tsconfig.compilerOptions?.outDir) {
+      return tsconfig.compilerOptions.outDir.replace(/^\.\//, "");
+    }
+  } catch {}
+  return null;
+}
+function resolveCompiledPath(tsPath, baseDir) {
+  const relativePath = path2.relative(baseDir, tsPath);
+  const withoutExt = relativePath.replace(/\.tsx?$/, "");
+  const srcPrefix = withoutExt.replace(/^src\//, "");
+  const tsconfigOutDir = readTsconfigOutDir(baseDir);
+  const extensions = [".js", ".mjs", ".cjs"];
+  const candidates = [];
+  if (tsconfigOutDir) {
+    for (const ext of extensions) {
+      candidates.push(path2.join(baseDir, tsconfigOutDir, `${srcPrefix}${ext}`));
+    }
+  }
+  const commonOutDirs = ["dist", "build", "lib", "out"];
+  for (const outDir of commonOutDirs) {
+    if (outDir === tsconfigOutDir)
+      continue;
+    for (const ext of extensions) {
+      candidates.push(path2.join(baseDir, outDir, `${srcPrefix}${ext}`));
+    }
+  }
+  for (const ext of extensions) {
+    candidates.push(path2.join(baseDir, `${withoutExt}${ext}`));
+  }
+  const workspaceMatch = baseDir.match(/^(.+\/packages\/[^/]+)$/);
+  if (workspaceMatch) {
+    const pkgRoot = workspaceMatch[1];
+    for (const ext of extensions) {
+      candidates.push(path2.join(pkgRoot, "dist", `${srcPrefix}${ext}`));
+    }
+  }
+  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", libraryOptions } = options;
+  const result = {
+    schemas: new Map,
+    errors: []
+  };
+  if (!fs.existsSync(compiledJsPath)) {
+    result.errors.push(`Compiled JS not found: ${compiledJsPath}`);
+    return result;
+  }
+  const optionsJson = JSON.stringify({ target, libraryOptions });
+  return new Promise((resolve) => {
+    const child = spawn("node", ["-e", WORKER_SCRIPT, compiledJsPath, optionsJson], {
+      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 { 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 }
+      };
+    }
+  }
+  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
+import * as fs2 from "node:fs";
+import * as path3 from "node:path";
 import { SCHEMA_URL, SCHEMA_VERSION } from "@openpkg-ts/spec";
 import ts8 from "typescript";
 
@@ -1541,6 +2002,34 @@ function createContext(program, sourceFile, options = {}) {
   };
 }
 
+// src/builder/schema-merger.ts
+function mergeRuntimeSchemas(staticExports, runtimeSchemas) {
+  let merged = 0;
+  const exports = staticExports.map((exp) => {
+    const runtime = runtimeSchemas.get(exp.name);
+    if (!runtime)
+      return exp;
+    merged++;
+    const mergedExport = {
+      ...exp,
+      schema: runtime.outputSchema,
+      tags: [
+        ...exp.tags || [],
+        { name: "vendor", text: runtime.vendor },
+        { name: "schema-source", text: "standard-json-schema" }
+      ]
+    };
+    if (runtime.inputSchema && JSON.stringify(runtime.inputSchema) !== JSON.stringify(runtime.outputSchema)) {
+      mergedExport.flags = {
+        ...mergedExport.flags,
+        inputSchema: runtime.inputSchema
+      };
+    }
+    return mergedExport;
+  });
+  return { merged, exports };
+}
+
 // src/builder/spec-builder.ts
 var BUILTIN_TYPES2 = new Set([
   "Array",
@@ -1638,7 +2127,7 @@ async function extract(options) {
     ignore
   } = options;
   const diagnostics = [];
-  const exports = [];
+  let exports = [];
   const result = createProgram({ entryFile, baseDir, content });
   const { program, sourceFile } = result;
   if (!sourceFile) {
@@ -1715,6 +2204,33 @@ async function extract(options) {
       code: "EXTERNAL_TYPES"
     });
   }
+  let runtimeMetadata;
+  if (options.schemaExtraction === "hybrid") {
+    const projectBaseDir = baseDir || path3.dirname(entryFile);
+    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: `Runtime schema extraction: ${error}`,
+        severity: "warning",
+        code: "RUNTIME_SCHEMA_ERROR"
+      });
+    }
+  }
   const spec = {
     ...includeSchema ? { $schema: SCHEMA_URL } : {},
     openpkg: SCHEMA_VERSION,
@@ -1723,14 +2239,16 @@ async function extract(options) {
     types,
     generation: {
       generator: "@openpkg-ts/extract",
-      timestamp: new Date().toISOString()
+      timestamp: new Date().toISOString(),
+      ...options.schemaExtraction === "hybrid" ? { schemaExtraction: "hybrid" } : {}
     }
   };
   const internalForgotten = forgottenExports.filter((f) => !f.isExternal);
   return {
     spec,
     diagnostics,
-    ...internalForgotten.length > 0 ? { forgottenExports: internalForgotten } : {}
+    ...internalForgotten.length > 0 ? { forgottenExports: internalForgotten } : {},
+    ...runtimeMetadata ? { runtimeSchemas: runtimeMetadata } : {}
   };
 }
 function collectAllRefsWithContext(obj, refs, state) {
@@ -2036,7 +2554,7 @@ function createEmptySpec(entryFile, includeSchema) {
   return {
     ...includeSchema ? { $schema: SCHEMA_URL } : {},
     openpkg: SCHEMA_VERSION,
-    meta: { name: path2.basename(entryFile, path2.extname(entryFile)) },
+    meta: { name: path3.basename(entryFile, path3.extname(entryFile)) },
     exports: [],
     generation: {
       generator: "@openpkg-ts/extract",
@@ -2045,18 +2563,18 @@ function createEmptySpec(entryFile, includeSchema) {
   };
 }
 async function getPackageMeta(entryFile, baseDir) {
-  const searchDir = baseDir ?? path2.dirname(entryFile);
-  const pkgPath = path2.join(searchDir, "package.json");
+  const searchDir = baseDir ?? path3.dirname(entryFile);
+  const pkgPath = path3.join(searchDir, "package.json");
   try {
-    if (fs.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    if (fs2.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf-8"));
       return {
-        name: pkg.name ?? path2.basename(searchDir),
+        name: pkg.name ?? path3.basename(searchDir),
         version: pkg.version,
         description: pkg.description
       };
     }
   } catch {}
-  return { name: path2.basename(searchDir) };
+  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, 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, serializeVariable, isStandardJSONSchema, detectTsRuntime, extractStandardSchemasFromTs, resolveCompiledPath, extractStandardSchemas, extractStandardSchemasFromProject, extract };

package/dist/src/index.d.ts

@@ -73,6 +73,8 @@ interface ExtractOptions {
 	maxExternalTypeDepth?: number;
 	resolveExternalTypes?: boolean;
 	schemaExtraction?: "static" | "hybrid";
+	/** Target JSON Schema dialect for runtime schema extraction */
+	schemaTarget?: "draft-2020-12" | "draft-07" | "openapi-3.0";
 	/** Include $schema URL in output */
 	includeSchema?: boolean;
 	/** Only extract these exports (supports * wildcards) */
@@ -84,6 +86,19 @@ interface ExtractResult {
 	spec: OpenPkg;
 	diagnostics: Diagnostic[];
 	forgottenExports?: ForgottenExport[];
+	/** Metadata about runtime schema extraction (when schemaExtraction: 'hybrid') */
+	runtimeSchemas?: {
+		/** Number of schema exports found */
+		extracted: number;
+		/** Number of schemas successfully merged with static types */
+		merged: number;
+		/** Schema vendors detected (e.g., 'zod', 'arktype', 'valibot', 'typebox') */
+		vendors: string[];
+		/** Any errors encountered during runtime extraction */
+		errors: string[];
+		/** Extraction method used: 'compiled' or 'direct-ts (runtime)' */
+		method?: string;
+	};
 }
 interface Diagnostic {
 	message: string;
@@ -112,73 +127,6 @@ interface ForgottenExport {
 	fix?: string;
 }
 declare function extract(options: ExtractOptions): Promise<ExtractResult>;
-import ts4 from "typescript";
-interface ProgramOptions {
-	entryFile: string;
-	baseDir?: string;
-	content?: string;
-}
-interface ProgramResult {
-	program: ts4.Program;
-	compilerHost: ts4.CompilerHost;
-	compilerOptions: ts4.CompilerOptions;
-	sourceFile?: ts4.SourceFile;
-	configPath?: string;
-}
-declare function createProgram({ entryFile, baseDir, content }: ProgramOptions): ProgramResult;
-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(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;
 /**
 * Target version for JSON Schema generation.
 * @see https://standardschema.dev/json-schema
@@ -253,8 +201,35 @@ 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.
-* Tries common output locations: dist/, build/, lib/, same dir.
+* Reads tsconfig.json for outDir and tries multiple output patterns.
+* Supports .js, .mjs, and .cjs extensions.
 */
 declare function resolveCompiledPath(tsPath: string, baseDir: string): string | null;
 /**
@@ -269,33 +244,127 @@ 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>;
-import { SpecExport } from "@openpkg-ts/spec";
-import ts5 from "typescript";
-declare function serializeClass(node: ts5.ClassDeclaration, ctx: SerializerContext): SpecExport | null;
+declare function extractStandardSchemasFromProject(entryFile: string, baseDir: string, options?: ExtractFromProjectOptions): Promise<ProjectExtractionOutput>;
+import ts4 from "typescript";
+interface ProgramOptions {
+	entryFile: string;
+	baseDir?: string;
+	content?: string;
+}
+interface ProgramResult {
+	program: ts4.Program;
+	compilerHost: ts4.CompilerHost;
+	compilerOptions: ts4.CompilerOptions;
+	sourceFile?: ts4.SourceFile;
+	configPath?: string;
+}
+declare function createProgram({ entryFile, baseDir, content }: ProgramOptions): ProgramResult;
+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(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 { SpecExport as SpecExport2 } from "@openpkg-ts/spec";
-import ts6 from "typescript";
-declare function serializeEnum(node: ts6.EnumDeclaration, ctx: SerializerContext): SpecExport2 | null;
+import ts5 from "typescript";
+declare function serializeClass(node: ts5.ClassDeclaration, ctx: SerializerContext): SpecExport2 | null;
 import { SpecExport as SpecExport3 } from "@openpkg-ts/spec";
-import ts7 from "typescript";
-declare function serializeFunctionExport(node: ts7.FunctionDeclaration | ts7.ArrowFunction, ctx: SerializerContext): SpecExport3 | null;
+import ts6 from "typescript";
+declare function serializeEnum(node: ts6.EnumDeclaration, ctx: SerializerContext): SpecExport3 | null;
 import { SpecExport as SpecExport4 } from "@openpkg-ts/spec";
-import ts8 from "typescript";
-declare function serializeInterface(node: ts8.InterfaceDeclaration, ctx: SerializerContext): SpecExport4 | null;
+import ts7 from "typescript";
+declare function serializeFunctionExport(node: ts7.FunctionDeclaration | ts7.ArrowFunction, ctx: SerializerContext): SpecExport4 | null;
 import { SpecExport as SpecExport5 } from "@openpkg-ts/spec";
-import ts9 from "typescript";
-declare function serializeTypeAlias(node: ts9.TypeAliasDeclaration, ctx: SerializerContext): SpecExport5 | null;
+import ts8 from "typescript";
+declare function serializeInterface(node: ts8.InterfaceDeclaration, ctx: SerializerContext): SpecExport5 | null;
 import { SpecExport as SpecExport6 } from "@openpkg-ts/spec";
+import ts9 from "typescript";
+declare function serializeTypeAlias(node: ts9.TypeAliasDeclaration, ctx: SerializerContext): SpecExport6 | null;
+import { SpecExport as SpecExport7 } from "@openpkg-ts/spec";
 import ts10 from "typescript";
-declare function serializeVariable(node: ts10.VariableDeclaration, statement: ts10.VariableStatement, ctx: SerializerContext): SpecExport6 | null;
+declare function serializeVariable(node: ts10.VariableDeclaration, statement: ts10.VariableStatement, ctx: SerializerContext): SpecExport7 | null;
 import { SpecSignatureParameter } from "@openpkg-ts/spec";
 import ts11 from "typescript";
 declare function extractParameters(signature: ts11.Signature, ctx: SerializerContext): SpecSignatureParameter[];
@@ -359,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

@@ -4,8 +4,12 @@ import {
   buildSchema,
   createProgram,
   deduplicateSchemas,
+  detectTsRuntime,
   extract,
   extractParameters,
+  extractStandardSchemas,
+  extractStandardSchemasFromProject,
+  extractStandardSchemasFromTs,
   extractTypeParameters,
   findDiscriminatorProperty,
   getJSDocComment,
@@ -15,8 +19,10 @@ import {
   isBuiltinGeneric,
   isPrimitiveName,
   isPureRefSchema,
+  isStandardJSONSchema,
   isSymbolDeprecated,
   registerReferencedTypes,
+  resolveCompiledPath,
   schemaIsAny,
   schemasAreEqual,
   serializeClass,
@@ -26,7 +32,7 @@ import {
   serializeTypeAlias,
   serializeVariable,
   withDescription
-} from "../shared/chunk-rej3ws8m.js";
+} from "../shared/chunk-nymjpc96.js";
 // src/schema/registry.ts
 function isTypeReference(type) {
   return !!(type.flags & 524288 && type.objectFlags && type.objectFlags & 4);
@@ -57,7 +63,7 @@ function extractSchemaType(type, checker) {
   const outputType = adapter.extractOutputType(type, checker);
   if (!outputType)
     return null;
-  const inputType = adapter.extractInputType?.(type, checker);
+  const inputType = adapter.extractInputType?.(type, checker) ?? undefined;
   return {
     adapter,
     outputType,
@@ -189,200 +195,6 @@ 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 (stdObj.version !== 1)
-    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" && typeof jsObj.input === "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, optionsJson] = process.argv.slice(1);
-  const { target, libraryOptions } = JSON.parse(optionsJson || '{}');
-
-  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 JSON Schema (Zod 4.2+, ArkType 2.1.28+, Valibot 1.2+)
-      const std = value['~standard'];
-      if (std && typeof std === 'object' && std.version === 1 && typeof std.vendor === 'string' && std.jsonSchema && typeof std.jsonSchema.output === 'function') {
-        try {
-          // Per spec: pass options object with target and optional libraryOptions
-          const options = { target: target || 'draft-2020-12', ...(libraryOptions && { libraryOptions }) };
-          const outputSchema = std.jsonSchema.output(options);
-          const inputSchema = typeof std.jsonSchema.input === 'function' ? std.jsonSchema.input(options) : 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", libraryOptions } = options;
-  const result = {
-    schemas: new Map,
-    errors: []
-  };
-  if (!fs.existsSync(compiledJsPath)) {
-    result.errors.push(`Compiled JS not found: ${compiledJsPath}`);
-    return result;
-  }
-  const optionsJson = JSON.stringify({ target, libraryOptions });
-  return new Promise((resolve) => {
-    const child = spawn("node", ["-e", WORKER_SCRIPT, compiledJsPath, optionsJson], {
-      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/types/utils.ts
 function isExported(node) {
   const modifiers = node.modifiers;
@@ -430,11 +242,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.20.0",
+  "version": "0.22.0",
   "description": "TypeScript export extraction to OpenPkg spec",
   "keywords": [
     "openpkg",