@openpkg-ts/extract 0.11.3 → 0.12.0

package/dist/src/index.d.ts

@@ -2,10 +2,17 @@ import { SpecType } from "@openpkg-ts/spec";
 import ts from "typescript";
 declare class TypeRegistry {
 	private types;
+	private processing;
 	add(type: SpecType): void;
 	get(id: string): SpecType | undefined;
 	has(id: string): boolean;
 	getAll(): SpecType[];
+	/**
+	* Register a type from a ts.Type, extracting its structure.
+	* Returns the type ID if registered, undefined if skipped.
+	*/
+	registerType(type: ts.Type, checker: ts.TypeChecker, exportedIds: Set<string>): string | undefined;
+	private buildSpecType;
 	registerFromSymbol(symbol: ts.Symbol, checker: ts.TypeChecker): SpecType | undefined;
 }
 import { SpecExample, SpecSource, SpecTag } from "@openpkg-ts/spec";
@@ -17,14 +24,12 @@ declare function getJSDocComment(node: ts2.Node): {
 };
 declare function getSourceLocation(node: ts2.Node, sourceFile: ts2.SourceFile): SpecSource;
 import { OpenPkg } from "@openpkg-ts/spec";
-import { TypeChecker as TypeChecker_vexmldwuwp } from "typescript";
-import { Program as Program_lhgjafqgga } from "typescript";
-import { SourceFile as SourceFile_sameteuoys } from "typescript";
 interface ExtractOptions {
 	entryFile: string;
 	baseDir?: string;
 	content?: string;
 	maxTypeDepth?: number;
+	maxExternalTypeDepth?: number;
 	resolveExternalTypes?: boolean;
 	schemaExtraction?: "static" | "hybrid";
 }
@@ -41,13 +46,6 @@ interface Diagnostic {
 		column?: number;
 	};
 }
-interface SerializerContext {
-	typeChecker: TypeChecker_vexmldwuwp;
-	program: Program_lhgjafqgga;
-	sourceFile: SourceFile_sameteuoys;
-	maxTypeDepth: number;
-	resolveExternalTypes: boolean;
-}
 declare function extract(options: ExtractOptions): Promise<ExtractResult>;
 import ts3 from "typescript";
 interface ProgramOptions {
@@ -88,40 +86,66 @@ declare function extractStandardSchemas(_program: ts5.Program, _entryFile: strin
 import { SpecExport } from "@openpkg-ts/spec";
 import ts7 from "typescript";
 import ts6 from "typescript";
-interface SerializerContext2 {
+interface SerializerContext {
 	typeChecker: ts6.TypeChecker;
 	program: ts6.Program;
 	sourceFile: ts6.SourceFile;
 	maxTypeDepth: number;
+	maxExternalTypeDepth: number;
+	currentDepth: number;
 	resolveExternalTypes: boolean;
 	typeRegistry: TypeRegistry;
+	exportedIds: Set<string>;
+	/** Track visited types to prevent infinite recursion */
+	visitedTypes: Set<ts6.Type>;
 }
-declare function serializeClass(node: ts7.ClassDeclaration, ctx: SerializerContext2): SpecExport | null;
+declare function serializeClass(node: ts7.ClassDeclaration, ctx: SerializerContext): SpecExport | null;
 import { SpecExport as SpecExport2 } from "@openpkg-ts/spec";
 import ts8 from "typescript";
-declare function serializeEnum(node: ts8.EnumDeclaration, ctx: SerializerContext2): SpecExport2 | null;
+declare function serializeEnum(node: ts8.EnumDeclaration, ctx: SerializerContext): SpecExport2 | null;
 import { SpecExport as SpecExport3 } from "@openpkg-ts/spec";
 import ts9 from "typescript";
-declare function serializeFunctionExport(node: ts9.FunctionDeclaration | ts9.ArrowFunction, ctx: SerializerContext2): SpecExport3 | null;
+declare function serializeFunctionExport(node: ts9.FunctionDeclaration | ts9.ArrowFunction, ctx: SerializerContext): SpecExport3 | null;
 import { SpecExport as SpecExport4 } from "@openpkg-ts/spec";
 import ts10 from "typescript";
-declare function serializeInterface(node: ts10.InterfaceDeclaration, ctx: SerializerContext2): SpecExport4 | null;
+declare function serializeInterface(node: ts10.InterfaceDeclaration, ctx: SerializerContext): SpecExport4 | null;
 import { SpecExport as SpecExport5 } from "@openpkg-ts/spec";
 import ts11 from "typescript";
-declare function serializeTypeAlias(node: ts11.TypeAliasDeclaration, ctx: SerializerContext2): SpecExport5 | null;
+declare function serializeTypeAlias(node: ts11.TypeAliasDeclaration, ctx: SerializerContext): SpecExport5 | null;
 import { SpecExport as SpecExport6 } from "@openpkg-ts/spec";
 import ts12 from "typescript";
-declare function serializeVariable(node: ts12.VariableDeclaration, statement: ts12.VariableStatement, ctx: SerializerContext2): SpecExport6 | null;
+declare function serializeVariable(node: ts12.VariableDeclaration, statement: ts12.VariableStatement, ctx: SerializerContext): SpecExport6 | null;
 import ts13 from "typescript";
 declare function formatTypeReference(type: ts13.Type, checker: ts13.TypeChecker): string;
 declare function collectReferencedTypes(type: ts13.Type, checker: ts13.TypeChecker, visited?: Set<string>): string[];
 import { SpecSignatureParameter } from "@openpkg-ts/spec";
 import ts14 from "typescript";
-declare function extractParameters(signature: ts14.Signature, checker: ts14.TypeChecker): SpecSignatureParameter[];
+declare function extractParameters(signature: ts14.Signature, ctx: SerializerContext): SpecSignatureParameter[];
+/**
+* Recursively register types referenced by a ts.Type.
+* Uses ctx.visitedTypes to prevent infinite recursion on circular types.
+*/
+declare function registerReferencedTypes(type: ts14.Type, ctx: SerializerContext): void;
 import { SpecSchema as SpecSchema3 } from "@openpkg-ts/spec";
 import ts15 from "typescript";
-declare function buildSchema(type: ts15.Type, checker: ts15.TypeChecker, depth?: number): SpecSchema3;
+/**
+* Check if a name is a primitive type
+*/
+declare function isPrimitiveName(name: string): boolean;
+/**
+* Check if a name is a built-in generic type
+*/
+declare function isBuiltinGeneric(name: string): boolean;
+/**
+* Check if a type is anonymous (no meaningful symbol name)
+*/
+declare function isAnonymous(type: ts15.Type): boolean;
+/**
+* Build a structured SpecSchema from a TypeScript type.
+* Uses $ref for named types and typeArguments for generics.
+*/
+declare function buildSchema(type: ts15.Type, checker: ts15.TypeChecker, ctx?: SerializerContext, _depth?: number): SpecSchema3;
 import ts16 from "typescript";
 declare function isExported(node: ts16.Node): boolean;
 declare function getNodeName(node: ts16.Node): string | undefined;
-export { zodAdapter, valibotAdapter, typeboxAdapter, serializeVariable, serializeTypeAlias, serializeInterface, serializeFunctionExport, serializeEnum, serializeClass, registerAdapter, isSchemaType, isExported, getSourceLocation, getNodeName, getJSDocComment, formatTypeReference, findAdapter, extractStandardSchemas, extractSchemaType, extractParameters, extract, createProgram, collectReferencedTypes, buildSchema, arktypeAdapter, TypeRegistry, StandardSchemaResult, SerializerContext, SchemaAdapter, ProgramResult, ProgramOptions, ExtractResult, ExtractOptions, Diagnostic };
+export { zodAdapter, valibotAdapter, typeboxAdapter, serializeVariable, serializeTypeAlias, serializeInterface, serializeFunctionExport, serializeEnum, serializeClass, registerReferencedTypes, registerAdapter, isSchemaType, isPrimitiveName, isExported, isBuiltinGeneric, isAnonymous, getSourceLocation, getNodeName, getJSDocComment, formatTypeReference, findAdapter, extractStandardSchemas, extractSchemaType, extractParameters, extract, createProgram, collectReferencedTypes, buildSchema, arktypeAdapter, TypeRegistry, StandardSchemaResult, SerializerContext, SchemaAdapter, ProgramResult, ProgramOptions, ExtractResult, ExtractOptions, Diagnostic };

package/dist/src/index.js

@@ -1,17 +1,22 @@
 import {
   TypeRegistry,
+  buildSchema,
   createProgram,
   extract,
   extractParameters,
   getJSDocComment,
   getSourceLocation,
+  isAnonymous,
+  isBuiltinGeneric,
+  isPrimitiveName,
+  registerReferencedTypes,
   serializeClass,
   serializeEnum,
   serializeFunctionExport,
   serializeInterface,
   serializeTypeAlias,
   serializeVariable
-} from "../shared/chunk-9x67bae3.js";
+} from "../shared/chunk-wddga8ye.js";
 // src/schema/adapters/arktype.ts
 var arktypeAdapter = {
   name: "arktype",
@@ -69,32 +74,6 @@ function collectReferencedTypes(type, checker, visited = new Set) {
   visited.add(name);
   return [name];
 }
-// src/types/schema-builder.ts
-function buildSchema(type, checker, depth = 0) {
-  if (depth > 10) {
-    return { type: checker.typeToString(type) };
-  }
-  const typeString = checker.typeToString(type);
-  if (type.flags & 4)
-    return { type: "string" };
-  if (type.flags & 8)
-    return { type: "number" };
-  if (type.flags & 16)
-    return { type: "boolean" };
-  if (type.flags & 32768)
-    return { type: "undefined" };
-  if (type.flags & 65536)
-    return { type: "null" };
-  if (type.flags & 16384)
-    return { type: "void" };
-  if (type.flags & 1)
-    return { type: "any" };
-  if (type.flags & 2)
-    return { type: "unknown" };
-  if (type.flags & 131072)
-    return { type: "never" };
-  return { type: typeString };
-}
 // src/types/utils.ts
 function isExported(node) {
   const modifiers = node.modifiers;
@@ -119,9 +98,13 @@ export {
   serializeFunctionExport,
   serializeEnum,
   serializeClass,
+  registerReferencedTypes,
   registerAdapter,
   isSchemaType,
+  isPrimitiveName,
   isExported,
+  isBuiltinGeneric,
+  isAnonymous,
   getSourceLocation,
   getNodeName,
   getJSDocComment,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpkg-ts/extract",
-  "version": "0.11.3",
+  "version": "0.12.0",
   "description": "TypeScript export extraction to OpenPkg spec",
   "keywords": [
     "openpkg",
@@ -40,7 +40,7 @@
     "format": "biome format --write src/"
   },
   "dependencies": {
-    "@openpkg-ts/spec": "^0.11.1",
+    "@openpkg-ts/spec": "^0.12.0",
     "commander": "^12.0.0",
     "typescript": "^5.0.0"
   },

package/dist/shared/chunk-9x67bae3.js

@@ -1,431 +0,0 @@
-// src/ast/registry.ts
-class TypeRegistry {
-  types = new Map;
-  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());
-  }
-  registerFromSymbol(symbol, checker) {
-    const name = symbol.getName();
-    if (this.has(name))
-      return this.get(name);
-    const type = {
-      id: name,
-      name,
-      kind: "type"
-    };
-    this.add(type);
-    return type;
-  }
-}
-
-// src/ast/utils.ts
-import ts 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 = ts.getJSDocTags(node);
-  const tags = jsDocTags.map((tag) => ({
-    name: tag.tagName.text,
-    text: typeof tag.comment === "string" ? tag.comment : ts.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 : ts.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
-  };
-}
-
-// src/compiler/program.ts
-import * as path from "node:path";
-import ts2 from "typescript";
-var DEFAULT_COMPILER_OPTIONS = {
-  target: ts2.ScriptTarget.Latest,
-  module: ts2.ModuleKind.CommonJS,
-  lib: ["lib.es2021.d.ts"],
-  declaration: true,
-  moduleResolution: ts2.ModuleResolutionKind.NodeJs
-};
-function createProgram({
-  entryFile,
-  baseDir = path.dirname(entryFile),
-  content
-}) {
-  const configPath = ts2.findConfigFile(baseDir, ts2.sys.fileExists, "tsconfig.json");
-  let compilerOptions = { ...DEFAULT_COMPILER_OPTIONS };
-  if (configPath) {
-    const configFile = ts2.readConfigFile(configPath, ts2.sys.readFile);
-    const parsedConfig = ts2.parseJsonConfigFileContent(configFile.config, ts2.sys, path.dirname(configPath));
-    compilerOptions = { ...compilerOptions, ...parsedConfig.options };
-  }
-  const allowJsVal = compilerOptions.allowJs;
-  if (typeof allowJsVal === "boolean" && allowJsVal) {
-    compilerOptions = { ...compilerOptions, allowJs: false, checkJs: false };
-  }
-  const compilerHost = ts2.createCompilerHost(compilerOptions, true);
-  let inMemorySource;
-  if (content !== undefined) {
-    inMemorySource = ts2.createSourceFile(entryFile, content, ts2.ScriptTarget.Latest, true, ts2.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 = ts2.createProgram([entryFile], compilerOptions, compilerHost);
-  const sourceFile = inMemorySource ?? program.getSourceFile(entryFile);
-  return {
-    program,
-    compilerHost,
-    compilerOptions,
-    sourceFile,
-    configPath
-  };
-}
-
-// src/serializers/classes.ts
-function serializeClass(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);
-  return {
-    id: name,
-    name,
-    kind: "class",
-    description,
-    tags,
-    source,
-    members: [],
-    ...examples.length > 0 ? { examples } : {}
-  };
-}
-
-// src/serializers/enums.ts
-function serializeEnum(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 members = node.members.map((member) => {
-    const memberSymbol = ctx.typeChecker.getSymbolAtLocation(member.name);
-    const memberName = memberSymbol?.getName() ?? member.name.getText();
-    return {
-      id: memberName,
-      name: memberName,
-      kind: "enum-member"
-    };
-  });
-  return {
-    id: name,
-    name,
-    kind: "enum",
-    description,
-    tags,
-    source,
-    members,
-    ...examples.length > 0 ? { examples } : {}
-  };
-}
-
-// src/types/parameters.ts
-function extractParameters(signature, checker) {
-  return signature.getParameters().map((param) => {
-    const type = checker.getTypeOfSymbolAtLocation(param, param.valueDeclaration);
-    return {
-      name: param.getName(),
-      schema: { type: checker.typeToString(type) },
-      required: !(param.flags & 16777216)
-    };
-  });
-}
-
-// 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 type = ctx.typeChecker.getTypeAtLocation(node);
-  const callSignatures = type.getCallSignatures();
-  const signatures = callSignatures.map((sig) => {
-    const params = extractParameters(sig, ctx.typeChecker);
-    const returnType = ctx.typeChecker.getReturnTypeOfSignature(sig);
-    return {
-      parameters: params,
-      returns: {
-        schema: { type: ctx.typeChecker.typeToString(returnType) }
-      }
-    };
-  });
-  return {
-    id: name,
-    name,
-    kind: "function",
-    description,
-    tags,
-    source,
-    signatures,
-    ...examples.length > 0 ? { examples } : {}
-  };
-}
-
-// src/serializers/interfaces.ts
-function serializeInterface(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);
-  return {
-    id: name,
-    name,
-    kind: "interface",
-    description,
-    tags,
-    source,
-    members: [],
-    ...examples.length > 0 ? { examples } : {}
-  };
-}
-
-// 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 type = ctx.typeChecker.getTypeAtLocation(node);
-  const typeString = ctx.typeChecker.typeToString(type);
-  return {
-    id: name,
-    name,
-    kind: "type",
-    description,
-    tags,
-    source,
-    ...typeString !== name ? { type: typeString } : {},
-    ...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 typeString = ctx.typeChecker.typeToString(type);
-  return {
-    id: name,
-    name,
-    kind: "variable",
-    description,
-    tags,
-    source,
-    ...typeString && typeString !== name ? { type: typeString } : {},
-    ...examples.length > 0 ? { examples } : {}
-  };
-}
-
-// src/builder/spec-builder.ts
-import * as fs from "node:fs";
-import * as path2 from "node:path";
-import { SCHEMA_VERSION } from "@openpkg-ts/spec";
-import ts3 from "typescript";
-
-// src/serializers/context.ts
-function createContext(program, sourceFile, options = {}) {
-  return {
-    typeChecker: program.getTypeChecker(),
-    program,
-    sourceFile,
-    maxTypeDepth: options.maxTypeDepth ?? 20,
-    resolveExternalTypes: options.resolveExternalTypes ?? true,
-    typeRegistry: new TypeRegistry
-  };
-}
-
-// src/builder/spec-builder.ts
-async function extract(options) {
-  const { entryFile, baseDir, content, maxTypeDepth, 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 ctx = createContext(program, sourceFile, { maxTypeDepth, resolveExternalTypes });
-  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);
-  for (const symbol of exportedSymbols) {
-    try {
-      const { declaration, targetSymbol } = resolveExportTarget(symbol, typeChecker);
-      if (!declaration)
-        continue;
-      const exportName = symbol.getName();
-      const exp = serializeDeclaration(declaration, 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 & ts3.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 !== ts3.SyntaxKind.ExportSpecifier) || declarations[0];
-  return { declaration, targetSymbol };
-}
-function serializeDeclaration(declaration, symbol, exportName, ctx) {
-  let result = null;
-  if (ts3.isFunctionDeclaration(declaration)) {
-    result = serializeFunctionExport(declaration, ctx);
-  } else if (ts3.isClassDeclaration(declaration)) {
-    result = serializeClass(declaration, ctx);
-  } else if (ts3.isInterfaceDeclaration(declaration)) {
-    result = serializeInterface(declaration, ctx);
-  } else if (ts3.isTypeAliasDeclaration(declaration)) {
-    result = serializeTypeAlias(declaration, ctx);
-  } else if (ts3.isEnumDeclaration(declaration)) {
-    result = serializeEnum(declaration, ctx);
-  } else if (ts3.isVariableDeclaration(declaration)) {
-    const varStatement = declaration.parent?.parent;
-    if (varStatement && ts3.isVariableStatement(varStatement)) {
-      result = serializeVariable(declaration, varStatement, ctx);
-    }
-  }
-  if (result) {
-    result = withExportName(result, exportName);
-  }
-  return result;
-}
-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: path2.basename(entryFile, path2.extname(entryFile)) },
-    exports: [],
-    generation: {
-      generator: "@openpkg-ts/extract",
-      timestamp: new Date().toISOString()
-    }
-  };
-}
-async function getPackageMeta(entryFile, baseDir) {
-  const searchDir = baseDir ?? path2.dirname(entryFile);
-  const pkgPath = path2.join(searchDir, "package.json");
-  try {
-    if (fs.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-      return {
-        name: pkg.name ?? path2.basename(searchDir),
-        version: pkg.version,
-        description: pkg.description
-      };
-    }
-  } catch {}
-  return { name: path2.basename(searchDir) };
-}
-export { TypeRegistry, getJSDocComment, getSourceLocation, createProgram, serializeClass, serializeEnum, extractParameters, serializeFunctionExport, serializeInterface, serializeTypeAlias, serializeVariable, extract };