@openpkg-ts/extract 0.21.0 → 0.22.0

package/dist/bin/tspec.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   extract
-} from "../shared/chunk-yh8v9dbt.js";
+} from "../shared/chunk-nymjpc96.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-nymjpc96.js}

@@ -1523,8 +1523,9 @@ function serializeVariable(node, statement, ctx) {
 }
 
 // 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 +1544,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 +1686,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 +1950,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 +2207,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 +2577,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, 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

@@ -4,10 +4,12 @@ import {
   buildSchema,
   createProgram,
   deduplicateSchemas,
+  detectTsRuntime,
   extract,
   extractParameters,
   extractStandardSchemas,
   extractStandardSchemasFromProject,
+  extractStandardSchemasFromTs,
   extractTypeParameters,
   findDiscriminatorProperty,
   getJSDocComment,
@@ -30,7 +32,7 @@ import {
   serializeTypeAlias,
   serializeVariable,
   withDescription
-} from "../shared/chunk-yh8v9dbt.js";
+} from "../shared/chunk-nymjpc96.js";
 // src/schema/registry.ts
 function isTypeReference(type) {
   return !!(type.flags & 524288 && type.objectFlags && type.objectFlags & 4);
@@ -240,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.21.0",
+  "version": "0.22.0",
   "description": "TypeScript export extraction to OpenPkg spec",
   "keywords": [
     "openpkg",