@openpkg-ts/sdk 0.54.9 → 0.54.11

package/dist/index.d.ts

@@ -1202,6 +1202,12 @@ import { assertSpec, getAvailableVersions, getValidationErrors, LATEST_VERSION,
 import { SpecType as SpecType4 } from "@openpkg-ts/spec";
 import ts2 from "typescript";
 import ts from "typescript";
+interface ExpansionBudget {
+	/** Export name, or `type <id>` for a registered type. */
+	owner: string;
+	ops: number;
+	exceeded: boolean;
+}
 interface SerializerContext {
 	typeChecker: ts.TypeChecker;
 	program: ts.Program;
@@ -1214,6 +1220,8 @@ interface SerializerContext {
 	visitedTypes: Set<ts.Type>;
 	/** Permanent "already processed" set for registerReferencedTypes */
 	registeredTypes: Set<ts.Type>;
+	/** Generic union/intersection alias being built at its own declaration: decomposed once, referenced everywhere else. */
+	aliasBody?: ts.Type;
 	/** Flag to indicate we're processing tuple elements - skip Array prototype methods */
 	inTupleElement?: boolean;
 	/** Include private/protected class members (default: false) */
@@ -1242,12 +1250,22 @@ interface SerializerContext {
 	idOwner: Map<string, string>;
 	/** Workspace package name → dir, used to package-scope colliding type ids. */
 	workspacePackages: ReadonlyMap<string, string>;
-	/** Structural schema-build steps taken this extract. */
+	/**
+	* Schema-build steps of the or registered type being built. Each gets
+	* its own budget, so what one spends never changes what another emits: the
+	* same comes out the same in a full run and under `only`.
+	*/
+	budget: ExpansionBudget;
+	/** Cap on one budget's steps; past this, that owner's deep parts emit x-ts-type text. */
+	maxBudgetOps: number;
+	/** Structural schema-build steps taken this extract, all budgets together. */
 	schemaOps: number;
-	/** Cap on schema-build steps; past this, emit x-ts-type text. */
+	/** Safety ceiling on schemaOps against runaway expansion; past this, everything emits text. */
 	maxSchemaOps: number;
-	/** True once schemaOps exceeded maxSchemaOps. */
+	/** True once any schema degraded to text (a budget ran out, or a type defers expansion). */
 	budgetExceeded: boolean;
+	/** Owners whose budget ran out, in the order they did. */
+	exhaustedBudgets: string[];
 }
 declare class TypeRegistry {
 	private types;
@@ -1905,6 +1923,16 @@ declare function typeNodeOfSignature(sig: ts16.Signature): ts16.TypeNode | undef
 */
 declare function buildSchemaFromTypeNode(node: ts16.TypeNode, checker: ts16.TypeChecker, ctx?: SerializerContext): SpecSchema5;
 /**
+* Schema arms for the bases of a class or interface the checker cannot see
+* into (`any`: an unresolved import, an alias over a missing global). Such a
+* base contributes members nobody can list, so the own shape must not read as
+* closed: callers emit `allOf: [own shape, ...arms]`, the form an alias
+* intersection with the same arm (`{...} & Config`) already takes.
+*/
+declare function openHeritageArms(declarations: readonly ts16.Declaration[], checker: ts16.TypeChecker, ctx?: SerializerContext): SpecSchema5[];
+/** `allOf` of a shape and the open heritage arms; the shape alone when there are none. */
+declare function withOpenHeritage(schema: SpecSchema5, arms: readonly SpecSchema5[]): SpecSchema5;
+/**
 * Strip `undefined` from a union type when optionality is already expressed
 * elsewhere (`required: false`, `flags.optional`). Used for both schema shape
 * and x-ts-type text so neither re-encodes optionality as `| undefined`.
@@ -1981,6 +2009,11 @@ declare function ensureNonEmptySchema(schema: SpecSchema5, type: ts16.Type, chec
 */
 declare function buildSchema(type: ts16.Type, checker: ts16.TypeChecker, ctx?: SerializerContext, typeNode?: ts16.TypeNode): SpecSchema5;
 /**
+* Schema of a named type at its own declaration. A generic union/intersection
+* alias is decomposed here and nowhere else; every use of it is a `$ref`.
+*/
+declare function buildAliasBodySchema(type: ts16.Type, checker: ts16.TypeChecker, ctx: SerializerContext): SpecSchema5;
+/**
 * Build schema for function types
 */
 declare function buildFunctionSchema(callSignatures: readonly ts16.Signature[], checker: ts16.TypeChecker, ctx: SerializerContext | undefined): SpecSchema5;
@@ -2024,4 +2057,4 @@ declare function findDiscriminatorProperty(unionTypes: ts16.Type[], checker: ts1
 import ts17 from "typescript";
 declare function isExported(node: ts17.Node): boolean;
 declare function getNodeName(node: ts17.Node): string | undefined;
-export { zodAdapter, writtenTypeText, withDescription2 as withDescription, withDeprecated, validateSpec, valibotAdapter, typeboxAdapter, typeNodeOfSignature, typeNodeDefersExpansion, toToolSchema, toSearchIndexJSON, toSearchIndex2 as toSearchIndex, toPagefindRecords2 as toPagefindRecords, toNavigation2 as toNavigation, toMarkdown2 as toMarkdown, toJsonSchema, toJSONString, toJSON2 as toJSON, toHTML2 as toHTML, toFumadocsMetaJSON, toDocusaurusSidebarJS, toAlgoliaRecords2 as toAlgoliaRecords, stripUndefinedFromType, stripTsExtensions, sortByName, shouldEmitAliasTypeText, serializeVariable, serializeTypeAlias, serializeInterface, serializeFunctionExport, serializeEnum, serializeClass, scrubImportQualifiers, schemasAreEqual, schemaIsAny, resolveTypeRef, resolveTarget, resolveExportTarget, resolveCompiledPath, resolveAliasSymbol, renderTypeText, registerReferencedTypes, registerAdapter, recommendSemverBump, query, pickEntry, parseGithubRepo, normalizeType, normalizeSchema, normalizeMembers, normalizeExport, mergeConfig, loadSpec, loadConfig, listExports, isTypeReference, isTypeOnlyExport, isSymbolDeprecated, isStandardJSONSchema, isSchemaType, isRemoteInput, isReadonlyPropertySymbol, isPureRefSchema, isProperty, isPrimitiveName, isPathLikeInput, isMethod, isExported, isEntryFilePath, isDeferredMappedOrConditional, isBuiltinSymbol, isBuiltinGeneric, isAnonymous, groupByVisibility, getValidationErrors, getTypeOrigin, getSourceLocation, getProperties, getParamDescription, getNonNullableType, getNodeName, getMethods, getMemberBadges, getJSDocComment, getExportKind, getExport2 as getExport, getAvailableVersions, toMarkdown2 as generateDocs, formatTypeParameters, formatSchema, formatReturnType, formatParameters, formatMappedType, formatConditionalType, formatBadges, findWorkspaceRoot, findDiscriminatorProperty, findAdapter, filterSpec, extractTypeParameters, extractStandardSchemasFromTs, extractStandardSchemasFromProject, extractStandardSchemas, extractSpec, extractSchemaType, extractParameters, extract, exportToMarkdown, exportToJsonSchema, ensureNonEmptySchema, diffSpec2 as diffSpecs, diffSpec, detectTsRuntime, deduplicateSchemas, decoratePropertySchema, declaredTypeNode, createProgram, createDocs, cloneRemote, categorizeBreakingChanges, catalogPackages, calculateNextVersion, bundleRefs, buildSignatureString, buildSchemaFromTypeNode, buildSchema, buildObjectSchema, buildFunctionSchema, assertSpec, asStandardSchema, arktypeAdapter, TypeRegistry, TypeReference2 as TypeReference, TsRuntime, ToolSchemaResult, ToolSchemaProvider, ToToolSchemaOptions, ToJsonSchemaOptions, StandardSchemaExtractionResult, StandardSchemaExtractionOutput, StandardJSONSchemaV1, StandardJSONSchemaTarget, StandardJSONSchemaOptions, SpecMappedType, SpecError, SpecDiff, SpecConditionalType, SkippedExportDetail, SimplifiedSpec, SimplifiedSignature, SimplifiedReturn, SimplifiedParameter, SimplifiedMember, SimplifiedExport, SimplifiedExample, SerializerContext, SemverRecommendation, SemverBump, SearchRecord, SearchOptions, SearchIndex, SchemaVersion, SchemaExtractionResult, SchemaAdapter, STRING_PROTOTYPE_METHODS, ResolveTargetResult, ResolveTargetOptions, ResolveOk, ResolveNeedsBuild, ResolveExplicit, ResolveEmpty, ResolveAmbiguous, QueryBuilder, ProjectExtractionOutput, ProjectExtractionInfo, ProgramResult, ProgramOptions, PagefindRecord, PackageRecord, PRIMITIVES, OpenpkgConfig, NormalizeOptions, NavOptions, NavItem, NavGroup, NavFormat, NUMBER_PROTOTYPE_METHODS, MemberChangeInfo, MarkdownOptions, LoadOptions, ListExportsResult, ListExportsOptions, LATEST_VERSION, JsonSchemaDocument, 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, Diagnostic, CloneFn, CategorizedBreaking, CacheManagerOptions, CacheManager, CONFIG_FILENAME, BundleResult, BundleOptions, BuiltinSchema, BreakingSeverity, BUILTIN_TYPE_SCHEMAS, AsStandardSchemaOptions, AlgoliaRecord, ARRAY_PROTOTYPE_METHODS };
+export { zodAdapter, writtenTypeText, withOpenHeritage, withDescription2 as withDescription, withDeprecated, validateSpec, valibotAdapter, typeboxAdapter, typeNodeOfSignature, typeNodeDefersExpansion, toToolSchema, toSearchIndexJSON, toSearchIndex2 as toSearchIndex, toPagefindRecords2 as toPagefindRecords, toNavigation2 as toNavigation, toMarkdown2 as toMarkdown, toJsonSchema, toJSONString, toJSON2 as toJSON, toHTML2 as toHTML, toFumadocsMetaJSON, toDocusaurusSidebarJS, toAlgoliaRecords2 as toAlgoliaRecords, stripUndefinedFromType, stripTsExtensions, sortByName, shouldEmitAliasTypeText, serializeVariable, serializeTypeAlias, serializeInterface, serializeFunctionExport, serializeEnum, serializeClass, scrubImportQualifiers, schemasAreEqual, schemaIsAny, resolveTypeRef, resolveTarget, resolveExportTarget, resolveCompiledPath, resolveAliasSymbol, renderTypeText, registerReferencedTypes, registerAdapter, recommendSemverBump, query, pickEntry, parseGithubRepo, openHeritageArms, normalizeType, normalizeSchema, normalizeMembers, normalizeExport, mergeConfig, loadSpec, loadConfig, listExports, isTypeReference, isTypeOnlyExport, isSymbolDeprecated, isStandardJSONSchema, isSchemaType, isRemoteInput, isReadonlyPropertySymbol, isPureRefSchema, isProperty, isPrimitiveName, isPathLikeInput, isMethod, isExported, isEntryFilePath, isDeferredMappedOrConditional, isBuiltinSymbol, isBuiltinGeneric, isAnonymous, groupByVisibility, getValidationErrors, getTypeOrigin, getSourceLocation, getProperties, getParamDescription, getNonNullableType, getNodeName, getMethods, getMemberBadges, getJSDocComment, getExportKind, getExport2 as getExport, getAvailableVersions, toMarkdown2 as generateDocs, formatTypeParameters, formatSchema, formatReturnType, formatParameters, formatMappedType, formatConditionalType, formatBadges, findWorkspaceRoot, findDiscriminatorProperty, findAdapter, filterSpec, extractTypeParameters, extractStandardSchemasFromTs, extractStandardSchemasFromProject, extractStandardSchemas, extractSpec, extractSchemaType, extractParameters, extract, exportToMarkdown, exportToJsonSchema, ensureNonEmptySchema, diffSpec2 as diffSpecs, diffSpec, detectTsRuntime, deduplicateSchemas, decoratePropertySchema, declaredTypeNode, createProgram, createDocs, cloneRemote, categorizeBreakingChanges, catalogPackages, calculateNextVersion, bundleRefs, buildSignatureString, buildSchemaFromTypeNode, buildSchema, buildObjectSchema, buildFunctionSchema, buildAliasBodySchema, assertSpec, asStandardSchema, arktypeAdapter, TypeRegistry, TypeReference2 as TypeReference, TsRuntime, ToolSchemaResult, ToolSchemaProvider, ToToolSchemaOptions, ToJsonSchemaOptions, StandardSchemaExtractionResult, StandardSchemaExtractionOutput, StandardJSONSchemaV1, StandardJSONSchemaTarget, StandardJSONSchemaOptions, SpecMappedType, SpecError, SpecDiff, SpecConditionalType, SkippedExportDetail, SimplifiedSpec, SimplifiedSignature, SimplifiedReturn, SimplifiedParameter, SimplifiedMember, SimplifiedExport, SimplifiedExample, SerializerContext, SemverRecommendation, SemverBump, SearchRecord, SearchOptions, SearchIndex, SchemaVersion, SchemaExtractionResult, SchemaAdapter, STRING_PROTOTYPE_METHODS, ResolveTargetResult, ResolveTargetOptions, ResolveOk, ResolveNeedsBuild, ResolveExplicit, ResolveEmpty, ResolveAmbiguous, QueryBuilder, ProjectExtractionOutput, ProjectExtractionInfo, ProgramResult, ProgramOptions, PagefindRecord, PackageRecord, PRIMITIVES, OpenpkgConfig, NormalizeOptions, NavOptions, NavItem, NavGroup, NavFormat, NUMBER_PROTOTYPE_METHODS, MemberChangeInfo, MarkdownOptions, LoadOptions, ListExportsResult, ListExportsOptions, LATEST_VERSION, JsonSchemaDocument, 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, Diagnostic, CloneFn, CategorizedBreaking, CacheManagerOptions, CacheManager, CONFIG_FILENAME, BundleResult, BundleOptions, BuiltinSchema, BreakingSeverity, BUILTIN_TYPE_SCHEMAS, AsStandardSchemaOptions, AlgoliaRecord, ARRAY_PROTOTYPE_METHODS };

package/dist/index.js

@@ -2263,6 +2263,21 @@ function getExportKind(declaration, type) {
     return "function";
   return "variable";
 }
+function getExtendsExpressions(node) {
+  return node.heritageClauses?.find((clause) => clause.token === ts2.SyntaxKind.ExtendsKeyword)?.types ?? [];
+}
+function getExtendsText(node, checker) {
+  const names = getExtendsExpressions(node).map((expr) => {
+    const name = checker.getTypeAtLocation(expr).getSymbol()?.getName();
+    return name && !name.startsWith("__") ? name : expr.expression.getText();
+  });
+  return names.length > 0 ? names.join(" & ") : undefined;
+}
+function propertyNameText(name) {
+  if (ts2.isComputedPropertyName(name))
+    return name.getText();
+  return name.text;
+}
 
 // src/compiler/program.ts
 import * as fs4 from "node:fs";
@@ -2603,8 +2618,39 @@ function createProgram(options) {
 import ts10 from "typescript";
 
 // src/types/parameters.ts
+import ts7 from "typescript";
+
+// src/ast/registry.ts
 import ts6 from "typescript";
 
+// src/serializers/expansion-budget.ts
+var MAX_BUDGET_OPS = 1e4;
+var MAX_SCHEMA_OPS = 200000;
+function withExpansionBudget(ctx, owner, fn) {
+  const outer = {
+    budget: ctx.budget,
+    currentDepth: ctx.currentDepth,
+    visitedTypes: ctx.visitedTypes,
+    inTupleElement: ctx.inTupleElement,
+    aliasBody: ctx.aliasBody
+  };
+  const budget = { owner, ops: 0, exceeded: false };
+  Object.assign(ctx, {
+    budget,
+    currentDepth: 0,
+    visitedTypes: new Set,
+    inTupleElement: undefined,
+    aliasBody: undefined
+  });
+  try {
+    return fn();
+  } finally {
+    if (budget.exceeded)
+      ctx.exhaustedBudgets.push(owner);
+    Object.assign(ctx, outer);
+  }
+}
+
 // src/types/schema-builder.ts
 import ts5 from "typescript";
 
@@ -2662,6 +2708,10 @@ function resolveFromModuleSpecifier(decl, symbol, checker, program) {
   if (ts4.isExportSpecifier(decl)) {
     const exportDecl = decl.parent?.parent;
     if (exportDecl && ts4.isExportDeclaration(exportDecl)) {
+      if (!exportDecl.moduleSpecifier) {
+        const local = checker.getExportSpecifierLocalTargetSymbol(decl);
+        return local && local !== symbol ? local : undefined;
+      }
       moduleSpecifier = exportDecl.moduleSpecifier;
       importedName = (decl.propertyName ?? decl.name).text;
     }
@@ -2834,7 +2884,8 @@ function resolvedSymbol(symbol, checker) {
     return;
   if (symbol.flags & ts5.SymbolFlags.Alias) {
     try {
-      return checker.getAliasedSymbol(symbol);
+      const target = checker.getAliasedSymbol(symbol);
+      return checker.isUnknownSymbol(target) ? symbol : target;
     } catch {
       return symbol;
     }
@@ -2869,10 +2920,11 @@ function buildSchemaFromTypeNode(node, checker, ctx) {
   if (node.kind === ts5.SyntaxKind.UnknownKeyword) {
     return { type: "unknown" };
   }
-  if (ts5.isTypeReferenceNode(node)) {
-    const raw = checker.getSymbolAtLocation(ts5.isQualifiedName(node.typeName) ? node.typeName.right : node.typeName);
+  const nameNode = ts5.isTypeReferenceNode(node) ? node.typeName : ts5.isExpressionWithTypeArguments(node) && (ts5.isIdentifier(node.expression) || ts5.isPropertyAccessExpression(node.expression)) ? node.expression : undefined;
+  if (nameNode) {
+    const raw = checker.getSymbolAtLocation(ts5.isQualifiedName(nameNode) ? nameNode.right : ts5.isPropertyAccessExpression(nameNode) ? nameNode.name : nameNode);
     const symbol = resolvedSymbol(raw, checker);
-    const name = symbol?.getName() ?? node.typeName.getText();
+    const name = symbol?.getName() ?? nameNode.getText();
     const args = node.typeArguments?.map((arg) => {
       if (typeNodeDefersExpansion(arg, checker, ctx?.program)) {
         return buildSchemaFromTypeNode(arg, checker, ctx);
@@ -2888,6 +2940,9 @@ function buildSchemaFromTypeNode(node, checker, ctx) {
       }
       return { ...schema, typeArguments: args };
     };
+    if (symbol && symbol.flags & ts5.SymbolFlags.TypeParameter) {
+      return { "x-ts-type": name };
+    }
     if (name && isBuiltinGeneric(name) && (!symbol || isBuiltinSymbol(symbol))) {
       return withArgs({ ...builtinSchema(name) });
     }
@@ -2900,6 +2955,9 @@ function buildSchemaFromTypeNode(node, checker, ctx) {
           refId = name;
         }
       }
+      if (ctx && symbol && symbol.flags & ts5.SymbolFlags.Alias && !ctx.typeRegistry.has(refId)) {
+        ctx.typeRegistry.add({ id: refId, name, kind: "type", schema: { "x-ts-type": name } });
+      }
       return withArgs({ $ref: `#/types/${refId}` });
     }
     return {
@@ -2912,6 +2970,23 @@ function buildSchemaFromTypeNode(node, checker, ctx) {
   }
   return { "x-ts-type": scrubImportQualifiers(node.getText().replace(/\s+/g, " ")) };
 }
+function openHeritageArms(declarations, checker, ctx) {
+  return declarations.filter((decl) => ts5.isClassLike(decl) || ts5.isInterfaceDeclaration(decl)).flatMap((decl) => [...getExtendsExpressions(decl)]).flatMap((expr) => {
+    const base = checker.getTypeAtLocation(expr);
+    if (!(base.flags & ts5.TypeFlags.Any))
+      return [];
+    const registered = ctx?.typeRegistry.registerType(base, ctx);
+    const written = checker.getSymbolAtLocation(expr.expression);
+    const unresolvedImport = !!written && !!(written.flags & ts5.SymbolFlags.Alias) && resolvedSymbol(written, checker) === written;
+    if (!registered && unresolvedImport) {
+      return [{ "x-ts-type": scrubImportQualifiers(expr.getText()) }];
+    }
+    return [buildSchemaFromTypeNode(expr, checker, ctx)];
+  });
+}
+function withOpenHeritage(schema, arms) {
+  return arms.length > 0 ? { allOf: [schema, ...arms] } : schema;
+}
 function stripUndefinedFromType(type, checker) {
   if (!type.isUnion())
     return type;
@@ -2991,6 +3066,7 @@ var BUILTIN_GENERICS = new Set([
   "AsyncIterableIterator",
   "Generator",
   "AsyncGenerator",
+  "ArrayLike",
   "Partial",
   "Required",
   "Readonly",
@@ -3135,6 +3211,7 @@ var BUILTIN_TYPES = new Set([
   "Error",
   "Function",
   "ArrayBuffer",
+  "ArrayBufferLike",
   "SharedArrayBuffer",
   "DataView",
   "Uint8Array",
@@ -3318,7 +3395,12 @@ function isUtilityOverTypeParameter(type) {
   const args = type.aliasTypeArguments;
   if (!args || args.length === 0)
     return false;
-  return args.some((t) => containsUnresolvedTypeParameter(t));
+  if (!args.some((t) => containsUnresolvedTypeParameter(t)))
+    return false;
+  if (args[0].flags & ts5.TypeFlags.TypeParameter || !(type.flags & ts5.TypeFlags.Object)) {
+    return true;
+  }
+  return type.getProperties().length === 0;
 }
 function writtenUtilityText(type, checker, typeNode) {
   let node = typeNode;
@@ -3398,6 +3480,14 @@ function buildSchema(type, checker, ctx, typeNode) {
   const schema = buildSchemaInternal(type, checker, ctx, typeNode);
   return ensureNonEmptySchema(schema, type, checker);
 }
+function buildAliasBodySchema(type, checker, ctx) {
+  ctx.aliasBody = type;
+  try {
+    return buildSchema(type, checker, ctx);
+  } finally {
+    ctx.aliasBody = undefined;
+  }
+}
 function buildMaxDepthSchema(type, checker, typeNode, ctx) {
   if (type.flags & ts5.TypeFlags.Any) {
     if (typeNode)
@@ -3446,13 +3536,44 @@ function buildMaxDepthSchema(type, checker, typeNode, ctx) {
   }
   return { type: checker.typeToString(type) };
 }
+function writtenTypeArguments(typeNode, symbol, checker) {
+  if (!typeNode || !symbol || !ts5.isTypeReferenceNode(typeNode) || !typeNode.typeArguments) {
+    return;
+  }
+  const name = ts5.isQualifiedName(typeNode.typeName) ? typeNode.typeName.right : typeNode.typeName;
+  const written = resolvedSymbol(checker.getSymbolAtLocation(name), checker);
+  return written === symbol ? typeNode.typeArguments : undefined;
+}
+function genericAliasRef(type, checker, ctx, typeNode) {
+  const aliasTypeArgs = type.aliasTypeArguments;
+  const name = type.aliasSymbol?.getName();
+  if (!name || !aliasTypeArgs?.length)
+    return;
+  if (name.startsWith("__") || BUILTIN_TYPES.has(name) || isBuiltinGeneric(name))
+    return;
+  const argNodes = writtenTypeArguments(typeNode, type.aliasSymbol, checker);
+  const build = () => {
+    const schema = {
+      $ref: `#/types/${namedRefId(type, name, ctx)}`,
+      typeArguments: aliasTypeArgs.map((t, i) => buildSchema(t, checker, ctx, argNodes?.[i]))
+    };
+    const packageOrigin = getTypeOrigin(type, checker);
+    if (packageOrigin) {
+      setSchemaExtension(schema, "x-ts-package", packageOrigin);
+    }
+    return schema;
+  };
+  return ctx ? withDepth(ctx, build) : build();
+}
 function buildSchemaInternal(type, checker, ctx, typeNode) {
   if (isAtMaxDepth(ctx)) {
     return buildMaxDepthSchema(type, checker, typeNode, ctx);
   }
   if (ctx) {
     ctx.schemaOps += 1;
-    if (ctx.schemaOps > ctx.maxSchemaOps) {
+    ctx.budget.ops += 1;
+    if (ctx.budget.ops > ctx.maxBudgetOps || ctx.schemaOps > ctx.maxSchemaOps) {
+      ctx.budget.exceeded = true;
       ctx.budgetExceeded = true;
       return { "x-ts-type": cheapTypeText(type, checker, typeNode) };
     }
@@ -3537,6 +3658,9 @@ function buildSchemaInternal(type, checker, ctx, typeNode) {
     }
     if (type.aliasSymbol && !type.aliasTypeArguments?.length) {
       const aliasName = type.aliasSymbol.getName();
+      if ((BUILTIN_TYPES.has(aliasName) || isBuiltinGeneric(aliasName)) && isBuiltinSymbol(type.aliasSymbol)) {
+        return builtinSchema(aliasName);
+      }
       if (!aliasName.startsWith("__") && !isPrimitiveName(aliasName)) {
         const packageOrigin = getTypeOrigin(type, checker);
         const schema = { $ref: `#/types/${namedRefId(type, aliasName, ctx)}` };
@@ -3546,6 +3670,14 @@ function buildSchemaInternal(type, checker, ctx, typeNode) {
         return schema;
       }
     }
+    if (type.isUnion() || type.isIntersection()) {
+      const ownBody = ctx?.aliasBody === type;
+      if (ownBody && ctx)
+        ctx.aliasBody = undefined;
+      const aliasRef = ownBody ? undefined : genericAliasRef(type, checker, ctx, typeNode);
+      if (aliasRef)
+        return aliasRef;
+    }
     if (type.flags & ts5.TypeFlags.TemplateLiteral) {
       return {
         type: "string",
@@ -3670,11 +3802,12 @@ function buildSchemaInternal(type, checker, ctx, typeNode) {
       }
       if (name && !isAnonymous(typeRef.target)) {
         const packageOrigin = getTypeOrigin(typeRef.target, checker);
+        const argNodes = writtenTypeArguments(typeNode, symbol2, checker);
         if (ctx) {
           return withDepth(ctx, () => {
             const schema2 = {
               $ref: `#/types/${namedRefId(typeRef.target, name, ctx)}`,
-              typeArguments: typeArgs.map((t) => buildSchema(t, checker, ctx))
+              typeArguments: typeArgs.map((t, i) => buildSchema(t, checker, ctx, argNodes?.[i]))
             };
             if (packageOrigin) {
               setSchemaExtension(schema2, "x-ts-package", packageOrigin);
@@ -3713,29 +3846,9 @@ function buildSchemaInternal(type, checker, ctx, typeNode) {
         });
         return ctx ? withDepth(ctx, build) : build();
       }
-      if (!name.startsWith("__")) {
-        const packageOrigin = getTypeOrigin(type, checker);
-        if (ctx) {
-          return withDepth(ctx, () => {
-            const schema2 = {
-              $ref: `#/types/${namedRefId(type, name, ctx)}`,
-              typeArguments: aliasTypeArgs.map((t) => buildSchema(t, checker, ctx))
-            };
-            if (packageOrigin) {
-              setSchemaExtension(schema2, "x-ts-package", packageOrigin);
-            }
-            return schema2;
-          });
-        }
-        const schema = {
-          $ref: `#/types/${name}`,
-          typeArguments: aliasTypeArgs.map((t) => buildSchema(t, checker, ctx))
-        };
-        if (packageOrigin) {
-          setSchemaExtension(schema, "x-ts-package", packageOrigin);
-        }
-        return schema;
-      }
+      const aliasRef = genericAliasRef(type, checker, ctx, typeNode);
+      if (aliasRef)
+        return aliasRef;
     }
     if (type.flags & ts5.TypeFlags.Object) {
       const callSignatures = type.getCallSignatures();
@@ -4000,219 +4113,7 @@ function findDiscriminatorProperty(unionTypes, checker) {
   return;
 }
 
-// src/types/parameters.ts
-function extractParameters(signature, ctx) {
-  const { typeChecker: checker } = ctx;
-  const result = [];
-  const signatureDecl = signature.getDeclaration();
-  const jsdocTags = signatureDecl ? ts6.getJSDocTags(signatureDecl) : [];
-  for (const param of signature.getParameters()) {
-    const decl = param.valueDeclaration;
-    if (!decl)
-      continue;
-    const defer = typeNodeDefersExpansion(decl.type, checker, ctx.program);
-    const type = defer ? undefined : checker.getTypeOfSymbolAtLocation(param, decl);
-    if (decl && ts6.isObjectBindingPattern(decl.name)) {
-      const expandedParams = expandBindingPattern(decl, type ?? checker.getTypeOfSymbolAtLocation(param, decl), jsdocTags, ctx);
-      result.push(...expandedParams);
-    } else {
-      const isOptional = !!decl?.questionToken || !!decl?.initializer;
-      const isRest = !!decl.dotDotDotToken;
-      const paramName = param.getName();
-      const description = getParamDescription(paramName, jsdocTags);
-      const schema = defer ? buildSchemaFromTypeNode(decl.type, checker, ctx) : buildSchema(isOptional ? stripUndefinedFromType(type, checker) : type, checker, ctx, decl.type);
-      if (!defer && type) {
-        registerReferencedTypes(isOptional ? stripUndefinedFromType(type, checker) : type, ctx);
-      }
-      const paramResult = {
-        name: paramName,
-        schema,
-        required: !isOptional && !isRest,
-        ...isRest ? { rest: true } : {}
-      };
-      if (description) {
-        paramResult.description = description;
-        const inlineTags = parseInlineTags(description);
-        if (inlineTags)
-          paramResult.inlineTags = inlineTags;
-      }
-      if (decl.initializer) {
-        applyDefault(paramResult, decl.initializer);
-      }
-      result.push(paramResult);
-    }
-  }
-  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 (!ts6.isBindingElement(element))
-      continue;
-    const propertyName = element.propertyName ? ts6.isIdentifier(element.propertyName) ? element.propertyName.text : element.propertyName.getText() : ts6.isIdentifier(element.name) ? element.name.text : element.name.getText();
-    const propSymbol = allProperties.get(propertyName);
-    if (!propSymbol)
-      continue;
-    const isOptional = !!(propSymbol.flags & ts6.SymbolFlags.Optional) || element.initializer !== undefined;
-    const propType = checker.getTypeOfSymbol(propSymbol);
-    const effectiveType = isOptional ? stripUndefinedFromType(propType, checker) : propType;
-    registerReferencedTypes(effectiveType, ctx);
-    const description = getParamDescription(propertyName, jsdocTags, inferredAlias);
-    const param = {
-      name: propertyName,
-      schema: buildSchema(effectiveType, checker, ctx, declaredTypeNode(propSymbol.valueDeclaration)),
-      required: !isOptional
-    };
-    if (description) {
-      param.description = description;
-      const inlineTags = parseInlineTags(description);
-      if (inlineTags)
-        param.inlineTags = inlineTags;
-    }
-    if (element.initializer) {
-      applyDefault(param, 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 : ts6.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 extractLiteralDefault(initializer) {
-  if (ts6.isStringLiteral(initializer)) {
-    return { literal: true, value: initializer.text };
-  }
-  if (ts6.isNumericLiteral(initializer)) {
-    return { literal: true, value: Number(initializer.text) };
-  }
-  if (ts6.isPrefixUnaryExpression(initializer) && initializer.operator === ts6.SyntaxKind.MinusToken && ts6.isNumericLiteral(initializer.operand)) {
-    return { literal: true, value: -Number(initializer.operand.text) };
-  }
-  if (initializer.kind === ts6.SyntaxKind.TrueKeyword) {
-    return { literal: true, value: true };
-  }
-  if (initializer.kind === ts6.SyntaxKind.FalseKeyword) {
-    return { literal: true, value: false };
-  }
-  if (initializer.kind === ts6.SyntaxKind.NullKeyword) {
-    return { literal: true, value: null };
-  }
-  return { literal: false, text: initializer.getText() };
-}
-function applyDefault(param, initializer) {
-  const extracted = extractLiteralDefault(initializer);
-  if (extracted.literal) {
-    param.default = extracted.value;
-    if (param.schema && typeof param.schema === "object" && !Array.isArray(param.schema)) {
-      param.schema.default = extracted.value;
-    }
-  } else {
-    param.default = extracted.text;
-    if (param.schema && typeof param.schema === "object" && !Array.isArray(param.schema)) {
-      param.schema["x-ts-default"] = extracted.text;
-    }
-  }
-}
-function registerReferencedTypes(type, ctx, depth = 0) {
-  if (depth > ctx.maxTypeDepth)
-    return;
-  if (ctx.registeredTypes.has(type))
-    return;
-  const isPrimitive = type.flags & (ts6.TypeFlags.String | ts6.TypeFlags.Number | ts6.TypeFlags.Boolean | ts6.TypeFlags.Void | ts6.TypeFlags.Undefined | ts6.TypeFlags.Null | ts6.TypeFlags.Any | ts6.TypeFlags.Unknown | ts6.TypeFlags.Never | ts6.TypeFlags.StringLiteral | ts6.TypeFlags.NumberLiteral | ts6.TypeFlags.BooleanLiteral);
-  if (!isPrimitive) {
-    ctx.registeredTypes.add(type);
-  }
-  const { typeChecker: checker, typeRegistry } = ctx;
-  typeRegistry.registerType(type, ctx);
-  const typeArgs = type.typeArguments;
-  if (typeArgs) {
-    for (const arg of typeArgs) {
-      registerReferencedTypes(arg, ctx, depth + 1);
-    }
-  }
-  if (type.isUnion()) {
-    for (const t of type.types) {
-      registerReferencedTypes(t, ctx, depth + 1);
-    }
-  }
-  if (type.isIntersection()) {
-    for (const t of type.types) {
-      registerReferencedTypes(t, ctx, depth + 1);
-    }
-  }
-  const typeSymbol = type.aliasSymbol ?? type.getSymbol();
-  if (typeSymbol && ctx.shouldExpandExternal && !typeSymbol.getName().startsWith("__") && !ctx.shouldExpandExternal(typeSymbol)) {
-    return;
-  }
-  if (isForeignPackage(typeSymbol, ctx.workspacePackages)) {
-    return;
-  }
-  if (isDeferredMappedOrConditional(type)) {
-    return;
-  }
-  if (type.flags & ts6.TypeFlags.Object) {
-    const props = type.getProperties();
-    const limit = ctx.maxProperties;
-    if (props.length > limit && ctx.onTruncation) {
-      const typeName = type.getSymbol()?.getName() ?? "anonymous";
-      ctx.onTruncation(typeName, props.length, limit);
-    }
-    for (const prop of props.slice(0, limit)) {
-      const propType = checker.getTypeOfSymbol(prop);
-      registerReferencedTypes(propType, ctx, depth + 1);
-    }
-  }
-}
-
-// src/serializers/context.ts
-import ts8 from "typescript";
-
 // src/ast/registry.ts
-import ts7 from "typescript";
 var BUILTINS = new Set([
   "Array",
   "ArrayBuffer",
@@ -4289,6 +4190,26 @@ function isExternalType(decl) {
     return false;
   return sourceFile.fileName.includes("node_modules");
 }
+function declaredForm(type, checker, symbol = type.aliasSymbol ?? type.getSymbol()) {
+  if (!symbol)
+    return type;
+  const generic = ts6.SymbolFlags.TypeAlias | ts6.SymbolFlags.Interface | ts6.SymbolFlags.Class;
+  if (!(symbol.flags & generic))
+    return type;
+  const target = type.target;
+  const instantiated = type.aliasTypeArguments?.length || target && target !== type;
+  return instantiated ? declaredTypeOf(symbol, type, checker) : type;
+}
+function declaredTypeOf(symbol, fallback, checker) {
+  const declared = checker.getDeclaredTypeOfSymbol(symbol);
+  return declared.flags & ts6.TypeFlags.Any ? fallback : declared;
+}
+function registeredForm(type, symbol, checker) {
+  const constructorSide = symbol.flags & ts6.SymbolFlags.Class && type.objectFlags & ts6.ObjectFlags.Anonymous;
+  if (constructorSide)
+    return declaredTypeOf(symbol, type, checker);
+  return declaredForm(type, checker, symbol);
+}
 
 class TypeRegistry {
   types = new Map;
@@ -4322,13 +4243,13 @@ class TypeRegistry {
       return;
     if (name.startsWith('"'))
       return;
-    if (symbol.flags & ts7.SymbolFlags.EnumMember)
+    if (symbol.flags & ts6.SymbolFlags.EnumMember)
       return;
-    if (symbol.flags & ts7.SymbolFlags.TypeParameter)
+    if (symbol.flags & ts6.SymbolFlags.TypeParameter)
       return;
-    if (symbol.flags & ts7.SymbolFlags.Method)
+    if (symbol.flags & ts6.SymbolFlags.Method)
       return;
-    if (symbol.flags & ts7.SymbolFlags.Function)
+    if (symbol.flags & ts6.SymbolFlags.Function)
       return;
     if (isGenericTypeParameter(name))
       return;
@@ -4361,7 +4282,7 @@ class TypeRegistry {
       return id;
     this.processing.add(id);
     try {
-      const specType = this.buildSpecType(type, symbol, id, ctx);
+      const specType = withExpansionBudget(ctx, `type ${id}`, () => this.buildSpecType(registeredForm(type, symbol, ctx.typeChecker), symbol, id, ctx));
       if (specType) {
         this.add(specType);
         return specType.id;
@@ -4378,17 +4299,17 @@ class TypeRegistry {
     let kind = "type";
     const external = decl ? isExternalType(decl) : false;
     if (decl) {
-      if (ts7.isClassDeclaration(decl))
+      if (ts6.isClassDeclaration(decl))
         kind = "class";
-      else if (ts7.isInterfaceDeclaration(decl))
+      else if (ts6.isInterfaceDeclaration(decl))
         kind = "interface";
-      else if (ts7.isEnumDeclaration(decl))
+      else if (ts6.isEnumDeclaration(decl))
         kind = "enum";
     }
     if (external) {
       kind = "external";
     }
-    let schema = buildSchema(type, checker, ctx);
+    let schema = buildAliasBodySchema(type, checker, ctx);
     if (this.isSelfRef(schema, id)) {
       schema = this.resolveSelRefSchema(type, checker, ctx);
     }
@@ -4398,8 +4319,8 @@ class TypeRegistry {
         schema = enumSchema;
       }
     }
-    if (kind === "type" && decl && ts7.isTypeAliasDeclaration(decl) && shouldEmitAliasTypeText(decl.type) && typeof schema === "object" && schema !== null && !("x-ts-type" in schema)) {
-      const text = renderTypeText(type, checker, decl, ts7.TypeFormatFlags.InTypeAlias);
+    if (kind === "type" && decl && ts6.isTypeAliasDeclaration(decl) && shouldEmitAliasTypeText(decl.type) && typeof schema === "object" && schema !== null && !("x-ts-type" in schema)) {
+      const text = renderTypeText(type, checker, decl, ts6.TypeFormatFlags.InTypeAlias);
       if (!PRIMITIVES.has(text) && text !== name) {
         schema["x-ts-type"] = text;
         const declared = writtenTypeText(declaredTypeNode(decl));
@@ -4408,8 +4329,11 @@ class TypeRegistry {
         }
       }
     }
+    const heritage = (symbol.declarations ?? []).filter((d) => ts6.isClassDeclaration(d) || ts6.isInterfaceDeclaration(d));
+    const extendsText = heritage.map((d) => getExtendsText(d, checker)).find(Boolean);
+    schema = withOpenHeritage(schema, openHeritageArms(heritage, checker, ctx));
     let typeParameters;
-    if (decl && (ts7.isTypeAliasDeclaration(decl) || ts7.isInterfaceDeclaration(decl) || ts7.isClassDeclaration(decl))) {
+    if (decl && (ts6.isTypeAliasDeclaration(decl) || ts6.isInterfaceDeclaration(decl) || ts6.isClassDeclaration(decl))) {
       typeParameters = extractTypeParameters(decl, checker);
     }
     return {
@@ -4418,6 +4342,7 @@ class TypeRegistry {
       kind,
       ...typeParameters && typeParameters.length > 0 ? { typeParameters } : {},
       schema,
+      ...extendsText ? { extends: extendsText } : {},
       ...external ? { external: true } : {}
     };
   }
@@ -4430,14 +4355,14 @@ class TypeRegistry {
   resolveSelRefSchema(type, checker, ctx) {
     if (type.isUnion()) {
       const types = type.types;
-      const allStringLiterals = types.every((t) => t.flags & ts7.TypeFlags.StringLiteral);
+      const allStringLiterals = types.every((t) => t.flags & ts6.TypeFlags.StringLiteral);
       if (allStringLiterals) {
         return {
           type: "string",
           enum: types.map((t) => t.value)
         };
       }
-      const allNumberLiterals = types.every((t) => t.flags & ts7.TypeFlags.NumberLiteral);
+      const allNumberLiterals = types.every((t) => t.flags & ts6.TypeFlags.NumberLiteral);
       if (allNumberLiterals) {
         return {
           type: "number",
@@ -4472,18 +4397,18 @@ class TypeRegistry {
       const elementType = checker.getTypeArguments(type)?.[0];
       return elementType ? { type: "array", items: buildSchema(elementType, checker, ctx) } : { type: "array" };
     }
-    if (type.flags & ts7.TypeFlags.Conditional) {
+    if (type.flags & ts6.TypeFlags.Conditional) {
       return { "x-ts-type": renderTypeText(type, checker) };
     }
     const constraint = checker.getBaseConstraintOfType(type);
-    const primitive = constraint && constraint.flags & ts7.TypeFlags.StringLike ? "string" : constraint && constraint.flags & ts7.TypeFlags.NumberLike ? "number" : constraint && constraint.flags & ts7.TypeFlags.BooleanLike ? "boolean" : undefined;
+    const primitive = constraint && constraint.flags & ts6.TypeFlags.StringLike ? "string" : constraint && constraint.flags & ts6.TypeFlags.NumberLike ? "number" : constraint && constraint.flags & ts6.TypeFlags.BooleanLike ? "boolean" : undefined;
     if (primitive) {
       return { type: primitive, "x-ts-type": renderTypeText(type, checker) };
     }
     return this.buildObjectSchemaFromProperties(type, checker, ctx);
   }
   buildEnumSchema(symbol, checker) {
-    const decl = symbol.declarations?.find(ts7.isEnumDeclaration);
+    const decl = symbol.declarations?.find(ts6.isEnumDeclaration);
     if (!decl)
       return;
     const members = [];
@@ -4510,8 +4435,8 @@ class TypeRegistry {
   buildObjectSchemaFromProperties(type, checker, ctx) {
     const properties = type.getProperties();
     const indexInfos = checker.getIndexInfosOfType(type);
-    const stringIndex = indexInfos.find((i) => i.keyType.flags & ts7.TypeFlags.String);
-    const numberIndex = indexInfos.find((i) => i.keyType.flags & ts7.TypeFlags.Number);
+    const stringIndex = indexInfos.find((i) => i.keyType.flags & ts6.TypeFlags.String);
+    const numberIndex = indexInfos.find((i) => i.keyType.flags & ts6.TypeFlags.Number);
     if (properties.length === 0 && !stringIndex && !numberIndex) {
       return { type: checker.typeToString(type) };
     }
@@ -4519,8 +4444,8 @@ class TypeRegistry {
     const required = [];
     const limit = ctx.maxProperties;
     const isArrayLike = checker.isArrayType(type) || checker.isTupleType(type) || type.symbol?.getName() === "Array" && isLibFile(type.symbol?.getDeclarations()?.[0]?.getSourceFile()?.fileName ?? "");
-    const isStringLike = type.flags & ts7.TypeFlags.StringLike;
-    const isNumberLike = type.flags & ts7.TypeFlags.NumberLike;
+    const isStringLike = type.flags & ts6.TypeFlags.StringLike;
+    const isNumberLike = type.flags & ts6.TypeFlags.NumberLike;
     const included = properties.filter((prop) => {
       const propName = prop.getName();
       if (propName.startsWith("__@"))
@@ -4540,7 +4465,7 @@ class TypeRegistry {
     for (const prop of included.slice(0, limit)) {
       const propName = prop.getName();
       const rawPropType = checker.getTypeOfSymbol(prop);
-      const propType = prop.flags & ts7.SymbolFlags.Optional ? stripUndefinedFromType(rawPropType, checker) : rawPropType;
+      const propType = prop.flags & ts6.SymbolFlags.Optional ? stripUndefinedFromType(rawPropType, checker) : rawPropType;
       this.registerType(propType, ctx);
       let propSchema = buildSchema(propType, checker, ctx, declaredTypeNode(prop.valueDeclaration ?? prop.getDeclarations()?.[0]));
       const docComment = prop.getDocumentationComment(checker);
@@ -4557,7 +4482,7 @@ class TypeRegistry {
       }
       propSchema = decoratePropertySchema(propSchema, prop, propType, checker);
       props[propName] = propSchema;
-      if (!(prop.flags & ts7.SymbolFlags.Optional)) {
+      if (!(prop.flags & ts6.SymbolFlags.Optional)) {
         required.push(propName);
       }
     }
@@ -4574,7 +4499,224 @@ class TypeRegistry {
   }
 }
 
+// src/types/parameters.ts
+function extractParameters(signature, ctx) {
+  const { typeChecker: checker } = ctx;
+  const result = [];
+  const signatureDecl = signature.getDeclaration();
+  const jsdocTags = signatureDecl ? ts7.getJSDocTags(signatureDecl) : [];
+  for (const param of signature.getParameters()) {
+    const decl = param.valueDeclaration;
+    if (!decl)
+      continue;
+    const defer = typeNodeDefersExpansion(decl.type, checker, ctx.program);
+    const type = defer ? undefined : checker.getTypeOfSymbolAtLocation(param, decl);
+    if (decl && ts7.isObjectBindingPattern(decl.name)) {
+      const expandedParams = expandBindingPattern(decl, type ?? checker.getTypeOfSymbolAtLocation(param, decl), jsdocTags, ctx);
+      result.push(...expandedParams);
+    } else {
+      const isOptional = !!decl?.questionToken || !!decl?.initializer;
+      const isRest = !!decl.dotDotDotToken;
+      const paramName = param.getName();
+      const description = getParamDescription(paramName, jsdocTags);
+      const schema = defer ? buildSchemaFromTypeNode(decl.type, checker, ctx) : buildSchema(isOptional ? stripUndefinedFromType(type, checker) : type, checker, ctx, decl.type);
+      if (!defer && type) {
+        registerReferencedTypes(isOptional ? stripUndefinedFromType(type, checker) : type, ctx);
+      }
+      const paramResult = {
+        name: paramName,
+        schema,
+        required: !isOptional && !isRest,
+        ...isRest ? { rest: true } : {}
+      };
+      if (description) {
+        paramResult.description = description;
+        const inlineTags = parseInlineTags(description);
+        if (inlineTags)
+          paramResult.inlineTags = inlineTags;
+      }
+      if (decl.initializer) {
+        applyDefault(paramResult, decl.initializer);
+      }
+      result.push(paramResult);
+    }
+  }
+  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 (!ts7.isBindingElement(element))
+      continue;
+    const propertyName = element.propertyName ? ts7.isIdentifier(element.propertyName) ? element.propertyName.text : element.propertyName.getText() : ts7.isIdentifier(element.name) ? element.name.text : element.name.getText();
+    const propSymbol = allProperties.get(propertyName);
+    if (!propSymbol)
+      continue;
+    const isOptional = !!(propSymbol.flags & ts7.SymbolFlags.Optional) || element.initializer !== undefined;
+    const propType = checker.getTypeOfSymbol(propSymbol);
+    const effectiveType = isOptional ? stripUndefinedFromType(propType, checker) : propType;
+    registerReferencedTypes(effectiveType, ctx);
+    const description = getParamDescription(propertyName, jsdocTags, inferredAlias);
+    const param = {
+      name: propertyName,
+      schema: buildSchema(effectiveType, checker, ctx, declaredTypeNode(propSymbol.valueDeclaration)),
+      required: !isOptional
+    };
+    if (description) {
+      param.description = description;
+      const inlineTags = parseInlineTags(description);
+      if (inlineTags)
+        param.inlineTags = inlineTags;
+    }
+    if (element.initializer) {
+      applyDefault(param, 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 : ts7.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 extractLiteralDefault(initializer) {
+  if (ts7.isStringLiteral(initializer)) {
+    return { literal: true, value: initializer.text };
+  }
+  if (ts7.isNumericLiteral(initializer)) {
+    return { literal: true, value: Number(initializer.text) };
+  }
+  if (ts7.isPrefixUnaryExpression(initializer) && initializer.operator === ts7.SyntaxKind.MinusToken && ts7.isNumericLiteral(initializer.operand)) {
+    return { literal: true, value: -Number(initializer.operand.text) };
+  }
+  if (initializer.kind === ts7.SyntaxKind.TrueKeyword) {
+    return { literal: true, value: true };
+  }
+  if (initializer.kind === ts7.SyntaxKind.FalseKeyword) {
+    return { literal: true, value: false };
+  }
+  if (initializer.kind === ts7.SyntaxKind.NullKeyword) {
+    return { literal: true, value: null };
+  }
+  return { literal: false, text: initializer.getText() };
+}
+function applyDefault(param, initializer) {
+  const extracted = extractLiteralDefault(initializer);
+  if (extracted.literal) {
+    param.default = extracted.value;
+    if (param.schema && typeof param.schema === "object" && !Array.isArray(param.schema)) {
+      param.schema.default = extracted.value;
+    }
+  } else {
+    param.default = extracted.text;
+    if (param.schema && typeof param.schema === "object" && !Array.isArray(param.schema)) {
+      param.schema["x-ts-default"] = extracted.text;
+    }
+  }
+}
+function registerReferencedTypes(type, ctx, depth = 0) {
+  if (depth > ctx.maxTypeDepth)
+    return;
+  if (ctx.registeredTypes.has(type))
+    return;
+  const isPrimitive = type.flags & (ts7.TypeFlags.String | ts7.TypeFlags.Number | ts7.TypeFlags.Boolean | ts7.TypeFlags.Void | ts7.TypeFlags.Undefined | ts7.TypeFlags.Null | ts7.TypeFlags.Any | ts7.TypeFlags.Unknown | ts7.TypeFlags.Never | ts7.TypeFlags.StringLiteral | ts7.TypeFlags.NumberLiteral | ts7.TypeFlags.BooleanLiteral);
+  if (!isPrimitive) {
+    ctx.registeredTypes.add(type);
+  }
+  const { typeChecker: checker, typeRegistry } = ctx;
+  typeRegistry.registerType(type, ctx);
+  const typeArgs = type.typeArguments;
+  if (typeArgs) {
+    for (const arg of typeArgs) {
+      registerReferencedTypes(arg, ctx, depth + 1);
+    }
+  }
+  for (const arg of type.aliasTypeArguments ?? []) {
+    registerReferencedTypes(arg, ctx, depth + 1);
+  }
+  const declared = declaredForm(type, checker);
+  if (declared !== type) {
+    registerReferencedTypes(declared, ctx, depth);
+    return;
+  }
+  if (type.isUnion()) {
+    for (const t of type.types) {
+      registerReferencedTypes(t, ctx, depth + 1);
+    }
+  }
+  if (type.isIntersection()) {
+    for (const t of type.types) {
+      registerReferencedTypes(t, ctx, depth + 1);
+    }
+  }
+  const typeSymbol = type.aliasSymbol ?? type.getSymbol();
+  if (typeSymbol && ctx.shouldExpandExternal && !typeSymbol.getName().startsWith("__") && !ctx.shouldExpandExternal(typeSymbol)) {
+    return;
+  }
+  if (isForeignPackage(typeSymbol, ctx.workspacePackages)) {
+    return;
+  }
+  if (isDeferredMappedOrConditional(type)) {
+    return;
+  }
+  if (type.flags & ts7.TypeFlags.Object) {
+    const props = type.getProperties();
+    const limit = ctx.maxProperties;
+    if (props.length > limit && ctx.onTruncation) {
+      const typeName = type.getSymbol()?.getName() ?? "anonymous";
+      ctx.onTruncation(typeName, props.length, limit);
+    }
+    for (const prop of props.slice(0, limit)) {
+      const propType = checker.getTypeOfSymbol(prop);
+      registerReferencedTypes(propType, ctx, depth + 1);
+    }
+  }
+}
+
 // src/serializers/context.ts
+import ts8 from "typescript";
 function createContext(program, sourceFile, options = {}) {
   return {
     typeChecker: program.getTypeChecker(),
@@ -4594,9 +4736,12 @@ function createContext(program, sourceFile, options = {}) {
     declIds: new Map,
     idOwner: new Map,
     workspacePackages: options.workspacePackages ?? new Map,
+    budget: { owner: "", ops: 0, exceeded: false },
+    maxBudgetOps: MAX_BUDGET_OPS,
     schemaOps: 0,
-    maxSchemaOps: 20000,
-    budgetExceeded: false
+    maxSchemaOps: MAX_SCHEMA_OPS,
+    budgetExceeded: false,
+    exhaustedBudgets: []
   };
 }
 function getInheritedMembers(classType, ownMemberNames, ctx, isStatic = false) {
@@ -4662,7 +4807,7 @@ function getStaticMembers(classType, checker) {
   });
 }
 function inheritedMethodSchema(symbol, type, ctx) {
-  if (!ctx.budgetExceeded) {
+  if (!ctx.budget.exceeded) {
     return decoratePropertySchema({ "x-ts-function": true }, symbol, type, ctx.typeChecker);
   }
   return {
@@ -4680,7 +4825,7 @@ function serializeInheritedMember(symbol, inheritedFrom, ctx, isStatic) {
   const isOptional = !!(symbol.flags & ts8.SymbolFlags.Optional);
   const rawType = checker.getTypeOfSymbol(symbol);
   const type = isOptional ? stripUndefinedFromType(rawType, checker) : rawType;
-  const registerTypes = !ctx.budgetExceeded;
+  const registerTypes = !ctx.budget.exceeded;
   if (registerTypes)
     registerReferencedTypes(type, ctx);
   let visibility;
@@ -4849,7 +4994,8 @@ function serializeClass(node, ctx) {
   members.push(...inheritedInstance);
   const inheritedStatic = getInheritedMembers(classType, ownMemberNames, ctx, true);
   members.push(...inheritedStatic);
-  const extendsClause = getExtendsClause(node, checker);
+  const extendsClause = getExtendsText(node, checker);
+  const openArms = openHeritageArms([node], checker, ctx);
   const implementsClause = getImplementsClause(node, checker);
   const classFlags = {};
   const classModifiers = ts10.getModifiers(node);
@@ -4867,6 +5013,7 @@ function serializeClass(node, ctx) {
     members: members.length > 0 ? members : undefined,
     signatures: signatures.length > 0 ? signatures : undefined,
     extends: extendsClause,
+    ...openArms.length > 0 ? { schema: { allOf: openArms } } : {},
     implements: implementsClause?.length ? implementsClause : undefined,
     ...deprecated ? { deprecated: true, deprecationReason } : {},
     ...examples.length > 0 ? { examples } : {},
@@ -4879,11 +5026,7 @@ function getMemberName(member) {
     return "constructor";
   if (!member.name)
     return;
-  if (ts10.isIdentifier(member.name))
-    return member.name.text;
-  if (ts10.isPrivateIdentifier(member.name))
-    return member.name.text;
-  return member.name.getText();
+  return propertyNameText(member.name);
 }
 function getVisibility(member) {
   const modifiers = ts10.canHaveModifiers(member) ? ts10.getModifiers(member) : undefined;
@@ -5085,21 +5228,6 @@ function serializeAccessor(node, ctx) {
     ...inlineTags ? { inlineTags } : {}
   };
 }
-function getExtendsClause(node, checker) {
-  if (!node.heritageClauses)
-    return;
-  for (const clause of node.heritageClauses) {
-    if (clause.token === ts10.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;
@@ -5336,7 +5464,8 @@ function serializeInterface(node, ctx) {
   const { description, tags, examples, source, deprecated, deprecationReason, inlineTags } = extractExportMetadata(node, symbol, checker);
   const typeParameters = extractTypeParameters(node, checker);
   const { members, callSignatureMember } = serializeTypeElements(node.members, ctx);
-  const extendsClause = getInterfaceExtends(node, checker);
+  const extendsClause = getExtendsText(node, checker);
+  const openArms = openHeritageArms([node], checker, ctx);
   const exportSignatures = callSignatureMember?.signatures && callSignatureMember.signatures.length > 0 ? callSignatureMember.signatures : undefined;
   return {
     id: name,
@@ -5349,6 +5478,7 @@ function serializeInterface(node, ctx) {
     members: members.length > 0 ? members : undefined,
     signatures: exportSignatures,
     extends: extendsClause,
+    ...openArms.length > 0 ? { schema: { allOf: openArms } } : {},
     ...deprecated ? { deprecated: true, deprecationReason } : {},
     ...examples.length > 0 ? { examples } : {},
     ...inlineTags ? { inlineTags } : {}
@@ -5438,7 +5568,7 @@ function serializeMergedTypeSide(symbol, ctx) {
   const { description, tags } = getJSDocComment(typeDecl);
   return {
     members,
-    extends: interfaces.map((decl) => getInterfaceExtends(decl, checker)).find(Boolean),
+    extends: interfaces.map((decl) => getExtendsText(decl, checker)).find(Boolean),
     typeParameters: extractTypeParameters(typeDecl, checker),
     description,
     tags
@@ -5446,7 +5576,7 @@ function serializeMergedTypeSide(symbol, ctx) {
 }
 function serializePropertySignature(node, ctx) {
   const { typeChecker: checker } = ctx;
-  const name = node.name.getText();
+  const name = propertyNameText(node.name);
   const { description, tags, inlineTags } = getJSDocComment(node);
   const rawType = checker.getTypeAtLocation(node);
   const type = node.questionToken ? stripUndefinedFromType(rawType, checker) : rawType;
@@ -5476,7 +5606,7 @@ function serializePropertySignature(node, ctx) {
 }
 function serializeMethodSignature(node, ctx) {
   const { typeChecker: checker } = ctx;
-  const name = node.name.getText();
+  const name = propertyNameText(node.name);
   const { description, tags, inlineTags } = getJSDocComment(node);
   const rawType = checker.getTypeAtLocation(node);
   const type = node.questionToken ? stripUndefinedFromType(rawType, checker) : rawType;
@@ -5544,20 +5674,6 @@ function serializeIndexSignature(node, ctx) {
     ...inlineTags ? { inlineTags } : {}
   };
 }
-function getInterfaceExtends(node, checker) {
-  if (!node.heritageClauses)
-    return;
-  for (const clause of node.heritageClauses) {
-    if (clause.token === ts12.SyntaxKind.ExtendsKeyword && clause.types.length > 0) {
-      const names = clause.types.map((expr) => {
-        const type = checker.getTypeAtLocation(expr);
-        return type.getSymbol()?.getName() ?? expr.expression.getText();
-      });
-      return names.join(" & ");
-    }
-  }
-  return;
-}
 
 // src/serializers/type-aliases.ts
 import ts13 from "typescript";
@@ -5602,7 +5718,7 @@ function serializeTypeAlias(node, ctx) {
     schema = buildObjectSchema(type.getProperties(), ctx.typeChecker, ctx, type);
     members = serializeResolvedMembers(type, node, ctx);
   } else {
-    schema = buildSchema(type, ctx.typeChecker, ctx);
+    schema = buildAliasBodySchema(type, ctx.typeChecker, ctx);
     if (isObjectShapedAlias(type, ctx)) {
       members = serializeResolvedMembers(type, node, ctx);
     }
@@ -6317,10 +6433,14 @@ function normalizeExport(exp, options = {}) {
     result.members = exp.members.map((member) => normalizeMember(member, options));
   }
   if (!vendorSchema && shouldGenerateMembersSchema(exp.kind) && exp.members && exp.members.length > 0) {
-    result.schema = normalizeMembers(exp.members, options);
+    result.schema = withOpenArms(normalizeMembers(exp.members, options), result.schema);
   }
   return result;
 }
+function withOpenArms(membersSchema, provided) {
+  const arms = provided?.allOf;
+  return Array.isArray(arms) ? { allOf: [membersSchema, ...arms] } : membersSchema;
+}
 function normalizeType(type, options = {}) {
   const result = { ...type };
   if (type.schema) {
@@ -6330,7 +6450,7 @@ function normalizeType(type, options = {}) {
     result.members = type.members.map((member) => normalizeMember(member, options));
   }
   if (shouldGenerateMembersSchema(type.kind) && type.members && type.members.length > 0) {
-    result.schema = normalizeMembers(type.members, options);
+    result.schema = withOpenArms(normalizeMembers(type.members, options), result.schema);
   }
   return result;
 }
@@ -7708,6 +7828,11 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
         visit(t, depth + 1);
       }
     }
+    const declared = declaredForm(type, checker);
+    if (declared !== type) {
+      visit(declared, depth);
+      return;
+    }
     if (!allowed || isDeferredMappedOrConditional(type) || !(type.flags & ts20.TypeFlags.Object || type.isClassOrInterface())) {
       return;
     }
@@ -7781,7 +7906,7 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
         id,
         name,
         kind: symbolKind(symbol),
-        schema: ensureNonEmptySchema(buildSchema(declared, checker, ctx, writtenWhenAny(symbol, declared)), declared, checker)
+        schema: withExpansionBudget(ctx, `type ${id}`, () => ensureNonEmptySchema(buildSchema(declared, checker, ctx, writtenWhenAny(symbol, declared)), declared, checker))
       });
     }
     symbolByName.set(name, symbol);
@@ -8231,7 +8356,7 @@ async function extract(options) {
           }
           continue;
         }
-        const exp = serializeDeclaration2(declaration, symbol, exportName, ctx, isTypeOnly);
+        const exp = withExpansionBudget(ctx, exportName, () => serializeDeclaration2(declaration, symbol, exportName, ctx, isTypeOnly));
         if (exp) {
           const typeSide = mergedTypeSideOf(exp, declaration, targetSymbol, ctx);
           if (typeSide) {
@@ -8260,7 +8385,7 @@ async function extract(options) {
       }
     }
     for (const { index, symbol, ontoClass } of mergedTypeSides) {
-      exports[index] = withMergedTypeSide(exports[index], symbol, ctx, ontoClass);
+      exports[index] = withExpansionBudget(ctx, exports[index].name, () => withMergedTypeSide(exports[index], symbol, ctx, ontoClass));
     }
     const verification = buildVerificationSummary(exportedSymbols.length, exports.length, exportTracker);
     const meta = await getPackageMeta(entryFile, baseDir);
@@ -8271,7 +8396,7 @@ async function extract(options) {
     });
     if (ctx.budgetExceeded) {
       diagnostics.push({
-        message: "Stopped expanding some types after hitting the schema expansion budget",
+        message: `Stopped expanding some types after hitting the schema expansion budget${exhaustedBudgetNote(ctx)}`,
         severity: "warning",
         code: "TYPE_EXPANSION_LIMIT"
       });
@@ -8751,6 +8876,13 @@ function withMergedTypeSide(entry, symbol, ctx, ontoClass) {
     ...entry.description ? {} : { description, tags: [...entry.tags ?? [], ...tags ?? []] }
   };
 }
+function exhaustedBudgetNote(ctx) {
+  const owners = [...new Set(ctx.exhaustedBudgets)];
+  if (owners.length === 0)
+    return "";
+  const shown = owners.slice(0, 10).join(", ");
+  return `: ${shown}${owners.length > 10 ? ` (+${owners.length - 10} more)` : ""}`;
+}
 function withExportName(entry, exportName) {
   if (entry.name === exportName) {
     return entry;
@@ -9322,6 +9454,7 @@ function getNodeName(node) {
 export {
   zodAdapter,
   writtenTypeText,
+  withOpenHeritage,
   withDescription,
   withDeprecated,
   validateSpec2 as validateSpec,
@@ -9367,6 +9500,7 @@ export {
   query,
   pickEntry,
   parseGithubRepo,
+  openHeritageArms,
   normalizeType,
   normalizeSchema,
   normalizeMembers,
@@ -9448,6 +9582,7 @@ export {
   buildSchema,
   buildObjectSchema,
   buildFunctionSchema,
+  buildAliasBodySchema,
   assertSpec,
   asStandardSchema,
   arktypeAdapter,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpkg-ts/sdk",
-  "version": "0.54.9",
+  "version": "0.54.11",
   "description": "TypeScript API extraction SDK - programmatic primitives for OpenPkg specs",
   "keywords": [
     "openpkg",