@openpkg-ts/extract 0.23.2 → 0.24.1

package/dist/shared/{chunk-8898fs2f.js → chunk-2fes3xf8.js}

@@ -89,9 +89,76 @@ var BUILTIN_TYPES = new Set([
   "BigInt64Array",
   "BigUint64Array"
 ]);
+var ARRAY_PROTOTYPE_METHODS = new Set([
+  "pop",
+  "push",
+  "shift",
+  "unshift",
+  "splice",
+  "sort",
+  "reverse",
+  "fill",
+  "copyWithin",
+  "concat",
+  "join",
+  "slice",
+  "indexOf",
+  "lastIndexOf",
+  "includes",
+  "find",
+  "findIndex",
+  "findLast",
+  "findLastIndex",
+  "filter",
+  "map",
+  "reduce",
+  "reduceRight",
+  "every",
+  "some",
+  "flat",
+  "flatMap",
+  "forEach",
+  "entries",
+  "keys",
+  "values",
+  "at",
+  "with",
+  "toReversed",
+  "toSorted",
+  "toSpliced",
+  "length",
+  Symbol.iterator.toString(),
+  "toString",
+  "toLocaleString"
+]);
 function isPrimitiveName(name) {
   return PRIMITIVES.has(name);
 }
+function isBuiltinSymbol(symbol) {
+  if (!symbol)
+    return false;
+  const declarations = symbol.getDeclarations();
+  if (!declarations || declarations.length === 0)
+    return false;
+  const sourceFile = declarations[0].getSourceFile();
+  const fileName = sourceFile.fileName;
+  return fileName.includes("/typescript/lib/lib.") || fileName.includes("\\typescript\\lib\\lib.");
+}
+function getTypeOrigin(type, _checker) {
+  const symbol = type.getSymbol() ?? type.aliasSymbol;
+  if (!symbol)
+    return;
+  const declarations = symbol.getDeclarations();
+  if (!declarations || declarations.length === 0)
+    return;
+  const fileName = declarations[0].getSourceFile().fileName;
+  const match = fileName.match(/node_modules\/(@[^/]+\/[^/]+|[^/]+)/);
+  if (!match)
+    return;
+  if (match[1] === "typescript")
+    return;
+  return match[1];
+}
 function isBuiltinGeneric(name) {
   return BUILTIN_GENERICS.has(name);
 }
@@ -170,8 +237,8 @@ function buildSchema(type, checker, ctx, _depth = 0) {
     return { type: "number", enum: [literal] };
   }
   if (type.flags & ts.TypeFlags.BooleanLiteral) {
-    const typeString = checker.typeToString(type);
-    return { type: "boolean", enum: [typeString === "true"] };
+    const typeString2 = checker.typeToString(type);
+    return { type: "boolean", enum: [typeString2 === "true"] };
   }
   if (type.isUnion()) {
     const types = type.types;
@@ -193,12 +260,27 @@ function buildSchema(type, checker, ctx, _depth = 0) {
     return { anyOf: types.map((t) => buildSchema(t, checker, ctx)) };
   }
   if (type.isIntersection()) {
+    const filteredTypes = type.types.filter((t) => !(t.flags & ts.TypeFlags.Never));
+    if (filteredTypes.length === 0) {
+      return { type: "never" };
+    }
+    if (filteredTypes.length === 1) {
+      return buildSchema(filteredTypes[0], checker, ctx);
+    }
     if (ctx) {
       return withDepth(ctx, () => ({
-        allOf: type.types.map((t) => buildSchema(t, checker, ctx))
+        allOf: filteredTypes.map((t) => buildSchema(t, checker, ctx))
       }));
     }
-    return { allOf: type.types.map((t) => buildSchema(t, checker, ctx)) };
+    return { allOf: filteredTypes.map((t) => buildSchema(t, checker, ctx)) };
+  }
+  const typeString = checker.typeToString(type);
+  if (typeString === "never[]" || typeString === "[]") {
+    return { type: "array", prefixedItems: [], minItems: 0, maxItems: 0 };
+  }
+  const symbol = type.getSymbol() || type.aliasSymbol;
+  if (symbol?.getName() === "Array" && isBuiltinSymbol(symbol)) {
+    return { type: "array", items: {} };
   }
   if (checker.isArrayType(type)) {
     const typeRef2 = type;
@@ -218,12 +300,20 @@ function buildSchema(type, checker, ctx, _depth = 0) {
     const typeRef2 = type;
     const elementTypes = typeRef2.typeArguments ?? [];
     if (ctx) {
-      return withDepth(ctx, () => ({
-        type: "array",
-        prefixedItems: elementTypes.map((t) => buildSchema(t, checker, ctx)),
-        minItems: elementTypes.length,
-        maxItems: elementTypes.length
-      }));
+      return withDepth(ctx, () => {
+        const prevInTupleElement = ctx.inTupleElement;
+        ctx.inTupleElement = true;
+        try {
+          return {
+            type: "array",
+            prefixedItems: elementTypes.map((t) => buildSchema(t, checker, ctx)),
+            minItems: elementTypes.length,
+            maxItems: elementTypes.length
+          };
+        } finally {
+          ctx.inTupleElement = prevInTupleElement;
+        }
+      });
     }
     return {
       type: "array",
@@ -240,16 +330,27 @@ function buildSchema(type, checker, ctx, _depth = 0) {
       return { $ref: `#/types/${name}` };
     }
     if (name && (isBuiltinGeneric(name) || !isAnonymous(typeRef.target))) {
+      const packageOrigin = getTypeOrigin(typeRef.target, checker);
       if (ctx) {
-        return withDepth(ctx, () => ({
-          $ref: `#/types/${name}`,
-          typeArguments: typeRef.typeArguments.map((t) => buildSchema(t, checker, ctx))
-        }));
+        return withDepth(ctx, () => {
+          const schema2 = {
+            $ref: `#/types/${name}`,
+            typeArguments: typeRef.typeArguments.map((t) => buildSchema(t, checker, ctx))
+          };
+          if (packageOrigin) {
+            schema2["x-ts-package"] = packageOrigin;
+          }
+          return schema2;
+        });
       }
-      return {
+      const schema = {
         $ref: `#/types/${name}`,
         typeArguments: typeRef.typeArguments.map((t) => buildSchema(t, checker, ctx))
       };
+      if (packageOrigin) {
+        schema["x-ts-package"] = packageOrigin;
+      }
+      return schema;
     }
   }
   if (type.flags & ts.TypeFlags.Object) {
@@ -258,7 +359,6 @@ function buildSchema(type, checker, ctx, _depth = 0) {
       return buildFunctionSchema(callSignatures, checker, ctx);
     }
   }
-  const symbol = type.getSymbol() || type.aliasSymbol;
   if (symbol && !isAnonymous(type)) {
     const name = symbol.getName();
     if (isPrimitiveName(name)) {
@@ -268,7 +368,12 @@ function buildSchema(type, checker, ctx, _depth = 0) {
       return { $ref: `#/types/${name}` };
     }
     if (!name.startsWith("__")) {
-      return { $ref: `#/types/${name}` };
+      const packageOrigin = getTypeOrigin(type, checker);
+      const schema = { $ref: `#/types/${name}` };
+      if (packageOrigin) {
+        schema["x-ts-package"] = packageOrigin;
+      }
+      return schema;
     }
   }
   if (type.flags & ts.TypeFlags.Object) {
@@ -314,6 +419,9 @@ function buildObjectSchema(properties, checker, ctx) {
       const propName = prop.getName();
       if (propName.startsWith("_"))
         continue;
+      if (ARRAY_PROTOTYPE_METHODS.has(propName)) {
+        continue;
+      }
       const propType = checker.getTypeOfSymbol(prop);
       props[propName] = buildSchema(propType, checker, ctx);
       if (!(prop.flags & ts.SymbolFlags.Optional)) {
@@ -632,6 +740,8 @@ class TypeRegistry {
       const propName = prop.getName();
       if (propName.startsWith("_"))
         continue;
+      if (ARRAY_PROTOTYPE_METHODS.has(propName))
+        continue;
       const propType = checker.getTypeOfSymbol(prop);
       this.registerType(propType, ctx);
       props[propName] = buildSchema(propType, checker, ctx);
@@ -685,6 +795,42 @@ function stripTypeParamSeparator(text) {
   }
   return text.trim() || undefined;
 }
+function extractSeeTagText(tag) {
+  const fullText = tag.getText();
+  const seeMatch = fullText.match(/@see\s+(.+?)(?:\s*\*\s*@|\s*\*\/|$)/s);
+  if (seeMatch) {
+    let text = seeMatch[1].trim();
+    text = text.replace(/\s*\*\s*$/gm, "").trim();
+    if (text)
+      return text;
+  }
+  if (tag.comment) {
+    if (typeof tag.comment === "string") {
+      if (!tag.comment.startsWith("://")) {
+        return tag.comment;
+      }
+    }
+    if (Array.isArray(tag.comment)) {
+      const parts = [];
+      for (const part of tag.comment) {
+        if (ts3.isJSDocLink(part) || ts3.isJSDocLinkCode(part) || ts3.isJSDocLinkPlain(part)) {
+          if (part.name) {
+            parts.push(part.name.getText());
+          }
+          if (part.text) {
+            parts.push(part.text);
+          }
+        } else if (part.kind === ts3.SyntaxKind.JSDocText) {
+          parts.push(part.text);
+        }
+      }
+      const result = parts.join("").trim();
+      if (result && !result.startsWith("://"))
+        return result;
+    }
+  }
+  return typeof tag.comment === "string" ? tag.comment : ts3.getTextOfJSDocComment(tag.comment) ?? "";
+}
 function getJSDocComment(node) {
   const jsDocTags = ts3.getJSDocTags(node);
   const tags = jsDocTags.map((tag) => {
@@ -709,6 +855,10 @@ function getJSDocComment(node) {
       const text = stripTypeParamSeparator(rawText) ?? "";
       return { name: tag.tagName.text, text };
     }
+    if (tag.tagName.text === "see") {
+      const text = extractSeeTagText(tag);
+      return { name: tag.tagName.text, text };
+    }
     return { name: tag.tagName.text, text: rawText };
   });
   const jsDocComments = ts3.getJSDocCommentsAndTags(node).filter(ts3.isJSDoc);
@@ -759,10 +909,33 @@ function extractTypeParameters(node, checker) {
       const defType = checker.getTypeAtLocation(tp.default);
       defaultType = checker.typeToString(defType);
     }
+    let variance;
+    let isConst;
+    const modifiers = ts3.getModifiers(tp);
+    if (modifiers) {
+      let hasIn = false;
+      let hasOut = false;
+      for (const mod of modifiers) {
+        if (mod.kind === ts3.SyntaxKind.InKeyword)
+          hasIn = true;
+        if (mod.kind === ts3.SyntaxKind.OutKeyword)
+          hasOut = true;
+        if (mod.kind === ts3.SyntaxKind.ConstKeyword)
+          isConst = true;
+      }
+      if (hasIn && hasOut)
+        variance = "inout";
+      else if (hasIn)
+        variance = "in";
+      else if (hasOut)
+        variance = "out";
+    }
     return {
       name,
       ...constraint ? { constraint } : {},
-      ...defaultType ? { default: defaultType } : {}
+      ...defaultType ? { default: defaultType } : {},
+      ...variance ? { variance } : {},
+      ...isConst ? { const: isConst } : {}
     };
   });
 }
@@ -781,6 +954,67 @@ function isSymbolDeprecated(symbol) {
   }
   return false;
 }
+function getJSDocForSignature(signature) {
+  const decl = signature.getDeclaration();
+  if (!decl) {
+    return { tags: [], examples: [] };
+  }
+  return getJSDocComment(decl);
+}
+function extractTypeParametersFromSignature(signature, checker) {
+  const typeParams = signature.getTypeParameters();
+  if (!typeParams || typeParams.length === 0) {
+    return;
+  }
+  return typeParams.map((tp) => {
+    const name = tp.getSymbol()?.getName() ?? "T";
+    let constraint;
+    const constraintType = tp.getConstraint();
+    if (constraintType) {
+      constraint = checker.typeToString(constraintType);
+    }
+    let defaultType;
+    const defaultT = tp.getDefault();
+    if (defaultT) {
+      defaultType = checker.typeToString(defaultT);
+    }
+    let variance;
+    let isConst;
+    const tpSymbol = tp.getSymbol();
+    const declarations = tpSymbol?.getDeclarations() ?? [];
+    for (const decl of declarations) {
+      if (ts3.isTypeParameterDeclaration(decl)) {
+        const modifiers = ts3.getModifiers(decl);
+        if (modifiers) {
+          let hasIn = false;
+          let hasOut = false;
+          for (const mod of modifiers) {
+            if (mod.kind === ts3.SyntaxKind.InKeyword)
+              hasIn = true;
+            if (mod.kind === ts3.SyntaxKind.OutKeyword)
+              hasOut = true;
+            if (mod.kind === ts3.SyntaxKind.ConstKeyword)
+              isConst = true;
+          }
+          if (hasIn && hasOut)
+            variance = "inout";
+          else if (hasIn)
+            variance = "in";
+          else if (hasOut)
+            variance = "out";
+        }
+        break;
+      }
+    }
+    return {
+      name,
+      ...constraint ? { constraint } : {},
+      ...defaultType ? { default: defaultType } : {},
+      ...variance ? { variance } : {},
+      ...isConst ? { const: isConst } : {}
+    };
+  });
+}
 
 // src/compiler/program.ts
 import * as path from "node:path";
@@ -855,160 +1089,762 @@ function createProgram({
   };
 }
 
-// src/types/parameters.ts
-import ts5 from "typescript";
-function extractParameters(signature, ctx) {
-  const { typeChecker: checker } = ctx;
-  const result = [];
-  const signatureDecl = signature.getDeclaration();
-  const jsdocTags = signatureDecl ? ts5.getJSDocTags(signatureDecl) : [];
-  for (const param of signature.getParameters()) {
-    const decl = param.valueDeclaration;
-    const type = checker.getTypeOfSymbolAtLocation(param, decl ?? param.valueDeclaration);
-    if (decl && ts5.isObjectBindingPattern(decl.name)) {
-      const expandedParams = expandBindingPattern(decl, type, jsdocTags, ctx);
-      result.push(...expandedParams);
-    } else {
-      registerReferencedTypes(type, ctx);
-      result.push({
-        name: param.getName(),
-        schema: buildSchema(type, checker, ctx),
-        required: !(param.flags & 16777216)
-      });
-    }
-  }
-  return result;
-}
-function expandBindingPattern(paramDecl, paramType, jsdocTags, ctx) {
-  const { typeChecker: checker } = ctx;
-  const result = [];
-  const bindingPattern = paramDecl.name;
-  const allProperties = getEffectiveProperties(paramType, checker);
-  const inferredAlias = inferParamAlias(jsdocTags);
-  for (const element of bindingPattern.elements) {
-    if (!ts5.isBindingElement(element))
-      continue;
-    const propertyName = element.propertyName ? ts5.isIdentifier(element.propertyName) ? element.propertyName.text : element.propertyName.getText() : ts5.isIdentifier(element.name) ? element.name.text : element.name.getText();
-    const propSymbol = allProperties.get(propertyName);
-    if (!propSymbol)
-      continue;
-    const propType = checker.getTypeOfSymbol(propSymbol);
-    registerReferencedTypes(propType, ctx);
-    const isOptional = !!(propSymbol.flags & ts5.SymbolFlags.Optional) || element.initializer !== undefined;
-    const description = getParamDescription(propertyName, jsdocTags, inferredAlias);
-    const param = {
-      name: propertyName,
-      schema: buildSchema(propType, checker, ctx),
-      required: !isOptional
-    };
-    if (description) {
-      param.description = description;
-    }
-    if (element.initializer) {
-      param.default = extractDefaultValue(element.initializer);
-    }
-    result.push(param);
-  }
-  return result;
-}
-function getEffectiveProperties(type, _checker) {
-  const properties = new Map;
-  if (type.isIntersection()) {
-    for (const subType of type.types) {
-      for (const prop of subType.getProperties()) {
-        properties.set(prop.getName(), prop);
-      }
-    }
-  } else {
-    for (const prop of type.getProperties()) {
-      properties.set(prop.getName(), prop);
-    }
-  }
-  return properties;
+// 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";
 }
-function inferParamAlias(jsdocTags) {
-  const prefixes = [];
-  for (const tag of jsdocTags) {
-    if (tag.tagName.text !== "param")
-      continue;
-    const tagText = typeof tag.comment === "string" ? tag.comment : ts5.getTextOfJSDocComment(tag.comment) ?? "";
-    const paramTag = tag;
-    const paramName = paramTag.name?.getText() ?? "";
-    if (paramName.includes(".")) {
-      const prefix = paramName.split(".")[0];
-      if (prefix && !prefix.startsWith("__")) {
-        prefixes.push(prefix);
-      }
-    } else if (tagText.includes(".")) {
-      const match = tagText.match(/^(\w+)\./);
-      if (match && !match[1].startsWith("__")) {
-        prefixes.push(match[1]);
-      }
-    }
+var cachedRuntime;
+function commandExists(cmd) {
+  try {
+    const result = spawnSync(process.platform === "win32" ? "where" : "which", [cmd], {
+      stdio: "ignore"
+    });
+    return result.status === 0;
+  } catch {
+    return false;
   }
-  if (prefixes.length === 0)
-    return;
-  const counts = new Map;
-  for (const p of prefixes)
-    counts.set(p, (counts.get(p) ?? 0) + 1);
-  return Array.from(counts.entries()).sort((a, b) => b[1] - a[1])[0]?.[0];
 }
-function extractDefaultValue(initializer) {
-  if (ts5.isStringLiteral(initializer)) {
-    return initializer.text;
+function detectTsRuntime() {
+  if (cachedRuntime !== undefined) {
+    return cachedRuntime;
   }
-  if (ts5.isNumericLiteral(initializer)) {
-    return Number(initializer.text);
+  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 (initializer.kind === ts5.SyntaxKind.TrueKeyword) {
-    return true;
+  if (commandExists("bun")) {
+    cachedRuntime = {
+      cmd: "bun",
+      args: ["run"],
+      name: "bun"
+    };
+    return cachedRuntime;
   }
-  if (initializer.kind === ts5.SyntaxKind.FalseKeyword) {
-    return false;
+  if (commandExists("tsx")) {
+    cachedRuntime = {
+      cmd: "tsx",
+      args: [],
+      name: "tsx"
+    };
+    return cachedRuntime;
   }
-  if (initializer.kind === ts5.SyntaxKind.NullKeyword) {
-    return null;
+  if (commandExists("ts-node")) {
+    cachedRuntime = {
+      cmd: "ts-node",
+      args: ["--transpile-only"],
+      name: "ts-node"
+    };
+    return cachedRuntime;
   }
-  return initializer.getText();
+  cachedRuntime = null;
+  return null;
 }
-function registerReferencedTypes(type, ctx, depth = 0) {
-  if (depth > ctx.maxTypeDepth)
-    return;
-  if (ctx.visitedTypes.has(type))
-    return;
-  const isPrimitive = type.flags & (ts5.TypeFlags.String | ts5.TypeFlags.Number | ts5.TypeFlags.Boolean | ts5.TypeFlags.Void | ts5.TypeFlags.Undefined | ts5.TypeFlags.Null | ts5.TypeFlags.Any | ts5.TypeFlags.Unknown | ts5.TypeFlags.Never | ts5.TypeFlags.StringLiteral | ts5.TypeFlags.NumberLiteral | ts5.TypeFlags.BooleanLiteral);
-  if (!isPrimitive) {
-    ctx.visitedTypes.add(type);
-  }
-  const { typeChecker: checker, typeRegistry } = ctx;
-  typeRegistry.registerType(type, ctx);
-  const typeArgs = type.typeArguments;
-  if (typeArgs) {
-    for (const arg of typeArgs) {
-      registerReferencedTypes(arg, ctx, depth + 1);
-    }
-  }
-  if (type.isUnion()) {
-    for (const t of type.types) {
-      registerReferencedTypes(t, ctx, depth + 1);
+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/types/parameters.ts
+import ts5 from "typescript";
+function extractParameters(signature, ctx) {
+  const { typeChecker: checker } = ctx;
+  const result = [];
+  const signatureDecl = signature.getDeclaration();
+  const jsdocTags = signatureDecl ? ts5.getJSDocTags(signatureDecl) : [];
+  for (const param of signature.getParameters()) {
+    const decl = param.valueDeclaration;
+    const type = checker.getTypeOfSymbolAtLocation(param, decl ?? param.valueDeclaration);
+    if (decl && ts5.isObjectBindingPattern(decl.name)) {
+      const expandedParams = expandBindingPattern(decl, type, jsdocTags, ctx);
+      result.push(...expandedParams);
+    } else {
+      registerReferencedTypes(type, ctx);
+      result.push({
+        name: param.getName(),
+        schema: buildSchema(type, checker, ctx),
+        required: !(param.flags & 16777216)
+      });
+    }
+  }
+  return result;
+}
+function expandBindingPattern(paramDecl, paramType, jsdocTags, ctx) {
+  const { typeChecker: checker } = ctx;
+  const result = [];
+  const bindingPattern = paramDecl.name;
+  const allProperties = getEffectiveProperties(paramType, checker);
+  const inferredAlias = inferParamAlias(jsdocTags);
+  for (const element of bindingPattern.elements) {
+    if (!ts5.isBindingElement(element))
+      continue;
+    const propertyName = element.propertyName ? ts5.isIdentifier(element.propertyName) ? element.propertyName.text : element.propertyName.getText() : ts5.isIdentifier(element.name) ? element.name.text : element.name.getText();
+    const propSymbol = allProperties.get(propertyName);
+    if (!propSymbol)
+      continue;
+    const propType = checker.getTypeOfSymbol(propSymbol);
+    registerReferencedTypes(propType, ctx);
+    const isOptional = !!(propSymbol.flags & ts5.SymbolFlags.Optional) || element.initializer !== undefined;
+    const description = getParamDescription(propertyName, jsdocTags, inferredAlias);
+    const param = {
+      name: propertyName,
+      schema: buildSchema(propType, checker, ctx),
+      required: !isOptional
+    };
+    if (description) {
+      param.description = description;
+    }
+    if (element.initializer) {
+      param.default = extractDefaultValue(element.initializer);
+    }
+    result.push(param);
+  }
+  return result;
+}
+function getEffectiveProperties(type, _checker) {
+  const properties = new Map;
+  if (type.isIntersection()) {
+    for (const subType of type.types) {
+      for (const prop of subType.getProperties()) {
+        properties.set(prop.getName(), prop);
+      }
+    }
+  } else {
+    for (const prop of type.getProperties()) {
+      properties.set(prop.getName(), prop);
+    }
+  }
+  return properties;
+}
+function inferParamAlias(jsdocTags) {
+  const prefixes = [];
+  for (const tag of jsdocTags) {
+    if (tag.tagName.text !== "param")
+      continue;
+    const tagText = typeof tag.comment === "string" ? tag.comment : ts5.getTextOfJSDocComment(tag.comment) ?? "";
+    const paramTag = tag;
+    const paramName = paramTag.name?.getText() ?? "";
+    if (paramName.includes(".")) {
+      const prefix = paramName.split(".")[0];
+      if (prefix && !prefix.startsWith("__")) {
+        prefixes.push(prefix);
+      }
+    } else if (tagText.includes(".")) {
+      const match = tagText.match(/^(\w+)\./);
+      if (match && !match[1].startsWith("__")) {
+        prefixes.push(match[1]);
+      }
+    }
+  }
+  if (prefixes.length === 0)
+    return;
+  const counts = new Map;
+  for (const p of prefixes)
+    counts.set(p, (counts.get(p) ?? 0) + 1);
+  return Array.from(counts.entries()).sort((a, b) => b[1] - a[1])[0]?.[0];
+}
+function extractDefaultValue(initializer) {
+  if (ts5.isStringLiteral(initializer)) {
+    return initializer.text;
+  }
+  if (ts5.isNumericLiteral(initializer)) {
+    return Number(initializer.text);
+  }
+  if (initializer.kind === ts5.SyntaxKind.TrueKeyword) {
+    return true;
+  }
+  if (initializer.kind === ts5.SyntaxKind.FalseKeyword) {
+    return false;
+  }
+  if (initializer.kind === ts5.SyntaxKind.NullKeyword) {
+    return null;
+  }
+  return initializer.getText();
+}
+function registerReferencedTypes(type, ctx, depth = 0) {
+  if (depth > ctx.maxTypeDepth)
+    return;
+  if (ctx.visitedTypes.has(type))
+    return;
+  const isPrimitive = type.flags & (ts5.TypeFlags.String | ts5.TypeFlags.Number | ts5.TypeFlags.Boolean | ts5.TypeFlags.Void | ts5.TypeFlags.Undefined | ts5.TypeFlags.Null | ts5.TypeFlags.Any | ts5.TypeFlags.Unknown | ts5.TypeFlags.Never | ts5.TypeFlags.StringLiteral | ts5.TypeFlags.NumberLiteral | ts5.TypeFlags.BooleanLiteral);
+  if (!isPrimitive) {
+    ctx.visitedTypes.add(type);
+  }
+  const { typeChecker: checker, typeRegistry } = ctx;
+  typeRegistry.registerType(type, ctx);
+  const typeArgs = type.typeArguments;
+  if (typeArgs) {
+    for (const arg of typeArgs) {
+      registerReferencedTypes(arg, ctx, depth + 1);
+    }
+  }
+  if (type.isUnion()) {
+    for (const t of type.types) {
+      registerReferencedTypes(t, ctx, depth + 1);
+    }
+  }
+  if (type.isIntersection()) {
+    for (const t of type.types) {
+      registerReferencedTypes(t, ctx, depth + 1);
+    }
+  }
+  if (type.flags & ts5.TypeFlags.Object) {
+    const props = type.getProperties();
+    for (const prop of props.slice(0, 20)) {
+      const propType = checker.getTypeOfSymbol(prop);
+      registerReferencedTypes(propType, ctx, depth + 1);
+    }
+  }
+}
+
+// src/serializers/classes.ts
+import ts7 from "typescript";
+
+// src/serializers/context.ts
+import ts6 from "typescript";
+function createContext(program, sourceFile, options = {}) {
+  return {
+    typeChecker: program.getTypeChecker(),
+    program,
+    sourceFile,
+    maxTypeDepth: options.maxTypeDepth ?? 4,
+    maxExternalTypeDepth: options.maxExternalTypeDepth ?? 2,
+    currentDepth: 0,
+    resolveExternalTypes: options.resolveExternalTypes ?? true,
+    typeRegistry: new TypeRegistry,
+    exportedIds: new Set,
+    visitedTypes: new Set
+  };
+}
+function getInheritedMembers(classType, ownMemberNames, ctx, isStatic = false) {
+  const { typeChecker: checker } = ctx;
+  const inherited = [];
+  const visited = new Set;
+  const inheritedNames = new Set;
+  const typeToWalk = isStatic ? classType.getSymbol()?.valueDeclaration && checker.getTypeOfSymbolAtLocation(classType.getSymbol(), classType.getSymbol().valueDeclaration) : classType;
+  if (!typeToWalk)
+    return inherited;
+  walkBaseTypes(typeToWalk, ownMemberNames, inherited, inheritedNames, visited, ctx, isStatic);
+  return inherited;
+}
+function walkBaseTypes(type, ownMemberNames, inherited, inheritedNames, visited, ctx, isStatic) {
+  if (visited.has(type))
+    return;
+  visited.add(type);
+  const { typeChecker: checker } = ctx;
+  const baseTypes = type.getBaseTypes?.() ?? [];
+  for (const baseType of baseTypes) {
+    const baseSymbol = baseType.getSymbol();
+    const baseName = baseSymbol?.getName() ?? "unknown";
+    const properties = isStatic ? getStaticMembers(baseType, checker) : baseType.getProperties();
+    for (const prop of properties) {
+      const propName = prop.getName();
+      if (ownMemberNames.has(propName))
+        continue;
+      if (inheritedNames.has(propName))
+        continue;
+      if (propName.startsWith("#") || propName.startsWith("__"))
+        continue;
+      const member = serializeInheritedMember(prop, baseName, ctx, isStatic);
+      if (member) {
+        inherited.push(member);
+        inheritedNames.add(propName);
+      }
     }
+    walkBaseTypes(baseType, ownMemberNames, inherited, inheritedNames, visited, ctx, isStatic);
   }
-  if (type.isIntersection()) {
-    for (const t of type.types) {
-      registerReferencedTypes(t, ctx, depth + 1);
+}
+function getStaticMembers(classType, checker) {
+  const symbol = classType.getSymbol();
+  if (!symbol)
+    return [];
+  const decl = symbol.valueDeclaration;
+  if (!decl)
+    return [];
+  const constructorType = checker.getTypeOfSymbolAtLocation(symbol, decl);
+  return constructorType.getProperties().filter((prop) => {
+    const name = prop.getName();
+    return name !== "prototype" && name !== "constructor" && !name.startsWith("__");
+  });
+}
+function serializeInheritedMember(symbol, inheritedFrom, ctx, isStatic) {
+  const { typeChecker: checker } = ctx;
+  const name = symbol.getName();
+  const declarations = symbol.getDeclarations() ?? [];
+  const decl = declarations[0];
+  if (!decl)
+    return null;
+  const type = checker.getTypeOfSymbol(symbol);
+  registerReferencedTypes(type, ctx);
+  let visibility;
+  if (decl && ts6.canHaveModifiers(decl)) {
+    const modifiers = ts6.getModifiers(decl);
+    if (modifiers) {
+      for (const mod of modifiers) {
+        if (mod.kind === ts6.SyntaxKind.PrivateKeyword)
+          visibility = "private";
+        else if (mod.kind === ts6.SyntaxKind.ProtectedKeyword)
+          visibility = "protected";
+        else if (mod.kind === ts6.SyntaxKind.PublicKeyword)
+          visibility = "public";
+      }
     }
   }
-  if (type.flags & ts5.TypeFlags.Object) {
-    const props = type.getProperties();
-    for (const prop of props.slice(0, 20)) {
-      const propType = checker.getTypeOfSymbol(prop);
-      registerReferencedTypes(propType, ctx, depth + 1);
+  if (visibility === "private")
+    return null;
+  const { description, tags } = getJSDocComment(decl);
+  let kind = "property";
+  const callSigs = type.getCallSignatures();
+  if (callSigs.length > 0) {
+    kind = "method";
+  } else if (ts6.isGetAccessorDeclaration(decl)) {
+    kind = "getter";
+  } else if (ts6.isSetAccessorDeclaration(decl)) {
+    kind = "setter";
+  }
+  const flags = {};
+  if (isStatic)
+    flags.static = true;
+  if (decl && ts6.canHaveModifiers(decl)) {
+    const modifiers = ts6.getModifiers(decl);
+    if (modifiers?.some((m) => m.kind === ts6.SyntaxKind.ReadonlyKeyword)) {
+      flags.readonly = true;
     }
   }
+  let signatures;
+  if (kind === "method" && callSigs.length > 0) {
+    signatures = callSigs.map((sig, index) => {
+      const params = extractParameters(sig, ctx);
+      const returnType = checker.getReturnTypeOfSignature(sig);
+      registerReferencedTypes(returnType, ctx);
+      const sigDoc = getJSDocForSignature(sig);
+      return {
+        parameters: params.length > 0 ? params : undefined,
+        returns: {
+          schema: buildSchema(returnType, checker, ctx)
+        },
+        ...sigDoc.description ? { description: sigDoc.description } : {},
+        ...sigDoc.tags.length > 0 ? { tags: sigDoc.tags } : {},
+        ...callSigs.length > 1 ? { overloadIndex: index } : {}
+      };
+    });
+  }
+  return {
+    name,
+    kind,
+    inheritedFrom,
+    description,
+    tags: tags.length > 0 ? tags : undefined,
+    visibility,
+    schema: kind !== "method" ? buildSchema(type, checker, ctx) : undefined,
+    signatures,
+    flags: Object.keys(flags).length > 0 ? flags : undefined
+  };
 }
 
 // src/serializers/classes.ts
-import ts6 from "typescript";
 function serializeClass(node, ctx) {
   const { typeChecker: checker } = ctx;
   const symbol = checker.getSymbolAtLocation(node.name ?? node);
@@ -1027,11 +1863,11 @@ function serializeClass(node, ctx) {
     const memberName = getMemberName(member);
     if (memberName?.startsWith("#"))
       continue;
-    if (ts6.isPropertyDeclaration(member)) {
+    if (ts7.isPropertyDeclaration(member)) {
       const propMember = serializeProperty(member, ctx);
       if (propMember)
         members.push(propMember);
-    } else if (ts6.isMethodDeclaration(member)) {
+    } else if (ts7.isMethodDeclaration(member)) {
       const methodMember = serializeMethod(member, ctx);
       if (methodMember?.name) {
         if (!methodsByName.has(methodMember.name)) {
@@ -1046,17 +1882,28 @@ function serializeClass(node, ctx) {
           }
         }
       }
-    } else if (ts6.isConstructorDeclaration(member)) {
+    } else if (ts7.isConstructorDeclaration(member)) {
       const ctorSig = serializeConstructor(member, ctx);
       if (ctorSig)
         signatures.push(ctorSig);
-    } else if (ts6.isGetAccessorDeclaration(member) || ts6.isSetAccessorDeclaration(member)) {
+    } else if (ts7.isGetAccessorDeclaration(member) || ts7.isSetAccessorDeclaration(member)) {
       const accessorMember = serializeAccessor(member, ctx);
       if (accessorMember)
         members.push(accessorMember);
     }
   }
   members.push(...methodsByName.values());
+  const ownMemberNames = new Set;
+  for (const member of node.members) {
+    const memberName = getMemberName(member);
+    if (memberName)
+      ownMemberNames.add(memberName);
+  }
+  const classType = checker.getTypeAtLocation(node);
+  const inheritedInstance = getInheritedMembers(classType, ownMemberNames, ctx, false);
+  members.push(...inheritedInstance);
+  const inheritedStatic = getInheritedMembers(classType, ownMemberNames, ctx, true);
+  members.push(...inheritedStatic);
   const extendsClause = getExtendsClause(node, checker);
   const implementsClause = getImplementsClause(node, checker);
   return {
@@ -1076,37 +1923,37 @@ function serializeClass(node, ctx) {
   };
 }
 function getMemberName(member) {
-  if (ts6.isConstructorDeclaration(member))
+  if (ts7.isConstructorDeclaration(member))
     return "constructor";
   if (!member.name)
     return;
-  if (ts6.isIdentifier(member.name))
+  if (ts7.isIdentifier(member.name))
     return member.name.text;
-  if (ts6.isPrivateIdentifier(member.name))
+  if (ts7.isPrivateIdentifier(member.name))
     return member.name.text;
   return member.name.getText();
 }
 function getVisibility(member) {
-  const modifiers = ts6.canHaveModifiers(member) ? ts6.getModifiers(member) : undefined;
+  const modifiers = ts7.canHaveModifiers(member) ? ts7.getModifiers(member) : undefined;
   if (!modifiers)
     return;
   for (const mod of modifiers) {
-    if (mod.kind === ts6.SyntaxKind.PrivateKeyword)
+    if (mod.kind === ts7.SyntaxKind.PrivateKeyword)
       return "private";
-    if (mod.kind === ts6.SyntaxKind.ProtectedKeyword)
+    if (mod.kind === ts7.SyntaxKind.ProtectedKeyword)
       return "protected";
-    if (mod.kind === ts6.SyntaxKind.PublicKeyword)
+    if (mod.kind === ts7.SyntaxKind.PublicKeyword)
       return "public";
   }
   return;
 }
 function isStatic(member) {
-  const modifiers = ts6.canHaveModifiers(member) ? ts6.getModifiers(member) : undefined;
-  return modifiers?.some((m) => m.kind === ts6.SyntaxKind.StaticKeyword) ?? false;
+  const modifiers = ts7.canHaveModifiers(member) ? ts7.getModifiers(member) : undefined;
+  return modifiers?.some((m) => m.kind === ts7.SyntaxKind.StaticKeyword) ?? false;
 }
 function isReadonly(member) {
-  const modifiers = ts6.canHaveModifiers(member) ? ts6.getModifiers(member) : undefined;
-  return modifiers?.some((m) => m.kind === ts6.SyntaxKind.ReadonlyKeyword) ?? false;
+  const modifiers = ts7.canHaveModifiers(member) ? ts7.getModifiers(member) : undefined;
+  return modifiers?.some((m) => m.kind === ts7.SyntaxKind.ReadonlyKeyword) ?? false;
 }
 function serializeProperty(node, ctx) {
   const { typeChecker: checker } = ctx;
@@ -1144,15 +1991,22 @@ function serializeMethod(node, ctx) {
   const visibility = getVisibility(node);
   const type = checker.getTypeAtLocation(node);
   const callSignatures = type.getCallSignatures();
-  const signatures = callSignatures.map((sig) => {
+  const signatures = callSignatures.map((sig, index) => {
     const params = extractParameters(sig, ctx);
     const returnType = checker.getReturnTypeOfSignature(sig);
     registerReferencedTypes(returnType, ctx);
+    const sigDoc = getJSDocForSignature(sig);
+    const sigTypeParams = extractTypeParametersFromSignature(sig, checker);
     return {
       parameters: params.length > 0 ? params : undefined,
       returns: {
         schema: buildSchema(returnType, checker, ctx)
-      }
+      },
+      ...sigDoc.description ? { description: sigDoc.description } : {},
+      ...sigDoc.tags.length > 0 ? { tags: sigDoc.tags } : {},
+      ...sigDoc.examples.length > 0 ? { examples: sigDoc.examples } : {},
+      ...sigTypeParams ? { typeParameters: sigTypeParams } : {},
+      ...callSignatures.length > 1 ? { overloadIndex: index } : {}
     };
   });
   const flags = {};
@@ -1160,8 +2014,8 @@ function serializeMethod(node, ctx) {
     flags.static = true;
   if (node.asteriskToken)
     flags.generator = true;
-  const modifiers = ts6.getModifiers(node);
-  if (modifiers?.some((m) => m.kind === ts6.SyntaxKind.AsyncKeyword)) {
+  const modifiers = ts7.getModifiers(node);
+  if (modifiers?.some((m) => m.kind === ts7.SyntaxKind.AsyncKeyword)) {
     flags.async = true;
   }
   return {
@@ -1196,7 +2050,7 @@ function serializeAccessor(node, ctx) {
   const type = checker.getTypeAtLocation(node);
   const schema = buildSchema(type, checker, ctx);
   registerReferencedTypes(type, ctx);
-  const kind = ts6.isGetAccessorDeclaration(node) ? "getter" : "setter";
+  const kind = ts7.isGetAccessorDeclaration(node) ? "getter" : "setter";
   const flags = {};
   if (isStatic(node))
     flags.static = true;
@@ -1214,7 +2068,7 @@ function getExtendsClause(node, checker) {
   if (!node.heritageClauses)
     return;
   for (const clause of node.heritageClauses) {
-    if (clause.token === ts6.SyntaxKind.ExtendsKeyword) {
+    if (clause.token === ts7.SyntaxKind.ExtendsKeyword) {
       const expr = clause.types[0];
       if (expr) {
         const type = checker.getTypeAtLocation(expr);
@@ -1229,7 +2083,7 @@ function getImplementsClause(node, checker) {
   if (!node.heritageClauses)
     return;
   for (const clause of node.heritageClauses) {
-    if (clause.token === ts6.SyntaxKind.ImplementsKeyword) {
+    if (clause.token === ts7.SyntaxKind.ImplementsKeyword) {
       return clause.types.map((expr) => {
         const type = checker.getTypeAtLocation(expr);
         const symbol = type.getSymbol();
@@ -1286,6 +2140,35 @@ function serializeEnum(node, ctx) {
 }
 
 // src/serializers/functions.ts
+import ts8 from "typescript";
+function buildReturnSchema(sig, ctx) {
+  const returnType = ctx.typeChecker.getReturnTypeOfSignature(sig);
+  registerReferencedTypes(returnType, ctx);
+  const schema = buildSchema(returnType, ctx.typeChecker, ctx);
+  const declaration = sig.getDeclaration();
+  if (declaration && ts8.isFunctionLike(declaration) && declaration.type) {
+    const returnTypeNode = declaration.type;
+    if (ts8.isTypePredicateNode(returnTypeNode)) {
+      const parameterName = ts8.isIdentifier(returnTypeNode.parameterName) ? returnTypeNode.parameterName.text : returnTypeNode.parameterName.getText();
+      let predicateTypeSchema = { type: "unknown" };
+      if (returnTypeNode.type) {
+        const predicateType = ctx.typeChecker.getTypeAtLocation(returnTypeNode.type);
+        predicateTypeSchema = buildSchema(predicateType, ctx.typeChecker, ctx);
+        registerReferencedTypes(predicateType, ctx);
+      }
+      const baseSchema = typeof schema === "string" ? { type: schema } : schema;
+      const schemaWithPredicate = {
+        ...baseSchema,
+        "x-ts-type-predicate": {
+          parameterName,
+          type: predicateTypeSchema
+        }
+      };
+      return { schema: schemaWithPredicate };
+    }
+  }
+  return { schema };
+}
 function serializeFunctionExport(node, ctx) {
   const symbol = ctx.typeChecker.getSymbolAtLocation(node.name ?? node);
   const name = symbol?.getName() ?? node.name?.getText();
@@ -1298,15 +2181,18 @@ function serializeFunctionExport(node, ctx) {
   const typeParameters = extractTypeParameters(node, ctx.typeChecker);
   const type = ctx.typeChecker.getTypeAtLocation(node);
   const callSignatures = type.getCallSignatures();
-  const signatures = callSignatures.map((sig) => {
+  const signatures = callSignatures.map((sig, index) => {
     const params = extractParameters(sig, ctx);
-    const returnType = ctx.typeChecker.getReturnTypeOfSignature(sig);
-    registerReferencedTypes(returnType, ctx);
+    const sigDoc = getJSDocForSignature(sig);
+    const sigTypeParams = extractTypeParametersFromSignature(sig, ctx.typeChecker);
     return {
       parameters: params,
-      returns: {
-        schema: buildSchema(returnType, ctx.typeChecker, ctx)
-      }
+      returns: buildReturnSchema(sig, ctx),
+      ...sigDoc.description ? { description: sigDoc.description } : {},
+      ...sigDoc.tags.length > 0 ? { tags: sigDoc.tags } : {},
+      ...sigDoc.examples.length > 0 ? { examples: sigDoc.examples } : {},
+      ...sigTypeParams ? { typeParameters: sigTypeParams } : {},
+      ...callSignatures.length > 1 ? { overloadIndex: index } : {}
     };
   });
   return {
@@ -1324,7 +2210,7 @@ function serializeFunctionExport(node, ctx) {
 }
 
 // src/serializers/interfaces.ts
-import ts7 from "typescript";
+import ts9 from "typescript";
 function serializeInterface(node, ctx) {
   const { typeChecker: checker } = ctx;
   const symbol = checker.getSymbolAtLocation(node.name ?? node);
@@ -1339,22 +2225,22 @@ function serializeInterface(node, ctx) {
   const members = [];
   const methodsByName = new Map;
   for (const member of node.members) {
-    if (ts7.isPropertySignature(member)) {
+    if (ts9.isPropertySignature(member)) {
       const propMember = serializePropertySignature(member, ctx);
       if (propMember)
         members.push(propMember);
-    } else if (ts7.isMethodSignature(member)) {
+    } else if (ts9.isMethodSignature(member)) {
       const methodMember = serializeMethodSignature(member, ctx);
       if (methodMember?.name) {
         if (!methodsByName.has(methodMember.name)) {
           methodsByName.set(methodMember.name, methodMember);
         }
       }
-    } else if (ts7.isCallSignatureDeclaration(member)) {
+    } else if (ts9.isCallSignatureDeclaration(member)) {
       const callMember = serializeCallSignature(member, ctx);
       if (callMember)
         members.push(callMember);
-    } else if (ts7.isIndexSignatureDeclaration(member)) {
+    } else if (ts9.isIndexSignatureDeclaration(member)) {
       const indexMember = serializeIndexSignature(member, ctx);
       if (indexMember)
         members.push(indexMember);
@@ -1386,7 +2272,7 @@ function serializePropertySignature(node, ctx) {
   const flags = {};
   if (node.questionToken)
     flags.optional = true;
-  if (node.modifiers?.some((m) => m.kind === ts7.SyntaxKind.ReadonlyKeyword)) {
+  if (node.modifiers?.some((m) => m.kind === ts9.SyntaxKind.ReadonlyKeyword)) {
     flags.readonly = true;
   }
   return {
@@ -1404,15 +2290,22 @@ function serializeMethodSignature(node, ctx) {
   const { description, tags } = getJSDocComment(node);
   const type = checker.getTypeAtLocation(node);
   const callSignatures = type.getCallSignatures();
-  const signatures = callSignatures.map((sig) => {
+  const signatures = callSignatures.map((sig, index) => {
     const params = extractParameters(sig, ctx);
     const returnType = checker.getReturnTypeOfSignature(sig);
     registerReferencedTypes(returnType, ctx);
+    const sigDoc = getJSDocForSignature(sig);
+    const sigTypeParams = extractTypeParametersFromSignature(sig, checker);
     return {
       parameters: params.length > 0 ? params : undefined,
       returns: {
         schema: buildSchema(returnType, checker, ctx)
-      }
+      },
+      ...sigDoc.description ? { description: sigDoc.description } : {},
+      ...sigDoc.tags.length > 0 ? { tags: sigDoc.tags } : {},
+      ...sigDoc.examples.length > 0 ? { examples: sigDoc.examples } : {},
+      ...sigTypeParams ? { typeParameters: sigTypeParams } : {},
+      ...callSignatures.length > 1 ? { overloadIndex: index } : {}
     };
   });
   const flags = {};
@@ -1436,735 +2329,299 @@ function serializeCallSignature(node, ctx) {
   const params = extractParameters(sig, ctx);
   const returnType = checker.getReturnTypeOfSignature(sig);
   registerReferencedTypes(returnType, ctx);
-  return {
-    name: "()",
-    kind: "call-signature",
-    description,
-    tags: tags.length > 0 ? tags : undefined,
-    signatures: [
-      {
-        parameters: params.length > 0 ? params : undefined,
-        returns: {
-          schema: buildSchema(returnType, checker, ctx)
-        }
-      }
-    ]
-  };
-}
-function serializeIndexSignature(node, ctx) {
-  const { typeChecker: checker } = ctx;
-  const { description, tags } = getJSDocComment(node);
-  const valueType = node.type ? checker.getTypeAtLocation(node.type) : checker.getAnyType();
-  const valueSchema = buildSchema(valueType, checker, ctx);
-  registerReferencedTypes(valueType, ctx);
-  const keyParam = node.parameters[0];
-  const keyType = keyParam?.type ? checker.getTypeAtLocation(keyParam.type) : checker.getStringType();
-  const keyTypeName = checker.typeToString(keyType);
-  return {
-    name: `[${keyTypeName}]`,
-    kind: "index-signature",
-    description,
-    tags: tags.length > 0 ? tags : undefined,
-    schema: {
-      type: "object",
-      additionalProperties: valueSchema
-    }
-  };
-}
-function getInterfaceExtends(node, checker) {
-  if (!node.heritageClauses)
-    return;
-  for (const clause of node.heritageClauses) {
-    if (clause.token === ts7.SyntaxKind.ExtendsKeyword && clause.types.length > 0) {
-      const names = clause.types.map((expr) => {
-        const type = checker.getTypeAtLocation(expr);
-        return type.getSymbol()?.getName() ?? expr.expression.getText();
-      });
-      return names.join(" & ");
-    }
-  }
-  return;
-}
-
-// src/serializers/type-aliases.ts
-function serializeTypeAlias(node, ctx) {
-  const symbol = ctx.typeChecker.getSymbolAtLocation(node.name ?? node);
-  const name = symbol?.getName() ?? node.name?.getText();
-  if (!name)
-    return null;
-  const deprecated = isSymbolDeprecated(symbol);
-  const declSourceFile = node.getSourceFile();
-  const { description, tags, examples } = getJSDocComment(node);
-  const source = getSourceLocation(node, declSourceFile);
-  const typeParameters = extractTypeParameters(node, ctx.typeChecker);
-  const type = ctx.typeChecker.getTypeAtLocation(node);
-  registerReferencedTypes(type, ctx);
-  const schema = buildSchema(type, ctx.typeChecker, ctx);
-  return {
-    id: name,
-    name,
-    kind: "type",
-    description,
-    tags,
-    source,
-    typeParameters,
-    schema,
-    ...deprecated ? { deprecated: true } : {},
-    ...examples.length > 0 ? { examples } : {}
-  };
-}
-
-// 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;
+  return {
+    name: "()",
+    kind: "call-signature",
+    description,
+    tags: tags.length > 0 ? tags : undefined,
+    signatures: [
+      {
+        parameters: params.length > 0 ? params : undefined,
+        returns: {
+          schema: buildSchema(returnType, checker, ctx)
+        }
+      }
+    ]
+  };
+}
+function serializeIndexSignature(node, ctx) {
+  const { typeChecker: checker } = ctx;
+  const { description, tags } = getJSDocComment(node);
+  const valueType = node.type ? checker.getTypeAtLocation(node.type) : checker.getAnyType();
+  const valueSchema = buildSchema(valueType, checker, ctx);
+  registerReferencedTypes(valueType, ctx);
+  const keyParam = node.parameters[0];
+  const keyType = keyParam?.type ? checker.getTypeAtLocation(keyParam.type) : checker.getStringType();
+  const keyTypeName = checker.typeToString(keyType);
+  return {
+    name: `[${keyTypeName}]`,
+    kind: "index-signature",
+    description,
+    tags: tags.length > 0 ? tags : undefined,
+    schema: {
+      type: "object",
+      additionalProperties: valueSchema
     }
-    let typesType = checker.getTypeOfSymbol(typesSymbol);
-    typesType = getNonNullableType(typesType);
-    const inputSymbol = typesType.getProperty("input");
-    if (!inputSymbol) {
-      return null;
+  };
+}
+function getInterfaceExtends(node, checker) {
+  if (!node.heritageClauses)
+    return;
+  for (const clause of node.heritageClauses) {
+    if (clause.token === ts9.SyntaxKind.ExtendsKeyword && clause.types.length > 0) {
+      const names = clause.types.map((expr) => {
+        const type = checker.getTypeAtLocation(expr);
+        return type.getSymbol()?.getName() ?? expr.expression.getText();
+      });
+      return names.join(" & ");
     }
-    return checker.getTypeOfSymbol(inputSymbol);
   }
-};
+  return;
+}
 
-// 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/serializers/type-aliases.ts
+import ts10 from "typescript";
+function buildIntersectionSchemaFromNode(node, ctx) {
+  const types = node.types;
+  const schemas = [];
+  for (const typeNode of types) {
+    const type = ctx.typeChecker.getTypeAtLocation(typeNode);
+    registerReferencedTypes(type, ctx);
+    schemas.push(buildSchema(type, ctx.typeChecker, ctx));
+  }
+  if (schemas.length === 0) {
+    return { type: "never" };
   }
-};
-
-// 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);
-  const name = symbol?.getName() ?? node.name.getText();
+  if (schemas.length === 1) {
+    return schemas[0];
+  }
+  return { allOf: schemas };
+}
+function serializeTypeAlias(node, ctx) {
+  const symbol = ctx.typeChecker.getSymbolAtLocation(node.name ?? node);
+  const name = symbol?.getName() ?? node.name?.getText();
   if (!name)
     return null;
   const deprecated = isSymbolDeprecated(symbol);
   const declSourceFile = node.getSourceFile();
-  const { description, tags, examples } = getJSDocComment(statement);
+  const { description, tags, examples } = getJSDocComment(node);
   const source = getSourceLocation(node, declSourceFile);
+  const typeParameters = extractTypeParameters(node, ctx.typeChecker);
   const type = ctx.typeChecker.getTypeAtLocation(node);
-  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;
+  registerReferencedTypes(type, ctx);
+  let schema;
+  if (ts10.isIntersectionTypeNode(node.type)) {
+    schema = buildIntersectionSchemaFromNode(node.type, ctx);
+  } else {
+    schema = buildSchema(type, ctx.typeChecker, ctx);
+  }
   return {
     id: name,
     name,
-    kind: "variable",
+    kind: "type",
     description,
     tags,
     source,
+    typeParameters,
     schema,
-    ...flags ? { flags } : {},
     ...deprecated ? { deprecated: true } : {},
     ...examples.length > 0 ? { examples } : {}
   };
 }
 
-// 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;
-      }
+// 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];
     }
-
-    console.log(JSON.stringify({ success: true, results }));
-  } catch (e) {
-    console.log(JSON.stringify({ success: false, error: e.message }));
   }
+  return type;
 }
-
-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;
+var adapters = [];
+function registerAdapter(adapter) {
+  adapters.push(adapter);
 }
-
-function sanitizeTypeBoxSchema(schema: unknown): unknown {
-  return JSON.parse(JSON.stringify(schema));
+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
+  };
 }
 
-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;
-      }
+// 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;
     }
-
-    // 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 {}
-      }
+    const args = checker.getTypeArguments(type);
+    if (args.length < 1) {
+      return null;
     }
-
-    console.log(JSON.stringify({ success: true, results }));
-  } catch (e) {
-    console.log(JSON.stringify({ success: false, error: (e as Error).message }));
+    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];
   }
-}
+};
 
-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;
+// 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;
   }
-}
-function readTsconfigOutDir(baseDir) {
-  const tsconfigPath = path2.join(baseDir, "tsconfig.json");
-  try {
-    if (!fs.existsSync(tsconfigPath)) {
+};
+
+// 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;
     }
-    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}`));
+    let typesType = checker.getTypeOfSymbol(typesSymbol);
+    typesType = getNonNullableType(typesType);
+    const outputSymbol = typesType.getProperty("output");
+    if (!outputSymbol) {
+      return null;
     }
-  }
-  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}`));
+    return checker.getTypeOfSymbol(outputSymbol);
+  },
+  extractInputType(type, checker) {
+    const typesSymbol = type.getProperty("~types");
+    if (!typesSymbol) {
+      return null;
     }
-  }
-  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}`));
+    let typesType = checker.getTypeOfSymbol(typesSymbol);
+    typesType = getNonNullableType(typesType);
+    const inputSymbol = typesType.getProperty("input");
+    if (!inputSymbol) {
+      return null;
     }
+    return checker.getTypeOfSymbol(inputSymbol);
   }
-  for (const candidate of candidates) {
-    if (fs.existsSync(candidate)) {
-      return candidate;
+};
+
+// 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);
     }
-  }
-  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 }
-      };
+    const typeSymbol = type.getProperty("_type");
+    if (typeSymbol) {
+      return checker.getTypeOfSymbol(typeSymbol);
     }
-  }
-  if (isTypeScript) {
-    const runtime2 = detectTsRuntime();
-    if (runtime2) {
-      const result = await extractStandardSchemasFromTs(entryFile, extractOptions);
-      return {
-        ...result,
-        info: { method: "direct-ts", runtime: runtime2.name, path: entryFile }
-      };
+    return null;
+  },
+  extractInputType(type, checker) {
+    const inputSymbol = type.getProperty("_input");
+    if (inputSymbol) {
+      return checker.getTypeOfSymbol(inputSymbol);
     }
+    return null;
   }
-  const runtime = detectTsRuntime();
-  const hint = isTypeScript && !runtime ? " Install bun, tsx, or ts-node for direct TS execution." : "";
+};
+
+// 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);
+  const name = symbol?.getName() ?? node.name.getText();
+  if (!name)
+    return null;
+  const deprecated = isSymbolDeprecated(symbol);
+  const declSourceFile = node.getSourceFile();
+  const { description, tags, examples } = getJSDocComment(statement);
+  const source = getSourceLocation(node, declSourceFile);
+  const type = ctx.typeChecker.getTypeAtLocation(node);
+  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 {
-    schemas: new Map,
-    errors: [`Could not find compiled JS for ${entryFile}.${hint}`]
+    id: name,
+    name,
+    kind: "variable",
+    description,
+    tags,
+    source,
+    schema,
+    ...flags ? { flags } : {},
+    ...deprecated ? { deprecated: true } : {},
+    ...examples.length > 0 ? { examples } : {}
   };
 }
 
@@ -2381,6 +2838,18 @@ function normalizeStandardType(schema, options) {
       result[keyword] = schema[keyword];
     }
   }
+  for (const key of Object.keys(schema)) {
+    if (key.startsWith("x-ts-") && schema[key] !== undefined) {
+      const value = schema[key];
+      if (isSchemaLike(value)) {
+        result[key] = normalizeSchemaInternal(value, options);
+      } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        result[key] = normalizeGenericObject(value, options);
+      } else {
+        result[key] = value;
+      }
+    }
+  }
   return result;
 }
 function normalizeRef(schema, options) {
@@ -2388,6 +2857,11 @@ function normalizeRef(schema, options) {
   if (schema.typeArguments && schema.typeArguments.length > 0) {
     result["x-ts-type-arguments"] = schema.typeArguments.map((arg) => normalizeSchemaInternal(arg, options));
   }
+  for (const key of Object.keys(schema)) {
+    if (key.startsWith("x-ts-") && schema[key] !== undefined) {
+      result[key] = schema[key];
+    }
+  }
   return result;
 }
 function normalizeCombinator(keyword, schemas, originalSchema, options) {
@@ -2589,23 +3063,7 @@ function isOptionalMember(member) {
 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";
-
-// src/serializers/context.ts
-function createContext(program, sourceFile, options = {}) {
-  return {
-    typeChecker: program.getTypeChecker(),
-    program,
-    sourceFile,
-    maxTypeDepth: options.maxTypeDepth ?? 4,
-    maxExternalTypeDepth: options.maxExternalTypeDepth ?? 2,
-    currentDepth: 0,
-    resolveExternalTypes: options.resolveExternalTypes ?? true,
-    typeRegistry: new TypeRegistry,
-    exportedIds: new Set,
-    visitedTypes: new Set
-  };
-}
+import ts11 from "typescript";
 
 // src/builder/schema-merger.ts
 function mergeRuntimeSchemas(staticExports, runtimeSchemas) {
@@ -2636,6 +3094,24 @@ function mergeRuntimeSchemas(staticExports, runtimeSchemas) {
 }
 
 // src/builder/spec-builder.ts
+var typeDefinitionCache = null;
+function getTypeDefinitionCache() {
+  if (!typeDefinitionCache) {
+    typeDefinitionCache = new Map;
+  }
+  return typeDefinitionCache;
+}
+var internalTagCache = null;
+function getInternalTagCache() {
+  if (!internalTagCache) {
+    internalTagCache = new Map;
+  }
+  return internalTagCache;
+}
+function clearTypeDefinitionCache() {
+  typeDefinitionCache = null;
+  internalTagCache = null;
+}
 var BUILTIN_TYPES2 = new Set([
   "Array",
   "ArrayBuffer",
@@ -2720,6 +3196,7 @@ function shouldSkipDanglingRef(name) {
   return false;
 }
 async function extract(options) {
+  clearTypeDefinitionCache();
   const {
     entryFile,
     baseDir,
@@ -2781,7 +3258,8 @@ async function extract(options) {
   const meta = await getPackageMeta(entryFile, baseDir);
   const types = ctx.typeRegistry.getAll();
   const projectBaseDir = baseDir ?? path3.dirname(entryFile);
-  const forgottenExports = collectForgottenExports(exports, types, program, sourceFile, exportedIds, projectBaseDir);
+  const definedTypes = new Set(types.map((t) => t.id));
+  const forgottenExports = collectForgottenExports(exports, types, program, sourceFile, exportedIds, projectBaseDir, definedTypes);
   for (const forgotten of forgottenExports) {
     const refSummary = forgotten.referencedBy.slice(0, 3).map((r) => `${r.exportName} (${r.location})`).join(", ");
     const moreRefs = forgotten.referencedBy.length > 3 ? ` +${forgotten.referencedBy.length - 3} more` : "";
@@ -2864,10 +3342,9 @@ function collectAllRefsWithContext(obj, refs, state) {
     return;
   if (Array.isArray(obj)) {
     for (let i = 0;i < obj.length; i++) {
-      collectAllRefsWithContext(obj[i], refs, {
-        ...state,
-        path: [...state.path, `[${i}]`]
-      });
+      state.path.push(`[${i}]`);
+      collectAllRefsWithContext(obj[i], refs, state);
+      state.path.pop();
     }
     return;
   }
@@ -2880,53 +3357,63 @@ function collectAllRefsWithContext(obj, refs, state) {
         typeName,
         exportName: state.exportName,
         location: state.location,
-        path: state.path.join(".") || undefined
+        path: state.path.length > 0 ? state.path.join(".") : undefined
       });
       refs.set(typeName, existing);
     }
+    const prevLocation = state.location;
     for (const [key, value] of Object.entries(record)) {
-      let newLocation = state.location;
       if (key === "returnType" || key === "returns")
-        newLocation = "return";
+        state.location = "return";
       else if (key === "parameters" || key === "params")
-        newLocation = "parameter";
+        state.location = "parameter";
       else if (key === "properties" || key === "members")
-        newLocation = "property";
+        state.location = "property";
       else if (key === "extends" || key === "implements")
-        newLocation = "extends";
+        state.location = "extends";
       else if (key === "typeParameters" || key === "typeParams")
-        newLocation = "type-parameter";
-      collectAllRefsWithContext(value, refs, {
-        ...state,
-        location: newLocation,
-        path: [...state.path, key]
-      });
+        state.location = "type-parameter";
+      state.path.push(key);
+      collectAllRefsWithContext(value, refs, state);
+      state.path.pop();
+      state.location = prevLocation;
     }
   }
 }
 function findTypeDefinition(typeName, program, sourceFile) {
+  const cache = getTypeDefinitionCache();
+  if (cache.has(typeName)) {
+    return cache.get(typeName);
+  }
   const checker = program.getTypeChecker();
   const findInNode = (node) => {
-    if ((ts8.isInterfaceDeclaration(node) || ts8.isTypeAliasDeclaration(node) || ts8.isClassDeclaration(node) || ts8.isEnumDeclaration(node)) && node.name?.text === typeName) {
+    if ((ts11.isInterfaceDeclaration(node) || ts11.isTypeAliasDeclaration(node) || ts11.isClassDeclaration(node) || ts11.isEnumDeclaration(node)) && node.name?.text === typeName) {
       const sf = node.getSourceFile();
       return sf.fileName;
     }
-    return ts8.forEachChild(node, findInNode);
+    return ts11.forEachChild(node, findInNode);
   };
   const entryResult = findInNode(sourceFile);
-  if (entryResult)
+  if (entryResult) {
+    cache.set(typeName, entryResult);
     return entryResult;
+  }
   for (const sf of program.getSourceFiles()) {
     if (sf.isDeclarationFile && !sf.fileName.includes("node_modules")) {
       const result = findInNode(sf);
-      if (result)
+      if (result) {
+        cache.set(typeName, result);
         return result;
+      }
     }
   }
-  const symbol = checker.resolveName(typeName, sourceFile, ts8.SymbolFlags.Type, false);
+  const symbol = checker.resolveName(typeName, sourceFile, ts11.SymbolFlags.Type, false);
   if (symbol?.declarations?.[0]) {
-    return symbol.declarations[0].getSourceFile().fileName;
+    const result = symbol.declarations[0].getSourceFile().fileName;
+    cache.set(typeName, result);
+    return result;
   }
+  cache.set(typeName, undefined);
   return;
 }
 function isExternalType2(definedIn, baseDir) {
@@ -2939,15 +3426,23 @@ function isExternalType2(definedIn, baseDir) {
   return !normalizedDefined.startsWith(normalizedBase);
 }
 function hasInternalTag(typeName, program, sourceFile) {
+  const cache = getInternalTagCache();
+  const cached = cache.get(typeName);
+  if (cached !== undefined) {
+    return cached;
+  }
   const checker = program.getTypeChecker();
-  const symbol = checker.resolveName(typeName, sourceFile, ts8.SymbolFlags.Type, false);
-  if (!symbol)
+  const symbol = checker.resolveName(typeName, sourceFile, ts11.SymbolFlags.Type, false);
+  if (!symbol) {
+    cache.set(typeName, false);
     return false;
+  }
   const jsTags = symbol.getJsDocTags();
-  return jsTags.some((tag) => tag.name === "internal");
+  const isInternal = jsTags.some((tag) => tag.name === "internal");
+  cache.set(typeName, isInternal);
+  return isInternal;
 }
-function collectForgottenExports(exports, types, program, sourceFile, exportedIds, baseDir) {
-  const definedTypes = new Set(types.map((t) => t.id));
+function collectForgottenExports(exports, types, program, sourceFile, exportedIds, baseDir, definedTypes) {
   const referencedTypes = new Map;
   for (const exp of exports) {
     collectAllRefsWithContext(exp, referencedTypes, {
@@ -2989,36 +3484,36 @@ function collectForgottenExports(exports, types, program, sourceFile, exportedId
 }
 function resolveExportTarget(symbol, checker) {
   let targetSymbol = symbol;
-  if (symbol.flags & ts8.SymbolFlags.Alias) {
+  if (symbol.flags & ts11.SymbolFlags.Alias) {
     const aliasTarget = checker.getAliasedSymbol(symbol);
     if (aliasTarget && aliasTarget !== symbol) {
       targetSymbol = aliasTarget;
     }
   }
   const declarations = targetSymbol.declarations ?? [];
-  const declaration = targetSymbol.valueDeclaration || declarations.find((decl) => decl.kind !== ts8.SyntaxKind.ExportSpecifier) || declarations[0];
+  const declaration = targetSymbol.valueDeclaration || declarations.find((decl) => decl.kind !== ts11.SyntaxKind.ExportSpecifier) || declarations[0];
   return { declaration, targetSymbol };
 }
 function serializeDeclaration(declaration, exportSymbol, _targetSymbol, exportName, ctx) {
   let result = null;
-  if (ts8.isFunctionDeclaration(declaration)) {
+  if (ts11.isFunctionDeclaration(declaration)) {
     result = serializeFunctionExport(declaration, ctx);
-  } else if (ts8.isClassDeclaration(declaration)) {
+  } else if (ts11.isClassDeclaration(declaration)) {
     result = serializeClass(declaration, ctx);
-  } else if (ts8.isInterfaceDeclaration(declaration)) {
+  } else if (ts11.isInterfaceDeclaration(declaration)) {
     result = serializeInterface(declaration, ctx);
-  } else if (ts8.isTypeAliasDeclaration(declaration)) {
+  } else if (ts11.isTypeAliasDeclaration(declaration)) {
     result = serializeTypeAlias(declaration, ctx);
-  } else if (ts8.isEnumDeclaration(declaration)) {
+  } else if (ts11.isEnumDeclaration(declaration)) {
     result = serializeEnum(declaration, ctx);
-  } else if (ts8.isVariableDeclaration(declaration)) {
+  } else if (ts11.isVariableDeclaration(declaration)) {
     const varStatement = declaration.parent?.parent;
-    if (varStatement && ts8.isVariableStatement(varStatement)) {
+    if (varStatement && ts11.isVariableStatement(varStatement)) {
       result = serializeVariable(declaration, varStatement, ctx);
     }
-  } else if (ts8.isNamespaceExport(declaration) || ts8.isModuleDeclaration(declaration)) {
+  } else if (ts11.isNamespaceExport(declaration) || ts11.isModuleDeclaration(declaration)) {
     result = serializeNamespaceExport(exportSymbol, exportName, ctx);
-  } else if (ts8.isSourceFile(declaration)) {
+  } else if (ts11.isSourceFile(declaration)) {
     result = serializeNamespaceExport(exportSymbol, exportName, ctx);
   }
   if (result) {
@@ -3031,7 +3526,7 @@ function serializeNamespaceExport(symbol, exportName, ctx) {
   const members = [];
   const checker = ctx.program.getTypeChecker();
   let targetSymbol = symbol;
-  if (symbol.flags & ts8.SymbolFlags.Alias) {
+  if (symbol.flags & ts11.SymbolFlags.Alias) {
     const aliased = checker.getAliasedSymbol(symbol);
     if (aliased && aliased !== symbol) {
       targetSymbol = aliased;
@@ -3058,30 +3553,31 @@ function serializeNamespaceExport(symbol, exportName, ctx) {
 function serializeNamespaceMember(symbol, memberName, ctx) {
   const checker = ctx.program.getTypeChecker();
   let targetSymbol = symbol;
-  if (symbol.flags & ts8.SymbolFlags.Alias) {
+  if (symbol.flags & ts11.SymbolFlags.Alias) {
     const aliased = checker.getAliasedSymbol(symbol);
     if (aliased && aliased !== symbol) {
       targetSymbol = aliased;
     }
   }
   const declarations = targetSymbol.declarations ?? [];
-  const declaration = targetSymbol.valueDeclaration || declarations.find((d) => d.kind !== ts8.SyntaxKind.ExportSpecifier) || declarations[0];
+  const declaration = targetSymbol.valueDeclaration || declarations.find((d) => d.kind !== ts11.SyntaxKind.ExportSpecifier) || declarations[0];
   if (!declaration)
     return null;
+  const type = checker.getTypeAtLocation(declaration);
+  const callSignatures = type.getCallSignatures();
+  const deprecated = isSymbolDeprecated(targetSymbol);
   let kind = "variable";
-  if (ts8.isFunctionDeclaration(declaration) || ts8.isFunctionExpression(declaration)) {
+  if (ts11.isFunctionDeclaration(declaration) || ts11.isFunctionExpression(declaration)) {
     kind = "function";
-  } else if (ts8.isClassDeclaration(declaration)) {
+  } else if (ts11.isClassDeclaration(declaration)) {
     kind = "class";
-  } else if (ts8.isInterfaceDeclaration(declaration)) {
+  } else if (ts11.isInterfaceDeclaration(declaration)) {
     kind = "interface";
-  } else if (ts8.isTypeAliasDeclaration(declaration)) {
+  } else if (ts11.isTypeAliasDeclaration(declaration)) {
     kind = "type";
-  } else if (ts8.isEnumDeclaration(declaration)) {
+  } else if (ts11.isEnumDeclaration(declaration)) {
     kind = "enum";
-  } else if (ts8.isVariableDeclaration(declaration)) {
-    const type = checker.getTypeAtLocation(declaration);
-    const callSignatures = type.getCallSignatures();
+  } else if (ts11.isVariableDeclaration(declaration)) {
     if (callSignatures.length > 0) {
       kind = "function";
     }
@@ -3089,10 +3585,38 @@ function serializeNamespaceMember(symbol, memberName, ctx) {
   const docComment = targetSymbol.getDocumentationComment(checker);
   const description = docComment.map((c) => c.text).join(`
 `) || undefined;
+  let signatures;
+  if (kind === "function" && callSignatures.length > 0) {
+    signatures = callSignatures.map((sig, index) => {
+      const params = extractParameters(sig, ctx);
+      const returnType = checker.getReturnTypeOfSignature(sig);
+      registerReferencedTypes(returnType, ctx);
+      const returnSchema = buildSchema(returnType, ctx.typeChecker, ctx);
+      const sigDoc = getJSDocForSignature(sig);
+      const sigTypeParams = extractTypeParametersFromSignature(sig, ctx.typeChecker);
+      return {
+        parameters: params,
+        returns: { schema: returnSchema },
+        ...sigDoc.description ? { description: sigDoc.description } : {},
+        ...sigDoc.tags.length > 0 ? { tags: sigDoc.tags } : {},
+        ...sigDoc.examples.length > 0 ? { examples: sigDoc.examples } : {},
+        ...sigTypeParams ? { typeParameters: sigTypeParams } : {},
+        ...callSignatures.length > 1 ? { overloadIndex: index } : {}
+      };
+    });
+  }
+  let schema;
+  if (kind !== "function") {
+    registerReferencedTypes(type, ctx);
+    schema = buildSchema(type, ctx.typeChecker, ctx);
+  }
   return {
     name: memberName,
     kind,
-    ...description ? { description } : {}
+    ...description ? { description } : {},
+    ...signatures ? { signatures } : {},
+    ...schema ? { schema } : {},
+    ...deprecated ? { flags: { deprecated: true } } : {}
   };
 }
 function getJSDocFromExportSymbol(symbol) {
@@ -3100,11 +3624,11 @@ function getJSDocFromExportSymbol(symbol) {
   const examples = [];
   const decl = symbol.declarations?.[0];
   if (decl) {
-    const exportDecl = ts8.isNamespaceExport(decl) ? decl.parent : decl;
-    if (exportDecl && ts8.isExportDeclaration(exportDecl)) {
-      const jsDocs = ts8.getJSDocCommentsAndTags(exportDecl);
+    const exportDecl = ts11.isNamespaceExport(decl) ? decl.parent : decl;
+    if (exportDecl && ts11.isExportDeclaration(exportDecl)) {
+      const jsDocs = ts11.getJSDocCommentsAndTags(exportDecl);
       for (const doc of jsDocs) {
-        if (ts8.isJSDoc(doc) && doc.comment) {
+        if (ts11.isJSDoc(doc) && doc.comment) {
           const commentText = typeof doc.comment === "string" ? doc.comment : doc.comment.map((c) => ("text" in c) ? c.text : "").join("");
           if (commentText) {
             return {
@@ -3189,4 +3713,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, isTypeReference, getNonNullableType, registerAdapter, findAdapter, isSchemaType, extractSchemaType, arktypeAdapter, typeboxAdapter, valibotAdapter, zodAdapter, serializeVariable, isStandardJSONSchema, detectTsRuntime, extractStandardSchemasFromTs, resolveCompiledPath, extractStandardSchemas, extractStandardSchemasFromProject, normalizeSchema, normalizeExport, normalizeType, normalizeMembers, extract };
+export { BUILTIN_TYPE_SCHEMAS, ARRAY_PROTOTYPE_METHODS, isPrimitiveName, getTypeOrigin, isBuiltinGeneric, isAnonymous, buildSchema, isPureRefSchema, withDescription, schemaIsAny, schemasAreEqual, deduplicateSchemas, findDiscriminatorProperty, TypeRegistry, getJSDocComment, getSourceLocation, getParamDescription, extractTypeParameters, isSymbolDeprecated, createProgram, isStandardJSONSchema, detectTsRuntime, extractStandardSchemasFromTs, resolveCompiledPath, extractStandardSchemas, extractStandardSchemasFromProject, extractParameters, registerReferencedTypes, serializeClass, serializeEnum, serializeFunctionExport, serializeInterface, serializeTypeAlias, isTypeReference, getNonNullableType, registerAdapter, findAdapter, isSchemaType, extractSchemaType, arktypeAdapter, typeboxAdapter, valibotAdapter, zodAdapter, serializeVariable, normalizeSchema, normalizeExport, normalizeType, normalizeMembers, extract };