@openpkg-ts/sdk 0.42.0 → 0.43.0

package/dist/index.d.ts

@@ -35,6 +35,13 @@ interface ExtractOptions {
 	externals?: ExternalsConfig;
 	/** Max properties to serialize per object type (default: 500) */
 	maxProperties?: number;
+	/**
+	* Register referenced-but-not-exported types from dependencies as named
+	* types[] entries. true → all packages; string[] → listed packages (plus
+	* workspace siblings); false → disable the expansion pass; default →
+	* workspace sibling packages only.
+	*/
+	followExternal?: boolean | string[];
 	/** Callback when properties are truncated */
 	onTruncation?: (typeName: string, actual: number, limit: number) => void;
 }
@@ -1202,6 +1209,12 @@ declare class TypeRegistry {
 	*/
 	private resolveSelRefSchema;
 	/**
+	* Build an enum schema with member names from the enum declaration.
+	* Returns undefined when the symbol has no enum declaration or no
+	* constant-valued members.
+	*/
+	private buildEnumSchema;
+	/**
 	* Build object schema from type properties (for interfaces/classes)
 	*/
 	private buildObjectSchemaFromProperties;
@@ -1550,6 +1563,8 @@ interface ProgramResult {
 	configPath?: string;
 	/** Resolved project references (workspace packages) */
 	projectReferences?: ts7.ResolvedProjectReference[];
+	/** Workspace sibling packages discovered from the workspace map (name → dir) */
+	workspacePackages?: Map<string, string>;
 }
 declare function createProgram(options: ProgramOptions): ProgramResult;
 import * as TS from "typescript";
@@ -1694,6 +1709,11 @@ declare function isPureRefSchema(schema: SpecSchema2): schema is {
 */
 declare function withDescription2(schema: SpecSchema2, description: string): SpecSchema2;
 /**
+* Mark a schema as deprecated, handling $ref properly.
+* For pure $ref schemas, wraps in allOf to preserve the reference.
+*/
+declare function withDeprecated(schema: SpecSchema2, reason?: string): SpecSchema2;
+/**
 * Check if a schema represents the 'any' type
 */
 declare function schemaIsAny(schema: SpecSchema2): boolean;
@@ -1775,4 +1795,4 @@ declare function normalizeMembers(members: SpecMember3[], options?: NormalizeOpt
 import ts16 from "typescript";
 declare function isExported(node: ts16.Node): boolean;
 declare function getNodeName(node: ts16.Node): string | undefined;
-export { zodAdapter, withDescription2 as withDescription, valibotAdapter, typeboxAdapter, toSearchIndexJSON, toSearchIndex2 as toSearchIndex, toPagefindRecords2 as toPagefindRecords, toNavigation2 as toNavigation, toMarkdown2 as toMarkdown, toJSONString, toJSON2 as toJSON, toHTML2 as toHTML, toFumadocsMetaJSON, toDocusaurusSidebarJS, toAlgoliaRecords2 as toAlgoliaRecords, sortByName, serializeVariable, serializeTypeAlias, serializeInterface, serializeFunctionExport, serializeEnum, serializeClass, schemasAreEqual, schemaIsAny, resolveTypeRef, resolveExportTarget, resolveCompiledPath, registerReferencedTypes, registerAdapter, recommendSemverBump, query, normalizeType, normalizeSchema, normalizeMembers, normalizeExport, mergeConfig, loadSpec, loadConfig, listExports, isTypeReference, isTypeOnlyExport, isSymbolDeprecated, isStandardJSONSchema, isSchemaType, isPureRefSchema, isProperty, isPrimitiveName, isMethod, isExported, isBuiltinGeneric, isAnonymous, hasDeprecatedTag, groupByVisibility, getTypeOrigin, getSourceLocation, getProperties, getParamDescription, getNonNullableType, getNodeName, getMethods, getMemberBadges, getJSDocComment, getExportKind, getExport2 as getExport, getDeprecationMessage, toMarkdown2 as generateDocs, formatTypeParameters, formatSchema, formatReturnType, formatParameters, formatMappedType, formatConditionalType, formatBadges, findMissingParamDocs, findDiscriminatorProperty, findAdapter, filterSpec, extractTypeParameters, extractStandardSchemasFromTs, extractStandardSchemasFromProject, extractStandardSchemas, extractSpec, extractSchemaType, extractParameters, extract, exportToMarkdown, ensureNonEmptySchema, diffSpec2 as diffSpecs, diffSpec, detectTsRuntime, deduplicateSchemas, createProgram, createDocs, categorizeBreakingChanges, calculateNextVersion, buildSignatureString, buildSchema, buildObjectSchema, buildFunctionSchema, arktypeAdapter, analyzeSpec, TypeRegistry, TypeReference2 as TypeReference, TsRuntime, StandardSchemaExtractionResult, StandardSchemaExtractionOutput, StandardJSONSchemaV1, StandardJSONSchemaTarget, StandardJSONSchemaOptions, SpecMappedType, SpecDiff, SpecDiagnostics, SpecConditionalType, SkippedExportDetail, SimplifiedSpec, SimplifiedSignature, SimplifiedReturn, SimplifiedParameter, SimplifiedMember, SimplifiedExport, SimplifiedExample, SerializerContext, SemverRecommendation, SemverBump, SearchRecord, SearchOptions, SearchIndex, SchemaExtractionResult, SchemaAdapter, STRING_PROTOTYPE_METHODS, QueryBuilder, ProjectExtractionOutput, ProjectExtractionInfo, ProgramResult, ProgramOptions, PagefindRecord, PRIMITIVES, OpenpkgConfig, NormalizeOptions, NavOptions, NavItem, NavGroup, NavFormat, NUMBER_PROTOTYPE_METHODS, MemberChangeInfo, MarkdownOptions, LoadOptions, ListExportsResult, ListExportsOptions, JSONSchema, JSONOptions, HTMLOptions, GroupBy, GetExportResult, GetExportOptions, GenericNav, FumadocsMetaItem, FumadocsMeta, FormatSchemaOptions, ForgottenExport, FilterResult, FilterCriteria, ExtractionWarningCode, ExtractionWarning, ExtractStandardSchemasOptions, ExtractResult, ExtractOptions, ExtractFromProjectOptions, ExternalsConfig, ExportVerification, ExportTracker, ExportMarkdownOptions, ExportItem, DocusaurusSidebarItem, DocusaurusSidebar, DocsInstance, DiagnosticItem, Diagnostic, CategorizedBreaking, CacheManagerOptions, CacheManager, CONFIG_FILENAME, BreakingSeverity, BUILTIN_TYPE_SCHEMAS, AlgoliaRecord, ARRAY_PROTOTYPE_METHODS };
+export { zodAdapter, withDescription2 as withDescription, withDeprecated, valibotAdapter, typeboxAdapter, toSearchIndexJSON, toSearchIndex2 as toSearchIndex, toPagefindRecords2 as toPagefindRecords, toNavigation2 as toNavigation, toMarkdown2 as toMarkdown, toJSONString, toJSON2 as toJSON, toHTML2 as toHTML, toFumadocsMetaJSON, toDocusaurusSidebarJS, toAlgoliaRecords2 as toAlgoliaRecords, sortByName, serializeVariable, serializeTypeAlias, serializeInterface, serializeFunctionExport, serializeEnum, serializeClass, schemasAreEqual, schemaIsAny, resolveTypeRef, resolveExportTarget, resolveCompiledPath, registerReferencedTypes, registerAdapter, recommendSemverBump, query, normalizeType, normalizeSchema, normalizeMembers, normalizeExport, mergeConfig, loadSpec, loadConfig, listExports, isTypeReference, isTypeOnlyExport, isSymbolDeprecated, isStandardJSONSchema, isSchemaType, isPureRefSchema, isProperty, isPrimitiveName, isMethod, isExported, isBuiltinGeneric, isAnonymous, hasDeprecatedTag, groupByVisibility, getTypeOrigin, getSourceLocation, getProperties, getParamDescription, getNonNullableType, getNodeName, getMethods, getMemberBadges, getJSDocComment, getExportKind, getExport2 as getExport, getDeprecationMessage, toMarkdown2 as generateDocs, formatTypeParameters, formatSchema, formatReturnType, formatParameters, formatMappedType, formatConditionalType, formatBadges, findMissingParamDocs, findDiscriminatorProperty, findAdapter, filterSpec, extractTypeParameters, extractStandardSchemasFromTs, extractStandardSchemasFromProject, extractStandardSchemas, extractSpec, extractSchemaType, extractParameters, extract, exportToMarkdown, ensureNonEmptySchema, diffSpec2 as diffSpecs, diffSpec, detectTsRuntime, deduplicateSchemas, createProgram, createDocs, categorizeBreakingChanges, calculateNextVersion, buildSignatureString, buildSchema, buildObjectSchema, buildFunctionSchema, arktypeAdapter, analyzeSpec, TypeRegistry, TypeReference2 as TypeReference, TsRuntime, StandardSchemaExtractionResult, StandardSchemaExtractionOutput, StandardJSONSchemaV1, StandardJSONSchemaTarget, StandardJSONSchemaOptions, SpecMappedType, SpecDiff, SpecDiagnostics, SpecConditionalType, SkippedExportDetail, SimplifiedSpec, SimplifiedSignature, SimplifiedReturn, SimplifiedParameter, SimplifiedMember, SimplifiedExport, SimplifiedExample, SerializerContext, SemverRecommendation, SemverBump, SearchRecord, SearchOptions, SearchIndex, SchemaExtractionResult, SchemaAdapter, STRING_PROTOTYPE_METHODS, QueryBuilder, ProjectExtractionOutput, ProjectExtractionInfo, ProgramResult, ProgramOptions, PagefindRecord, PRIMITIVES, OpenpkgConfig, NormalizeOptions, NavOptions, NavItem, NavGroup, NavFormat, NUMBER_PROTOTYPE_METHODS, MemberChangeInfo, MarkdownOptions, LoadOptions, ListExportsResult, ListExportsOptions, JSONSchema, JSONOptions, HTMLOptions, GroupBy, GetExportResult, GetExportOptions, GenericNav, FumadocsMetaItem, FumadocsMeta, FormatSchemaOptions, ForgottenExport, FilterResult, FilterCriteria, ExtractionWarningCode, ExtractionWarning, ExtractStandardSchemasOptions, ExtractResult, ExtractOptions, ExtractFromProjectOptions, ExternalsConfig, ExportVerification, ExportTracker, ExportMarkdownOptions, ExportItem, DocusaurusSidebarItem, DocusaurusSidebar, DocsInstance, DiagnosticItem, Diagnostic, CategorizedBreaking, CacheManagerOptions, CacheManager, CONFIG_FILENAME, BreakingSeverity, BUILTIN_TYPE_SCHEMAS, AlgoliaRecord, ARRAY_PROTOTYPE_METHODS };

package/dist/index.js

@@ -1769,7 +1769,16 @@ function createProgram(options) {
     const parsedConfig = ts2.parseJsonConfigFileContent(configFile.config, ts2.sys, path3.dirname(configPath));
     compilerOptions = { ...compilerOptions, ...parsedConfig.options };
     additionalRootFiles = resolveProjectReferences(configPath, parsedConfig);
-    const sourceFiles = parsedConfig.fileNames.filter((f) => !f.includes(".test.") && !f.includes(".spec.") && !f.includes("/dist/") && !f.includes("/node_modules/"));
+    let sourceFiles = parsedConfig.fileNames.filter((f) => !f.includes(".test.") && !f.includes(".spec.") && !f.includes("/dist/") && !f.includes("/node_modules/"));
+    if (/\.d\.[cm]?ts$/.test(entryFile)) {
+      sourceFiles = sourceFiles.filter((f) => {
+        try {
+          return !ts2.getOutputFileNames(parsedConfig, f, !ts2.sys.useCaseSensitiveFileNames).some((out) => path3.resolve(out) === entryFile);
+        } catch {
+          return true;
+        }
+      });
+    }
     additionalRootFiles.push(...sourceFiles);
   }
   if (isJsFile(entryFile)) {
@@ -1826,7 +1835,8 @@ function createProgram(options) {
     compilerHost,
     compilerOptions,
     sourceFile,
-    configPath
+    configPath,
+    workspacePackages: new Map(workspaceMap?.packages ?? [])
   };
 }
 
@@ -2459,7 +2469,20 @@ function buildObjectSchema(properties, checker, ctx, originalType) {
         continue;
       }
       const propType = checker.getTypeOfSymbol(prop);
-      props[propName] = buildSchema(propType, checker, ctx);
+      let propSchema = buildSchema(propType, checker, ctx);
+      const docComment = prop.getDocumentationComment(checker);
+      if (docComment.length > 0) {
+        const description = docComment.map((c) => c.text).join(`
+`);
+        if (description.trim()) {
+          propSchema = withDescription(propSchema, description);
+        }
+      }
+      const { deprecated, reason } = isSymbolDeprecated(prop);
+      if (deprecated) {
+        propSchema = withDeprecated(propSchema, reason);
+      }
+      props[propName] = propSchema;
       if (!(prop.flags & ts3.SymbolFlags.Optional)) {
         required.push(propName);
       }
@@ -2498,6 +2521,19 @@ function withDescription(schema, description) {
   }
   return { ...schema, description };
 }
+function withDeprecated(schema, reason) {
+  const extra = { deprecated: true };
+  if (reason?.trim()) {
+    extra["x-deprecated-reason"] = reason;
+  }
+  if (typeof schema === "string") {
+    return { type: schema, ...extra };
+  }
+  if (isPureRefSchema(schema)) {
+    return { allOf: [schema], ...extra };
+  }
+  return { ...schema, ...extra };
+}
 function schemaIsAny(schema) {
   if (typeof schema === "string") {
     return schema === "any";
@@ -2923,6 +2959,12 @@ class TypeRegistry {
     if (this.isSelfRef(schema, name)) {
       schema = this.resolveSelRefSchema(type, checker, ctx);
     }
+    if (kind === "enum") {
+      const enumSchema = this.buildEnumSchema(symbol, checker);
+      if (enumSchema) {
+        schema = enumSchema;
+      }
+    }
     return {
       id: name,
       name,
@@ -2960,32 +3002,42 @@ class TypeRegistry {
     }
     const symbol = type.getSymbol() ?? type.aliasSymbol;
     if (symbol) {
-      const decl = symbol.declarations?.find(ts5.isEnumDeclaration);
-      if (decl) {
-        const members = [];
-        for (const member of decl.members) {
-          const memberSymbol = checker.getSymbolAtLocation(member.name);
-          if (memberSymbol) {
-            const constantValue = checker.getConstantValue(member);
-            if (constantValue !== undefined) {
-              members.push({
-                name: memberSymbol.getName(),
-                value: constantValue
-              });
-            }
-          }
-        }
-        if (members.length > 0) {
-          return {
-            type: typeof members[0].value === "string" ? "string" : "number",
-            enum: members.map((m) => m.value),
-            "x-enum-members": members
-          };
-        }
+      const enumSchema = this.buildEnumSchema(symbol, checker);
+      if (enumSchema) {
+        return enumSchema;
       }
     }
+    const callSignatures = type.getCallSignatures();
+    if (callSignatures.length > 0 && type.getProperties().length === 0) {
+      return buildFunctionSchema(callSignatures, checker, ctx);
+    }
     return this.buildObjectSchemaFromProperties(type, checker, ctx);
   }
+  buildEnumSchema(symbol, checker) {
+    const decl = symbol.declarations?.find(ts5.isEnumDeclaration);
+    if (!decl)
+      return;
+    const members = [];
+    for (const member of decl.members) {
+      const memberSymbol = checker.getSymbolAtLocation(member.name);
+      if (memberSymbol) {
+        const constantValue = checker.getConstantValue(member);
+        if (constantValue !== undefined) {
+          members.push({
+            name: memberSymbol.getName(),
+            value: constantValue
+          });
+        }
+      }
+    }
+    if (members.length === 0)
+      return;
+    return {
+      type: typeof members[0].value === "string" ? "string" : "number",
+      enum: members.map((m) => m.value),
+      "x-enum-members": members
+    };
+  }
   buildObjectSchemaFromProperties(type, checker, ctx) {
     const properties = type.getProperties();
     const stringIndex = checker.getIndexInfosOfType(type).find((i) => i.keyType.flags & ts5.TypeFlags.String);
@@ -3018,7 +3070,20 @@ class TypeRegistry {
       const propName = prop.getName();
       const propType = checker.getTypeOfSymbol(prop);
       this.registerType(propType, ctx);
-      props[propName] = buildSchema(propType, checker, ctx);
+      let propSchema = buildSchema(propType, checker, ctx);
+      const docComment = prop.getDocumentationComment(checker);
+      if (docComment.length > 0) {
+        const description = docComment.map((c) => c.text).join(`
+`);
+        if (description.trim()) {
+          propSchema = withDescription(propSchema, description);
+        }
+      }
+      const { deprecated, reason } = isSymbolDeprecated(prop);
+      if (deprecated) {
+        propSchema = withDeprecated(propSchema, reason);
+      }
+      props[propName] = propSchema;
       if (!(prop.flags & ts5.SymbolFlags.Optional)) {
         required.push(propName);
       }
@@ -3824,6 +3889,9 @@ function serializeTypeAlias(node, ctx) {
   let members;
   if (ts10.isIntersectionTypeNode(node.type)) {
     schema = buildIntersectionSchemaFromNode(node.type, ctx);
+    if (type.getProperties().length > 0 && type.getCallSignatures().length === 0) {
+      members = serializeResolvedMembers(type, node, ctx);
+    }
   } else if (isInlineFunctionAlias(node.type) && type.getCallSignatures().length > 0) {
     schema = buildFunctionSchema(type.getCallSignatures(), ctx.typeChecker, ctx);
   } else if ((ts10.isMappedTypeNode(node.type) || ts10.isConditionalTypeNode(node.type)) && type.getProperties().length > 0 && type.getCallSignatures().length === 0) {
@@ -3902,7 +3970,8 @@ function serializeResolvedMembers(type, node, ctx) {
     const propType = checker.getTypeOfSymbolAtLocation(prop, decl);
     registerReferencedTypes(propType, ctx);
     const callSigs = propType.getCallSignatures();
-    const kind = callSigs.length > 0 ? "method" : "property";
+    const isMethodDecl = ts10.isMethodSignature(decl) || ts10.isMethodDeclaration(decl) || ts10.isFunctionDeclaration(decl);
+    const kind = callSigs.length > 0 && isMethodDecl ? "method" : "property";
     let { description, tags } = getJSDocComment(decl, prop, checker);
     let { deprecated, reason: deprecationReason } = isSymbolDeprecated(prop);
     const arm = armDocs.get(prop.getName());
@@ -4150,6 +4219,19 @@ function normalizeSchema(schema, options = {}) {
   return normalized;
 }
 function normalizeSchemaInternal(schema, options) {
+  const result = normalizeSchemaDispatch(schema, options);
+  if (schema && typeof schema === "object") {
+    const s = schema;
+    if (s.deprecated === true && result.deprecated === undefined) {
+      result.deprecated = true;
+    }
+    if (typeof s["x-deprecated-reason"] === "string" && result["x-deprecated-reason"] === undefined) {
+      result["x-deprecated-reason"] = s["x-deprecated-reason"];
+    }
+  }
+  return result;
+}
+function normalizeSchemaDispatch(schema, options) {
   if (typeof schema === "string") {
     return normalizeStringType(schema);
   }
@@ -4338,7 +4420,7 @@ function normalizeStandardType(schema, options) {
     }
   }
   for (const key of Object.keys(schema)) {
-    if (key.startsWith("x-ts-") && schema[key] !== undefined) {
+    if (key.startsWith("x-") && schema[key] !== undefined) {
       const value = schema[key];
       if (isSchemaLike(value)) {
         result[key] = normalizeSchemaInternal(value, options);
@@ -4364,9 +4446,25 @@ function normalizeRef(schema, options) {
   return result;
 }
 function normalizeCombinator(keyword, schemas, originalSchema, options) {
-  const result = {
-    [keyword]: schemas.map((s) => normalizeSchemaInternal(s, options))
-  };
+  let branches = schemas.map((s) => normalizeSchemaInternal(s, options));
+  if (keyword !== "allOf") {
+    const seen = new Set;
+    branches = branches.filter((b) => {
+      const key = JSON.stringify(b);
+      if (seen.has(key))
+        return false;
+      seen.add(key);
+      return true;
+    });
+    if (branches.length === 1) {
+      const single = { ...branches[0] };
+      if ("description" in originalSchema && originalSchema.description && !single.description) {
+        single.description = originalSchema.description;
+      }
+      return single;
+    }
+  }
+  const result = { [keyword]: branches };
   if ((keyword === "anyOf" || keyword === "oneOf") && "discriminator" in originalSchema && originalSchema.discriminator) {
     result.discriminator = originalSchema.discriminator;
   }
@@ -4503,8 +4601,22 @@ function normalizeMembers(members, options = {}) {
   }
   return result;
 }
+function memberDocExtras(member) {
+  const extras = {};
+  if (member.description) {
+    extras.description = member.description;
+  }
+  if (member.deprecated) {
+    extras.deprecated = true;
+    const reason = member.deprecationReason ?? member.tags?.find((t) => t.name === "deprecated")?.text;
+    if (reason?.trim()) {
+      extras["x-deprecated-reason"] = reason;
+    }
+  }
+  return extras;
+}
 function normalizeMemberToSchema(member, options) {
-  const { kind, schema, signatures, description } = member;
+  const { kind, schema, signatures } = member;
   if (kind === "method" || kind === "call-signature") {
     return normalizeMethodMember(member, options);
   }
@@ -4513,7 +4625,7 @@ function normalizeMemberToSchema(member, options) {
     return {
       ...baseSchema2,
       "x-ts-accessor": "getter",
-      ...description ? { description } : {}
+      ...memberDocExtras(member)
     };
   }
   if (kind === "setter") {
@@ -4521,7 +4633,7 @@ function normalizeMemberToSchema(member, options) {
     return {
       ...baseSchema2,
       "x-ts-accessor": "setter",
-      ...description ? { description } : {}
+      ...memberDocExtras(member)
     };
   }
   if (kind === "index" || kind === "index-signature") {
@@ -4534,7 +4646,8 @@ function normalizeMemberToSchema(member, options) {
     return normalizeMethodMember(member, options);
   }
   const baseSchema = schema ? normalizeSchemaInternal(schema, options) : {};
-  return description ? { ...baseSchema, description } : baseSchema;
+  const extras = memberDocExtras(member);
+  return Object.keys(extras).length > 0 ? { ...baseSchema, ...extras } : baseSchema;
 }
 function normalizeMethodMember(member, options) {
   const result = {
@@ -4543,9 +4656,7 @@ function normalizeMethodMember(member, options) {
   if (member.signatures && member.signatures.length > 0) {
     result["x-ts-signatures"] = member.signatures.map((sig) => normalizeSignature(sig, options));
   }
-  if (member.description) {
-    result.description = member.description;
-  }
+  Object.assign(result, memberDocExtras(member));
   return result;
 }
 function isOptionalMember(member) {
@@ -4789,6 +4900,12 @@ async function listExports(options) {
     };
   }
   const exportedSymbols = checker.getExportsOfModule(moduleSymbol);
+  if (exportedSymbols.length === 0) {
+    return {
+      exports: [],
+      errors: [`No exports found in ${entryFile}. Is this the right entry point?`]
+    };
+  }
   for (const symbol of exportedSymbols) {
     try {
       const exportItem = extractExportItem(symbol, checker, entryFile, sourceFile);
@@ -4862,10 +4979,10 @@ function getDescriptionPreview(symbol, checker) {
   return `${firstLine.slice(0, 77)}...`;
 }
 // src/builder/spec-builder.ts
-import * as fs6 from "node:fs";
-import * as path8 from "node:path";
+import * as fs7 from "node:fs";
+import * as path9 from "node:path";
 import { SCHEMA_URL, SCHEMA_VERSION } from "@openpkg-ts/spec";
-import ts16 from "typescript";
+import ts17 from "typescript";
 
 // src/ast/resolve.ts
 import ts13 from "typescript";
@@ -5735,8 +5852,268 @@ function hasInternalTag(typeName, program, sourceFile) {
   });
 }
 
-// src/builder/verification.ts
+// src/builder/type-expansion.ts
+import * as fs6 from "node:fs";
 import * as path7 from "node:path";
+import ts16 from "typescript";
+function findPackageDir(fromFile) {
+  let dir = path7.dirname(path7.resolve(fromFile));
+  while (true) {
+    if (fs6.existsSync(path7.join(dir, "package.json")))
+      return dir;
+    const parent = path7.dirname(dir);
+    if (parent === dir)
+      return;
+    dir = parent;
+  }
+}
+var NODE_MODULES_PKG = /node_modules\/(@[^/]+\/[^/]+|[^/]+)/;
+function isLibFile(fileName) {
+  return fileName.includes("/typescript/lib/lib.") || fileName.includes("\\typescript\\lib\\lib.");
+}
+function expandReachableTypes(exportedSymbols, ctx, opts) {
+  if (opts.followExternal === false)
+    return;
+  const checker = ctx.typeChecker;
+  const visited = new Set;
+  const MAX_DEPTH = 30;
+  const packageAllowed = (pkg) => {
+    if (pkg === "typescript")
+      return false;
+    if (opts.followExternal === true)
+      return true;
+    if (Array.isArray(opts.followExternal) && opts.followExternal.includes(pkg))
+      return true;
+    return opts.workspacePackages.has(pkg);
+  };
+  const entryPackageDir = findPackageDir(opts.entryFile);
+  const packageLabel = (fileName) => {
+    const match = fileName.match(NODE_MODULES_PKG);
+    let pkg = match?.[1];
+    if (!pkg) {
+      for (const [name, dir] of opts.workspacePackages) {
+        if (fileName.startsWith(`${path7.resolve(dir)}${path7.sep}`)) {
+          pkg = name;
+          break;
+        }
+      }
+    }
+    return (pkg ?? "local").replace(/^@/, "").replace(/\//g, "-");
+  };
+  const symbolAllowed = (symbol) => {
+    const decl = symbol.declarations?.[0];
+    if (!decl)
+      return false;
+    const fileName = decl.getSourceFile().fileName;
+    if (isLibFile(fileName))
+      return false;
+    const match = fileName.match(NODE_MODULES_PKG);
+    if (match)
+      return packageAllowed(match[1]);
+    return true;
+  };
+  const visit = (type, depth) => {
+    if (!type || depth > MAX_DEPTH || visited.has(type))
+      return;
+    visited.add(type);
+    const symbol = type.aliasSymbol ?? type.getSymbol();
+    const named = !!symbol && !symbol.getName().startsWith("__");
+    const allowed = !named || !symbol || symbolAllowed(symbol);
+    if (named && allowed && symbol && !ctx.exportedIds.has(symbol.getName())) {
+      ctx.typeRegistry.registerType(type, ctx);
+      const name = symbol.getName();
+      if (!symbolByName.has(name)) {
+        symbolByName.set(name, symbol);
+      }
+    }
+    for (const arg of type.aliasTypeArguments ?? []) {
+      visit(arg, depth + 1);
+    }
+    const typeRef = type;
+    if (typeRef.target) {
+      for (const arg of checker.getTypeArguments(typeRef) ?? []) {
+        visit(arg, depth + 1);
+      }
+    }
+    if (type.isUnion() || type.isIntersection()) {
+      for (const t of type.types) {
+        visit(t, depth + 1);
+      }
+    }
+    if (!allowed || !(type.flags & ts16.TypeFlags.Object || type.isClassOrInterface())) {
+      return;
+    }
+    if (type.isClassOrInterface()) {
+      for (const base of checker.getBaseTypes(type) ?? []) {
+        visit(base, depth + 1);
+      }
+    }
+    for (const prop of type.getProperties().slice(0, ctx.maxProperties)) {
+      if (prop.getName().startsWith("__@"))
+        continue;
+      visit(checker.getTypeOfSymbol(prop), depth + 1);
+    }
+    for (const sig of [...type.getCallSignatures(), ...type.getConstructSignatures()]) {
+      for (const param of sig.getParameters()) {
+        visit(checker.getTypeOfSymbol(param), depth + 1);
+      }
+      visit(sig.getReturnType(), depth + 1);
+    }
+    for (const info of checker.getIndexInfosOfType(type)) {
+      visit(info.type, depth + 1);
+    }
+  };
+  const TYPE_SYMBOL_FLAGS = ts16.SymbolFlags.Interface | ts16.SymbolFlags.TypeAlias | ts16.SymbolFlags.Class | ts16.SymbolFlags.RegularEnum | ts16.SymbolFlags.ConstEnum;
+  const visitedSymbols = new Set;
+  const symbolKind = (symbol) => {
+    if (symbol.flags & ts16.SymbolFlags.Interface)
+      return "interface";
+    if (symbol.flags & ts16.SymbolFlags.Class)
+      return "class";
+    if (symbol.flags & (ts16.SymbolFlags.RegularEnum | ts16.SymbolFlags.ConstEnum))
+      return "enum";
+    return "type";
+  };
+  const resolveAlias = (symbol) => {
+    if (symbol.flags & ts16.SymbolFlags.Alias) {
+      try {
+        return checker.getAliasedSymbol(symbol);
+      } catch {
+        return;
+      }
+    }
+    return symbol;
+  };
+  const symbolByName = new Map;
+  const registerTypeSymbol = (symbol) => {
+    const name = symbol.getName();
+    if (name.startsWith("__"))
+      return;
+    if (!(symbol.flags & TYPE_SYMBOL_FLAGS))
+      return;
+    if (!symbolAllowed(symbol))
+      return;
+    if (ctx.exportedIds.has(name)) {
+      walkDeclarations(symbol);
+      return;
+    }
+    if (ctx.typeRegistry.has(name)) {
+      const prior = symbolByName.get(name);
+      if (prior !== symbol) {
+        const declFile = symbol.declarations?.[0]?.getSourceFile().fileName ?? "";
+        const foreign = !!entryPackageDir && !declFile.startsWith(`${entryPackageDir}${path7.sep}`);
+        if (prior !== undefined || foreign) {
+          const scopedId = `${packageLabel(declFile)}.${name}`;
+          if (!ctx.typeRegistry.has(scopedId)) {
+            const declared2 = checker.getDeclaredTypeOfSymbol(symbol);
+            const schema = ensureNonEmptySchema(buildSchema(declared2, checker, ctx), declared2, checker);
+            const selfRef = JSON.stringify(schema) === JSON.stringify({ $ref: `#/types/${name}` });
+            if (!selfRef && JSON.stringify(ctx.typeRegistry.get(name)?.schema) !== JSON.stringify(schema)) {
+              ctx.typeRegistry.add({
+                id: scopedId,
+                name,
+                kind: symbolKind(symbol),
+                schema
+              });
+              visit(declared2, 0);
+            }
+          }
+        }
+      }
+      walkDeclarations(symbol);
+      return;
+    }
+    const declared = checker.getDeclaredTypeOfSymbol(symbol);
+    ctx.typeRegistry.registerType(declared, ctx);
+    if (!ctx.typeRegistry.has(name)) {
+      ctx.typeRegistry.add({
+        id: name,
+        name,
+        kind: symbolKind(symbol),
+        schema: ensureNonEmptySchema(buildSchema(declared, checker, ctx), declared, checker)
+      });
+    }
+    symbolByName.set(name, symbol);
+    visit(declared, 0);
+    walkDeclarations(symbol);
+  };
+  const handleRef = (nameNode) => {
+    const symbol = checker.getSymbolAtLocation(nameNode);
+    const target = symbol && resolveAlias(symbol);
+    if (target)
+      registerTypeSymbol(target);
+  };
+  const handleNamespaceRef = (nameNode) => {
+    const symbol = checker.getSymbolAtLocation(nameNode);
+    const target = symbol && resolveAlias(symbol);
+    if (!target || visitedSymbols.has(target))
+      return;
+    if (!(target.flags & (ts16.SymbolFlags.ValueModule | ts16.SymbolFlags.NamespaceModule)))
+      return;
+    if (!symbolAllowed(target))
+      return;
+    visitedSymbols.add(target);
+    for (const exp of checker.getExportsOfModule(target)) {
+      const expTarget = resolveAlias(exp);
+      if (!expTarget)
+        continue;
+      if (expTarget.flags & TYPE_SYMBOL_FLAGS) {
+        registerTypeSymbol(expTarget);
+      }
+    }
+  };
+  const walkNode = (node) => {
+    if (ts16.isTypeReferenceNode(node)) {
+      handleRef(node.typeName);
+      if (ts16.isQualifiedName(node.typeName)) {
+        handleNamespaceRef(node.typeName.left);
+      }
+    } else if (ts16.isExpressionWithTypeArguments(node)) {
+      handleRef(node.expression);
+    } else if (ts16.isTypeQueryNode(node)) {
+      handleRef(node.exprName);
+      if (ts16.isQualifiedName(node.exprName)) {
+        handleRef(node.exprName.left);
+        handleNamespaceRef(node.exprName.left);
+      }
+    } else if (ts16.isImportTypeNode(node) && node.qualifier) {
+      handleRef(node.qualifier);
+      if (ts16.isQualifiedName(node.qualifier)) {
+        handleNamespaceRef(node.qualifier.left);
+      }
+    }
+    node.forEachChild(walkNode);
+  };
+  const walkDeclarations = (symbol) => {
+    if (visitedSymbols.has(symbol))
+      return;
+    visitedSymbols.add(symbol);
+    for (const decl of symbol.declarations ?? []) {
+      walkNode(decl);
+    }
+  };
+  for (const exportSymbol of exportedSymbols) {
+    let target = exportSymbol;
+    if (exportSymbol.flags & ts16.SymbolFlags.Alias) {
+      try {
+        target = checker.getAliasedSymbol(exportSymbol);
+      } catch {
+        continue;
+      }
+    }
+    const decl = target.valueDeclaration ?? target.declarations?.[0];
+    if (decl) {
+      visit(checker.getTypeOfSymbolAtLocation(target, decl), 0);
+    }
+    if (target.flags & TYPE_SYMBOL_FLAGS) {
+      visit(checker.getDeclaredTypeOfSymbol(target), 0);
+    }
+    walkDeclarations(target);
+  }
+}
+
+// src/builder/verification.ts
+import * as path8 from "node:path";
 var BUILTIN_TYPES2 = new Set([
   "Array",
   "ArrayBuffer",
@@ -5825,8 +6202,8 @@ function isExternalType2(definedIn, baseDir) {
     return true;
   if (definedIn.includes("node_modules"))
     return true;
-  const normalizedDefined = path7.resolve(definedIn);
-  const normalizedBase = path7.resolve(baseDir);
+  const normalizedDefined = path8.resolve(definedIn);
+  const normalizedBase = path8.resolve(baseDir);
   return !normalizedDefined.startsWith(normalizedBase);
 }
 function shouldSkipDanglingRef(name) {
@@ -6008,12 +6385,23 @@ async function extract(options) {
         diagnostics: [
           {
             message: `No exports found in ${entryFile}. Is this the right entry point?`,
-            severity: "warning"
+            severity: "error"
           }
         ]
       };
     }
     const exportedSymbols = typeChecker.getExportsOfModule(moduleSymbol);
+    if (exportedSymbols.length === 0) {
+      return {
+        spec: createEmptySpec(entryFile, includeSchema, isDtsSource),
+        diagnostics: [
+          {
+            message: `No exports found in ${entryFile}. Is this the right entry point?`,
+            severity: "error"
+          }
+        ]
+      };
+    }
     const exportedIds = new Set;
     for (const symbol of exportedSymbols) {
       exportedIds.add(symbol.getName());
@@ -6064,9 +6452,9 @@ async function extract(options) {
                 break;
               }
             }
-            if (ts16.isExportSpecifier(decl)) {
+            if (ts17.isExportSpecifier(decl)) {
               const exportDecl = decl.parent?.parent;
-              if (exportDecl && ts16.isExportDeclaration(exportDecl) && exportDecl.moduleSpecifier) {
+              if (exportDecl && ts17.isExportDeclaration(exportDecl) && exportDecl.moduleSpecifier) {
                 const moduleText = exportDecl.moduleSpecifier.getText().slice(1, -1);
                 if (!moduleText.startsWith(".") && !moduleText.startsWith("/")) {
                   externalPackage = moduleText;
@@ -6129,8 +6517,13 @@ async function extract(options) {
     }
     const verification = buildVerificationSummary(exportedSymbols.length, exports.length, exportTracker);
     const meta = await getPackageMeta(entryFile, baseDir);
+    expandReachableTypes(filteredSymbols, ctx, {
+      followExternal: options.followExternal,
+      workspacePackages: result.workspacePackages ?? new Map,
+      entryFile
+    });
     {
-      const symFlags = ts16.SymbolFlags.Type | ts16.SymbolFlags.Interface | ts16.SymbolFlags.Class;
+      const symFlags = ts17.SymbolFlags.Type | ts17.SymbolFlags.Interface | ts17.SymbolFlags.Class;
       const maxPasses = 5;
       for (let pass = 0;pass < maxPasses; pass++) {
         const allRefs = new Map;
@@ -6165,7 +6558,7 @@ async function extract(options) {
       }
     }
     const types = ctx.typeRegistry.getAll();
-    const projectBaseDir = baseDir ?? path8.dirname(entryFile);
+    const projectBaseDir = baseDir ?? path9.dirname(entryFile);
     const definedTypes = new Set(types.map((t) => t.id));
     const forgottenExports = collectForgottenExports(exports, types, program, sourceFile, exportedIds, projectBaseDir, definedTypes);
     for (const forgotten of forgottenExports) {
@@ -6198,7 +6591,7 @@ async function extract(options) {
     }
     let runtimeMetadata;
     if (options.schemaExtraction === "hybrid") {
-      const projectBaseDir2 = baseDir || path8.dirname(entryFile);
+      const projectBaseDir2 = baseDir || path9.dirname(entryFile);
       const runtimeResult = await extractStandardSchemasFromProject(entryFile, projectBaseDir2, {
         target: options.schemaTarget || "draft-2020-12",
         timeout: 15000
@@ -6277,21 +6670,21 @@ async function extract(options) {
 }
 function serializeDeclaration2(declaration, exportSymbol, exportName, ctx, isTypeOnly = false) {
   let result = null;
-  if (ts16.isFunctionDeclaration(declaration)) {
+  if (ts17.isFunctionDeclaration(declaration)) {
     result = serializeFunctionExport(declaration, ctx);
-  } else if (ts16.isClassDeclaration(declaration)) {
+  } else if (ts17.isClassDeclaration(declaration)) {
     result = serializeClass(declaration, ctx);
-  } else if (ts16.isInterfaceDeclaration(declaration)) {
+  } else if (ts17.isInterfaceDeclaration(declaration)) {
     result = serializeInterface(declaration, ctx);
-  } else if (ts16.isTypeAliasDeclaration(declaration)) {
+  } else if (ts17.isTypeAliasDeclaration(declaration)) {
     result = serializeTypeAlias(declaration, ctx);
-  } else if (ts16.isEnumDeclaration(declaration)) {
+  } else if (ts17.isEnumDeclaration(declaration)) {
     result = serializeEnum(declaration, ctx);
-  } else if (ts16.isVariableDeclaration(declaration)) {
+  } else if (ts17.isVariableDeclaration(declaration)) {
     const varStatement = declaration.parent?.parent;
-    if (varStatement && ts16.isVariableStatement(varStatement)) {
-      if (declaration.initializer && (ts16.isArrowFunction(declaration.initializer) || ts16.isFunctionExpression(declaration.initializer))) {
-        const varName = ts16.isIdentifier(declaration.name) ? declaration.name.text : declaration.name.getText();
+    if (varStatement && ts17.isVariableStatement(varStatement)) {
+      if (declaration.initializer && (ts17.isArrowFunction(declaration.initializer) || ts17.isFunctionExpression(declaration.initializer))) {
+        const varName = ts17.isIdentifier(declaration.name) ? declaration.name.text : declaration.name.getText();
         result = serializeFunctionExport(declaration.initializer, ctx, varName);
       } else {
         result = serializeVariable(declaration, varStatement, ctx);
@@ -6303,7 +6696,7 @@ function serializeDeclaration2(declaration, exportSymbol, exportName, ctx, isTyp
         }
       }
     }
-  } else if (ts16.isNamespaceExport(declaration) || ts16.isModuleDeclaration(declaration) || ts16.isNamespaceImport(declaration) || ts16.isSourceFile(declaration)) {
+  } else if (ts17.isNamespaceExport(declaration) || ts17.isModuleDeclaration(declaration) || ts17.isNamespaceImport(declaration) || ts17.isSourceFile(declaration)) {
     try {
       result = serializeNamespaceExport(exportSymbol, exportName, ctx);
     } catch {
@@ -6339,7 +6732,7 @@ function serializeNamespaceExport(symbol, exportName, ctx) {
   const members = [];
   const checker = ctx.program.getTypeChecker();
   let targetSymbol = symbol;
-  if (symbol.flags & ts16.SymbolFlags.Alias) {
+  if (symbol.flags & ts17.SymbolFlags.Alias) {
     const aliased = checker.getAliasedSymbol(symbol);
     if (aliased && aliased !== symbol) {
       targetSymbol = aliased;
@@ -6366,31 +6759,31 @@ function serializeNamespaceExport(symbol, exportName, ctx) {
 function serializeNamespaceMember(symbol, memberName, ctx) {
   const checker = ctx.program.getTypeChecker();
   let targetSymbol = symbol;
-  if (symbol.flags & ts16.SymbolFlags.Alias) {
+  if (symbol.flags & ts17.SymbolFlags.Alias) {
     const aliased = checker.getAliasedSymbol(symbol);
     if (aliased && aliased !== symbol) {
       targetSymbol = aliased;
     }
   }
   const declarations = targetSymbol.declarations ?? [];
-  const declaration = targetSymbol.valueDeclaration || declarations.find((d) => d.kind !== ts16.SyntaxKind.ExportSpecifier) || declarations[0];
+  const declaration = targetSymbol.valueDeclaration || declarations.find((d) => d.kind !== ts17.SyntaxKind.ExportSpecifier) || declarations[0];
   if (!declaration)
     return null;
   const type = checker.getTypeAtLocation(declaration);
   const callSignatures = type.getCallSignatures();
   const { deprecated } = isSymbolDeprecated(targetSymbol);
   let kind = "variable";
-  if (ts16.isFunctionDeclaration(declaration) || ts16.isFunctionExpression(declaration)) {
+  if (ts17.isFunctionDeclaration(declaration) || ts17.isFunctionExpression(declaration)) {
     kind = "function";
-  } else if (ts16.isClassDeclaration(declaration)) {
+  } else if (ts17.isClassDeclaration(declaration)) {
     kind = "class";
-  } else if (ts16.isInterfaceDeclaration(declaration)) {
+  } else if (ts17.isInterfaceDeclaration(declaration)) {
     kind = "interface";
-  } else if (ts16.isTypeAliasDeclaration(declaration)) {
+  } else if (ts17.isTypeAliasDeclaration(declaration)) {
     kind = "type";
-  } else if (ts16.isEnumDeclaration(declaration)) {
+  } else if (ts17.isEnumDeclaration(declaration)) {
     kind = "enum";
-  } else if (ts16.isVariableDeclaration(declaration)) {
+  } else if (ts17.isVariableDeclaration(declaration)) {
     if (callSignatures.length > 0) {
       kind = "function";
     }
@@ -6421,11 +6814,11 @@ function getJSDocFromExportSymbol(symbol) {
   const examples = [];
   const decl = symbol.declarations?.[0];
   if (decl) {
-    const exportDecl = ts16.isNamespaceExport(decl) ? decl.parent : decl;
-    if (exportDecl && ts16.isExportDeclaration(exportDecl)) {
-      const jsDocs = ts16.getJSDocCommentsAndTags(exportDecl);
+    const exportDecl = ts17.isNamespaceExport(decl) ? decl.parent : decl;
+    if (exportDecl && ts17.isExportDeclaration(exportDecl)) {
+      const jsDocs = ts17.getJSDocCommentsAndTags(exportDecl);
       for (const doc of jsDocs) {
-        if (ts16.isJSDoc(doc) && doc.comment) {
+        if (ts17.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 {
@@ -6487,7 +6880,7 @@ function createEmptySpec(entryFile, includeSchema, isDtsSource) {
   return {
     ...includeSchema ? { $schema: SCHEMA_URL } : {},
     openpkg: SCHEMA_VERSION,
-    meta: { name: path8.basename(entryFile, path8.extname(entryFile)) },
+    meta: { name: path9.basename(entryFile, path9.extname(entryFile)) },
     exports: [],
     generation: {
       generator: "@openpkg-ts/sdk",
@@ -6503,7 +6896,7 @@ function findTypeInProgram(name, checker, program, sourceFile, symFlags) {
   const localSym = checker.resolveName(name, sourceFile, symFlags, false);
   if (localSym)
     return checker.getDeclaredTypeOfSymbol(localSym);
-  const entryDir = path8.dirname(sourceFile.fileName);
+  const entryDir = path9.dirname(sourceFile.fileName);
   for (const sf of program.getSourceFiles()) {
     const fn = sf.fileName;
     if (fn.includes("/typescript/lib/lib.") || fn.includes("\\typescript\\lib\\lib."))
@@ -6519,33 +6912,33 @@ function findTypeInProgram(name, checker, program, sourceFile, symFlags) {
   return;
 }
 async function getPackageMeta(entryFile, baseDir) {
-  let dir = baseDir ?? path8.dirname(entryFile);
-  while (dir !== path8.dirname(dir)) {
-    const pkgPath = path8.join(dir, "package.json");
+  let dir = baseDir ?? path9.dirname(entryFile);
+  while (dir !== path9.dirname(dir)) {
+    const pkgPath = path9.join(dir, "package.json");
     try {
-      if (fs6.existsSync(pkgPath)) {
-        const pkg = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
+      if (fs7.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
         return {
-          name: pkg.name ?? path8.basename(dir),
+          name: pkg.name ?? path9.basename(dir),
           version: pkg.version,
           description: pkg.description
         };
       }
     } catch {}
-    dir = path8.dirname(dir);
+    dir = path9.dirname(dir);
   }
-  return { name: path8.basename(baseDir ?? path8.dirname(entryFile)) };
+  return { name: path9.basename(baseDir ?? path9.dirname(entryFile)) };
 }
 
 // src/primitives/spec.ts
 var extractSpec = extract;
 // src/types/utils.ts
-import ts17 from "typescript";
+import ts18 from "typescript";
 function isExported(node) {
   const modifiers = node.modifiers;
   if (!modifiers)
     return false;
-  return modifiers.some((m) => m.kind === ts17.SyntaxKind.ExportKeyword);
+  return modifiers.some((m) => m.kind === ts18.SyntaxKind.ExportKeyword);
 }
 function getNodeName(node) {
   if ("name" in node && node.name) {
@@ -6557,6 +6950,7 @@ function getNodeName(node) {
 export {
   zodAdapter,
   withDescription,
+  withDeprecated,
   valibotAdapter,
   typeboxAdapter,
   toSearchIndexJSON,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpkg-ts/sdk",
-  "version": "0.42.0",
+  "version": "0.43.0",
   "description": "TypeScript API extraction SDK - programmatic primitives for OpenPkg specs",
   "keywords": [
     "openpkg",
@@ -43,7 +43,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@openpkg-ts/spec": "^0.41.0",
+    "@openpkg-ts/spec": "^0.43.0",
     "picomatch": "4.0.3",
     "typescript": "^5.0.0"
   },