@openpkg-ts/sdk 0.54.8 → 0.54.10

package/dist/index.js

@@ -1830,6 +1830,18 @@ function declKey(symbol, checker) {
     return;
   return `${decl.getSourceFile().fileName}#${decl.getStart()}`;
 }
+function fileLabel(fileName) {
+  const base = path3.basename(fileName).replace(/(\.d)?\.[cm]?[tj]sx?$/, "");
+  return base === "index" ? path3.basename(path3.dirname(fileName)) || base : base;
+}
+function namespaceLabel(decl) {
+  const names = [];
+  for (let node = decl?.parent;node; node = node.parent) {
+    if (ts.isModuleDeclaration(node) && ts.isIdentifier(node.name))
+      names.unshift(node.name.text);
+  }
+  return names.length > 0 ? names.join(".") : undefined;
+}
 function resolveTypeId(symbol, ctx) {
   const cached = ctx.typeIds.get(symbol);
   if (cached)
@@ -1853,16 +1865,49 @@ function resolveTypeId(symbol, ctx) {
   const owner = ctx.idOwner.get(name);
   if (!owner || owner === key)
     return claim(name);
-  const file = symbol.declarations?.[0]?.getSourceFile().fileName ?? "";
-  const scoped = `${packageLabel(file, ctx.workspacePackages)}.${name}`;
-  const scopedOwner = ctx.idOwner.get(scoped);
-  if (!scopedOwner || scopedOwner === key)
-    return claim(scoped);
+  const decl = symbol.declarations?.[0];
+  const file = decl?.getSourceFile().fileName ?? "";
+  const pkg = packageLabel(file, ctx.workspacePackages);
+  const ownerFile = owner.includes("#") ? owner.slice(0, owner.lastIndexOf("#")) : "";
+  const scopes = pkg === packageLabel(ownerFile, ctx.workspacePackages) ? [] : [pkg];
+  const namespace = namespaceLabel(decl);
+  if (namespace)
+    scopes.push(namespace);
+  if (file)
+    scopes.push(fileLabel(file));
+  for (const scope of scopes) {
+    const scoped = `${scope}.${name}`;
+    const scopedOwner = ctx.idOwner.get(scoped);
+    if (!scopedOwner || scopedOwner === key)
+      return claim(scoped);
+  }
   let n = 2;
   while (ctx.idOwner.has(`${name}_${n}`))
     n++;
   return claim(`${name}_${n}`);
 }
+var EXPORTABLE_TYPE_FLAGS = ts.SymbolFlags.Interface | ts.SymbolFlags.TypeAlias | ts.SymbolFlags.Class | ts.SymbolFlags.RegularEnum | ts.SymbolFlags.ConstEnum;
+function claimExportedTypeIds(exportedSymbols, ctx) {
+  const renamed = [];
+  for (const exported of exportedSymbols) {
+    let target = exported;
+    if (exported.flags & ts.SymbolFlags.Alias) {
+      try {
+        target = ctx.typeChecker.getAliasedSymbol(exported);
+      } catch {
+        continue;
+      }
+    }
+    if (!(target.flags & EXPORTABLE_TYPE_FLAGS))
+      continue;
+    if (target.getName() === exported.getName())
+      resolveTypeId(target, ctx);
+    else
+      renamed.push(target);
+  }
+  for (const target of renamed)
+    resolveTypeId(target, ctx);
+}
 function typeRefId(type, ctx) {
   const symbol = type.aliasSymbol ?? type.getSymbol();
   if (!symbol)
@@ -2218,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";
@@ -2558,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";
 
@@ -2617,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;
     }
@@ -2789,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;
     }
@@ -2824,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);
@@ -2843,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) });
     }
@@ -2850,20 +2950,42 @@ function buildSchemaFromTypeNode(node, checker, ctx) {
       let refId = name;
       if (symbol && ctx) {
         try {
-          refId = namedRefId(checker.getDeclaredTypeOfSymbol(symbol), name, ctx);
+          refId = typeRefId(checker.getDeclaredTypeOfSymbol(symbol), ctx) || (symbol.flags & ts5.SymbolFlags.TypeAlias ? resolveTypeId(symbol, ctx) : name);
         } catch {
           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 { "x-ts-type": scrubImportQualifiers(node.getText()) };
+    return {
+      "x-ts-type": scrubImportQualifiers(node.getText().replace(/\s+/g, " "))
+    };
   }
   const t = checker.getTypeFromTypeNode(node);
   if (!(t.flags & ts5.TypeFlags.Any)) {
     return buildSchema(t, checker, ctx);
   }
-  return { "x-ts-type": scrubImportQualifiers(node.getText()) };
+  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())
@@ -3047,7 +3169,20 @@ function typeNodeDefersExpansion(node, checker, program) {
   const symbol = resolveAliasSymbol(raw, checker, undefined, program);
   return shouldDeferAlias(symbol);
 }
-function cheapTypeText(type, _checker, typeNode) {
+function isStaleTypeParameterNode(type, checker, typeNode) {
+  if (type.flags & ts5.TypeFlags.TypeParameter)
+    return false;
+  if (!ts5.isTypeReferenceNode(typeNode) || !ts5.isIdentifier(typeNode.typeName))
+    return false;
+  const symbol = checker.getSymbolAtLocation(typeNode.typeName);
+  return !!symbol && (symbol.flags & ts5.SymbolFlags.TypeParameter) !== 0;
+}
+function cheapTypeText(type, checker, typeNode) {
+  if (typeNode && isStaleTypeParameterNode(type, checker, typeNode)) {
+    const argument = type.aliasSymbol?.getName() ?? type.getSymbol()?.getName();
+    if (argument && !argument.startsWith("__") && !isBuiltinGeneric(argument))
+      return argument;
+  }
   if (typeNode) {
     try {
       const text = scrubImportQualifiers(typeNode.getText().replace(/\s+/g, " ").trim());
@@ -3258,7 +3393,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;
@@ -3338,10 +3478,18 @@ function buildSchema(type, checker, ctx, typeNode) {
   const schema = buildSchemaInternal(type, checker, ctx, typeNode);
   return ensureNonEmptySchema(schema, type, checker);
 }
-function buildMaxDepthSchema(type, checker, typeNode) {
+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)
-      return buildSchemaFromTypeNode(typeNode, checker);
+      return buildSchemaFromTypeNode(typeNode, checker, ctx);
     return { "x-ts-type": checker.typeToString(type) };
   }
   if (type.flags & ts5.TypeFlags.TypeParameter && !isFluentThisType(type)) {
@@ -3354,7 +3502,7 @@ function buildMaxDepthSchema(type, checker, typeNode) {
       return builtinSchema(name);
     }
     if (!name.startsWith("__") && !isPrimitiveName(name)) {
-      return { $ref: `#/types/${name}` };
+      return { $ref: `#/types/${ctx ? resolveTypeId(symbol, ctx) : name}` };
     }
   }
   if (type.flags & ts5.TypeFlags.String)
@@ -3377,22 +3525,53 @@ function buildMaxDepthSchema(type, checker, typeNode) {
     };
   }
   if (type.isUnion()) {
-    const schemas = type.types.map((t) => buildMaxDepthSchema(t, checker));
+    const schemas = type.types.map((t) => buildMaxDepthSchema(t, checker, undefined, ctx));
     return { anyOf: schemas };
   }
   if (type.isIntersection()) {
-    const schemas = type.types.map((t) => buildMaxDepthSchema(t, checker));
+    const schemas = type.types.map((t) => buildMaxDepthSchema(t, checker, undefined, ctx));
     return { allOf: schemas };
   }
   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);
+    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) };
     }
@@ -3486,6 +3665,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",
@@ -3610,11 +3797,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);
@@ -3653,29 +3841,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();
@@ -3940,219 +4108,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",
@@ -4229,6 +4185,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;
@@ -4262,13 +4238,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;
@@ -4301,7 +4277,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;
@@ -4318,17 +4294,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);
     }
@@ -4338,8 +4314,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));
@@ -4348,8 +4324,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 {
@@ -4358,6 +4337,7 @@ class TypeRegistry {
       kind,
       ...typeParameters && typeParameters.length > 0 ? { typeParameters } : {},
       schema,
+      ...extendsText ? { extends: extendsText } : {},
       ...external ? { external: true } : {}
     };
   }
@@ -4370,14 +4350,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",
@@ -4395,126 +4375,343 @@ class TypeRegistry {
         return enumSchema;
       }
     }
-    const callSignatures = type.getCallSignatures();
-    if (callSignatures.length > 0 && type.getProperties().length === 0) {
-      return buildFunctionSchema(callSignatures, checker, ctx);
+    const callSignatures = type.getCallSignatures();
+    if (callSignatures.length > 0 && type.getProperties().length === 0) {
+      return buildFunctionSchema(callSignatures, checker, ctx);
+    }
+    if (checker.isTupleType(type)) {
+      const elementTypes = checker.getTypeArguments(type) ?? [];
+      return {
+        type: "array",
+        prefixItems: elementTypes.map((t) => buildSchema(t, checker, ctx)),
+        minItems: elementTypes.length,
+        maxItems: elementTypes.length
+      };
+    }
+    if (checker.isArrayType(type)) {
+      const elementType = checker.getTypeArguments(type)?.[0];
+      return elementType ? { type: "array", items: buildSchema(elementType, checker, ctx) } : { type: "array" };
+    }
+    if (type.flags & ts6.TypeFlags.Conditional) {
+      return { "x-ts-type": renderTypeText(type, checker) };
+    }
+    const constraint = checker.getBaseConstraintOfType(type);
+    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(ts6.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 indexInfos = checker.getIndexInfosOfType(type);
+    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) };
+    }
+    const props = {};
+    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 & ts6.TypeFlags.StringLike;
+    const isNumberLike = type.flags & ts6.TypeFlags.NumberLike;
+    const included = properties.filter((prop) => {
+      const propName = prop.getName();
+      if (propName.startsWith("__@"))
+        return false;
+      if (isArrayLike && ARRAY_PROTOTYPE_METHODS.has(propName))
+        return false;
+      if (isStringLike && STRING_PROTOTYPE_METHODS.has(propName))
+        return false;
+      if (isNumberLike && NUMBER_PROTOTYPE_METHODS.has(propName))
+        return false;
+      return true;
+    });
+    if (included.length > limit && ctx.onTruncation) {
+      const typeName = type.getSymbol()?.getName() ?? "anonymous";
+      ctx.onTruncation(typeName, included.length, limit);
+    }
+    for (const prop of included.slice(0, limit)) {
+      const propName = prop.getName();
+      const rawPropType = checker.getTypeOfSymbol(prop);
+      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);
+      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);
+      }
+      propSchema = decoratePropertySchema(propSchema, prop, propType, checker);
+      props[propName] = propSchema;
+      if (!(prop.flags & ts6.SymbolFlags.Optional)) {
+        required.push(propName);
+      }
+    }
+    return {
+      type: "object",
+      properties: props,
+      ...required.length > 0 ? { required } : {},
+      ...stringIndex ? { additionalProperties: buildSchema(stringIndex.type, checker, ctx) } : {},
+      ...numberIndex ? {
+        patternProperties: { "^\\d+$": buildSchema(numberIndex.type, checker, ctx) },
+        "x-ts-index-key": "number"
+      } : {}
+    };
+  }
+}
+
+// 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);
     }
-    if (checker.isTupleType(type)) {
-      const elementTypes = checker.getTypeArguments(type) ?? [];
-      return {
-        type: "array",
-        prefixItems: elementTypes.map((t) => buildSchema(t, checker, ctx)),
-        minItems: elementTypes.length,
-        maxItems: elementTypes.length
-      };
+  }
+  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 (checker.isArrayType(type)) {
-      const elementType = checker.getTypeArguments(type)?.[0];
-      return elementType ? { type: "array", items: buildSchema(elementType, checker, ctx) } : { type: "array" };
+  }
+  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;
     }
-    if (type.flags & ts7.TypeFlags.Conditional) {
-      return { "x-ts-type": renderTypeText(type, checker) };
+  } else {
+    param.default = extracted.text;
+    if (param.schema && typeof param.schema === "object" && !Array.isArray(param.schema)) {
+      param.schema["x-ts-default"] = extracted.text;
     }
-    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;
-    if (primitive) {
-      return { type: primitive, "x-ts-type": renderTypeText(type, checker) };
+  }
+}
+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);
     }
-    return this.buildObjectSchemaFromProperties(type, checker, ctx);
   }
-  buildEnumSchema(symbol, checker) {
-    const decl = symbol.declarations?.find(ts7.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
-          });
-        }
-      }
+  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 (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 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);
-    if (properties.length === 0 && !stringIndex && !numberIndex) {
-      return { type: checker.typeToString(type) };
+  if (type.isIntersection()) {
+    for (const t of type.types) {
+      registerReferencedTypes(t, ctx, depth + 1);
     }
-    const props = {};
-    const required = [];
+  }
+  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;
-    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 included = properties.filter((prop) => {
-      const propName = prop.getName();
-      if (propName.startsWith("__@"))
-        return false;
-      if (isArrayLike && ARRAY_PROTOTYPE_METHODS.has(propName))
-        return false;
-      if (isStringLike && STRING_PROTOTYPE_METHODS.has(propName))
-        return false;
-      if (isNumberLike && NUMBER_PROTOTYPE_METHODS.has(propName))
-        return false;
-      return true;
-    });
-    if (included.length > limit && ctx.onTruncation) {
+    if (props.length > limit && ctx.onTruncation) {
       const typeName = type.getSymbol()?.getName() ?? "anonymous";
-      ctx.onTruncation(typeName, included.length, limit);
+      ctx.onTruncation(typeName, props.length, limit);
     }
-    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;
-      this.registerType(propType, ctx);
-      let propSchema = buildSchema(propType, checker, ctx, declaredTypeNode(prop.valueDeclaration ?? prop.getDeclarations()?.[0]));
-      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);
-      }
-      propSchema = decoratePropertySchema(propSchema, prop, propType, checker);
-      props[propName] = propSchema;
-      if (!(prop.flags & ts7.SymbolFlags.Optional)) {
-        required.push(propName);
-      }
+    for (const prop of props.slice(0, limit)) {
+      const propType = checker.getTypeOfSymbol(prop);
+      registerReferencedTypes(propType, ctx, depth + 1);
     }
-    return {
-      type: "object",
-      properties: props,
-      ...required.length > 0 ? { required } : {},
-      ...stringIndex ? { additionalProperties: buildSchema(stringIndex.type, checker, ctx) } : {},
-      ...numberIndex ? {
-        patternProperties: { "^\\d+$": buildSchema(numberIndex.type, checker, ctx) },
-        "x-ts-index-key": "number"
-      } : {}
-    };
   }
 }
 
 // src/serializers/context.ts
+import ts8 from "typescript";
 function createContext(program, sourceFile, options = {}) {
   return {
     typeChecker: program.getTypeChecker(),
@@ -4534,9 +4731,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) {
@@ -4602,7 +4802,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 {
@@ -4620,7 +4820,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;
@@ -4789,7 +4989,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);
@@ -4807,6 +5008,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 } : {},
@@ -4819,11 +5021,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;
@@ -4934,8 +5132,18 @@ function serializeConstructor(node, ctx) {
     return null;
   return serializeConstructorSignature(node, sig, ctx);
 }
+function serializeConstructSignatures(sigs, ctx) {
+  return sigs.map((sig, index) => {
+    const typeParameters = extractTypeParametersFromSignature(sig, ctx.typeChecker);
+    return {
+      ...serializeConstructorSignature(sig.getDeclaration(), sig, ctx),
+      ...typeParameters ? { typeParameters } : {},
+      ...sigs.length > 1 ? { overloadIndex: index } : {}
+    };
+  });
+}
 function serializeConstructorSignature(node, sig, ctx) {
-  const { description, tags, examples, inlineTags } = getJSDocComment(node);
+  const { description, tags, examples, inlineTags } = node ? getJSDocComment(node) : { description: undefined, tags: [], examples: [], inlineTags: undefined };
   const params = extractParameters(sig, ctx);
   return {
     description,
@@ -5015,21 +5223,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;
@@ -5222,12 +5415,12 @@ function signaturesFromDeclaredType(typeNode, ctx) {
   const callSignatures = ctx.typeChecker.getTypeFromTypeNode(inner).getCallSignatures();
   return callSignatures.length > 0 ? signaturesFromChecker(callSignatures, ctx) : undefined;
 }
-function serializeFunctionExport(node, ctx, nameOverride, declaredType) {
+function serializeFunctionExport(node, ctx, nameOverride, declaredType, jsdocNode) {
   const symbol = ctx.typeChecker.getSymbolAtLocation(node.name ?? node);
   const name = nameOverride ?? symbol?.getName() ?? node.name?.getText() ?? anonymousDefaultName(node);
   if (!name)
     return null;
-  const { description, tags, examples, source, deprecated, deprecationReason, inlineTags } = extractExportMetadata(node, symbol, ctx.typeChecker);
+  const { description, tags, examples, source, deprecated, deprecationReason, inlineTags } = extractExportMetadata(node, symbol, ctx.typeChecker, jsdocNode);
   const declaredFn = declaredType && unwrapParens(declaredType);
   const typeParameters = extractTypeParameters(declaredFn && ts11.isFunctionTypeNode(declaredFn) ? declaredFn : node, ctx.typeChecker);
   const signatures = (declaredType && signaturesFromDeclaredType(declaredType, ctx)) ?? (anySignatureDefers(node, ctx) ? signaturesFromAst(functionSignatureDecls(node, ctx), ctx) : signaturesFromChecker(ctx.typeChecker.getTypeAtLocation(node).getCallSignatures(), ctx));
@@ -5266,7 +5459,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,
@@ -5279,6 +5473,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 } : {}
@@ -5368,7 +5563,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
@@ -5376,7 +5571,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;
@@ -5406,7 +5601,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;
@@ -5474,20 +5669,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";
@@ -5532,7 +5713,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);
     }
@@ -5847,12 +6028,17 @@ function serializeVariable(node, statement, ctx) {
   const name = symbol?.getName() ?? node.name.getText();
   if (!name)
     return null;
-  const { description, tags, examples, source, deprecated, deprecationReason, inlineTags } = extractExportMetadata(node, symbol, ctx.typeChecker, statement);
-  const type = ctx.typeChecker.getTypeAtLocation(node);
+  return serializeValue(name, node, symbol, statement, ctx.typeChecker.getTypeAtLocation(node), ts15.isVariableDeclaration(node) ? node.type : undefined, ctx);
+}
+function serializeDefaultExpression(node, symbol, type, ctx) {
+  return serializeValue(symbol.getName(), node.expression, symbol, node, type, undefined, ctx);
+}
+function serializeValue(name, node, symbol, jsdocNode, type, typeNode, ctx) {
+  const { description, tags, examples, source, deprecated, deprecationReason, inlineTags } = extractExportMetadata(node, symbol, ctx.typeChecker, jsdocNode);
   const schemaExtraction = extractSchemaType(type, ctx.typeChecker);
   const typeToSerialize = schemaExtraction?.outputType ?? type;
   registerReferencedTypes(typeToSerialize, ctx);
-  const schema = buildSchema(typeToSerialize, ctx.typeChecker, ctx, ts15.isVariableDeclaration(node) ? node.type : undefined);
+  const schema = buildSchema(typeToSerialize, ctx.typeChecker, ctx, typeNode);
   const flags = schemaExtraction ? {
     schemaLibrary: schemaExtraction.adapter.id,
     ...schemaExtraction.inputType && schemaExtraction.inputType !== schemaExtraction.outputType ? { hasTransform: true } : {}
@@ -6242,10 +6428,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) {
@@ -6255,7 +6445,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;
 }
@@ -6438,6 +6628,7 @@ async function getExport(options) {
   }
   const ctx = createContext(program, sourceFile, { maxTypeDepth });
   ctx.exportedIds = exportedIds;
+  claimExportedTypeIds(exportedSymbols, ctx);
   try {
     const originalDecls = targetSymbol.declarations ?? [];
     const isNamespaceExportDecl = originalDecls.some((d) => ts16.isNamespaceExport(d) || ts16.isNamespaceImport(d));
@@ -7611,7 +7802,7 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
     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())) {
+    if (named && allowed && symbol && !isExportedType(symbol)) {
       ctx.typeRegistry.registerType(type, ctx);
       const name = symbol.getName();
       if (!symbolByName.has(name)) {
@@ -7632,6 +7823,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;
     }
@@ -7659,6 +7855,12 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
     }
   };
   const TYPE_SYMBOL_FLAGS = ts20.SymbolFlags.Interface | ts20.SymbolFlags.TypeAlias | ts20.SymbolFlags.Class | ts20.SymbolFlags.RegularEnum | ts20.SymbolFlags.ConstEnum;
+  const isExportedType = (symbol) => {
+    const name = symbol.getName();
+    if (!ctx.exportedIds.has(name))
+      return false;
+    return !(symbol.flags & TYPE_SYMBOL_FLAGS) || resolveTypeId(symbol, ctx) === name;
+  };
   const visitedSymbols = new Set;
   const symbolKind = (symbol) => {
     if (symbol.flags & ts20.SymbolFlags.Interface)
@@ -7673,6 +7875,7 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
     const resolved = resolveAliasSymbol(symbol, checker, undefined, ctx.program);
     return resolved;
   };
+  const writtenWhenAny = (symbol, declared) => declared.flags & ts20.TypeFlags.Any ? symbol.declarations?.find(ts20.isTypeAliasDeclaration)?.type : undefined;
   const symbolByName = new Map;
   const registerTypeSymbol = (symbol) => {
     const name = symbol.getName();
@@ -7682,7 +7885,7 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
       return;
     if (!symbolAllowed(symbol))
       return;
-    if (ctx.exportedIds.has(name)) {
+    if (isExportedType(symbol)) {
       walkDeclarations(symbol);
       return;
     }
@@ -7698,7 +7901,7 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
         id,
         name,
         kind: symbolKind(symbol),
-        schema: ensureNonEmptySchema(buildSchema(declared, checker, ctx), declared, checker)
+        schema: withExpansionBudget(ctx, `type ${id}`, () => ensureNonEmptySchema(buildSchema(declared, checker, ctx, writtenWhenAny(symbol, declared)), declared, checker))
       });
     }
     symbolByName.set(name, symbol);
@@ -8080,6 +8283,7 @@ async function extract(options) {
       workspacePackages: result.workspacePackages ?? new Map
     });
     ctx.exportedIds = exportedIds;
+    claimExportedTypeIds(exportedSymbols, ctx);
     const filteredSymbols = exportedSymbols.filter((s) => shouldIncludeExport(s.getName(), only, ignore));
     const total = filteredSymbols.length;
     for (let i = 0;i < filteredSymbols.length; i++) {
@@ -8147,10 +8351,15 @@ 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) {
-          if (!exp.members && isValueDeclaration(declaration) && hasTypeSide(targetSymbol)) {
-            mergedTypeSides.push({ index: exports.length, symbol: targetSymbol });
+          const typeSide = mergedTypeSideOf(exp, declaration, targetSymbol, ctx);
+          if (typeSide) {
+            mergedTypeSides.push({
+              index: exports.length,
+              symbol: typeSide,
+              ontoClass: ts21.isClassDeclaration(declaration)
+            });
           }
           exports.push(exp);
           tracker.status = "success";
@@ -8170,8 +8379,8 @@ async function extract(options) {
         });
       }
     }
-    for (const { index, symbol } of mergedTypeSides) {
-      exports[index] = withMergedTypeSide(exports[index], symbol, ctx);
+    for (const { index, symbol, ontoClass } of mergedTypeSides) {
+      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);
@@ -8182,7 +8391,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"
       });
@@ -8354,21 +8563,18 @@ function serializeDeclaration2(declaration, exportSymbol, exportName, ctx, isTyp
         result = serializeVariable(declaration, varStatement, ctx);
         if (result?.kind === "variable") {
           const type = ctx.typeChecker.getTypeAtLocation(declaration);
-          if (type.getConstructSignatures().length > 0) {
-            result = { ...result, kind: "class" };
-          } else {
-            const callSigs = callSignaturesForVariable(declaration, ctx);
-            if (callSigs.length > 0) {
-              result = {
-                ...result,
-                kind: "function",
-                signatures: buildSignatures(callSigs, ctx.typeChecker, ctx)
-              };
-            }
-          }
+          result = withCallableKind(result, type, callSignaturesForVariable(declaration, ctx), ctx);
         }
       }
     }
+  } else if (ts21.isExportAssignment(declaration) && !declaration.isExportEquals) {
+    const expression = skipOuterExpressions(declaration.expression);
+    if (ts21.isArrowFunction(expression) || ts21.isFunctionExpression(expression)) {
+      result = serializeFunctionExport(expression, ctx, exportName, undefined, declaration);
+    } else {
+      const type = ctx.typeChecker.getTypeOfSymbol(exportSymbol);
+      result = withCallableKind(serializeDefaultExpression(declaration, exportSymbol, type, ctx), type, type.getCallSignatures(), ctx);
+    }
   } else if (ts21.isNamespaceExport(declaration) || ts21.isModuleDeclaration(declaration) || ts21.isNamespaceImport(declaration) || ts21.isSourceFile(declaration)) {
     try {
       result = serializeNamespaceExport(exportSymbol, exportName, ctx);
@@ -8559,6 +8765,30 @@ function variableStatementOf(declaration) {
   const statement = node.parent?.parent;
   return statement && ts21.isVariableStatement(statement) ? statement : undefined;
 }
+function skipOuterExpressions(expression) {
+  let node = expression;
+  while (ts21.isParenthesizedExpression(node) || ts21.isAsExpression(node) || ts21.isSatisfiesExpression(node) || ts21.isTypeAssertionExpression(node) || ts21.isNonNullExpression(node)) {
+    node = node.expression;
+  }
+  return node;
+}
+function withCallableKind(entry, type, callSigs, ctx) {
+  const constructSigs = type.getConstructSignatures();
+  if (constructSigs.length > 0) {
+    return {
+      ...entry,
+      kind: "class",
+      signatures: serializeConstructSignatures(constructSigs, ctx)
+    };
+  }
+  if (callSigs.length === 0)
+    return entry;
+  return {
+    ...entry,
+    kind: "function",
+    signatures: buildSignatures(callSigs, ctx.typeChecker, ctx)
+  };
+}
 function callSignaturesForVariable(declaration, ctx) {
   const checker = ctx.typeChecker;
   if (ts21.isVariableDeclaration(declaration) && declaration.type && ts21.isTypeReferenceNode(declaration.type)) {
@@ -8609,18 +8839,45 @@ function isValueDeclaration(declaration) {
 function hasTypeSide(symbol) {
   return (symbol.flags & (ts21.SymbolFlags.Interface | ts21.SymbolFlags.TypeAlias)) !== 0;
 }
-function withMergedTypeSide(entry, symbol, ctx) {
+function mergedTypeSideOf(exp, declaration, symbol, ctx) {
+  if (ts21.isClassDeclaration(declaration)) {
+    return symbol.flags & ts21.SymbolFlags.Interface ? symbol : undefined;
+  }
+  if (exp.members || !isValueDeclaration(declaration))
+    return;
+  if (hasTypeSide(symbol))
+    return symbol;
+  if (exp.kind !== "class")
+    return;
+  const [construct] = ctx.typeChecker.getTypeAtLocation(declaration).getConstructSignatures();
+  const instance = construct?.getReturnType();
+  const constructed = instance && (instance.aliasSymbol ?? instance.getSymbol());
+  if (!constructed || !hasTypeSide(constructed))
+    return;
+  if (ctx.shouldExpandExternal && !ctx.shouldExpandExternal(constructed))
+    return;
+  return constructed;
+}
+function withMergedTypeSide(entry, symbol, ctx, ontoClass) {
   const typeSide = serializeMergedTypeSide(symbol, ctx);
   if (!typeSide)
     return entry;
   const { members, description, tags, ...instanceType } = typeSide;
+  const own = new Set(entry.members?.map((m) => m.name));
   return {
     ...entry,
-    members,
-    ...entry.kind === "class" ? instanceType : {},
+    members: [...entry.members ?? [], ...(members ?? []).filter((m) => !own.has(m.name))],
+    ...entry.kind === "class" && !ontoClass ? instanceType : {},
     ...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;
@@ -9192,6 +9449,7 @@ function getNodeName(node) {
 export {
   zodAdapter,
   writtenTypeText,
+  withOpenHeritage,
   withDescription,
   withDeprecated,
   validateSpec2 as validateSpec,
@@ -9237,6 +9495,7 @@ export {
   query,
   pickEntry,
   parseGithubRepo,
+  openHeritageArms,
   normalizeType,
   normalizeSchema,
   normalizeMembers,
@@ -9318,6 +9577,7 @@ export {
   buildSchema,
   buildObjectSchema,
   buildFunctionSchema,
+  buildAliasBodySchema,
   assertSpec,
   asStandardSchema,
   arktypeAdapter,