@openpkg-ts/extract 0.11.4 → 0.13.0

package/dist/shared/chunk-ksf9k654.js

@@ -0,0 +1,1662 @@
+// src/ast/registry.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import ts from "typescript";
+var PRIMITIVES = new Set([
+  "string",
+  "number",
+  "boolean",
+  "void",
+  "any",
+  "undefined",
+  "null",
+  "never",
+  "unknown",
+  "object",
+  "symbol",
+  "bigint"
+]);
+var BUILTINS = new Set([
+  "Array",
+  "ArrayBuffer",
+  "ArrayBufferLike",
+  "ArrayLike",
+  "Promise",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Date",
+  "RegExp",
+  "Error",
+  "Function",
+  "Object",
+  "String",
+  "Number",
+  "Boolean",
+  "Symbol",
+  "BigInt",
+  "Uint8Array",
+  "Int8Array",
+  "Uint16Array",
+  "Int16Array",
+  "Uint32Array",
+  "Int32Array",
+  "Float32Array",
+  "Float64Array",
+  "BigInt64Array",
+  "BigUint64Array",
+  "DataView",
+  "ReadonlyArray",
+  "Readonly",
+  "Partial",
+  "Required",
+  "Pick",
+  "Omit",
+  "Record",
+  "Exclude",
+  "Extract",
+  "NonNullable",
+  "Parameters",
+  "ReturnType",
+  "ConstructorParameters",
+  "InstanceType",
+  "ThisType",
+  "Awaited",
+  "PromiseLike",
+  "Iterable",
+  "Iterator",
+  "IterableIterator",
+  "Generator",
+  "AsyncGenerator",
+  "AsyncIterable",
+  "AsyncIterator",
+  "AsyncIterableIterator",
+  "SharedArrayBuffer",
+  "Atomics",
+  "JSON",
+  "Math",
+  "console",
+  "globalThis"
+]);
+function isGenericTypeParameter(name) {
+  if (/^[A-Z]$/.test(name))
+    return true;
+  if (/^T[A-Z]/.test(name))
+    return true;
+  if (["Key", "Value", "Item", "Element"].includes(name))
+    return true;
+  return false;
+}
+function isExternalType(decl) {
+  const sourceFile = decl.getSourceFile();
+  if (!sourceFile)
+    return false;
+  return sourceFile.fileName.includes("node_modules");
+}
+function extractPackageName(filePath) {
+  const nmIndex = filePath.lastIndexOf("node_modules");
+  if (nmIndex === -1)
+    return;
+  const afterNm = filePath.slice(nmIndex + "node_modules/".length);
+  const parts = afterNm.split("/");
+  if (parts[0].startsWith("@") && parts.length >= 2) {
+    return `${parts[0]}/${parts[1]}`;
+  }
+  return parts[0];
+}
+function getPackageVersion(filePath, packageName) {
+  const nmIndex = filePath.lastIndexOf("node_modules");
+  if (nmIndex === -1)
+    return;
+  const nmDir = filePath.slice(0, nmIndex + "node_modules".length);
+  const pkgJsonPath = path.join(nmDir, packageName, "package.json");
+  try {
+    if (fs.existsSync(pkgJsonPath)) {
+      const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+      return pkg.version;
+    }
+  } catch {}
+  return;
+}
+function buildExternalSource(decl) {
+  const sourceFile = decl.getSourceFile();
+  if (!sourceFile)
+    return;
+  const filePath = sourceFile.fileName;
+  if (!filePath.includes("node_modules"))
+    return;
+  const packageName = extractPackageName(filePath);
+  if (!packageName)
+    return;
+  const version = getPackageVersion(filePath, packageName);
+  return {
+    file: filePath,
+    package: packageName,
+    version
+  };
+}
+
+class TypeRegistry {
+  types = new Map;
+  processing = new Set;
+  add(type) {
+    this.types.set(type.id, type);
+  }
+  get(id) {
+    return this.types.get(id);
+  }
+  has(id) {
+    return this.types.has(id);
+  }
+  getAll() {
+    return Array.from(this.types.values());
+  }
+  registerType(type, checker, exportedIds) {
+    const symbol = type.getSymbol() || type.aliasSymbol;
+    if (!symbol)
+      return;
+    const name = symbol.getName();
+    if (PRIMITIVES.has(name))
+      return;
+    if (BUILTINS.has(name))
+      return;
+    if (name.startsWith("__"))
+      return;
+    if (symbol.flags & ts.SymbolFlags.EnumMember)
+      return;
+    if (symbol.flags & ts.SymbolFlags.TypeParameter)
+      return;
+    if (isGenericTypeParameter(name))
+      return;
+    if (this.has(name))
+      return name;
+    if (exportedIds.has(name))
+      return name;
+    if (this.processing.has(name))
+      return name;
+    this.processing.add(name);
+    try {
+      const specType = this.buildSpecType(symbol, type, checker);
+      if (specType) {
+        this.add(specType);
+        return specType.id;
+      }
+    } finally {
+      this.processing.delete(name);
+    }
+    return;
+  }
+  buildSpecType(symbol, type, checker) {
+    const name = symbol.getName();
+    const decl = symbol.declarations?.[0];
+    let kind = "type";
+    const external = decl ? isExternalType(decl) : false;
+    if (decl) {
+      if (ts.isClassDeclaration(decl))
+        kind = "class";
+      else if (ts.isInterfaceDeclaration(decl))
+        kind = "interface";
+      else if (ts.isEnumDeclaration(decl))
+        kind = "enum";
+    }
+    if (external) {
+      kind = "external";
+    }
+    const source = decl ? buildExternalSource(decl) : undefined;
+    const schema = this.buildShallowSchema(type, checker);
+    let members;
+    if (decl && (ts.isClassDeclaration(decl) || ts.isInterfaceDeclaration(decl))) {
+      members = this.extractShallowMembers(decl, checker);
+    }
+    return {
+      id: name,
+      name,
+      kind,
+      schema,
+      members: members?.length ? members : undefined,
+      ...external ? { external: true } : {},
+      ...source ? { source } : {}
+    };
+  }
+  buildShallowSchema(type, checker) {
+    if (type.isUnion()) {
+      const allEnumLiterals = type.types.every((t) => t.flags & (ts.TypeFlags.EnumLiteral | ts.TypeFlags.NumberLiteral));
+      if (allEnumLiterals) {
+        const values = type.types.map((t) => {
+          if (t.flags & ts.TypeFlags.NumberLiteral) {
+            return t.value;
+          }
+          return checker.typeToString(t);
+        }).filter((v) => v !== undefined);
+        if (values.every((v) => typeof v === "number")) {
+          return { type: "number", enum: values };
+        }
+        return { type: "string", enum: values };
+      }
+      return {
+        anyOf: type.types.map((t) => {
+          if (t.flags & ts.TypeFlags.EnumLiteral) {
+            const value = t.value;
+            if (typeof value === "number") {
+              return { type: "number", enum: [value] };
+            }
+            return { type: checker.typeToString(t) };
+          }
+          const sym = t.getSymbol() || t.aliasSymbol;
+          if (sym && sym.flags & ts.SymbolFlags.EnumMember) {
+            return { type: checker.typeToString(t) };
+          }
+          if (sym && !sym.getName().startsWith("__")) {
+            return { $ref: sym.getName() };
+          }
+          if (t.flags & ts.TypeFlags.StringLiteral) {
+            return { type: "string", enum: [t.value] };
+          }
+          if (t.flags & ts.TypeFlags.NumberLiteral) {
+            return { type: "number", enum: [t.value] };
+          }
+          return { type: checker.typeToString(t) };
+        })
+      };
+    }
+    if (type.isIntersection()) {
+      return {
+        allOf: type.types.map((t) => {
+          const sym = t.getSymbol() || t.aliasSymbol;
+          if (sym && !sym.getName().startsWith("__")) {
+            return { $ref: sym.getName() };
+          }
+          return { type: checker.typeToString(t) };
+        })
+      };
+    }
+    const props = type.getProperties();
+    if (props.length > 0) {
+      const properties = {};
+      const required = [];
+      for (const prop of props.slice(0, 30)) {
+        const propName = prop.getName();
+        if (propName.startsWith("_"))
+          continue;
+        const propType = checker.getTypeOfSymbol(prop);
+        const callSigs = propType.getCallSignatures();
+        if (callSigs.length > 0) {
+          properties[propName] = { type: "function" };
+        } else {
+          const propSym = propType.getSymbol() || propType.aliasSymbol;
+          const symName = propSym?.getName();
+          if (propSym && symName && !symName.startsWith("__") && symName !== propName) {
+            properties[propName] = { $ref: symName };
+          } else {
+            properties[propName] = { type: checker.typeToString(propType) };
+          }
+        }
+        if (!(prop.flags & ts.SymbolFlags.Optional)) {
+          required.push(propName);
+        }
+      }
+      return {
+        type: "object",
+        properties,
+        ...required.length ? { required } : {}
+      };
+    }
+    return { type: checker.typeToString(type) };
+  }
+  extractShallowMembers(decl, checker) {
+    const members = [];
+    for (const member of decl.members) {
+      if (ts.isPropertyDeclaration(member) || ts.isPropertySignature(member)) {
+        const name = member.name?.getText();
+        if (!name || name.startsWith("#") || name.startsWith("_"))
+          continue;
+        const type = checker.getTypeAtLocation(member);
+        const sym = type.getSymbol() || type.aliasSymbol;
+        members.push({
+          name,
+          kind: "property",
+          schema: sym && !sym.getName().startsWith("__") ? { $ref: sym.getName() } : { type: checker.typeToString(type) }
+        });
+      } else if (ts.isMethodDeclaration(member) || ts.isMethodSignature(member)) {
+        const name = member.name?.getText();
+        if (!name || name.startsWith("#") || name.startsWith("_"))
+          continue;
+        members.push({
+          name,
+          kind: "method"
+        });
+      }
+    }
+    return members;
+  }
+  registerFromSymbol(symbol, checker) {
+    const name = symbol.getName();
+    if (this.has(name))
+      return this.get(name);
+    const type = checker.getDeclaredTypeOfSymbol(symbol);
+    const specType = this.buildSpecType(symbol, type, checker);
+    if (specType) {
+      this.add(specType);
+      return specType;
+    }
+    return;
+  }
+}
+
+// src/ast/utils.ts
+import ts2 from "typescript";
+function parseExamplesFromTags(tags) {
+  const examples = [];
+  for (const tag of tags) {
+    if (tag.name !== "example")
+      continue;
+    const text = tag.text.trim();
+    const fenceMatch = text.match(/^```(\w*)\n([\s\S]*?)\n?```$/);
+    if (fenceMatch) {
+      const lang = fenceMatch[1] || undefined;
+      const code = fenceMatch[2].trim();
+      const example = { code };
+      if (lang && ["ts", "js", "tsx", "jsx", "shell", "json"].includes(lang)) {
+        example.language = lang;
+      }
+      examples.push(example);
+    } else if (text) {
+      examples.push({ code: text });
+    }
+  }
+  return examples;
+}
+function getJSDocComment(node) {
+  const jsDocTags = ts2.getJSDocTags(node);
+  const tags = jsDocTags.map((tag) => ({
+    name: tag.tagName.text,
+    text: typeof tag.comment === "string" ? tag.comment : ts2.getTextOfJSDocComment(tag.comment) ?? ""
+  }));
+  const jsDocComments = node.jsDoc;
+  let description;
+  if (jsDocComments && jsDocComments.length > 0) {
+    const firstDoc = jsDocComments[0];
+    if (firstDoc.comment) {
+      description = typeof firstDoc.comment === "string" ? firstDoc.comment : ts2.getTextOfJSDocComment(firstDoc.comment);
+    }
+  }
+  const examples = parseExamplesFromTags(tags);
+  return { description, tags, examples };
+}
+function getSourceLocation(node, sourceFile) {
+  const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+  return {
+    file: sourceFile.fileName,
+    line: line + 1
+  };
+}
+function getParamDescription(propertyName, jsdocTags, inferredAlias) {
+  for (const tag of jsdocTags) {
+    if (tag.tagName.text !== "param")
+      continue;
+    const paramTag = tag;
+    const tagParamName = paramTag.name?.getText() ?? "";
+    const isMatch = tagParamName === propertyName || inferredAlias && tagParamName === `${inferredAlias}.${propertyName}` || tagParamName.endsWith(`.${propertyName}`);
+    if (isMatch) {
+      const comment = typeof tag.comment === "string" ? tag.comment : ts2.getTextOfJSDocComment(tag.comment);
+      return comment?.trim() || undefined;
+    }
+  }
+  return;
+}
+function extractTypeParameters(node, checker) {
+  if (!node.typeParameters || node.typeParameters.length === 0) {
+    return;
+  }
+  return node.typeParameters.map((tp) => {
+    const name = tp.name.text;
+    let constraint;
+    if (tp.constraint) {
+      const constraintType = checker.getTypeAtLocation(tp.constraint);
+      constraint = checker.typeToString(constraintType);
+    }
+    let defaultType;
+    if (tp.default) {
+      const defType = checker.getTypeAtLocation(tp.default);
+      defaultType = checker.typeToString(defType);
+    }
+    return {
+      name,
+      ...constraint ? { constraint } : {},
+      ...defaultType ? { default: defaultType } : {}
+    };
+  });
+}
+
+// src/compiler/program.ts
+import * as path2 from "node:path";
+import ts3 from "typescript";
+var DEFAULT_COMPILER_OPTIONS = {
+  target: ts3.ScriptTarget.Latest,
+  module: ts3.ModuleKind.CommonJS,
+  lib: ["lib.es2021.d.ts"],
+  declaration: true,
+  moduleResolution: ts3.ModuleResolutionKind.NodeJs
+};
+function createProgram({
+  entryFile,
+  baseDir = path2.dirname(entryFile),
+  content
+}) {
+  const configPath = ts3.findConfigFile(baseDir, ts3.sys.fileExists, "tsconfig.json");
+  let compilerOptions = { ...DEFAULT_COMPILER_OPTIONS };
+  if (configPath) {
+    const configFile = ts3.readConfigFile(configPath, ts3.sys.readFile);
+    const parsedConfig = ts3.parseJsonConfigFileContent(configFile.config, ts3.sys, path2.dirname(configPath));
+    compilerOptions = { ...compilerOptions, ...parsedConfig.options };
+  }
+  const allowJsVal = compilerOptions.allowJs;
+  if (typeof allowJsVal === "boolean" && allowJsVal) {
+    compilerOptions = { ...compilerOptions, allowJs: false, checkJs: false };
+  }
+  const compilerHost = ts3.createCompilerHost(compilerOptions, true);
+  let inMemorySource;
+  if (content !== undefined) {
+    inMemorySource = ts3.createSourceFile(entryFile, content, ts3.ScriptTarget.Latest, true, ts3.ScriptKind.TS);
+    const originalGetSourceFile = compilerHost.getSourceFile.bind(compilerHost);
+    compilerHost.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
+      if (fileName === entryFile) {
+        return inMemorySource;
+      }
+      return originalGetSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
+    };
+  }
+  const program = ts3.createProgram([entryFile], compilerOptions, compilerHost);
+  const sourceFile = inMemorySource ?? program.getSourceFile(entryFile);
+  return {
+    program,
+    compilerHost,
+    compilerOptions,
+    sourceFile,
+    configPath
+  };
+}
+
+// src/types/schema-builder.ts
+import ts4 from "typescript";
+var PRIMITIVES2 = new Set([
+  "string",
+  "number",
+  "boolean",
+  "void",
+  "undefined",
+  "null",
+  "any",
+  "unknown",
+  "never",
+  "object",
+  "symbol",
+  "bigint"
+]);
+var BUILTIN_GENERICS = new Set([
+  "Array",
+  "ReadonlyArray",
+  "Promise",
+  "PromiseLike",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Iterable",
+  "Iterator",
+  "IterableIterator",
+  "AsyncIterable",
+  "AsyncIterator",
+  "AsyncIterableIterator",
+  "Generator",
+  "AsyncGenerator",
+  "Partial",
+  "Required",
+  "Readonly",
+  "Pick",
+  "Omit",
+  "Record",
+  "Exclude",
+  "Extract",
+  "NonNullable",
+  "Parameters",
+  "ReturnType",
+  "ConstructorParameters",
+  "InstanceType",
+  "Awaited"
+]);
+var BUILTIN_TYPES = new Set([
+  "Date",
+  "RegExp",
+  "Error",
+  "Function",
+  "ArrayBuffer",
+  "SharedArrayBuffer",
+  "DataView",
+  "Uint8Array",
+  "Int8Array",
+  "Uint16Array",
+  "Int16Array",
+  "Uint32Array",
+  "Int32Array",
+  "Float32Array",
+  "Float64Array",
+  "BigInt64Array",
+  "BigUint64Array"
+]);
+function isPrimitiveName(name) {
+  return PRIMITIVES2.has(name);
+}
+function isBuiltinGeneric(name) {
+  return BUILTIN_GENERICS.has(name);
+}
+function isAnonymous(type) {
+  const symbol = type.getSymbol() || type.aliasSymbol;
+  if (!symbol)
+    return true;
+  const name = symbol.getName();
+  return name.startsWith("__") || name === "";
+}
+function withDepth(ctx, fn) {
+  ctx.currentDepth++;
+  try {
+    return fn();
+  } finally {
+    ctx.currentDepth--;
+  }
+}
+function isAtMaxDepth(ctx) {
+  if (!ctx)
+    return false;
+  return ctx.currentDepth >= ctx.maxTypeDepth;
+}
+function buildSchema(type, checker, ctx, _depth = 0) {
+  if (isAtMaxDepth(ctx)) {
+    return { type: checker.typeToString(type) };
+  }
+  if (ctx && ctx.visitedTypes.has(type)) {
+    const symbol2 = type.getSymbol() || type.aliasSymbol;
+    if (symbol2) {
+      return { $ref: symbol2.getName() };
+    }
+    return { type: checker.typeToString(type) };
+  }
+  if (type.flags & ts4.TypeFlags.String)
+    return { type: "string" };
+  if (type.flags & ts4.TypeFlags.Number)
+    return { type: "number" };
+  if (type.flags & ts4.TypeFlags.Boolean)
+    return { type: "boolean" };
+  if (type.flags & ts4.TypeFlags.Undefined)
+    return { type: "undefined" };
+  if (type.flags & ts4.TypeFlags.Null)
+    return { type: "null" };
+  if (type.flags & ts4.TypeFlags.Void)
+    return { type: "void" };
+  if (type.flags & ts4.TypeFlags.Any)
+    return { type: "any" };
+  if (type.flags & ts4.TypeFlags.Unknown)
+    return { type: "unknown" };
+  if (type.flags & ts4.TypeFlags.Never)
+    return { type: "never" };
+  if (type.flags & ts4.TypeFlags.BigInt)
+    return { type: "bigint" };
+  if (type.flags & ts4.TypeFlags.ESSymbol)
+    return { type: "symbol" };
+  if (type.flags & ts4.TypeFlags.StringLiteral) {
+    const literal = type.value;
+    return { type: "string", enum: [literal] };
+  }
+  if (type.flags & ts4.TypeFlags.NumberLiteral) {
+    const literal = type.value;
+    return { type: "number", enum: [literal] };
+  }
+  if (type.flags & ts4.TypeFlags.BooleanLiteral) {
+    const intrinsicName = type.intrinsicName;
+    return { type: "boolean", enum: [intrinsicName === "true"] };
+  }
+  if (type.isUnion()) {
+    const types = type.types;
+    const allStringLiterals = types.every((t) => t.flags & ts4.TypeFlags.StringLiteral);
+    if (allStringLiterals) {
+      const enumValues = types.map((t) => t.value);
+      return { type: "string", enum: enumValues };
+    }
+    const allNumberLiterals = types.every((t) => t.flags & ts4.TypeFlags.NumberLiteral);
+    if (allNumberLiterals) {
+      const enumValues = types.map((t) => t.value);
+      return { type: "number", enum: enumValues };
+    }
+    if (ctx) {
+      return withDepth(ctx, () => ({
+        anyOf: types.map((t) => buildSchema(t, checker, ctx))
+      }));
+    }
+    return { anyOf: types.map((t) => buildSchema(t, checker, ctx)) };
+  }
+  if (type.isIntersection()) {
+    if (ctx) {
+      return withDepth(ctx, () => ({
+        allOf: type.types.map((t) => buildSchema(t, checker, ctx))
+      }));
+    }
+    return { allOf: type.types.map((t) => buildSchema(t, checker, ctx)) };
+  }
+  if (checker.isArrayType(type)) {
+    const typeRef2 = type;
+    const elementType = typeRef2.typeArguments?.[0];
+    if (elementType) {
+      if (ctx) {
+        return withDepth(ctx, () => ({
+          type: "array",
+          items: buildSchema(elementType, checker, ctx)
+        }));
+      }
+      return { type: "array", items: buildSchema(elementType, checker, ctx) };
+    }
+    return { type: "array" };
+  }
+  if (checker.isTupleType(type)) {
+    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 {
+      type: "array",
+      prefixedItems: elementTypes.map((t) => buildSchema(t, checker, ctx)),
+      minItems: elementTypes.length,
+      maxItems: elementTypes.length
+    };
+  }
+  const typeRef = type;
+  if (typeRef.target && typeRef.typeArguments && typeRef.typeArguments.length > 0) {
+    const symbol2 = typeRef.target.getSymbol();
+    const name = symbol2?.getName();
+    if (name && BUILTIN_TYPES.has(name)) {
+      return { $ref: name };
+    }
+    if (name && (isBuiltinGeneric(name) || !isAnonymous(typeRef.target))) {
+      if (ctx) {
+        return withDepth(ctx, () => ({
+          $ref: name,
+          typeArguments: typeRef.typeArguments.map((t) => buildSchema(t, checker, ctx))
+        }));
+      }
+      return {
+        $ref: name,
+        typeArguments: typeRef.typeArguments.map((t) => buildSchema(t, checker, ctx))
+      };
+    }
+  }
+  const symbol = type.getSymbol() || type.aliasSymbol;
+  if (symbol && !isAnonymous(type)) {
+    const name = symbol.getName();
+    if (isPrimitiveName(name)) {
+      return { type: name };
+    }
+    if (BUILTIN_TYPES.has(name)) {
+      return { $ref: name };
+    }
+    if (!name.startsWith("__")) {
+      return { $ref: name };
+    }
+  }
+  if (type.flags & ts4.TypeFlags.Object) {
+    const objectType = type;
+    const callSignatures = type.getCallSignatures();
+    if (callSignatures.length > 0) {
+      return buildFunctionSchema(callSignatures, checker, ctx);
+    }
+    const properties = type.getProperties();
+    if (properties.length > 0 || objectType.objectFlags & ts4.ObjectFlags.Anonymous) {
+      return buildObjectSchema(properties, checker, ctx);
+    }
+  }
+  return { type: checker.typeToString(type) };
+}
+function buildFunctionSchema(callSignatures, checker, ctx) {
+  const buildSignatures = () => {
+    const signatures = callSignatures.map((sig) => {
+      const params = sig.getParameters().map((param) => {
+        const paramType = checker.getTypeOfSymbolAtLocation(param, param.valueDeclaration);
+        return {
+          name: param.getName(),
+          schema: buildSchema(paramType, checker, ctx),
+          required: !(param.flags & ts4.SymbolFlags.Optional)
+        };
+      });
+      const returnType = checker.getReturnTypeOfSignature(sig);
+      return {
+        parameters: params,
+        returns: {
+          schema: buildSchema(returnType, checker, ctx)
+        }
+      };
+    });
+    return signatures;
+  };
+  if (ctx) {
+    return withDepth(ctx, () => ({ type: "function", signatures: buildSignatures() }));
+  }
+  return { type: "function", signatures: buildSignatures() };
+}
+function buildObjectSchema(properties, checker, ctx) {
+  const buildProps = () => {
+    const props = {};
+    const required = [];
+    for (const prop of properties) {
+      const propName = prop.getName();
+      if (propName.startsWith("_"))
+        continue;
+      const propType = checker.getTypeOfSymbol(prop);
+      props[propName] = buildSchema(propType, checker, ctx);
+      if (!(prop.flags & ts4.SymbolFlags.Optional)) {
+        required.push(propName);
+      }
+    }
+    return {
+      type: "object",
+      properties: props,
+      ...required.length > 0 ? { required } : {}
+    };
+  };
+  if (ctx) {
+    return withDepth(ctx, buildProps);
+  }
+  return buildProps();
+}
+
+// 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) {
+  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, exportedIds } = ctx;
+  typeRegistry.registerType(type, checker, exportedIds);
+  const typeArgs = type.typeArguments;
+  if (typeArgs) {
+    for (const arg of typeArgs) {
+      registerReferencedTypes(arg, ctx);
+    }
+  }
+  if (type.isUnion()) {
+    for (const t of type.types) {
+      registerReferencedTypes(t, ctx);
+    }
+  }
+  if (type.isIntersection()) {
+    for (const t of type.types) {
+      registerReferencedTypes(t, ctx);
+    }
+  }
+}
+
+// src/serializers/classes.ts
+import ts6 from "typescript";
+function serializeClass(node, ctx) {
+  const { typeChecker: checker } = ctx;
+  const symbol = checker.getSymbolAtLocation(node.name ?? node);
+  const name = symbol?.getName() ?? node.name?.getText();
+  if (!name)
+    return null;
+  const declSourceFile = node.getSourceFile();
+  const { description, tags, examples } = getJSDocComment(node);
+  const source = getSourceLocation(node, declSourceFile);
+  const typeParameters = extractTypeParameters(node, checker);
+  const members = [];
+  const signatures = [];
+  const methodsByName = new Map;
+  for (const member of node.members) {
+    const memberName = getMemberName(member);
+    if (memberName?.startsWith("#"))
+      continue;
+    if (ts6.isPropertyDeclaration(member)) {
+      const propMember = serializeProperty(member, ctx);
+      if (propMember)
+        members.push(propMember);
+    } else if (ts6.isMethodDeclaration(member)) {
+      const methodMember = serializeMethod(member, ctx);
+      if (methodMember && methodMember.name) {
+        if (!methodsByName.has(methodMember.name)) {
+          methodsByName.set(methodMember.name, methodMember);
+        } else {
+          const existing = methodsByName.get(methodMember.name);
+          if (!existing.description && methodMember.description) {
+            existing.description = methodMember.description;
+          }
+          if (!existing.tags && methodMember.tags) {
+            existing.tags = methodMember.tags;
+          }
+        }
+      }
+    } else if (ts6.isConstructorDeclaration(member)) {
+      const ctorSig = serializeConstructor(member, ctx);
+      if (ctorSig)
+        signatures.push(ctorSig);
+    } else if (ts6.isGetAccessorDeclaration(member) || ts6.isSetAccessorDeclaration(member)) {
+      const accessorMember = serializeAccessor(member, ctx);
+      if (accessorMember)
+        members.push(accessorMember);
+    }
+  }
+  members.push(...methodsByName.values());
+  const extendsClause = getExtendsClause(node, checker);
+  const implementsClause = getImplementsClause(node, checker);
+  return {
+    id: name,
+    name,
+    kind: "class",
+    description,
+    tags,
+    source,
+    typeParameters,
+    members: members.length > 0 ? members : undefined,
+    signatures: signatures.length > 0 ? signatures : undefined,
+    extends: extendsClause,
+    implements: implementsClause?.length ? implementsClause : undefined,
+    ...examples.length > 0 ? { examples } : {}
+  };
+}
+function getMemberName(member) {
+  if (ts6.isConstructorDeclaration(member))
+    return "constructor";
+  if (!member.name)
+    return;
+  if (ts6.isIdentifier(member.name))
+    return member.name.text;
+  if (ts6.isPrivateIdentifier(member.name))
+    return member.name.text;
+  return member.name.getText();
+}
+function getVisibility(member) {
+  const modifiers = ts6.getModifiers(member);
+  if (!modifiers)
+    return;
+  for (const mod of modifiers) {
+    if (mod.kind === ts6.SyntaxKind.PrivateKeyword)
+      return "private";
+    if (mod.kind === ts6.SyntaxKind.ProtectedKeyword)
+      return "protected";
+    if (mod.kind === ts6.SyntaxKind.PublicKeyword)
+      return "public";
+  }
+  return;
+}
+function isStatic(member) {
+  const modifiers = ts6.getModifiers(member);
+  return modifiers?.some((m) => m.kind === ts6.SyntaxKind.StaticKeyword) ?? false;
+}
+function isReadonly(member) {
+  const modifiers = ts6.getModifiers(member);
+  return modifiers?.some((m) => m.kind === ts6.SyntaxKind.ReadonlyKeyword) ?? false;
+}
+function serializeProperty(node, ctx) {
+  const { typeChecker: checker } = ctx;
+  const name = getMemberName(node);
+  if (!name)
+    return null;
+  const { description, tags } = getJSDocComment(node);
+  const visibility = getVisibility(node);
+  const type = checker.getTypeAtLocation(node);
+  const schema = buildSchema(type, checker, ctx);
+  registerReferencedTypes(type, ctx);
+  const flags = {};
+  if (isStatic(node))
+    flags.static = true;
+  if (isReadonly(node))
+    flags.readonly = true;
+  if (node.questionToken)
+    flags.optional = true;
+  return {
+    name,
+    kind: "property",
+    description,
+    tags: tags.length > 0 ? tags : undefined,
+    visibility,
+    schema,
+    flags: Object.keys(flags).length > 0 ? flags : undefined
+  };
+}
+function serializeMethod(node, ctx) {
+  const { typeChecker: checker } = ctx;
+  const name = getMemberName(node);
+  if (!name)
+    return null;
+  const { description, tags } = getJSDocComment(node);
+  const visibility = getVisibility(node);
+  const type = checker.getTypeAtLocation(node);
+  const callSignatures = type.getCallSignatures();
+  const signatures = callSignatures.map((sig) => {
+    const params = extractParameters(sig, ctx);
+    const returnType = checker.getReturnTypeOfSignature(sig);
+    registerReferencedTypes(returnType, ctx);
+    return {
+      parameters: params.length > 0 ? params : undefined,
+      returns: {
+        schema: buildSchema(returnType, checker, ctx)
+      }
+    };
+  });
+  const flags = {};
+  if (isStatic(node))
+    flags.static = true;
+  if (node.asteriskToken)
+    flags.generator = true;
+  const modifiers = ts6.getModifiers(node);
+  if (modifiers?.some((m) => m.kind === ts6.SyntaxKind.AsyncKeyword)) {
+    flags.async = true;
+  }
+  return {
+    name,
+    kind: "method",
+    description,
+    tags: tags.length > 0 ? tags : undefined,
+    visibility,
+    signatures: signatures.length > 0 ? signatures : undefined,
+    flags: Object.keys(flags).length > 0 ? flags : undefined
+  };
+}
+function serializeConstructor(node, ctx) {
+  const { typeChecker: checker } = ctx;
+  const { description } = getJSDocComment(node);
+  const sig = checker.getSignatureFromDeclaration(node);
+  if (!sig)
+    return null;
+  const params = extractParameters(sig, ctx);
+  return {
+    description,
+    parameters: params.length > 0 ? params : undefined
+  };
+}
+function serializeAccessor(node, ctx) {
+  const { typeChecker: checker } = ctx;
+  const name = getMemberName(node);
+  if (!name)
+    return null;
+  const { description, tags } = getJSDocComment(node);
+  const visibility = getVisibility(node);
+  const type = checker.getTypeAtLocation(node);
+  const schema = buildSchema(type, checker, ctx);
+  registerReferencedTypes(type, ctx);
+  const kind = ts6.isGetAccessorDeclaration(node) ? "getter" : "setter";
+  const flags = {};
+  if (isStatic(node))
+    flags.static = true;
+  return {
+    name,
+    kind,
+    description,
+    tags: tags.length > 0 ? tags : undefined,
+    visibility,
+    schema,
+    flags: Object.keys(flags).length > 0 ? flags : undefined
+  };
+}
+function getExtendsClause(node, checker) {
+  if (!node.heritageClauses)
+    return;
+  for (const clause of node.heritageClauses) {
+    if (clause.token === ts6.SyntaxKind.ExtendsKeyword) {
+      const expr = clause.types[0];
+      if (expr) {
+        const type = checker.getTypeAtLocation(expr);
+        const symbol = type.getSymbol();
+        return symbol?.getName() ?? expr.expression.getText();
+      }
+    }
+  }
+  return;
+}
+function getImplementsClause(node, checker) {
+  if (!node.heritageClauses)
+    return;
+  for (const clause of node.heritageClauses) {
+    if (clause.token === ts6.SyntaxKind.ImplementsKeyword) {
+      return clause.types.map((expr) => {
+        const type = checker.getTypeAtLocation(expr);
+        const symbol = type.getSymbol();
+        return symbol?.getName() ?? expr.expression.getText();
+      });
+    }
+  }
+  return;
+}
+
+// src/serializers/enums.ts
+function serializeEnum(node, ctx) {
+  const { typeChecker: checker } = ctx;
+  const symbol = checker.getSymbolAtLocation(node.name ?? node);
+  const name = symbol?.getName() ?? node.name?.getText();
+  if (!name)
+    return null;
+  const declSourceFile = node.getSourceFile();
+  const { description, tags, examples } = getJSDocComment(node);
+  const source = getSourceLocation(node, declSourceFile);
+  const members = node.members.map((member) => {
+    const memberSymbol = checker.getSymbolAtLocation(member.name);
+    const memberName = memberSymbol?.getName() ?? member.name.getText();
+    const constantValue = checker.getConstantValue(member);
+    let schema;
+    if (typeof constantValue === "string") {
+      schema = { type: "string", enum: [constantValue] };
+    } else if (typeof constantValue === "number") {
+      schema = { type: "number", enum: [constantValue] };
+    } else if (member.initializer) {
+      schema = { type: member.initializer.getText() };
+    }
+    const { description: memberDesc } = getJSDocComment(member);
+    return {
+      id: memberName,
+      name: memberName,
+      kind: "enum-member",
+      ...schema ? { schema } : {},
+      ...memberDesc ? { description: memberDesc } : {}
+    };
+  });
+  return {
+    id: name,
+    name,
+    kind: "enum",
+    description,
+    tags,
+    source,
+    members,
+    ...examples.length > 0 ? { examples } : {}
+  };
+}
+
+// src/serializers/functions.ts
+function serializeFunctionExport(node, ctx) {
+  const symbol = ctx.typeChecker.getSymbolAtLocation(node.name ?? node);
+  const name = symbol?.getName() ?? node.name?.getText();
+  if (!name)
+    return null;
+  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);
+  const callSignatures = type.getCallSignatures();
+  const signatures = callSignatures.map((sig) => {
+    const params = extractParameters(sig, ctx);
+    const returnType = ctx.typeChecker.getReturnTypeOfSignature(sig);
+    registerReferencedTypes(returnType, ctx);
+    return {
+      parameters: params,
+      returns: {
+        schema: buildSchema(returnType, ctx.typeChecker, ctx)
+      }
+    };
+  });
+  return {
+    id: name,
+    name,
+    kind: "function",
+    description,
+    tags,
+    source,
+    typeParameters,
+    signatures,
+    ...examples.length > 0 ? { examples } : {}
+  };
+}
+
+// src/serializers/interfaces.ts
+import ts7 from "typescript";
+function serializeInterface(node, ctx) {
+  const { typeChecker: checker } = ctx;
+  const symbol = checker.getSymbolAtLocation(node.name ?? node);
+  const name = symbol?.getName() ?? node.name?.getText();
+  if (!name)
+    return null;
+  const declSourceFile = node.getSourceFile();
+  const { description, tags, examples } = getJSDocComment(node);
+  const source = getSourceLocation(node, declSourceFile);
+  const typeParameters = extractTypeParameters(node, checker);
+  const members = [];
+  const methodsByName = new Map;
+  for (const member of node.members) {
+    if (ts7.isPropertySignature(member)) {
+      const propMember = serializePropertySignature(member, ctx);
+      if (propMember)
+        members.push(propMember);
+    } else if (ts7.isMethodSignature(member)) {
+      const methodMember = serializeMethodSignature(member, ctx);
+      if (methodMember && methodMember.name) {
+        if (!methodsByName.has(methodMember.name)) {
+          methodsByName.set(methodMember.name, methodMember);
+        }
+      }
+    } else if (ts7.isCallSignatureDeclaration(member)) {
+      const callMember = serializeCallSignature(member, ctx);
+      if (callMember)
+        members.push(callMember);
+    } else if (ts7.isIndexSignatureDeclaration(member)) {
+      const indexMember = serializeIndexSignature(member, ctx);
+      if (indexMember)
+        members.push(indexMember);
+    }
+  }
+  members.push(...methodsByName.values());
+  const extendsClause = getInterfaceExtends(node, checker);
+  return {
+    id: name,
+    name,
+    kind: "interface",
+    description,
+    tags,
+    source,
+    typeParameters,
+    members: members.length > 0 ? members : undefined,
+    extends: extendsClause,
+    ...examples.length > 0 ? { examples } : {}
+  };
+}
+function serializePropertySignature(node, ctx) {
+  const { typeChecker: checker } = ctx;
+  const name = node.name.getText();
+  const { description, tags } = getJSDocComment(node);
+  const type = checker.getTypeAtLocation(node);
+  const schema = buildSchema(type, checker, ctx);
+  registerReferencedTypes(type, ctx);
+  const flags = {};
+  if (node.questionToken)
+    flags.optional = true;
+  if (node.modifiers?.some((m) => m.kind === ts7.SyntaxKind.ReadonlyKeyword)) {
+    flags.readonly = true;
+  }
+  return {
+    name,
+    kind: "property",
+    description,
+    tags: tags.length > 0 ? tags : undefined,
+    schema,
+    flags: Object.keys(flags).length > 0 ? flags : undefined
+  };
+}
+function serializeMethodSignature(node, ctx) {
+  const { typeChecker: checker } = ctx;
+  const name = node.name.getText();
+  const { description, tags } = getJSDocComment(node);
+  const type = checker.getTypeAtLocation(node);
+  const callSignatures = type.getCallSignatures();
+  const signatures = callSignatures.map((sig) => {
+    const params = extractParameters(sig, ctx);
+    const returnType = checker.getReturnTypeOfSignature(sig);
+    registerReferencedTypes(returnType, ctx);
+    return {
+      parameters: params.length > 0 ? params : undefined,
+      returns: {
+        schema: buildSchema(returnType, checker, ctx)
+      }
+    };
+  });
+  const flags = {};
+  if (node.questionToken)
+    flags.optional = true;
+  return {
+    name,
+    kind: "method",
+    description,
+    tags: tags.length > 0 ? tags : undefined,
+    signatures: signatures.length > 0 ? signatures : undefined,
+    flags: Object.keys(flags).length > 0 ? flags : undefined
+  };
+}
+function serializeCallSignature(node, ctx) {
+  const { typeChecker: checker } = ctx;
+  const { description, tags } = getJSDocComment(node);
+  const sig = checker.getSignatureFromDeclaration(node);
+  if (!sig)
+    return null;
+  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.length === 1 ? names[0] : names;
+    }
+  }
+  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 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);
+  const schema = buildSchema(type, ctx.typeChecker, ctx);
+  registerReferencedTypes(type, ctx);
+  return {
+    id: name,
+    name,
+    kind: "type",
+    description,
+    tags,
+    source,
+    typeParameters,
+    schema,
+    ...examples.length > 0 ? { examples } : {}
+  };
+}
+
+// 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 declSourceFile = node.getSourceFile();
+  const { description, tags, examples } = getJSDocComment(statement);
+  const source = getSourceLocation(node, declSourceFile);
+  const type = ctx.typeChecker.getTypeAtLocation(node);
+  const schema = buildSchema(type, ctx.typeChecker, ctx);
+  registerReferencedTypes(type, ctx);
+  return {
+    id: name,
+    name,
+    kind: "variable",
+    description,
+    tags,
+    source,
+    schema,
+    ...examples.length > 0 ? { examples } : {}
+  };
+}
+
+// src/builder/spec-builder.ts
+import * as fs2 from "node:fs";
+import * as path3 from "node:path";
+import { SCHEMA_VERSION } from "@openpkg-ts/spec";
+import 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
+  };
+}
+
+// src/builder/spec-builder.ts
+async function extract(options) {
+  const { entryFile, baseDir, content, maxTypeDepth, maxExternalTypeDepth, resolveExternalTypes } = options;
+  const diagnostics = [];
+  const exports = [];
+  const result = createProgram({ entryFile, baseDir, content });
+  const { program, sourceFile } = result;
+  if (!sourceFile) {
+    return {
+      spec: createEmptySpec(entryFile),
+      diagnostics: [{ message: `Could not load source file: ${entryFile}`, severity: "error" }]
+    };
+  }
+  const typeChecker = program.getTypeChecker();
+  const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
+  if (!moduleSymbol) {
+    return {
+      spec: createEmptySpec(entryFile),
+      diagnostics: [{ message: "Could not get module symbol", severity: "warning" }]
+    };
+  }
+  const exportedSymbols = typeChecker.getExportsOfModule(moduleSymbol);
+  const exportedIds = new Set;
+  for (const symbol of exportedSymbols) {
+    exportedIds.add(symbol.getName());
+  }
+  const ctx = createContext(program, sourceFile, { maxTypeDepth, maxExternalTypeDepth, resolveExternalTypes });
+  ctx.exportedIds = exportedIds;
+  for (const symbol of exportedSymbols) {
+    try {
+      const { declaration, targetSymbol } = resolveExportTarget(symbol, typeChecker);
+      if (!declaration)
+        continue;
+      const exportName = symbol.getName();
+      const exp = serializeDeclaration(declaration, symbol, targetSymbol, exportName, ctx);
+      if (exp)
+        exports.push(exp);
+    } catch (err) {
+      diagnostics.push({
+        message: `Failed to serialize ${symbol.getName()}: ${err}`,
+        severity: "warning"
+      });
+    }
+  }
+  const meta = await getPackageMeta(entryFile, baseDir);
+  const spec = {
+    openpkg: SCHEMA_VERSION,
+    meta,
+    exports,
+    types: ctx.typeRegistry.getAll(),
+    generation: {
+      generator: "@openpkg-ts/extract",
+      timestamp: new Date().toISOString()
+    }
+  };
+  return { spec, diagnostics };
+}
+function resolveExportTarget(symbol, checker) {
+  let targetSymbol = symbol;
+  if (symbol.flags & ts8.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];
+  return { declaration, targetSymbol };
+}
+function serializeDeclaration(declaration, exportSymbol, targetSymbol, exportName, ctx) {
+  let result = null;
+  if (ts8.isFunctionDeclaration(declaration)) {
+    result = serializeFunctionExport(declaration, ctx);
+  } else if (ts8.isClassDeclaration(declaration)) {
+    result = serializeClass(declaration, ctx);
+  } else if (ts8.isInterfaceDeclaration(declaration)) {
+    result = serializeInterface(declaration, ctx);
+  } else if (ts8.isTypeAliasDeclaration(declaration)) {
+    result = serializeTypeAlias(declaration, ctx);
+  } else if (ts8.isEnumDeclaration(declaration)) {
+    result = serializeEnum(declaration, ctx);
+  } else if (ts8.isVariableDeclaration(declaration)) {
+    const varStatement = declaration.parent?.parent;
+    if (varStatement && ts8.isVariableStatement(varStatement)) {
+      result = serializeVariable(declaration, varStatement, ctx);
+    }
+  } else if (ts8.isNamespaceExport(declaration) || ts8.isModuleDeclaration(declaration)) {
+    result = serializeNamespaceExport(exportSymbol, exportName, ctx);
+  } else if (ts8.isSourceFile(declaration)) {
+    result = serializeNamespaceExport(exportSymbol, exportName, ctx);
+  }
+  if (result) {
+    result = withExportName(result, exportName);
+  }
+  return result;
+}
+function serializeNamespaceExport(symbol, exportName, ctx) {
+  const { description, tags, examples } = getJSDocFromExportSymbol(symbol);
+  return {
+    id: exportName,
+    name: exportName,
+    kind: "namespace",
+    description,
+    tags,
+    ...examples.length > 0 ? { examples } : {}
+  };
+}
+function getJSDocFromExportSymbol(symbol) {
+  const tags = [];
+  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);
+      for (const doc of jsDocs) {
+        if (ts8.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 {
+              description: commentText,
+              tags: extractJSDocTags(doc),
+              examples: extractExamples(doc)
+            };
+          }
+        }
+      }
+    }
+  }
+  const docComment = symbol.getDocumentationComment(undefined);
+  const description = docComment.map((c) => c.text).join(`
+`) || undefined;
+  const jsTags = symbol.getJsDocTags();
+  for (const tag of jsTags) {
+    const text = tag.text?.map((t) => t.text).join("") ?? "";
+    if (tag.name === "example") {
+      examples.push(text);
+    } else {
+      tags.push({ name: tag.name, text });
+    }
+  }
+  return { description, tags, examples };
+}
+function extractJSDocTags(doc) {
+  const tags = [];
+  for (const tag of doc.tags ?? []) {
+    if (tag.tagName.text !== "example") {
+      const text = typeof tag.comment === "string" ? tag.comment : tag.comment?.map((c) => ("text" in c) ? c.text : "").join("") ?? "";
+      tags.push({ name: tag.tagName.text, text });
+    }
+  }
+  return tags;
+}
+function extractExamples(doc) {
+  const examples = [];
+  for (const tag of doc.tags ?? []) {
+    if (tag.tagName.text === "example") {
+      const text = typeof tag.comment === "string" ? tag.comment : tag.comment?.map((c) => ("text" in c) ? c.text : "").join("") ?? "";
+      if (text)
+        examples.push(text);
+    }
+  }
+  return examples;
+}
+function withExportName(entry, exportName) {
+  if (entry.name === exportName) {
+    return entry;
+  }
+  return {
+    ...entry,
+    id: exportName,
+    name: entry.name
+  };
+}
+function createEmptySpec(entryFile) {
+  return {
+    openpkg: SCHEMA_VERSION,
+    meta: { name: path3.basename(entryFile, path3.extname(entryFile)) },
+    exports: [],
+    generation: {
+      generator: "@openpkg-ts/extract",
+      timestamp: new Date().toISOString()
+    }
+  };
+}
+async function getPackageMeta(entryFile, baseDir) {
+  const searchDir = baseDir ?? path3.dirname(entryFile);
+  const pkgPath = path3.join(searchDir, "package.json");
+  try {
+    if (fs2.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf-8"));
+      return {
+        name: pkg.name ?? path3.basename(searchDir),
+        version: pkg.version,
+        description: pkg.description
+      };
+    }
+  } catch {}
+  return { name: path3.basename(searchDir) };
+}
+export { TypeRegistry, getJSDocComment, getSourceLocation, createProgram, isPrimitiveName, isBuiltinGeneric, isAnonymous, buildSchema, extractParameters, registerReferencedTypes, serializeClass, serializeEnum, serializeFunctionExport, serializeInterface, serializeTypeAlias, serializeVariable, extract };