@openpkg-ts/extract 0.11.3 → 0.11.4

package/dist/bin/tspec.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   extract
-} from "../shared/chunk-9x67bae3.js";
+} from "../shared/chunk-twaykyxs.js";
 
 // src/cli/spec.ts
 import * as fs from "node:fs";

package/dist/shared/{chunk-9x67bae3.js → chunk-twaykyxs.js}

@@ -1,6 +1,95 @@
 // src/ast/registry.ts
+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;
+}
+
 class TypeRegistry {
   types = new Map;
+  processing = new Set;
   add(type) {
     this.types.set(type.id, type);
   }
@@ -13,22 +102,77 @@ class TypeRegistry {
   getAll() {
     return Array.from(this.types.values());
   }
-  registerFromSymbol(symbol, checker) {
+  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 this.get(name);
-    const type = {
+      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";
+    if (decl) {
+      if (ts.isClassDeclaration(decl))
+        kind = "class";
+      else if (ts.isInterfaceDeclaration(decl))
+        kind = "interface";
+      else if (ts.isEnumDeclaration(decl))
+        kind = "enum";
+    }
+    const typeString = checker.typeToString(type);
+    return {
       id: name,
       name,
-      kind: "type"
+      kind,
+      type: typeString !== name ? typeString : undefined
     };
-    this.add(type);
-    return type;
+  }
+  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 ts from "typescript";
+import ts2 from "typescript";
 function parseExamplesFromTags(tags) {
   const examples = [];
   for (const tag of tags) {
@@ -51,17 +195,17 @@ function parseExamplesFromTags(tags) {
   return examples;
 }
 function getJSDocComment(node) {
-  const jsDocTags = ts.getJSDocTags(node);
+  const jsDocTags = ts2.getJSDocTags(node);
   const tags = jsDocTags.map((tag) => ({
     name: tag.tagName.text,
-    text: typeof tag.comment === "string" ? tag.comment : ts.getTextOfJSDocComment(tag.comment) ?? ""
+    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 : ts.getTextOfJSDocComment(firstDoc.comment);
+      description = typeof firstDoc.comment === "string" ? firstDoc.comment : ts2.getTextOfJSDocComment(firstDoc.comment);
     }
   }
   const examples = parseExamplesFromTags(tags);
@@ -77,34 +221,34 @@ function getSourceLocation(node, sourceFile) {
 
 // src/compiler/program.ts
 import * as path from "node:path";
-import ts2 from "typescript";
+import ts3 from "typescript";
 var DEFAULT_COMPILER_OPTIONS = {
-  target: ts2.ScriptTarget.Latest,
-  module: ts2.ModuleKind.CommonJS,
+  target: ts3.ScriptTarget.Latest,
+  module: ts3.ModuleKind.CommonJS,
   lib: ["lib.es2021.d.ts"],
   declaration: true,
-  moduleResolution: ts2.ModuleResolutionKind.NodeJs
+  moduleResolution: ts3.ModuleResolutionKind.NodeJs
 };
 function createProgram({
   entryFile,
   baseDir = path.dirname(entryFile),
   content
 }) {
-  const configPath = ts2.findConfigFile(baseDir, ts2.sys.fileExists, "tsconfig.json");
+  const configPath = ts3.findConfigFile(baseDir, ts3.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));
+    const configFile = ts3.readConfigFile(configPath, ts3.sys.readFile);
+    const parsedConfig = ts3.parseJsonConfigFileContent(configFile.config, ts3.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);
+  const compilerHost = ts3.createCompilerHost(compilerOptions, true);
   let inMemorySource;
   if (content !== undefined) {
-    inMemorySource = ts2.createSourceFile(entryFile, content, ts2.ScriptTarget.Latest, true, ts2.ScriptKind.TS);
+    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) {
@@ -113,7 +257,7 @@ function createProgram({
       return originalGetSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
     };
   }
-  const program = ts2.createProgram([entryFile], compilerOptions, compilerHost);
+  const program = ts3.createProgram([entryFile], compilerOptions, compilerHost);
   const sourceFile = inMemorySource ?? program.getSourceFile(entryFile);
   return {
     program,
@@ -176,9 +320,11 @@ function serializeEnum(node, ctx) {
 }
 
 // src/types/parameters.ts
-function extractParameters(signature, checker) {
+function extractParameters(signature, ctx) {
+  const { typeChecker: checker, typeRegistry, exportedIds } = ctx;
   return signature.getParameters().map((param) => {
     const type = checker.getTypeOfSymbolAtLocation(param, param.valueDeclaration);
+    registerReferencedTypes(type, ctx);
     return {
       name: param.getName(),
       schema: { type: checker.typeToString(type) },
@@ -186,6 +332,29 @@ function extractParameters(signature, checker) {
     };
   });
 }
+function registerReferencedTypes(type, ctx) {
+  if (ctx.visitedTypes.has(type))
+    return;
+  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/functions.ts
 function serializeFunctionExport(node, ctx) {
@@ -199,8 +368,9 @@ function serializeFunctionExport(node, ctx) {
   const type = ctx.typeChecker.getTypeAtLocation(node);
   const callSignatures = type.getCallSignatures();
   const signatures = callSignatures.map((sig) => {
-    const params = extractParameters(sig, ctx.typeChecker);
+    const params = extractParameters(sig, ctx);
     const returnType = ctx.typeChecker.getReturnTypeOfSignature(sig);
+    registerReferencedTypes(returnType, ctx);
     return {
       parameters: params,
       returns: {
@@ -275,6 +445,7 @@ function serializeVariable(node, statement, ctx) {
   const source = getSourceLocation(node, declSourceFile);
   const type = ctx.typeChecker.getTypeAtLocation(node);
   const typeString = ctx.typeChecker.typeToString(type);
+  registerReferencedTypes(type, ctx);
   return {
     id: name,
     name,
@@ -291,7 +462,7 @@ function serializeVariable(node, statement, ctx) {
 import * as fs from "node:fs";
 import * as path2 from "node:path";
 import { SCHEMA_VERSION } from "@openpkg-ts/spec";
-import ts3 from "typescript";
+import ts4 from "typescript";
 
 // src/serializers/context.ts
 function createContext(program, sourceFile, options = {}) {
@@ -301,7 +472,9 @@ function createContext(program, sourceFile, options = {}) {
     sourceFile,
     maxTypeDepth: options.maxTypeDepth ?? 20,
     resolveExternalTypes: options.resolveExternalTypes ?? true,
-    typeRegistry: new TypeRegistry
+    typeRegistry: new TypeRegistry,
+    exportedIds: new Set,
+    visitedTypes: new Set
   };
 }
 
@@ -318,7 +491,6 @@ async function extract(options) {
       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) {
@@ -328,13 +500,19 @@ async function extract(options) {
     };
   }
   const exportedSymbols = typeChecker.getExportsOfModule(moduleSymbol);
+  const exportedIds = new Set;
+  for (const symbol of exportedSymbols) {
+    exportedIds.add(symbol.getName());
+  }
+  const ctx = createContext(program, sourceFile, { maxTypeDepth, 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, targetSymbol, exportName, ctx);
+      const exp = serializeDeclaration(declaration, symbol, targetSymbol, exportName, ctx);
       if (exp)
         exports.push(exp);
     } catch (err) {
@@ -359,39 +537,111 @@ async function extract(options) {
 }
 function resolveExportTarget(symbol, checker) {
   let targetSymbol = symbol;
-  if (symbol.flags & ts3.SymbolFlags.Alias) {
+  if (symbol.flags & ts4.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];
+  const declaration = targetSymbol.valueDeclaration || declarations.find((decl) => decl.kind !== ts4.SyntaxKind.ExportSpecifier) || declarations[0];
   return { declaration, targetSymbol };
 }
-function serializeDeclaration(declaration, symbol, exportName, ctx) {
+function serializeDeclaration(declaration, exportSymbol, targetSymbol, exportName, ctx) {
   let result = null;
-  if (ts3.isFunctionDeclaration(declaration)) {
+  if (ts4.isFunctionDeclaration(declaration)) {
     result = serializeFunctionExport(declaration, ctx);
-  } else if (ts3.isClassDeclaration(declaration)) {
+  } else if (ts4.isClassDeclaration(declaration)) {
     result = serializeClass(declaration, ctx);
-  } else if (ts3.isInterfaceDeclaration(declaration)) {
+  } else if (ts4.isInterfaceDeclaration(declaration)) {
     result = serializeInterface(declaration, ctx);
-  } else if (ts3.isTypeAliasDeclaration(declaration)) {
+  } else if (ts4.isTypeAliasDeclaration(declaration)) {
     result = serializeTypeAlias(declaration, ctx);
-  } else if (ts3.isEnumDeclaration(declaration)) {
+  } else if (ts4.isEnumDeclaration(declaration)) {
     result = serializeEnum(declaration, ctx);
-  } else if (ts3.isVariableDeclaration(declaration)) {
+  } else if (ts4.isVariableDeclaration(declaration)) {
     const varStatement = declaration.parent?.parent;
-    if (varStatement && ts3.isVariableStatement(varStatement)) {
+    if (varStatement && ts4.isVariableStatement(varStatement)) {
       result = serializeVariable(declaration, varStatement, ctx);
     }
+  } else if (ts4.isNamespaceExport(declaration) || ts4.isModuleDeclaration(declaration)) {
+    result = serializeNamespaceExport(exportSymbol, exportName, ctx);
+  } else if (ts4.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 = ts4.isNamespaceExport(decl) ? decl.parent : decl;
+    if (exportDecl && ts4.isExportDeclaration(exportDecl)) {
+      const jsDocs = ts4.getJSDocCommentsAndTags(exportDecl);
+      for (const doc of jsDocs) {
+        if (ts4.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;
@@ -428,4 +678,4 @@ async function getPackageMeta(entryFile, baseDir) {
   } catch {}
   return { name: path2.basename(searchDir) };
 }
-export { TypeRegistry, getJSDocComment, getSourceLocation, createProgram, serializeClass, serializeEnum, extractParameters, serializeFunctionExport, serializeInterface, serializeTypeAlias, serializeVariable, extract };
+export { TypeRegistry, getJSDocComment, getSourceLocation, createProgram, serializeClass, serializeEnum, extractParameters, registerReferencedTypes, serializeFunctionExport, serializeInterface, serializeTypeAlias, serializeVariable, extract };

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,9 +24,9 @@ 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";
+import { TypeChecker as TypeChecker_lrgbhchnsl } from "typescript";
+import { Program as Program_jbfzpxflck } from "typescript";
+import { SourceFile as SourceFile_eubaywigwb } from "typescript";
 interface ExtractOptions {
 	entryFile: string;
 	baseDir?: string;
@@ -42,9 +49,9 @@ interface Diagnostic {
 	};
 }
 interface SerializerContext {
-	typeChecker: TypeChecker_vexmldwuwp;
-	program: Program_lhgjafqgga;
-	sourceFile: SourceFile_sameteuoys;
+	typeChecker: TypeChecker_lrgbhchnsl;
+	program: Program_jbfzpxflck;
+	sourceFile: SourceFile_eubaywigwb;
 	maxTypeDepth: number;
 	resolveExternalTypes: boolean;
 }
@@ -95,6 +102,9 @@ interface SerializerContext2 {
 	maxTypeDepth: 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;
 import { SpecExport as SpecExport2 } from "@openpkg-ts/spec";
@@ -117,11 +127,16 @@ declare function formatTypeReference(type: ts13.Type, checker: ts13.TypeChecker)
 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: SerializerContext2): 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: SerializerContext2): 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;
 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, isExported, 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

@@ -5,13 +5,14 @@ import {
   extractParameters,
   getJSDocComment,
   getSourceLocation,
+  registerReferencedTypes,
   serializeClass,
   serializeEnum,
   serializeFunctionExport,
   serializeInterface,
   serializeTypeAlias,
   serializeVariable
-} from "../shared/chunk-9x67bae3.js";
+} from "../shared/chunk-twaykyxs.js";
 // src/schema/adapters/arktype.ts
 var arktypeAdapter = {
   name: "arktype",
@@ -119,6 +120,7 @@ export {
   serializeFunctionExport,
   serializeEnum,
   serializeClass,
+  registerReferencedTypes,
   registerAdapter,
   isSchemaType,
   isExported,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpkg-ts/extract",
-  "version": "0.11.3",
+  "version": "0.11.4",
   "description": "TypeScript export extraction to OpenPkg spec",
   "keywords": [
     "openpkg",