@openpkg-ts/sdk 0.54.4 → 0.54.6

package/dist/index.js

@@ -1781,7 +1781,7 @@ function filterSpec(spec, criteria) {
   };
 }
 // src/primitives/get.ts
-import ts13 from "typescript";
+import ts14 from "typescript";
 
 // src/ast/type-identity.ts
 import * as path3 from "node:path";
@@ -2102,22 +2102,14 @@ function extractVarianceModifiers(modifiers) {
   const variance = hasIn && hasOut ? "inout" : hasIn ? "in" : hasOut ? "out" : undefined;
   return { variance, isConst };
 }
-function extractTypeParameters(node, checker) {
+function extractTypeParameters(node, _checker) {
   if (!node.typeParameters || node.typeParameters.length === 0) {
     return;
   }
   return node.typeParameters.map((tp) => {
     const name = tp.name.text;
-    let constraint;
-    if (tp.constraint) {
-      const constraintType = checker.getTypeAtLocation(tp.constraint);
-      constraint = checker.typeToString(constraintType);
-    }
-    let defaultType;
-    if (tp.default) {
-      const defType = checker.getTypeAtLocation(tp.default);
-      defaultType = checker.typeToString(defType);
-    }
+    const constraint = tp.constraint ? tp.constraint.getText() : undefined;
+    const defaultType = tp.default ? tp.default.getText() : undefined;
     const { variance, isConst } = extractVarianceModifiers(ts2.getModifiers(tp));
     return {
       name,
@@ -2175,7 +2167,7 @@ function getJSDocForSignature(signature, checker) {
   const symbol = checker?.getSymbolAtLocation(decl);
   return getJSDocComment(decl, symbol, checker);
 }
-function extractTypeParametersFromSignature(signature, checker) {
+function extractTypeParametersFromSignature(signature, _checker) {
   const typeParams = signature.getTypeParameters();
   if (!typeParams || typeParams.length === 0) {
     return;
@@ -2183,15 +2175,7 @@ function extractTypeParametersFromSignature(signature, checker) {
   return typeParams.map((tp) => {
     const name = tp.getSymbol()?.getName() ?? "T";
     let constraint;
-    const constraintType = tp.getConstraint();
-    if (constraintType) {
-      constraint = checker.typeToString(constraintType);
-    }
     let defaultType;
-    const defaultT = tp.getDefault();
-    if (defaultT) {
-      defaultType = checker.typeToString(defaultT);
-    }
     let variance;
     let isConst;
     const tpSymbol = tp.getSymbol();
@@ -2199,6 +2183,10 @@ function extractTypeParametersFromSignature(signature, checker) {
     for (const decl of declarations) {
       if (ts2.isTypeParameterDeclaration(decl)) {
         ({ variance, isConst } = extractVarianceModifiers(ts2.getModifiers(decl)));
+        if (decl.constraint)
+          constraint = decl.constraint.getText();
+        if (decl.default)
+          defaultType = decl.default.getText();
         break;
       }
     }
@@ -2235,6 +2223,37 @@ function getExportKind(declaration, type) {
 import * as fs4 from "node:fs";
 import * as path5 from "node:path";
 import ts3 from "typescript";
+function collectLocalModuleFiles(entryFile, host, options) {
+  const seen = new Set;
+  const queue = [entryFile];
+  while (queue.length > 0) {
+    const file = queue.pop();
+    if (seen.has(file))
+      continue;
+    seen.add(file);
+    const text = host.readFile(file);
+    if (text === undefined)
+      continue;
+    const sf = ts3.createSourceFile(file, text, ts3.ScriptTarget.Latest, true, getScriptKind(file));
+    for (const stmt of sf.statements) {
+      let spec;
+      if (ts3.isImportDeclaration(stmt))
+        spec = stmt.moduleSpecifier;
+      else if (ts3.isExportDeclaration(stmt))
+        spec = stmt.moduleSpecifier;
+      if (!spec || !ts3.isStringLiteral(spec))
+        continue;
+      if (!spec.text.startsWith("."))
+        continue;
+      const resolved = ts3.resolveModuleName(spec.text, file, options, host);
+      const resolvedFile = resolved.resolvedModule?.resolvedFileName;
+      if (resolvedFile && !resolvedFile.includes(`${path5.sep}node_modules${path5.sep}`)) {
+        queue.push(resolvedFile);
+      }
+    }
+  }
+  return [...seen];
+}
 function isJsFile(file) {
   return /\.(js|mjs|cjs|jsx)$/.test(file);
 }
@@ -2499,6 +2518,7 @@ function createProgram(options) {
       return ts3.resolveModuleName(literal.text, containingFile, options2, compilerHost, undefined, redirectedReference, mode);
     });
   }
+  const localRoots = collectLocalModuleFiles(entryFile, compilerHost, compilerOptions);
   if (content !== undefined) {
     inMemorySource = ts3.createSourceFile(entryFile, content, ts3.ScriptTarget.Latest, true, getScriptKind(entryFile));
     const originalGetSourceFile = compilerHost.getSourceFile.bind(compilerHost);
@@ -2509,7 +2529,7 @@ function createProgram(options) {
       return originalGetSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
     };
   }
-  const rootFiles = [entryFile, ...additionalRootFiles];
+  const rootFiles = [...new Set([entryFile, ...localRoots, ...additionalRootFiles])];
   const program = ts3.createProgram(rootFiles, compilerOptions, compilerHost);
   const sourceFile = inMemorySource ?? program.getSourceFile(entryFile);
   return {
@@ -2523,13 +2543,144 @@ function createProgram(options) {
 }
 
 // src/serializers/classes.ts
-import ts8 from "typescript";
+import ts9 from "typescript";
 
 // src/types/parameters.ts
-import ts5 from "typescript";
+import ts6 from "typescript";
 
 // src/types/schema-builder.ts
+import ts5 from "typescript";
+
+// src/ast/resolve.ts
 import ts4 from "typescript";
+function isTypeOnlyExport(symbol) {
+  const declarations = symbol.declarations ?? [];
+  for (const decl of declarations) {
+    if (ts4.isExportSpecifier(decl)) {
+      if (decl.isTypeOnly)
+        return true;
+      const exportDecl = decl.parent?.parent;
+      if (exportDecl && ts4.isExportDeclaration(exportDecl) && exportDecl.isTypeOnly) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function resolveExportTarget(symbol, checker, program) {
+  const isTypeOnly = isTypeOnlyExport(symbol);
+  const targetSymbol = resolveAliasSymbol(symbol, checker, undefined, program);
+  const declarations = targetSymbol.declarations ?? [];
+  const declaration = targetSymbol.valueDeclaration || declarations.find((decl) => decl.kind !== ts4.SyntaxKind.ExportSpecifier && decl.kind !== ts4.SyntaxKind.ImportSpecifier && decl.kind !== ts4.SyntaxKind.ExportDeclaration && decl.kind !== ts4.SyntaxKind.ImportClause && decl.kind !== ts4.SyntaxKind.NamespaceExport);
+  return { declaration, targetSymbol, isTypeOnly };
+}
+function resolveAliasSymbol(symbol, checker, seen = new Set, program) {
+  if (seen.has(symbol))
+    return symbol;
+  seen.add(symbol);
+  if (symbol.flags & ts4.SymbolFlags.Alias) {
+    try {
+      const aliased = checker.getAliasedSymbol(symbol);
+      if (aliased && aliased !== symbol && hasConcreteDeclaration(aliased)) {
+        return resolveAliasSymbol(aliased, checker, seen, program);
+      }
+    } catch {}
+  }
+  for (const decl of symbol.declarations ?? []) {
+    const fromModule = resolveFromModuleSpecifier(decl, symbol, checker, program);
+    if (fromModule && fromModule !== symbol) {
+      return resolveAliasSymbol(fromModule, checker, seen, program);
+    }
+  }
+  return symbol;
+}
+function hasConcreteDeclaration(symbol) {
+  if (symbol.valueDeclaration)
+    return true;
+  return (symbol.declarations ?? []).some((d) => d.kind !== ts4.SyntaxKind.ExportSpecifier && d.kind !== ts4.SyntaxKind.ImportSpecifier && d.kind !== ts4.SyntaxKind.ExportDeclaration && d.kind !== ts4.SyntaxKind.NamespaceExport);
+}
+function resolveFromModuleSpecifier(decl, symbol, checker, program) {
+  let moduleSpecifier;
+  let importedName;
+  if (ts4.isExportSpecifier(decl)) {
+    const exportDecl = decl.parent?.parent;
+    if (exportDecl && ts4.isExportDeclaration(exportDecl)) {
+      moduleSpecifier = exportDecl.moduleSpecifier;
+      importedName = (decl.propertyName ?? decl.name).text;
+    }
+  } else if (ts4.isImportSpecifier(decl)) {
+    const importDecl = decl.parent?.parent?.parent;
+    if (importDecl && ts4.isImportDeclaration(importDecl)) {
+      moduleSpecifier = importDecl.moduleSpecifier;
+      importedName = (decl.propertyName ?? decl.name).text;
+    }
+  } else if (ts4.isImportClause(decl) && decl.name) {
+    const importDecl = decl.parent;
+    if (ts4.isImportDeclaration(importDecl)) {
+      moduleSpecifier = importDecl.moduleSpecifier;
+      importedName = "default";
+    }
+  }
+  if (!moduleSpecifier || importedName === undefined || !ts4.isStringLiteral(moduleSpecifier)) {
+    return;
+  }
+  let modSym = checker.getSymbolAtLocation(moduleSpecifier);
+  if (!modSym && program) {
+    const containing = decl.getSourceFile().fileName;
+    const resolved = ts4.resolveModuleName(moduleSpecifier.text, containing, program.getCompilerOptions(), ts4.sys);
+    const file = resolved.resolvedModule?.resolvedFileName;
+    const sf = file ? program.getSourceFile(file) : undefined;
+    if (sf)
+      modSym = checker.getSymbolAtLocation(sf);
+  }
+  if (!modSym)
+    return;
+  if (modSym.flags & ts4.SymbolFlags.Alias) {
+    try {
+      modSym = checker.getAliasedSymbol(modSym);
+    } catch {
+      return;
+    }
+  }
+  if (!modSym)
+    return;
+  const exported = getModuleExportsFollowingStars(modSym, checker, program);
+  const match = exported.find((e) => e.getName() === importedName);
+  return match && match !== symbol ? match : undefined;
+}
+function getModuleExportsFollowingStars(modSym, checker, program, seen = new Set) {
+  if (seen.has(modSym))
+    return [];
+  seen.add(modSym);
+  const byName = new Map;
+  for (const s of checker.getExportsOfModule(modSym)) {
+    byName.set(s.getName(), s);
+  }
+  for (const decl of modSym.declarations ?? []) {
+    const sf = ts4.isSourceFile(decl) ? decl : decl.getSourceFile();
+    for (const stmt of sf.statements) {
+      if (!ts4.isExportDeclaration(stmt) || stmt.exportClause || !stmt.moduleSpecifier || !ts4.isStringLiteral(stmt.moduleSpecifier)) {
+        continue;
+      }
+      const nested = moduleSymbolFromPath(stmt.moduleSpecifier.text, sf.fileName, checker, program);
+      if (!nested)
+        continue;
+      for (const s of getModuleExportsFollowingStars(nested, checker, program, seen)) {
+        if (!byName.has(s.getName()))
+          byName.set(s.getName(), s);
+      }
+    }
+  }
+  return [...byName.values()];
+}
+function moduleSymbolFromPath(spec, containingFile, checker, program) {
+  if (!program)
+    return;
+  const resolved = ts4.resolveModuleName(spec, containingFile, program.getCompilerOptions(), ts4.sys);
+  const file = resolved.resolvedModule?.resolvedFileName;
+  const sf = file ? program.getSourceFile(file) : undefined;
+  return sf ? checker.getSymbolAtLocation(sf) : undefined;
+}
 
 // src/schema/builtins.ts
 var BUILTIN_TYPE_SCHEMAS = {
@@ -2566,11 +2717,11 @@ function escapeRegex(text) {
 }
 function buildTemplatePattern(type) {
   const slotPattern = (slot) => {
-    if (slot.flags & ts4.TypeFlags.NumberLike)
+    if (slot.flags & ts5.TypeFlags.NumberLike)
       return "-?\\d+(?:\\.\\d+)?";
-    if (slot.flags & ts4.TypeFlags.BigIntLike)
+    if (slot.flags & ts5.TypeFlags.BigIntLike)
       return "-?\\d+";
-    if (slot.flags & ts4.TypeFlags.BooleanLike)
+    if (slot.flags & ts5.TypeFlags.BooleanLike)
       return "(?:true|false)";
     return ".*";
   };
@@ -2597,12 +2748,12 @@ function scrubImportQualifiers(text) {
   return text.replace(/import\((?:"[^"]*"|'[^']*')\)\./g, "");
 }
 function renderTypeText(type, checker, enclosing, extraFlags = 0) {
-  return scrubImportQualifiers(checker.typeToString(type, enclosing, ts4.TypeFormatFlags.NoTruncation | extraFlags));
+  return scrubImportQualifiers(checker.typeToString(type, enclosing, ts5.TypeFormatFlags.NoTruncation | extraFlags));
 }
 function writtenTypeText(typeNode) {
   if (!typeNode)
     return;
-  if (!ts4.isTypeReferenceNode(typeNode) && !ts4.isUnionTypeNode(typeNode))
+  if (!ts5.isTypeReferenceNode(typeNode) && !ts5.isUnionTypeNode(typeNode))
     return;
   try {
     const text = scrubImportQualifiers(typeNode.getText().replace(/\s+/g, " ").replace(/^\|\s*/, "").trim());
@@ -2615,10 +2766,97 @@ function declaredTypeNode(decl) {
   const withType = decl;
   return withType?.type;
 }
+function typeNodeOfSignature(sig) {
+  const decl = sig.getDeclaration();
+  if (!decl || !ts5.isFunctionLike(decl))
+    return;
+  return decl.type;
+}
+function resolvedSymbol(symbol, checker) {
+  if (!symbol)
+    return;
+  if (symbol.flags & ts5.SymbolFlags.Alias) {
+    try {
+      return checker.getAliasedSymbol(symbol);
+    } catch {
+      return symbol;
+    }
+  }
+  return symbol;
+}
+function buildSchemaFromTypeNode(node, checker, ctx) {
+  if (ts5.isParenthesizedTypeNode(node)) {
+    return buildSchemaFromTypeNode(node.type, checker, ctx);
+  }
+  if (ts5.isUnionTypeNode(node)) {
+    return { anyOf: node.types.map((t2) => buildSchemaFromTypeNode(t2, checker, ctx)) };
+  }
+  if (ts5.isIntersectionTypeNode(node)) {
+    return { allOf: node.types.map((t2) => buildSchemaFromTypeNode(t2, checker, ctx)) };
+  }
+  if (node.kind === ts5.SyntaxKind.NullKeyword) {
+    return { type: "null" };
+  }
+  if (ts5.isLiteralTypeNode(node) && node.literal.kind === ts5.SyntaxKind.NullKeyword) {
+    return { type: "null" };
+  }
+  if (node.kind === ts5.SyntaxKind.UndefinedKeyword) {
+    return { type: "undefined" };
+  }
+  if (node.kind === ts5.SyntaxKind.VoidKeyword) {
+    return { type: "void" };
+  }
+  if (node.kind === ts5.SyntaxKind.AnyKeyword) {
+    return { "x-ts-type": "any" };
+  }
+  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 symbol = resolvedSymbol(raw, checker);
+    const name = symbol?.getName() ?? node.typeName.getText();
+    const args = node.typeArguments?.map((arg) => {
+      if (typeNodeDefersExpansion(arg, checker, ctx?.program)) {
+        return buildSchemaFromTypeNode(arg, checker, ctx);
+      }
+      const argType = checker.getTypeFromTypeNode(arg);
+      return buildSchema(argType, checker, ctx, arg);
+    });
+    const withArgs = (schema) => {
+      if (!args || args.length === 0)
+        return schema;
+      if (typeof schema !== "object" || schema === null || Array.isArray(schema)) {
+        return schema;
+      }
+      return { ...schema, typeArguments: args };
+    };
+    if (name && isBuiltinGeneric(name) && (!symbol || isBuiltinSymbol(symbol))) {
+      return withArgs({ ...builtinSchema(name) });
+    }
+    if (name && !name.startsWith("__")) {
+      let refId = name;
+      if (symbol && ctx) {
+        try {
+          refId = namedRefId(checker.getDeclaredTypeOfSymbol(symbol), name, ctx);
+        } catch {
+          refId = name;
+        }
+      }
+      return withArgs({ $ref: `#/types/${refId}` });
+    }
+    return { "x-ts-type": scrubImportQualifiers(node.getText()) };
+  }
+  const t = checker.getTypeFromTypeNode(node);
+  if (!(t.flags & ts5.TypeFlags.Any)) {
+    return buildSchema(t, checker, ctx);
+  }
+  return { "x-ts-type": scrubImportQualifiers(node.getText()) };
+}
 function stripUndefinedFromType(type, checker) {
   if (!type.isUnion())
     return type;
-  const nonUndefinedTypes = type.types.filter((t) => !(t.flags & ts4.TypeFlags.Undefined));
+  const nonUndefinedTypes = type.types.filter((t) => !(t.flags & ts5.TypeFlags.Undefined));
   if (nonUndefinedTypes.length === 0)
     return type;
   if (nonUndefinedTypes.length === 1)
@@ -2627,13 +2865,13 @@ function stripUndefinedFromType(type, checker) {
 }
 function isReadonlyPropertySymbol(prop) {
   const decls = prop.getDeclarations() ?? [];
-  return decls.some((d) => (ts4.getCombinedModifierFlags(d) & ts4.ModifierFlags.Readonly) !== 0);
+  return decls.some((d) => (ts5.getCombinedModifierFlags(d) & ts5.ModifierFlags.Readonly) !== 0);
 }
 function decoratePropertySchema(schema, prop, propType, checker) {
   if (typeof schema !== "object" || schema === null || Array.isArray(schema))
     return schema;
   const decl = prop.valueDeclaration ?? prop.getDeclarations()?.[0];
-  const optional = !!(prop.flags & ts4.SymbolFlags.Optional);
+  const optional = !!(prop.flags & ts5.SymbolFlags.Optional);
   const textType = optional ? stripUndefinedFromType(propType, checker) : propType;
   const text = renderTypeText(textType, checker, decl);
   const obj = schema;
@@ -2650,16 +2888,16 @@ function decoratePropertySchema(schema, prop, propType, checker) {
   if (isReadonlyPropertySymbol(prop) && !("readOnly" in obj)) {
     result = { ...result, readOnly: true };
   }
-  if (prop.flags & ts4.SymbolFlags.Method && !("x-ts-method" in obj)) {
+  if (prop.flags & ts5.SymbolFlags.Method && !("x-ts-method" in obj)) {
     result = { ...result, "x-ts-method": true };
   }
   return result;
 }
 function shouldEmitAliasTypeText(typeNode) {
-  if (ts4.isMappedTypeNode(typeNode))
+  if (ts5.isMappedTypeNode(typeNode))
     return false;
-  if (ts4.isTypeLiteralNode(typeNode)) {
-    return typeNode.members.length > 0 && typeNode.members.every((m) => ts4.isIndexSignatureDeclaration(m));
+  if (ts5.isTypeLiteralNode(typeNode)) {
+    return typeNode.members.length > 0 && typeNode.members.every((m) => ts5.isIndexSignatureDeclaration(m));
   }
   return true;
 }
@@ -2721,6 +2959,104 @@ var RESOLVED_UTILITY_TYPES = new Set([
   "NonNullable",
   "Awaited"
 ]);
+function isDeferredMappedOrConditional(type) {
+  if (shouldDeferAlias(type.aliasSymbol))
+    return true;
+  const target = type.target;
+  if (target && target !== type) {
+    if (shouldDeferAlias(target.aliasSymbol ?? target.getSymbol()))
+      return true;
+    const targetName = target.aliasSymbol?.getName() ?? target.getSymbol()?.getName();
+    if (targetName && RESOLVED_UTILITY_TYPES.has(targetName))
+      return false;
+  }
+  if (type.flags & ts5.TypeFlags.Conditional) {
+    const name = type.aliasSymbol?.getName();
+    if (name && RESOLVED_UTILITY_TYPES.has(name))
+      return false;
+    return true;
+  }
+  const objectFlags = type.objectFlags ?? 0;
+  if (objectFlags & ts5.ObjectFlags.Mapped) {
+    const name = type.aliasSymbol?.getName();
+    if (name && RESOLVED_UTILITY_TYPES.has(name))
+      return false;
+    if (aliasRhsIsUtility(type.aliasSymbol))
+      return false;
+    return true;
+  }
+  return false;
+}
+function typeRefName(node) {
+  return ts5.isQualifiedName(node.typeName) ? node.typeName.right.text : node.typeName.getText();
+}
+function aliasRhsIsUtility(symbol) {
+  const alias = symbol?.declarations?.find(ts5.isTypeAliasDeclaration);
+  if (!alias || !ts5.isTypeReferenceNode(alias.type))
+    return false;
+  return RESOLVED_UTILITY_TYPES.has(typeRefName(alias.type));
+}
+function isMappedOrConditionalBody(node) {
+  if (ts5.isParenthesizedTypeNode(node))
+    return isMappedOrConditionalBody(node.type);
+  if (ts5.isMappedTypeNode(node) || ts5.isConditionalTypeNode(node))
+    return true;
+  if (ts5.isUnionTypeNode(node) || ts5.isIntersectionTypeNode(node)) {
+    return node.types.some(isMappedOrConditionalBody);
+  }
+  return false;
+}
+function shouldDeferAlias(symbol) {
+  if (!symbol)
+    return false;
+  const name = symbol.getName();
+  if (!name || name.startsWith("__") || RESOLVED_UTILITY_TYPES.has(name))
+    return false;
+  if (aliasRhsIsUtility(symbol))
+    return false;
+  const alias = symbol.declarations?.find(ts5.isTypeAliasDeclaration);
+  if (!alias)
+    return false;
+  return isMappedOrConditionalBody(alias.type);
+}
+function typeNodeDefersExpansion(node, checker, program) {
+  if (!node)
+    return false;
+  if (ts5.isParenthesizedTypeNode(node))
+    return typeNodeDefersExpansion(node.type, checker, program);
+  if (ts5.isUnionTypeNode(node) || ts5.isIntersectionTypeNode(node)) {
+    return node.types.some((t) => typeNodeDefersExpansion(t, checker, program));
+  }
+  if (!ts5.isTypeReferenceNode(node))
+    return false;
+  const raw = checker.getSymbolAtLocation(ts5.isQualifiedName(node.typeName) ? node.typeName.right : node.typeName);
+  if (!raw)
+    return false;
+  const symbol = resolveAliasSymbol(raw, checker, undefined, program);
+  return shouldDeferAlias(symbol);
+}
+function cheapTypeText(type, _checker, typeNode) {
+  if (typeNode) {
+    try {
+      const text = scrubImportQualifiers(typeNode.getText().replace(/\s+/g, " ").trim());
+      if (text)
+        return text;
+    } catch {}
+  }
+  const alias = type.aliasSymbol;
+  const decl = alias?.declarations?.find(ts5.isTypeAliasDeclaration);
+  if (decl?.type) {
+    try {
+      const text = scrubImportQualifiers(decl.type.getText().replace(/\s+/g, " ").trim());
+      if (text)
+        return text;
+    } catch {}
+  }
+  const name = alias?.getName() ?? type.getSymbol()?.getName();
+  if (name && !name.startsWith("__"))
+    return name;
+  return "unknown";
+}
 var BUILTIN_TYPES = new Set([
   "Date",
   "RegExp",
@@ -2867,12 +3203,94 @@ function isAnonymous(type) {
   return name.startsWith("__") || name === "";
 }
 function isFluentThisType(type) {
-  if (!(type.flags & ts4.TypeFlags.TypeParameter))
+  if (!(type.flags & ts5.TypeFlags.TypeParameter))
     return false;
   const declarations = type.getSymbol()?.declarations;
   if (!declarations || declarations.length === 0)
     return false;
-  return declarations.some((decl) => ts4.isClassDeclaration(decl) || ts4.isClassExpression(decl) || ts4.isInterfaceDeclaration(decl));
+  return declarations.some((decl) => ts5.isClassDeclaration(decl) || ts5.isClassExpression(decl) || ts5.isInterfaceDeclaration(decl));
+}
+function containsUnresolvedTypeParameter(type, seen = new Set) {
+  if (seen.has(type))
+    return false;
+  seen.add(type);
+  if (type.flags & ts5.TypeFlags.TypeParameter) {
+    return !isFluentThisType(type);
+  }
+  if (type.isUnionOrIntersection()) {
+    return type.types.some((t) => containsUnresolvedTypeParameter(t, seen));
+  }
+  if (type.aliasTypeArguments) {
+    for (const arg of type.aliasTypeArguments) {
+      if (containsUnresolvedTypeParameter(arg, seen))
+        return true;
+    }
+  }
+  const targs = type.typeArguments;
+  if (targs) {
+    for (const arg of targs) {
+      if (containsUnresolvedTypeParameter(arg, seen))
+        return true;
+    }
+  }
+  if (type.flags & ts5.TypeFlags.IndexedAccess) {
+    const ia = type;
+    return containsUnresolvedTypeParameter(ia.objectType, seen) || containsUnresolvedTypeParameter(ia.indexType, seen);
+  }
+  return false;
+}
+function isUtilityOverTypeParameter(type) {
+  const name = type.aliasSymbol?.getName();
+  if (!name || !RESOLVED_UTILITY_TYPES.has(name))
+    return false;
+  const args = type.aliasTypeArguments;
+  if (!args || args.length === 0)
+    return false;
+  return args.some((t) => containsUnresolvedTypeParameter(t));
+}
+function writtenUtilityText(type, checker, typeNode) {
+  let node = typeNode;
+  while (node && ts5.isParenthesizedTypeNode(node))
+    node = node.type;
+  const fromNode = writtenTypeText(node);
+  if (fromNode)
+    return fromNode;
+  if (node) {
+    try {
+      const text = scrubImportQualifiers(node.getText().replace(/\s+/g, " ").trim());
+      if (text)
+        return text;
+    } catch {}
+  }
+  const name = type.aliasSymbol?.getName();
+  const args = type.aliasTypeArguments;
+  if (name && args && args.length > 0) {
+    const inner = args.map((t) => scrubImportQualifiers(checker.typeToString(t))).join(", ");
+    return `${name}<${inner}>`;
+  }
+  return renderTypeText(type, checker);
+}
+function isReadonlyArrayType(type, typeNode) {
+  let node = typeNode;
+  while (node && ts5.isParenthesizedTypeNode(node))
+    node = node.type;
+  if (node && ts5.isTypeOperatorNode(node) && node.operator === ts5.SyntaxKind.ReadonlyKeyword) {
+    return true;
+  }
+  if (node && ts5.isTypeReferenceNode(node) && typeRefName(node) === "ReadonlyArray") {
+    return true;
+  }
+  const ref = type;
+  const name = ref.target?.getSymbol()?.getName() ?? type.getSymbol()?.getName();
+  return name === "ReadonlyArray";
+}
+function withReadonlyArrayHint(schema, type, typeNode) {
+  if (!isReadonlyArrayType(type, typeNode))
+    return schema;
+  if (typeof schema !== "object" || schema === null || Array.isArray(schema))
+    return schema;
+  setSchemaExtension(schema, "x-ts-readonly", true);
+  return schema;
 }
 function withDepth(ctx, fn) {
   ctx.currentDepth++;
@@ -2904,12 +3322,17 @@ function ensureNonEmptySchema(schema, type, checker) {
   }
   return schema;
 }
-function buildSchema(type, checker, ctx) {
-  const schema = buildSchemaInternal(type, checker, ctx);
+function buildSchema(type, checker, ctx, typeNode) {
+  const schema = buildSchemaInternal(type, checker, ctx, typeNode);
   return ensureNonEmptySchema(schema, type, checker);
 }
-function buildMaxDepthSchema(type, checker) {
-  if (type.flags & ts4.TypeFlags.TypeParameter && !isFluentThisType(type)) {
+function buildMaxDepthSchema(type, checker, typeNode) {
+  if (type.flags & ts5.TypeFlags.Any) {
+    if (typeNode)
+      return buildSchemaFromTypeNode(typeNode, checker);
+    return { "x-ts-type": checker.typeToString(type) };
+  }
+  if (type.flags & ts5.TypeFlags.TypeParameter && !isFluentThisType(type)) {
     return { "x-ts-type": checker.typeToString(type) };
   }
   const symbol = type.getSymbol() || type.aliasSymbol;
@@ -2922,19 +3345,19 @@ function buildMaxDepthSchema(type, checker) {
       return { $ref: `#/types/${name}` };
     }
   }
-  if (type.flags & ts4.TypeFlags.String)
+  if (type.flags & ts5.TypeFlags.String)
     return { type: "string" };
-  if (type.flags & ts4.TypeFlags.Number)
+  if (type.flags & ts5.TypeFlags.Number)
     return { type: "number" };
-  if (type.flags & ts4.TypeFlags.Boolean)
+  if (type.flags & ts5.TypeFlags.Boolean)
     return { type: "boolean" };
-  if (type.flags & ts4.TypeFlags.Undefined)
+  if (type.flags & ts5.TypeFlags.Undefined)
     return { type: "undefined" };
-  if (type.flags & ts4.TypeFlags.Null)
+  if (type.flags & ts5.TypeFlags.Null)
     return { type: "null" };
-  if (type.flags & ts4.TypeFlags.Void)
+  if (type.flags & ts5.TypeFlags.Void)
     return { type: "void" };
-  if (type.flags & ts4.TypeFlags.TemplateLiteral) {
+  if (type.flags & ts5.TypeFlags.TemplateLiteral) {
     return {
       type: "string",
       pattern: buildTemplatePattern(type),
@@ -2951,9 +3374,21 @@ function buildMaxDepthSchema(type, checker) {
   }
   return { type: checker.typeToString(type) };
 }
-function buildSchemaInternal(type, checker, ctx) {
+function buildSchemaInternal(type, checker, ctx, typeNode) {
   if (isAtMaxDepth(ctx)) {
-    return buildMaxDepthSchema(type, checker);
+    return buildMaxDepthSchema(type, checker, typeNode);
+  }
+  if (ctx) {
+    ctx.schemaOps += 1;
+    if (ctx.schemaOps > ctx.maxSchemaOps) {
+      ctx.budgetExceeded = true;
+      return { "x-ts-type": cheapTypeText(type, checker, typeNode) };
+    }
+  }
+  if (isDeferredMappedOrConditional(type)) {
+    if (ctx)
+      ctx.budgetExceeded = true;
+    return { "x-ts-type": cheapTypeText(type, checker, typeNode) };
   }
   if (ctx?.visitedTypes.has(type)) {
     const callSignatures = type.getCallSignatures();
@@ -2970,32 +3405,35 @@ function buildSchemaInternal(type, checker, ctx) {
     }
     return { type: checker.typeToString(type) };
   }
-  const addedToVisited = !!(ctx && type.flags & ts4.TypeFlags.Object);
+  const addedToVisited = !!(ctx && type.flags & ts5.TypeFlags.Object);
   if (addedToVisited) {
     ctx.visitedTypes.add(type);
   }
   try {
-    if (type.flags & ts4.TypeFlags.String)
+    if (type.flags & ts5.TypeFlags.String)
       return { type: "string" };
-    if (type.flags & ts4.TypeFlags.Number)
+    if (type.flags & ts5.TypeFlags.Number)
       return { type: "number" };
-    if (type.flags & ts4.TypeFlags.Boolean)
+    if (type.flags & ts5.TypeFlags.Boolean)
       return { type: "boolean" };
-    if (type.flags & ts4.TypeFlags.Undefined)
+    if (type.flags & ts5.TypeFlags.Undefined)
       return { type: "undefined" };
-    if (type.flags & ts4.TypeFlags.Null)
+    if (type.flags & ts5.TypeFlags.Null)
       return { type: "null" };
-    if (type.flags & ts4.TypeFlags.Void)
+    if (type.flags & ts5.TypeFlags.Void)
       return { type: "void" };
-    if (type.flags & ts4.TypeFlags.Any)
-      return { type: "any" };
-    if (type.flags & ts4.TypeFlags.Unknown)
+    if (type.flags & ts5.TypeFlags.Any) {
+      if (typeNode)
+        return buildSchemaFromTypeNode(typeNode, checker, ctx);
+      return { "x-ts-type": checker.typeToString(type) };
+    }
+    if (type.flags & ts5.TypeFlags.Unknown)
       return { type: "unknown" };
-    if (type.flags & ts4.TypeFlags.Never)
+    if (type.flags & ts5.TypeFlags.Never)
       return { type: "never" };
-    if (type.flags & ts4.TypeFlags.BigInt)
+    if (type.flags & ts5.TypeFlags.BigInt)
       return { type: "bigint" };
-    if (type.flags & ts4.TypeFlags.ESSymbol)
+    if (type.flags & ts5.TypeFlags.ESSymbol)
       return { type: "symbol" };
     if (isFluentThisType(type)) {
       const constraint = type.getConstraint?.();
@@ -3007,18 +3445,21 @@ function buildSchemaInternal(type, checker, ctx) {
         };
       }
     }
-    if (type.flags & ts4.TypeFlags.TypeParameter) {
+    if (type.flags & ts5.TypeFlags.TypeParameter) {
       return { "x-ts-type": checker.typeToString(type) };
     }
-    if (type.flags & ts4.TypeFlags.StringLiteral) {
+    if (isUtilityOverTypeParameter(type)) {
+      return { "x-ts-type": writtenUtilityText(type, checker, typeNode) };
+    }
+    if (type.flags & ts5.TypeFlags.StringLiteral) {
       const literal = type.value;
       return { type: "string", enum: [literal] };
     }
-    if (type.flags & ts4.TypeFlags.NumberLiteral) {
+    if (type.flags & ts5.TypeFlags.NumberLiteral) {
       const literal = type.value;
       return { type: "number", enum: [literal] };
     }
-    if (type.flags & ts4.TypeFlags.BooleanLiteral) {
+    if (type.flags & ts5.TypeFlags.BooleanLiteral) {
       const typeString2 = checker.typeToString(type);
       return { type: "boolean", enum: [typeString2 === "true"] };
     }
@@ -3033,33 +3474,33 @@ function buildSchemaInternal(type, checker, ctx) {
         return schema;
       }
     }
-    if (type.flags & ts4.TypeFlags.TemplateLiteral) {
+    if (type.flags & ts5.TypeFlags.TemplateLiteral) {
       return {
         type: "string",
         pattern: buildTemplatePattern(type),
         "x-ts-type": renderTypeText(type, checker)
       };
     }
-    if (type.flags & ts4.TypeFlags.StringMapping) {
+    if (type.flags & ts5.TypeFlags.StringMapping) {
       return { type: "string", "x-ts-type": renderTypeText(type, checker) };
     }
     if (type.isUnion()) {
       const types = type.types;
-      const allStringLiterals = types.every((t) => t.flags & ts4.TypeFlags.StringLiteral);
+      const allStringLiterals = types.every((t) => t.flags & ts5.TypeFlags.StringLiteral);
       if (allStringLiterals) {
         const enumValues = types.map((t) => t.value);
         return { type: "string", enum: enumValues };
       }
-      const allNumberLiterals = types.every((t) => t.flags & ts4.TypeFlags.NumberLiteral);
+      const allNumberLiterals = types.every((t) => t.flags & ts5.TypeFlags.NumberLiteral);
       if (allNumberLiterals) {
         const enumValues = types.map((t) => t.value);
         return { type: "number", enum: enumValues };
       }
-      const allBooleanLiterals = types.every((t) => t.flags & ts4.TypeFlags.BooleanLiteral);
+      const allBooleanLiterals = types.every((t) => t.flags & ts5.TypeFlags.BooleanLiteral);
       if (allBooleanLiterals) {
         return { type: "boolean" };
       }
-      const isBoolLiteral = (t) => !!(t.flags & ts4.TypeFlags.BooleanLiteral);
+      const isBoolLiteral = (t) => !!(t.flags & ts5.TypeFlags.BooleanLiteral);
       let members = types;
       if (types.filter(isBoolLiteral).length === 2) {
         const firstBool = types.findIndex(isBoolLiteral);
@@ -3073,10 +3514,10 @@ function buildSchemaInternal(type, checker, ctx) {
       }
       return { anyOf: members.map(buildBranch) };
     }
-    const isIntersectionType = type.isIntersection() || !!(type.flags & ts4.TypeFlags.Intersection);
+    const isIntersectionType = type.isIntersection() || !!(type.flags & ts5.TypeFlags.Intersection);
     if (isIntersectionType && "types" in type) {
       const intersectionType = type;
-      const filteredTypes = intersectionType.types.filter((t) => !(t.flags & ts4.TypeFlags.Never));
+      const filteredTypes = intersectionType.types.filter((t) => !(t.flags & ts5.TypeFlags.Never));
       if (filteredTypes.length === 0) {
         return { type: "never" };
       }
@@ -3109,15 +3550,10 @@ function buildSchemaInternal(type, checker, ctx) {
       const arrayTypeArgs = checker.getTypeArguments(arrayTypeRef);
       const elementType = arrayTypeArgs?.[0];
       if (elementType) {
-        if (ctx) {
-          return withDepth(ctx, () => ({
-            type: "array",
-            items: buildSchema(elementType, checker, ctx)
-          }));
-        }
-        return { type: "array", items: buildSchema(elementType, checker, ctx) };
+        const build = () => withReadonlyArrayHint({ type: "array", items: buildSchema(elementType, checker, ctx) }, type, typeNode);
+        return ctx ? withDepth(ctx, build) : build();
       }
-      return { type: "array" };
+      return withReadonlyArrayHint({ type: "array" }, type, typeNode);
     }
     if (checker.isTupleType(type)) {
       const tupleTypeRef = type;
@@ -3191,7 +3627,7 @@ function buildSchemaInternal(type, checker, ctx) {
       if (BUILTIN_TYPES.has(name)) {
         return builtinSchema(name);
       }
-      if (RESOLVED_UTILITY_TYPES.has(name) && type.flags & ts4.TypeFlags.Object) {
+      if (RESOLVED_UTILITY_TYPES.has(name) && type.flags & ts5.TypeFlags.Object) {
         const props = type.getProperties();
         const hasIndex = checker.getIndexInfosOfType(type).length > 0;
         if (props.length > 0 || hasIndex) {
@@ -3229,7 +3665,7 @@ function buildSchemaInternal(type, checker, ctx) {
         return schema;
       }
     }
-    if (type.flags & ts4.TypeFlags.Object) {
+    if (type.flags & ts5.TypeFlags.Object) {
       const callSignatures = type.getCallSignatures();
       if (callSignatures.length > 0) {
         return buildFunctionSchema(callSignatures, checker, ctx);
@@ -3255,10 +3691,10 @@ function buildSchemaInternal(type, checker, ctx) {
         return schema;
       }
     }
-    if (type.flags & ts4.TypeFlags.Object) {
+    if (type.flags & ts5.TypeFlags.Object) {
       const objectType = type;
       const properties = type.getProperties();
-      if (properties.length > 0 || objectType.objectFlags & ts4.ObjectFlags.Anonymous || checker.getIndexInfosOfType(type).length > 0) {
+      if (properties.length > 0 || objectType.objectFlags & ts5.ObjectFlags.Anonymous || checker.getIndexInfosOfType(type).length > 0) {
         return buildObjectSchema(properties, checker, ctx, type);
       }
     }
@@ -3281,7 +3717,7 @@ function buildFunctionSchema(callSignatures, checker, ctx) {
         const effectiveType = isOptional ? stripUndefinedFromType(paramType, checker) : paramType;
         return {
           name: param.getName(),
-          schema: buildSchema(effectiveType, checker, ctx),
+          schema: buildSchema(effectiveType, checker, ctx, decl.type),
           required: !isOptional
         };
       });
@@ -3289,7 +3725,7 @@ function buildFunctionSchema(callSignatures, checker, ctx) {
       return {
         parameters: params,
         returns: {
-          schema: buildSchema(returnType, checker, ctx)
+          schema: buildSchema(returnType, checker, ctx, typeNodeOfSignature(sig))
         }
       };
     });
@@ -3302,8 +3738,8 @@ function buildFunctionSchema(callSignatures, checker, ctx) {
 }
 function buildObjectSchema(properties, checker, ctx, originalType) {
   const isArrayLikeType = originalType ? checker.isArrayType(originalType) || checker.isTupleType(originalType) || originalType.symbol?.getName() === "Array" && isBuiltinSymbol(originalType.symbol) : false;
-  const isStringLikeType = !!(originalType && originalType.flags & ts4.TypeFlags.StringLike);
-  const isNumberLikeType = !!(originalType && originalType.flags & ts4.TypeFlags.NumberLike);
+  const isStringLikeType = !!(originalType && originalType.flags & ts5.TypeFlags.StringLike);
+  const isNumberLikeType = !!(originalType && originalType.flags & ts5.TypeFlags.NumberLike);
   const buildProps = () => {
     const props = {};
     const required = [];
@@ -3320,10 +3756,11 @@ function buildObjectSchema(properties, checker, ctx, originalType) {
       if (isNumberLikeType && NUMBER_PROTOTYPE_METHODS.has(propName)) {
         continue;
       }
-      const isOptionalProp = !!(prop.flags & ts4.SymbolFlags.Optional);
+      const isOptionalProp = !!(prop.flags & ts5.SymbolFlags.Optional);
       const rawPropType = checker.getTypeOfSymbol(prop);
       const propType = isOptionalProp ? stripUndefinedFromType(rawPropType, checker) : rawPropType;
-      let propSchema = buildSchema(propType, checker, ctx);
+      const decl = prop.valueDeclaration ?? prop.getDeclarations()?.[0];
+      let propSchema = buildSchema(propType, checker, ctx, declaredTypeNode(decl));
       const docComment = prop.getDocumentationComment(checker);
       if (docComment.length > 0) {
         const description = docComment.map((c) => c.text).join(`
@@ -3338,7 +3775,7 @@ function buildObjectSchema(properties, checker, ctx, originalType) {
       }
       propSchema = decoratePropertySchema(propSchema, prop, propType, checker);
       props[propName] = propSchema;
-      if (!(prop.flags & ts4.SymbolFlags.Optional)) {
+      if (!(prop.flags & ts5.SymbolFlags.Optional)) {
         required.push(propName);
       }
     }
@@ -3348,11 +3785,11 @@ function buildObjectSchema(properties, checker, ctx, originalType) {
       ...required.length > 0 ? { required } : {}
     };
     const indexInfos = originalType ? checker.getIndexInfosOfType(originalType) : [];
-    const stringIndex = indexInfos.find((i) => i.keyType.flags & ts4.TypeFlags.String);
+    const stringIndex = indexInfos.find((i) => i.keyType.flags & ts5.TypeFlags.String);
     if (stringIndex) {
       schema.additionalProperties = buildSchema(stringIndex.type, checker, ctx);
     }
-    const numberIndex = indexInfos.find((i) => i.keyType.flags & ts4.TypeFlags.Number);
+    const numberIndex = indexInfos.find((i) => i.keyType.flags & ts5.TypeFlags.Number);
     if (numberIndex) {
       schema.patternProperties = {
         "^\\d+$": buildSchema(numberIndex.type, checker, ctx)
@@ -3441,7 +3878,7 @@ function deduplicateSchemas(schemas) {
 function findDiscriminatorProperty(unionTypes, checker) {
   const memberProps = [];
   for (const t of unionTypes) {
-    if (t.flags & (ts4.TypeFlags.Null | ts4.TypeFlags.Undefined)) {
+    if (t.flags & (ts5.TypeFlags.Null | ts5.TypeFlags.Undefined)) {
       continue;
     }
     const props = t.getProperties();
@@ -3495,24 +3932,27 @@ function extractParameters(signature, ctx) {
   const { typeChecker: checker } = ctx;
   const result = [];
   const signatureDecl = signature.getDeclaration();
-  const jsdocTags = signatureDecl ? ts5.getJSDocTags(signatureDecl) : [];
+  const jsdocTags = signatureDecl ? ts6.getJSDocTags(signatureDecl) : [];
   for (const param of signature.getParameters()) {
     const decl = param.valueDeclaration;
     if (!decl)
       continue;
-    const type = checker.getTypeOfSymbolAtLocation(param, decl);
-    if (decl && ts5.isObjectBindingPattern(decl.name)) {
-      const expandedParams = expandBindingPattern(decl, type, jsdocTags, ctx);
+    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 effectiveType = isOptional ? stripUndefinedFromType(type, checker) : type;
-      registerReferencedTypes(effectiveType, ctx);
       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: buildSchema(effectiveType, checker, ctx),
+        schema,
         required: !isOptional
       };
       if (description) {
@@ -3536,20 +3976,20 @@ function expandBindingPattern(paramDecl, paramType, jsdocTags, ctx) {
   const allProperties = getEffectiveProperties(paramType, checker);
   const inferredAlias = inferParamAlias(jsdocTags);
   for (const element of bindingPattern.elements) {
-    if (!ts5.isBindingElement(element))
+    if (!ts6.isBindingElement(element))
       continue;
-    const propertyName = element.propertyName ? ts5.isIdentifier(element.propertyName) ? element.propertyName.text : element.propertyName.getText() : ts5.isIdentifier(element.name) ? element.name.text : element.name.getText();
+    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 & ts5.SymbolFlags.Optional) || element.initializer !== undefined;
+    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),
+      schema: buildSchema(effectiveType, checker, ctx, declaredTypeNode(propSymbol.valueDeclaration)),
       required: !isOptional
     };
     if (description) {
@@ -3585,7 +4025,7 @@ function inferParamAlias(jsdocTags) {
   for (const tag of jsdocTags) {
     if (tag.tagName.text !== "param")
       continue;
-    const tagText = typeof tag.comment === "string" ? tag.comment : ts5.getTextOfJSDocComment(tag.comment) ?? "";
+    const tagText = typeof tag.comment === "string" ? tag.comment : ts6.getTextOfJSDocComment(tag.comment) ?? "";
     const paramTag = tag;
     const paramName = paramTag.name?.getText() ?? "";
     if (paramName.includes(".")) {
@@ -3608,22 +4048,22 @@ function inferParamAlias(jsdocTags) {
   return Array.from(counts.entries()).sort((a, b) => b[1] - a[1])[0]?.[0];
 }
 function extractLiteralDefault(initializer) {
-  if (ts5.isStringLiteral(initializer)) {
+  if (ts6.isStringLiteral(initializer)) {
     return { literal: true, value: initializer.text };
   }
-  if (ts5.isNumericLiteral(initializer)) {
+  if (ts6.isNumericLiteral(initializer)) {
     return { literal: true, value: Number(initializer.text) };
   }
-  if (ts5.isPrefixUnaryExpression(initializer) && initializer.operator === ts5.SyntaxKind.MinusToken && ts5.isNumericLiteral(initializer.operand)) {
+  if (ts6.isPrefixUnaryExpression(initializer) && initializer.operator === ts6.SyntaxKind.MinusToken && ts6.isNumericLiteral(initializer.operand)) {
     return { literal: true, value: -Number(initializer.operand.text) };
   }
-  if (initializer.kind === ts5.SyntaxKind.TrueKeyword) {
+  if (initializer.kind === ts6.SyntaxKind.TrueKeyword) {
     return { literal: true, value: true };
   }
-  if (initializer.kind === ts5.SyntaxKind.FalseKeyword) {
+  if (initializer.kind === ts6.SyntaxKind.FalseKeyword) {
     return { literal: true, value: false };
   }
-  if (initializer.kind === ts5.SyntaxKind.NullKeyword) {
+  if (initializer.kind === ts6.SyntaxKind.NullKeyword) {
     return { literal: true, value: null };
   }
   return { literal: false, text: initializer.getText() };
@@ -3635,8 +4075,11 @@ function applyDefault(param, initializer) {
     if (param.schema && typeof param.schema === "object" && !Array.isArray(param.schema)) {
       param.schema.default = extracted.value;
     }
-  } else if (param.schema && typeof param.schema === "object" && !Array.isArray(param.schema)) {
-    param.schema["x-ts-default"] = extracted.text;
+  } 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) {
@@ -3644,7 +4087,7 @@ function registerReferencedTypes(type, ctx, depth = 0) {
     return;
   if (ctx.registeredTypes.has(type))
     return;
-  const isPrimitive = type.flags & (ts5.TypeFlags.String | ts5.TypeFlags.Number | ts5.TypeFlags.Boolean | ts5.TypeFlags.Void | ts5.TypeFlags.Undefined | ts5.TypeFlags.Null | ts5.TypeFlags.Any | ts5.TypeFlags.Unknown | ts5.TypeFlags.Never | ts5.TypeFlags.StringLiteral | ts5.TypeFlags.NumberLiteral | ts5.TypeFlags.BooleanLiteral);
+  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);
   }
@@ -3673,7 +4116,10 @@ function registerReferencedTypes(type, ctx, depth = 0) {
   if (isForeignPackage(typeSymbol, ctx.workspacePackages)) {
     return;
   }
-  if (type.flags & ts5.TypeFlags.Object) {
+  if (isDeferredMappedOrConditional(type)) {
+    return;
+  }
+  if (type.flags & ts6.TypeFlags.Object) {
     const props = type.getProperties();
     const limit = ctx.maxProperties;
     if (props.length > limit && ctx.onTruncation) {
@@ -3688,10 +4134,10 @@ function registerReferencedTypes(type, ctx, depth = 0) {
 }
 
 // src/serializers/context.ts
-import ts7 from "typescript";
+import ts8 from "typescript";
 
 // src/ast/registry.ts
-import ts6 from "typescript";
+import ts7 from "typescript";
 var BUILTINS = new Set([
   "Array",
   "ArrayBuffer",
@@ -3788,9 +4234,10 @@ class TypeRegistry {
     return this.types.size;
   }
   registerType(type, ctx) {
-    const symbol = type.aliasSymbol || type.getSymbol();
-    if (!symbol)
+    const rawSymbol = type.aliasSymbol || type.getSymbol();
+    if (!rawSymbol)
       return;
+    const symbol = resolveAliasSymbol(rawSymbol, ctx.typeChecker, undefined, ctx.program);
     const name = symbol.getName();
     if (PRIMITIVES.has(name))
       return;
@@ -3800,13 +4247,13 @@ class TypeRegistry {
       return;
     if (name.startsWith('"'))
       return;
-    if (symbol.flags & ts6.SymbolFlags.EnumMember)
+    if (symbol.flags & ts7.SymbolFlags.EnumMember)
       return;
-    if (symbol.flags & ts6.SymbolFlags.TypeParameter)
+    if (symbol.flags & ts7.SymbolFlags.TypeParameter)
       return;
-    if (symbol.flags & ts6.SymbolFlags.Method)
+    if (symbol.flags & ts7.SymbolFlags.Method)
       return;
-    if (symbol.flags & ts6.SymbolFlags.Function)
+    if (symbol.flags & ts7.SymbolFlags.Function)
       return;
     if (isGenericTypeParameter(name))
       return;
@@ -3829,7 +4276,7 @@ class TypeRegistry {
       });
       return id;
     };
-    if (ctx.shouldExpandExternal && !ctx.shouldExpandExternal(symbol)) {
+    if (symbol.declarations?.[0] && ctx.shouldExpandExternal && !ctx.shouldExpandExternal(symbol)) {
       return stubExternal();
     }
     if (this.types.size >= MAX_REGISTERED_TYPES) {
@@ -3856,11 +4303,11 @@ class TypeRegistry {
     let kind = "type";
     const external = decl ? isExternalType(decl) : false;
     if (decl) {
-      if (ts6.isClassDeclaration(decl))
+      if (ts7.isClassDeclaration(decl))
         kind = "class";
-      else if (ts6.isInterfaceDeclaration(decl))
+      else if (ts7.isInterfaceDeclaration(decl))
         kind = "interface";
-      else if (ts6.isEnumDeclaration(decl))
+      else if (ts7.isEnumDeclaration(decl))
         kind = "enum";
     }
     if (external) {
@@ -3876,8 +4323,8 @@ class TypeRegistry {
         schema = enumSchema;
       }
     }
-    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 (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 (!PRIMITIVES.has(text) && text !== name) {
         schema["x-ts-type"] = text;
         const declared = writtenTypeText(declaredTypeNode(decl));
@@ -3887,7 +4334,7 @@ class TypeRegistry {
       }
     }
     let typeParameters;
-    if (decl && (ts6.isTypeAliasDeclaration(decl) || ts6.isInterfaceDeclaration(decl) || ts6.isClassDeclaration(decl))) {
+    if (decl && (ts7.isTypeAliasDeclaration(decl) || ts7.isInterfaceDeclaration(decl) || ts7.isClassDeclaration(decl))) {
       typeParameters = extractTypeParameters(decl, checker);
     }
     return {
@@ -3908,14 +4355,14 @@ class TypeRegistry {
   resolveSelRefSchema(type, checker, ctx) {
     if (type.isUnion()) {
       const types = type.types;
-      const allStringLiterals = types.every((t) => t.flags & ts6.TypeFlags.StringLiteral);
+      const allStringLiterals = types.every((t) => t.flags & ts7.TypeFlags.StringLiteral);
       if (allStringLiterals) {
         return {
           type: "string",
           enum: types.map((t) => t.value)
         };
       }
-      const allNumberLiterals = types.every((t) => t.flags & ts6.TypeFlags.NumberLiteral);
+      const allNumberLiterals = types.every((t) => t.flags & ts7.TypeFlags.NumberLiteral);
       if (allNumberLiterals) {
         return {
           type: "number",
@@ -3950,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 & ts6.TypeFlags.Conditional) {
+    if (type.flags & ts7.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;
+    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) };
     }
     return this.buildObjectSchemaFromProperties(type, checker, ctx);
   }
   buildEnumSchema(symbol, checker) {
-    const decl = symbol.declarations?.find(ts6.isEnumDeclaration);
+    const decl = symbol.declarations?.find(ts7.isEnumDeclaration);
     if (!decl)
       return;
     const members = [];
@@ -3988,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 & ts6.TypeFlags.String);
-    const numberIndex = indexInfos.find((i) => i.keyType.flags & ts6.TypeFlags.Number);
+    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) };
     }
@@ -3997,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 & ts6.TypeFlags.StringLike;
-    const isNumberLike = type.flags & ts6.TypeFlags.NumberLike;
+    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("__@"))
@@ -4018,9 +4465,9 @@ class TypeRegistry {
     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;
+      const propType = prop.flags & ts7.SymbolFlags.Optional ? stripUndefinedFromType(rawPropType, checker) : rawPropType;
       this.registerType(propType, ctx);
-      let propSchema = buildSchema(propType, checker, 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(`
@@ -4035,7 +4482,7 @@ class TypeRegistry {
       }
       propSchema = decoratePropertySchema(propSchema, prop, propType, checker);
       props[propName] = propSchema;
-      if (!(prop.flags & ts6.SymbolFlags.Optional)) {
+      if (!(prop.flags & ts7.SymbolFlags.Optional)) {
         required.push(propName);
       }
     }
@@ -4071,7 +4518,10 @@ function createContext(program, sourceFile, options = {}) {
     typeIds: new Map,
     declIds: new Map,
     idOwner: new Map,
-    workspacePackages: options.workspacePackages ?? new Map
+    workspacePackages: options.workspacePackages ?? new Map,
+    schemaOps: 0,
+    maxSchemaOps: 20000,
+    budgetExceeded: false
   };
 }
 function getInheritedMembers(classType, ownMemberNames, ctx, isStatic = false) {
@@ -4140,15 +4590,15 @@ function serializeInheritedMember(symbol, inheritedFrom, ctx, isStatic) {
   const type = checker.getTypeOfSymbol(symbol);
   registerReferencedTypes(type, ctx);
   let visibility;
-  if (decl && ts7.canHaveModifiers(decl)) {
-    const modifiers = ts7.getModifiers(decl);
+  if (decl && ts8.canHaveModifiers(decl)) {
+    const modifiers = ts8.getModifiers(decl);
     if (modifiers) {
       for (const mod of modifiers) {
-        if (mod.kind === ts7.SyntaxKind.PrivateKeyword)
+        if (mod.kind === ts8.SyntaxKind.PrivateKeyword)
           visibility = "private";
-        else if (mod.kind === ts7.SyntaxKind.ProtectedKeyword)
+        else if (mod.kind === ts8.SyntaxKind.ProtectedKeyword)
           visibility = "protected";
-        else if (mod.kind === ts7.SyntaxKind.PublicKeyword)
+        else if (mod.kind === ts8.SyntaxKind.PublicKeyword)
           visibility = "public";
       }
     }
@@ -4160,17 +4610,17 @@ function serializeInheritedMember(symbol, inheritedFrom, ctx, isStatic) {
   const callSigs = type.getCallSignatures();
   if (callSigs.length > 0) {
     kind = "method";
-  } else if (ts7.isGetAccessorDeclaration(decl)) {
+  } else if (ts8.isGetAccessorDeclaration(decl)) {
     kind = "getter";
-  } else if (ts7.isSetAccessorDeclaration(decl)) {
+  } else if (ts8.isSetAccessorDeclaration(decl)) {
     kind = "setter";
   }
   const flags = {};
   if (isStatic)
     flags.static = true;
-  if (decl && ts7.canHaveModifiers(decl)) {
-    const modifiers = ts7.getModifiers(decl);
-    if (modifiers?.some((m) => m.kind === ts7.SyntaxKind.ReadonlyKeyword)) {
+  if (decl && ts8.canHaveModifiers(decl)) {
+    const modifiers = ts8.getModifiers(decl);
+    if (modifiers?.some((m) => m.kind === ts8.SyntaxKind.ReadonlyKeyword)) {
       flags.readonly = true;
     }
   }
@@ -4184,7 +4634,7 @@ function serializeInheritedMember(symbol, inheritedFrom, ctx, isStatic) {
       return {
         parameters: params.length > 0 ? params : undefined,
         returns: {
-          schema: buildSchema(returnType, checker, ctx)
+          schema: buildSchema(returnType, checker, ctx, typeNodeOfSignature(sig))
         },
         ...sigDoc.description ? { description: sigDoc.description } : {},
         ...sigDoc.tags.length > 0 ? { tags: sigDoc.tags } : {},
@@ -4200,7 +4650,7 @@ function serializeInheritedMember(symbol, inheritedFrom, ctx, isStatic) {
     description,
     tags: tags.length > 0 ? tags : undefined,
     visibility,
-    schema: kind !== "method" ? buildSchema(type, checker, ctx) : decoratePropertySchema({ "x-ts-function": true }, symbol, type, checker),
+    schema: kind !== "method" ? buildSchema(type, checker, ctx, declaredTypeNode(decl)) : decoratePropertySchema({ "x-ts-function": true }, symbol, type, checker),
     signatures,
     flags: Object.keys(flags).length > 0 ? flags : undefined,
     ...inlineTags ? { inlineTags } : {}
@@ -4223,7 +4673,7 @@ function buildSignatures(callSignatures, checker, ctx) {
     const sigTypeParams = extractTypeParametersFromSignature(sig, checker);
     return {
       parameters: params.length > 0 ? params : undefined,
-      returns: { schema: buildSchema(returnType, checker, ctx) },
+      returns: { schema: buildSchema(returnType, checker, ctx, typeNodeOfSignature(sig)) },
       ...sigDoc.description ? { description: sigDoc.description } : {},
       ...sigDoc.tags.length > 0 ? { tags: sigDoc.tags } : {},
       ...sigDoc.examples.length > 0 ? { examples: sigDoc.examples } : {},
@@ -4250,11 +4700,11 @@ function serializeClass(node, ctx) {
     const memberName = getMemberName(member);
     if (memberName?.startsWith("#"))
       continue;
-    if (ts8.isPropertyDeclaration(member)) {
+    if (ts9.isPropertyDeclaration(member)) {
       const propMember = serializeProperty(member, ctx);
       if (propMember)
         members.push(propMember);
-    } else if (ts8.isMethodDeclaration(member)) {
+    } else if (ts9.isMethodDeclaration(member)) {
       const methodMember = serializeMethod(member, ctx);
       if (methodMember?.name) {
         if (!methodsByName.has(methodMember.name)) {
@@ -4271,11 +4721,11 @@ function serializeClass(node, ctx) {
           }
         }
       }
-    } else if (ts8.isConstructorDeclaration(member)) {
+    } else if (ts9.isConstructorDeclaration(member)) {
       const ctorSig = serializeConstructor(member, ctx);
       if (ctorSig)
         signatures.push(ctorSig);
-    } else if (ts8.isGetAccessorDeclaration(member) || ts8.isSetAccessorDeclaration(member)) {
+    } else if (ts9.isGetAccessorDeclaration(member) || ts9.isSetAccessorDeclaration(member)) {
       const accessorMember = serializeAccessor(member, ctx);
       if (accessorMember)
         members.push(accessorMember);
@@ -4299,8 +4749,8 @@ function serializeClass(node, ctx) {
   const extendsClause = getExtendsClause(node, checker);
   const implementsClause = getImplementsClause(node, checker);
   const classFlags = {};
-  const classModifiers = ts8.getModifiers(node);
-  if (classModifiers?.some((m) => m.kind === ts8.SyntaxKind.AbstractKeyword)) {
+  const classModifiers = ts9.getModifiers(node);
+  if (classModifiers?.some((m) => m.kind === ts9.SyntaxKind.AbstractKeyword)) {
     classFlags.abstract = true;
   }
   return {
@@ -4322,37 +4772,37 @@ function serializeClass(node, ctx) {
   };
 }
 function getMemberName(member) {
-  if (ts8.isConstructorDeclaration(member))
+  if (ts9.isConstructorDeclaration(member))
     return "constructor";
   if (!member.name)
     return;
-  if (ts8.isIdentifier(member.name))
+  if (ts9.isIdentifier(member.name))
     return member.name.text;
-  if (ts8.isPrivateIdentifier(member.name))
+  if (ts9.isPrivateIdentifier(member.name))
     return member.name.text;
   return member.name.getText();
 }
 function getVisibility(member) {
-  const modifiers = ts8.canHaveModifiers(member) ? ts8.getModifiers(member) : undefined;
+  const modifiers = ts9.canHaveModifiers(member) ? ts9.getModifiers(member) : undefined;
   if (!modifiers)
     return;
   for (const mod of modifiers) {
-    if (mod.kind === ts8.SyntaxKind.PrivateKeyword)
+    if (mod.kind === ts9.SyntaxKind.PrivateKeyword)
       return "private";
-    if (mod.kind === ts8.SyntaxKind.ProtectedKeyword)
+    if (mod.kind === ts9.SyntaxKind.ProtectedKeyword)
       return "protected";
-    if (mod.kind === ts8.SyntaxKind.PublicKeyword)
+    if (mod.kind === ts9.SyntaxKind.PublicKeyword)
       return "public";
   }
   return;
 }
 function isStatic(member) {
-  const modifiers = ts8.canHaveModifiers(member) ? ts8.getModifiers(member) : undefined;
-  return modifiers?.some((m) => m.kind === ts8.SyntaxKind.StaticKeyword) ?? false;
+  const modifiers = ts9.canHaveModifiers(member) ? ts9.getModifiers(member) : undefined;
+  return modifiers?.some((m) => m.kind === ts9.SyntaxKind.StaticKeyword) ?? false;
 }
 function isReadonly(member) {
-  const modifiers = ts8.canHaveModifiers(member) ? ts8.getModifiers(member) : undefined;
-  return modifiers?.some((m) => m.kind === ts8.SyntaxKind.ReadonlyKeyword) ?? false;
+  const modifiers = ts9.canHaveModifiers(member) ? ts9.getModifiers(member) : undefined;
+  return modifiers?.some((m) => m.kind === ts9.SyntaxKind.ReadonlyKeyword) ?? false;
 }
 function serializeProperty(node, ctx) {
   const { typeChecker: checker } = ctx;
@@ -4367,7 +4817,7 @@ function serializeProperty(node, ctx) {
   const rawType = checker.getTypeAtLocation(node);
   const type = node.questionToken ? stripUndefinedFromType(rawType, checker) : rawType;
   registerReferencedTypes(type, ctx);
-  let schema = buildSchema(type, checker, ctx);
+  let schema = buildSchema(type, checker, ctx, node.type);
   const flags = {};
   if (isStatic(node))
     flags.static = true;
@@ -4411,11 +4861,11 @@ function serializeMethod(node, ctx) {
   if (node.asteriskToken)
     flags.generator = true;
   flags.methodSyntax = true;
-  const modifiers = ts8.getModifiers(node);
-  if (modifiers?.some((m) => m.kind === ts8.SyntaxKind.AsyncKeyword)) {
+  const modifiers = ts9.getModifiers(node);
+  if (modifiers?.some((m) => m.kind === ts9.SyntaxKind.AsyncKeyword)) {
     flags.async = true;
   }
-  if (modifiers?.some((m) => m.kind === ts8.SyntaxKind.AbstractKeyword)) {
+  if (modifiers?.some((m) => m.kind === ts9.SyntaxKind.AbstractKeyword)) {
     flags.abstract = true;
   }
   const symbol = checker.getSymbolAtLocation(node.name ?? node);
@@ -4454,7 +4904,7 @@ function serializeConstructorSignature(node, sig, ctx) {
 }
 function serializeInheritedConstructors(node, ctx) {
   const { typeChecker: checker } = ctx;
-  const hasExtends = node.heritageClauses?.some((c) => c.token === ts8.SyntaxKind.ExtendsKeyword);
+  const hasExtends = node.heritageClauses?.some((c) => c.token === ts9.SyntaxKind.ExtendsKeyword);
   if (!hasExtends)
     return [];
   const symbol = checker.getSymbolAtLocation(node.name ?? node);
@@ -4463,11 +4913,11 @@ function serializeInheritedConstructors(node, ctx) {
   const staticType = checker.getTypeOfSymbolAtLocation(symbol, node);
   const ctorSigs = staticType.getConstructSignatures().filter((sig) => {
     const decl = sig.getDeclaration();
-    return decl !== undefined && ts8.isConstructorDeclaration(decl);
+    return decl !== undefined && ts9.isConstructorDeclaration(decl);
   });
   return ctorSigs.map((sig, index) => {
     const decl = sig.getDeclaration();
-    const owner = ts8.isClassLike(decl.parent) ? decl.parent.name?.text : undefined;
+    const owner = ts9.isClassLike(decl.parent) ? decl.parent.name?.text : undefined;
     return {
       ...serializeConstructorSignature(decl, sig, ctx),
       ...owner ? { inheritedFrom: owner } : {},
@@ -4486,14 +4936,14 @@ function serializeAccessor(node, ctx) {
     return null;
   }
   const type = checker.getTypeAtLocation(node);
-  const schema = buildSchema(type, checker, ctx);
+  const schema = buildSchema(type, checker, ctx, ts9.isGetAccessorDeclaration(node) ? node.type : undefined);
   registerReferencedTypes(type, ctx);
-  const kind = ts8.isGetAccessorDeclaration(node) ? "getter" : "setter";
+  const kind = ts9.isGetAccessorDeclaration(node) ? "getter" : "setter";
   const flags = {};
   if (isStatic(node))
     flags.static = true;
   let signatures;
-  if (ts8.isSetAccessorDeclaration(node) && node.parameters.length > 0) {
+  if (ts9.isSetAccessorDeclaration(node) && node.parameters.length > 0) {
     const param = node.parameters[0];
     const paramName = param.name.getText();
     const paramType = checker.getTypeAtLocation(param);
@@ -4503,7 +4953,7 @@ function serializeAccessor(node, ctx) {
         parameters: [
           {
             name: paramName,
-            schema: buildSchema(paramType, checker, ctx),
+            schema: buildSchema(paramType, checker, ctx, param.type),
             required: true
           }
         ]
@@ -4526,7 +4976,7 @@ function getExtendsClause(node, checker) {
   if (!node.heritageClauses)
     return;
   for (const clause of node.heritageClauses) {
-    if (clause.token === ts8.SyntaxKind.ExtendsKeyword) {
+    if (clause.token === ts9.SyntaxKind.ExtendsKeyword) {
       const expr = clause.types[0];
       if (expr) {
         const type = checker.getTypeAtLocation(expr);
@@ -4541,7 +4991,7 @@ function getImplementsClause(node, checker) {
   if (!node.heritageClauses)
     return;
   for (const clause of node.heritageClauses) {
-    if (clause.token === ts8.SyntaxKind.ImplementsKeyword) {
+    if (clause.token === ts9.SyntaxKind.ImplementsKeyword) {
       return clause.types.map((expr) => {
         const type = checker.getTypeAtLocation(expr);
         const symbol = type.getSymbol();
@@ -4604,16 +5054,16 @@ function serializeEnum(node, ctx) {
 }
 
 // src/serializers/functions.ts
-import ts9 from "typescript";
+import ts10 from "typescript";
 function buildReturnSchema(sig, ctx) {
   const returnType = ctx.typeChecker.getReturnTypeOfSignature(sig);
   registerReferencedTypes(returnType, ctx);
-  const schema = buildSchema(returnType, ctx.typeChecker, ctx);
+  const schema = buildSchema(returnType, ctx.typeChecker, ctx, typeNodeOfSignature(sig));
   const declaration = sig.getDeclaration();
-  if (declaration && ts9.isFunctionLike(declaration) && declaration.type) {
+  if (declaration && ts10.isFunctionLike(declaration) && declaration.type) {
     const returnTypeNode = declaration.type;
-    if (ts9.isTypePredicateNode(returnTypeNode)) {
-      const parameterName = ts9.isIdentifier(returnTypeNode.parameterName) ? returnTypeNode.parameterName.text : returnTypeNode.parameterName.getText();
+    if (ts10.isTypePredicateNode(returnTypeNode)) {
+      const parameterName = ts10.isIdentifier(returnTypeNode.parameterName) ? returnTypeNode.parameterName.text : returnTypeNode.parameterName.getText();
       let predicateTypeSchema = { type: "unknown" };
       if (returnTypeNode.type) {
         const predicateType = ctx.typeChecker.getTypeAtLocation(returnTypeNode.type);
@@ -4633,21 +5083,82 @@ function buildReturnSchema(sig, ctx) {
   }
   return { schema };
 }
-function serializeFunctionExport(node, ctx, nameOverride) {
-  const symbol = ctx.typeChecker.getSymbolAtLocation(node.name ?? node);
-  const name = nameOverride ?? symbol?.getName() ?? node.name?.getText();
-  if (!name)
-    return null;
-  const { description, tags, examples, source, deprecated, deprecationReason, inlineTags } = extractExportMetadata(node, symbol, ctx.typeChecker);
-  const typeParameters = extractTypeParameters(node, ctx.typeChecker);
+function functionSignatureDecls(node, ctx) {
+  if (!ts10.isFunctionDeclaration(node) || !node.name)
+    return [node];
+  const symbol = ctx.typeChecker.getSymbolAtLocation(node.name);
+  const fns = (symbol?.declarations ?? []).filter(ts10.isFunctionDeclaration);
+  const overloads = fns.filter((d) => !d.body);
+  return overloads.length > 0 ? overloads : [node];
+}
+function signatureDeclDefers(decl, ctx) {
+  const checker = ctx.typeChecker;
+  if (decl.typeParameters) {
+    for (const tp of decl.typeParameters) {
+      if (typeNodeDefersExpansion(tp.constraint, checker, ctx.program))
+        return true;
+      if (typeNodeDefersExpansion(tp.default, checker, ctx.program))
+        return true;
+    }
+  }
+  for (const p of decl.parameters) {
+    if (typeNodeDefersExpansion(p.type, checker, ctx.program))
+      return true;
+  }
+  return typeNodeDefersExpansion(decl.type, checker, ctx.program);
+}
+function anySignatureDefers(node, ctx) {
+  return functionSignatureDecls(node, ctx).some((d) => signatureDeclDefers(d, ctx));
+}
+function schemaFromTypeNode(node, ctx) {
+  if (!node)
+    return { type: "unknown" };
+  if (typeNodeDefersExpansion(node, ctx.typeChecker, ctx.program)) {
+    return buildSchemaFromTypeNode(node, ctx.typeChecker, ctx);
+  }
+  return buildSchema(ctx.typeChecker.getTypeFromTypeNode(node), ctx.typeChecker, ctx, node);
+}
+function parametersFromAst(decl, ctx) {
+  const jsdocTags = ts10.getJSDocTags(decl);
+  return decl.parameters.map((p) => {
+    const name = ts10.isIdentifier(p.name) ? p.name.text : p.name.getText();
+    const isOptional = !!p.questionToken || !!p.initializer;
+    const param = {
+      name,
+      schema: schemaFromTypeNode(p.type, ctx),
+      required: !isOptional
+    };
+    const description = getParamDescription(name, jsdocTags);
+    if (description)
+      param.description = description;
+    return param;
+  });
+}
+function signaturesFromAst(node, ctx) {
+  const decls = functionSignatureDecls(node, ctx);
+  return decls.map((decl, index) => {
+    const sigDoc = getJSDocComment(decl);
+    const sigTypeParams = ts10.isFunctionDeclaration(decl) || ts10.isArrowFunction(decl) || ts10.isFunctionExpression(decl) ? extractTypeParameters(decl, ctx.typeChecker) : undefined;
+    const returns = { schema: schemaFromTypeNode(decl.type, ctx) };
+    return {
+      parameters: parametersFromAst(decl, ctx),
+      returns,
+      ...sigDoc.description ? { description: sigDoc.description } : {},
+      ...sigDoc.tags.length > 0 ? { tags: sigDoc.tags } : {},
+      ...sigDoc.examples.length > 0 ? { examples: sigDoc.examples } : {},
+      ...sigTypeParams ? { typeParameters: sigTypeParams } : {},
+      ...decls.length > 1 ? { overloadIndex: index } : {}
+    };
+  });
+}
+function signaturesFromChecker(node, ctx) {
   const type = ctx.typeChecker.getTypeAtLocation(node);
   const callSignatures = type.getCallSignatures();
-  const signatures = callSignatures.map((sig, index) => {
-    const params = extractParameters(sig, ctx);
+  return callSignatures.map((sig, index) => {
     const sigDoc = getJSDocForSignature(sig, ctx.typeChecker);
     const sigTypeParams = extractTypeParametersFromSignature(sig, ctx.typeChecker);
     return {
-      parameters: params,
+      parameters: extractParameters(sig, ctx),
       returns: buildReturnSchema(sig, ctx),
       ...sigDoc.description ? { description: sigDoc.description } : {},
       ...sigDoc.tags.length > 0 ? { tags: sigDoc.tags } : {},
@@ -4656,9 +5167,18 @@ function serializeFunctionExport(node, ctx, nameOverride) {
       ...callSignatures.length > 1 ? { overloadIndex: index } : {}
     };
   });
+}
+function serializeFunctionExport(node, ctx, nameOverride) {
+  const symbol = ctx.typeChecker.getSymbolAtLocation(node.name ?? node);
+  const name = nameOverride ?? symbol?.getName() ?? node.name?.getText();
+  if (!name)
+    return null;
+  const { description, tags, examples, source, deprecated, deprecationReason, inlineTags } = extractExportMetadata(node, symbol, ctx.typeChecker);
+  const typeParameters = extractTypeParameters(node, ctx.typeChecker);
+  const signatures = anySignatureDefers(node, ctx) ? signaturesFromAst(node, ctx) : signaturesFromChecker(node, ctx);
   const flags = {};
-  const modifiers = ts9.getModifiers(node);
-  if (modifiers?.some((m) => m.kind === ts9.SyntaxKind.AsyncKeyword)) {
+  const modifiers = ts10.getModifiers(node);
+  if (modifiers?.some((m) => m.kind === ts10.SyntaxKind.AsyncKeyword)) {
     flags.async = true;
   }
   if (node.asteriskToken) {
@@ -4681,7 +5201,7 @@ function serializeFunctionExport(node, ctx, nameOverride) {
 }
 
 // src/serializers/interfaces.ts
-import ts10 from "typescript";
+import ts11 from "typescript";
 function serializeInterface(node, ctx) {
   const { typeChecker: checker } = ctx;
   const symbol = checker.getSymbolAtLocation(node.name ?? node);
@@ -4694,11 +5214,11 @@ function serializeInterface(node, ctx) {
   const methodsByName = new Map;
   let callSignatureMember = null;
   for (const member of node.members) {
-    if (ts10.isPropertySignature(member)) {
+    if (ts11.isPropertySignature(member)) {
       const propMember = serializePropertySignature(member, ctx);
       if (propMember)
         members.push(propMember);
-    } else if (ts10.isMethodSignature(member)) {
+    } else if (ts11.isMethodSignature(member)) {
       const methodMember = serializeMethodSignature(member, ctx);
       if (methodMember?.name && methodMember.signatures) {
         const existing = methodsByName.get(methodMember.name);
@@ -4719,7 +5239,7 @@ function serializeInterface(node, ctx) {
           methodsByName.set(methodMember.name, methodMember);
         }
       }
-    } else if (ts10.isCallSignatureDeclaration(member)) {
+    } else if (ts11.isCallSignatureDeclaration(member)) {
       const callSig = serializeCallSignature(member, ctx);
       if (callSig?.signatures) {
         if (callSignatureMember?.signatures) {
@@ -4742,7 +5262,7 @@ function serializeInterface(node, ctx) {
           callSignatureMember = callSig;
         }
       }
-    } else if (ts10.isIndexSignatureDeclaration(member)) {
+    } else if (ts11.isIndexSignatureDeclaration(member)) {
       const indexMember = serializeIndexSignature(member, ctx);
       if (indexMember)
         members.push(indexMember);
@@ -4776,12 +5296,12 @@ function serializePropertySignature(node, ctx) {
   const { description, tags, inlineTags } = getJSDocComment(node);
   const rawType = checker.getTypeAtLocation(node);
   const type = node.questionToken ? stripUndefinedFromType(rawType, checker) : rawType;
-  let schema = buildSchema(type, checker, ctx);
+  let schema = buildSchema(type, checker, ctx, node.type);
   registerReferencedTypes(type, ctx);
   const flags = {};
   if (node.questionToken)
     flags.optional = true;
-  if (node.modifiers?.some((m) => m.kind === ts10.SyntaxKind.ReadonlyKeyword)) {
+  if (node.modifiers?.some((m) => m.kind === ts11.SyntaxKind.ReadonlyKeyword)) {
     flags.readonly = true;
   }
   const symbol = checker.getSymbolAtLocation(node.name);
@@ -4845,7 +5365,7 @@ function serializeCallSignature(node, ctx) {
       {
         parameters: params.length > 0 ? params : undefined,
         returns: {
-          schema: buildSchema(returnType, checker, ctx)
+          schema: buildSchema(returnType, checker, ctx, node.type)
         }
       }
     ]
@@ -4855,7 +5375,7 @@ function serializeIndexSignature(node, ctx) {
   const { typeChecker: checker } = ctx;
   const { description, tags, inlineTags } = getJSDocComment(node);
   const valueType = node.type ? checker.getTypeAtLocation(node.type) : checker.getAnyType();
-  const valueSchema = buildSchema(valueType, checker, ctx);
+  const valueSchema = buildSchema(valueType, checker, ctx, node.type);
   registerReferencedTypes(valueType, ctx);
   const keyParam = node.parameters[0];
   const keyType = keyParam?.type ? checker.getTypeAtLocation(keyParam.type) : checker.getStringType();
@@ -4873,7 +5393,7 @@ function getInterfaceExtends(node, checker) {
   if (!node.heritageClauses)
     return;
   for (const clause of node.heritageClauses) {
-    if (clause.token === ts10.SyntaxKind.ExtendsKeyword && clause.types.length > 0) {
+    if (clause.token === ts11.SyntaxKind.ExtendsKeyword && clause.types.length > 0) {
       const names = clause.types.map((expr) => {
         const type = checker.getTypeAtLocation(expr);
         return type.getSymbol()?.getName() ?? expr.expression.getText();
@@ -4885,7 +5405,7 @@ function getInterfaceExtends(node, checker) {
 }
 
 // src/serializers/type-aliases.ts
-import ts11 from "typescript";
+import ts12 from "typescript";
 function buildIntersectionSchemaFromNode(node, ctx) {
   const types = node.types;
   const schemas = [];
@@ -4913,7 +5433,7 @@ function serializeTypeAlias(node, ctx) {
   registerReferencedTypes(type, ctx);
   let schema;
   let members;
-  if (ts11.isIntersectionTypeNode(node.type)) {
+  if (ts12.isIntersectionTypeNode(node.type)) {
     schema = buildIntersectionSchemaFromNode(node.type, ctx);
     if (type.getProperties().length > 0 && type.getCallSignatures().length === 0) {
       members = serializeResolvedMembers(type, node, ctx);
@@ -4923,7 +5443,7 @@ function serializeTypeAlias(node, ctx) {
     if (type.getProperties().length > 0) {
       members = serializeResolvedMembers(type, node, ctx);
     }
-  } else if ((ts11.isMappedTypeNode(node.type) || ts11.isConditionalTypeNode(node.type)) && type.getProperties().length > 0 && type.getCallSignatures().length === 0 && !(type.flags & ts11.TypeFlags.Conditional) && !(type.flags & (ts11.TypeFlags.StringLike | ts11.TypeFlags.NumberLike))) {
+  } else if ((ts12.isMappedTypeNode(node.type) || ts12.isConditionalTypeNode(node.type)) && type.getProperties().length > 0 && type.getCallSignatures().length === 0 && !(type.flags & ts12.TypeFlags.Conditional) && !(type.flags & (ts12.TypeFlags.StringLike | ts12.TypeFlags.NumberLike))) {
     schema = buildObjectSchema(type.getProperties(), ctx.typeChecker, ctx, type);
     members = serializeResolvedMembers(type, node, ctx);
   } else {
@@ -4933,7 +5453,7 @@ function serializeTypeAlias(node, ctx) {
     }
   }
   if (shouldEmitAliasTypeText(node.type) && typeof schema === "object" && schema !== null && !("x-ts-type" in schema)) {
-    const text = renderTypeText(type, ctx.typeChecker, node, ts11.TypeFormatFlags.InTypeAlias);
+    const text = renderTypeText(type, ctx.typeChecker, node, ts12.TypeFormatFlags.InTypeAlias);
     if (!PRIMITIVES.has(text) && text !== name) {
       schema["x-ts-type"] = text;
       const declared = writtenTypeText(declaredTypeNode(node));
@@ -4959,12 +5479,12 @@ function serializeTypeAlias(node, ctx) {
 }
 function isObjectShapedAlias(type, ctx) {
   const { typeChecker: checker } = ctx;
-  if (!(type.flags & ts11.TypeFlags.Object))
+  if (!(type.flags & ts12.TypeFlags.Object))
     return false;
   if (checker.isArrayType(type) || checker.isTupleType(type))
     return false;
   const objectFlags = type.objectFlags;
-  if (!(objectFlags & ts11.ObjectFlags.Mapped)) {
+  if (!(objectFlags & ts12.ObjectFlags.Mapped)) {
     const targetSymbol = type.target?.getSymbol?.() ?? type.getSymbol();
     if (isBuiltinSymbol(targetSymbol))
       return false;
@@ -4972,19 +5492,19 @@ function isObjectShapedAlias(type, ctx) {
   return type.getProperties().length > 0 && type.getCallSignatures().length === 0;
 }
 function isInlineFunctionAlias(typeNode) {
-  return ts11.isFunctionTypeNode(typeNode) || ts11.isTypeLiteralNode(typeNode) && typeNode.members.some(ts11.isCallSignatureDeclaration);
+  return ts12.isFunctionTypeNode(typeNode) || ts12.isTypeLiteralNode(typeNode) && typeNode.members.some(ts12.isCallSignatureDeclaration);
 }
 function buildConditionalArmDocs(typeNode, checker) {
   const docs = new Map;
-  if (!ts11.isMappedTypeNode(typeNode) || !typeNode.type)
+  if (!ts12.isMappedTypeNode(typeNode) || !typeNode.type)
     return docs;
   const literalKeys = (extendsType) => {
     const keys = [];
     const visit = (n) => {
-      if (ts11.isUnionTypeNode(n)) {
+      if (ts12.isUnionTypeNode(n)) {
         for (const member of n.types)
           visit(member);
-      } else if (ts11.isLiteralTypeNode(n) && ts11.isStringLiteral(n.literal)) {
+      } else if (ts12.isLiteralTypeNode(n) && ts12.isStringLiteral(n.literal)) {
         keys.push(n.literal.text);
       }
     };
@@ -4992,12 +5512,12 @@ function buildConditionalArmDocs(typeNode, checker) {
     return keys;
   };
   const armDoc = (armType) => {
-    if (!ts11.isTypeReferenceNode(armType))
+    if (!ts12.isTypeReferenceNode(armType))
       return;
     const symbol = checker.getSymbolAtLocation(armType.typeName);
     if (!symbol)
       return;
-    const target = symbol.flags & ts11.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+    const target = symbol.flags & ts12.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
     const { deprecated, reason } = isSymbolDeprecated(target);
     const targetDecl = target.getDeclarations()?.[0];
     const description = targetDecl ? getJSDocComment(targetDecl, target, checker).description : undefined;
@@ -5006,7 +5526,7 @@ function buildConditionalArmDocs(typeNode, checker) {
     return { deprecated, deprecationReason: reason, description };
   };
   let current = typeNode.type;
-  while (current && ts11.isConditionalTypeNode(current)) {
+  while (current && ts12.isConditionalTypeNode(current)) {
     const doc = armDoc(current.trueType);
     if (doc) {
       for (const key of literalKeys(current.extendsType)) {
@@ -5025,10 +5545,10 @@ function serializeResolvedMembers(type, node, ctx) {
   for (const prop of type.getProperties()) {
     const decl = prop.getDeclarations()?.[0] ?? node;
     const rawPropType = checker.getTypeOfSymbolAtLocation(prop, decl);
-    const propType = prop.flags & ts11.SymbolFlags.Optional ? stripUndefinedFromType(rawPropType, checker) : rawPropType;
+    const propType = prop.flags & ts12.SymbolFlags.Optional ? stripUndefinedFromType(rawPropType, checker) : rawPropType;
     registerReferencedTypes(propType, ctx);
     const callSigs = propType.getCallSignatures();
-    const isMethodDecl = ts11.isMethodSignature(decl) || ts11.isMethodDeclaration(decl) || ts11.isFunctionDeclaration(decl);
+    const isMethodDecl = ts12.isMethodSignature(decl) || ts12.isMethodDeclaration(decl) || ts12.isFunctionDeclaration(decl);
     const kind = callSigs.length > 0 && isMethodDecl ? "method" : "property";
     let { description, tags } = getJSDocComment(decl, prop, checker);
     let { deprecated, reason: deprecationReason } = isSymbolDeprecated(prop);
@@ -5046,13 +5566,13 @@ function serializeResolvedMembers(type, node, ctx) {
       ({ deprecated, reason: deprecationReason } = isSymbolDeprecated(armAlias));
     }
     const flags = {};
-    if (prop.flags & ts11.SymbolFlags.Optional)
+    if (prop.flags & ts12.SymbolFlags.Optional)
       flags.optional = true;
     if (isReadonlyPropertySymbol(prop))
       flags.readonly = true;
-    if (prop.flags & ts11.SymbolFlags.Method)
+    if (prop.flags & ts12.SymbolFlags.Method)
       flags.methodSyntax = true;
-    const schema = kind === "property" ? decoratePropertySchema(buildSchema(propType, checker, ctx), prop, propType, checker) : decoratePropertySchema({ "x-ts-function": true }, prop, propType, checker);
+    const schema = kind === "property" ? decoratePropertySchema(buildSchema(propType, checker, ctx, declaredTypeNode(prop.valueDeclaration ?? prop.getDeclarations()?.[0])), prop, propType, checker) : decoratePropertySchema({ "x-ts-function": true }, prop, propType, checker);
     const inlineTags = parseInlineTags(description);
     members.push({
       name: prop.getName(),
@@ -5070,13 +5590,13 @@ function serializeResolvedMembers(type, node, ctx) {
 }
 
 // src/schema/registry.ts
-import ts12 from "typescript";
+import ts13 from "typescript";
 function isTypeReference(type) {
-  return !!(type.flags & ts12.TypeFlags.Object && type.objectFlags && type.objectFlags & ts12.ObjectFlags.Reference);
+  return !!(type.flags & ts13.TypeFlags.Object && type.objectFlags && type.objectFlags & ts13.ObjectFlags.Reference);
 }
 function getNonNullableType(type) {
   if (type.isUnion()) {
-    const nonNullable = type.types.filter((t) => !(t.flags & ts12.TypeFlags.Undefined) && !(t.flags & ts12.TypeFlags.Null));
+    const nonNullable = type.types.filter((t) => !(t.flags & ts13.TypeFlags.Undefined) && !(t.flags & ts13.TypeFlags.Null));
     if (nonNullable.length === 1) {
       return nonNullable[0];
     }
@@ -5244,7 +5764,7 @@ function serializeVariable(node, statement, ctx) {
   const schemaExtraction = extractSchemaType(type, ctx.typeChecker);
   const typeToSerialize = schemaExtraction?.outputType ?? type;
   registerReferencedTypes(typeToSerialize, ctx);
-  const schema = buildSchema(typeToSerialize, ctx.typeChecker, ctx);
+  const schema = buildSchema(typeToSerialize, ctx.typeChecker, ctx, node.type);
   const flags = schemaExtraction ? {
     schemaLibrary: schemaExtraction.adapter.id,
     ...schemaExtraction.inputType && schemaExtraction.inputType !== schemaExtraction.outputType ? { hasTransform: true } : {}
@@ -5269,7 +5789,7 @@ import { JSON_SCHEMA_DRAFT } from "@openpkg-ts/spec";
 var TS_PRIMITIVE_NORMALIZATIONS = {
   void: () => ({ type: "null", "x-ts-type": "void" }),
   never: () => ({ not: {} }),
-  any: () => ({}),
+  any: () => ({ "x-ts-type": "any" }),
   unknown: () => ({ "x-ts-type": "unknown" }),
   undefined: () => ({ type: "null", "x-ts-type": "undefined" }),
   bigint: () => ({ type: "integer", "x-ts-type": "bigint" }),
@@ -5832,7 +6352,7 @@ async function getExport(options) {
   ctx.exportedIds = exportedIds;
   try {
     const originalDecls = targetSymbol.declarations ?? [];
-    const isNamespaceExportDecl = originalDecls.some((d) => ts13.isNamespaceExport(d) || ts13.isNamespaceImport(d));
+    const isNamespaceExportDecl = originalDecls.some((d) => ts14.isNamespaceExport(d) || ts14.isNamespaceImport(d));
     if (isNamespaceExportDecl) {
       const spec2 = serializeNamespaceForGet(targetSymbol, exportName, ctx);
       const types2 = ctx.typeRegistry.getAll().map((t) => normalizeType(t));
@@ -5842,7 +6362,7 @@ async function getExport(options) {
         errors
       };
     }
-    const { declaration, resolvedSymbol, isTypeOnly } = resolveExportTarget(targetSymbol, checker);
+    const { declaration, resolvedSymbol: resolvedSymbol2, isTypeOnly } = resolveExportTarget2(targetSymbol, checker);
     if (!declaration) {
       const externalPackage = detectExternalPackage(targetSymbol, checker);
       if (externalPackage) {
@@ -5856,7 +6376,7 @@ async function getExport(options) {
       }
       return { export: null, types: [], errors: [`No declaration found for '${exportName}'`] };
     }
-    let spec = serializeDeclaration(declaration, targetSymbol, resolvedSymbol, exportName, ctx, isTypeOnly);
+    let spec = serializeDeclaration(declaration, targetSymbol, resolvedSymbol2, exportName, ctx, isTypeOnly);
     if (!spec) {
       const externalPackage = detectExternalPackage(targetSymbol, checker);
       if (externalPackage) {
@@ -5878,47 +6398,47 @@ async function getExport(options) {
     return { export: null, types: [], errors };
   }
 }
-function resolveExportTarget(symbol, checker) {
-  let resolvedSymbol = symbol;
+function resolveExportTarget2(symbol, checker) {
+  let resolvedSymbol2 = symbol;
   let isTypeOnly = false;
   const declarations = symbol.declarations ?? [];
   for (const decl of declarations) {
-    if (ts13.isExportSpecifier(decl)) {
+    if (ts14.isExportSpecifier(decl)) {
       if (decl.isTypeOnly)
         isTypeOnly = true;
       const exportDecl = decl.parent?.parent;
-      if (exportDecl && ts13.isExportDeclaration(exportDecl) && exportDecl.isTypeOnly) {
+      if (exportDecl && ts14.isExportDeclaration(exportDecl) && exportDecl.isTypeOnly) {
         isTypeOnly = true;
       }
     }
   }
-  if (symbol.flags & ts13.SymbolFlags.Alias) {
+  if (symbol.flags & ts14.SymbolFlags.Alias) {
     const aliased = checker.getAliasedSymbol(symbol);
     if (aliased && aliased !== symbol) {
-      resolvedSymbol = aliased;
+      resolvedSymbol2 = aliased;
     }
   }
-  const targetDeclarations = resolvedSymbol.declarations ?? [];
-  const declaration = resolvedSymbol.valueDeclaration || targetDeclarations.find((d) => d.kind !== ts13.SyntaxKind.ExportSpecifier) || targetDeclarations[0];
-  return { declaration, resolvedSymbol, isTypeOnly };
+  const targetDeclarations = resolvedSymbol2.declarations ?? [];
+  const declaration = resolvedSymbol2.valueDeclaration || targetDeclarations.find((d) => d.kind !== ts14.SyntaxKind.ExportSpecifier) || targetDeclarations[0];
+  return { declaration, resolvedSymbol: resolvedSymbol2, isTypeOnly };
 }
 function serializeDeclaration(declaration, _exportSymbol, _targetSymbol, exportName, ctx, isTypeOnly) {
   let result = null;
-  if (ts13.isFunctionDeclaration(declaration)) {
+  if (ts14.isFunctionDeclaration(declaration)) {
     result = serializeFunctionExport(declaration, ctx);
-  } else if (ts13.isClassDeclaration(declaration)) {
+  } else if (ts14.isClassDeclaration(declaration)) {
     result = serializeClass(declaration, ctx);
-  } else if (ts13.isInterfaceDeclaration(declaration)) {
+  } else if (ts14.isInterfaceDeclaration(declaration)) {
     result = serializeInterface(declaration, ctx);
-  } else if (ts13.isTypeAliasDeclaration(declaration)) {
+  } else if (ts14.isTypeAliasDeclaration(declaration)) {
     result = serializeTypeAlias(declaration, ctx);
-  } else if (ts13.isEnumDeclaration(declaration)) {
+  } else if (ts14.isEnumDeclaration(declaration)) {
     result = serializeEnum(declaration, ctx);
-  } else if (ts13.isVariableDeclaration(declaration)) {
+  } else if (ts14.isVariableDeclaration(declaration)) {
     const varStatement = declaration.parent?.parent;
-    if (varStatement && ts13.isVariableStatement(varStatement)) {
-      if (declaration.initializer && (ts13.isArrowFunction(declaration.initializer) || ts13.isFunctionExpression(declaration.initializer))) {
-        const varName = ts13.isIdentifier(declaration.name) ? declaration.name.text : declaration.name.getText();
+    if (varStatement && ts14.isVariableStatement(varStatement)) {
+      if (declaration.initializer && (ts14.isArrowFunction(declaration.initializer) || ts14.isFunctionExpression(declaration.initializer))) {
+        const varName = ts14.isIdentifier(declaration.name) ? declaration.name.text : declaration.name.getText();
         result = serializeFunctionExport(declaration.initializer, ctx, varName);
       } else {
         const checker = ctx.program.getTypeChecker();
@@ -5932,7 +6452,7 @@ function serializeDeclaration(declaration, _exportSymbol, _targetSymbol, exportN
         }
       }
     }
-  } else if (ts13.isNamespaceExport(declaration) || ts13.isModuleDeclaration(declaration) || ts13.isNamespaceImport(declaration) || ts13.isSourceFile(declaration)) {
+  } else if (ts14.isNamespaceExport(declaration) || ts14.isModuleDeclaration(declaration) || ts14.isNamespaceImport(declaration) || ts14.isSourceFile(declaration)) {
     result = serializeNamespaceForGet(_exportSymbol, exportName, ctx);
   }
   if (result) {
@@ -5948,7 +6468,7 @@ function serializeDeclaration(declaration, _exportSymbol, _targetSymbol, exportN
 function serializeNamespaceForGet(symbol, exportName, ctx) {
   const checker = ctx.program.getTypeChecker();
   let targetSymbol = symbol;
-  if (symbol.flags & ts13.SymbolFlags.Alias) {
+  if (symbol.flags & ts14.SymbolFlags.Alias) {
     const aliased = checker.getAliasedSymbol(symbol);
     if (aliased && aliased !== symbol) {
       targetSymbol = aliased;
@@ -5978,7 +6498,7 @@ function serializeNamespaceForGet(symbol, exportName, ctx) {
 }
 function detectExternalPackage(symbol, checker) {
   let targetSymbol = symbol;
-  if (symbol.flags & ts13.SymbolFlags.Alias) {
+  if (symbol.flags & ts14.SymbolFlags.Alias) {
     const aliased = checker.getAliasedSymbol(symbol);
     if (aliased && aliased !== symbol) {
       targetSymbol = aliased;
@@ -5990,9 +6510,9 @@ function detectExternalPackage(symbol, checker) {
     const pkg = sf && packageNameFromPath(sf.fileName);
     if (pkg)
       return pkg;
-    if (ts13.isExportSpecifier(decl)) {
+    if (ts14.isExportSpecifier(decl)) {
       const exportDecl = decl.parent?.parent;
-      if (exportDecl && ts13.isExportDeclaration(exportDecl) && exportDecl.moduleSpecifier) {
+      if (exportDecl && ts14.isExportDeclaration(exportDecl) && exportDecl.moduleSpecifier) {
         const moduleText = exportDecl.moduleSpecifier.text;
         if (!moduleText.startsWith(".") && !moduleText.startsWith("/")) {
           return moduleText;
@@ -6004,7 +6524,7 @@ function detectExternalPackage(symbol, checker) {
 }
 // src/primitives/list.ts
 import * as path6 from "node:path";
-import ts14 from "typescript";
+import ts15 from "typescript";
 async function listExports(options) {
   const { entryFile, baseDir, content } = options;
   const errors = [];
@@ -6047,16 +6567,16 @@ async function listExports(options) {
 }
 function extractExportItem(symbol, checker, entryFile, entrySourceFile) {
   const name = symbol.getName();
-  const isReexport = !!(symbol.flags & ts14.SymbolFlags.Alias);
+  const isReexport = !!(symbol.flags & ts15.SymbolFlags.Alias);
   let targetSymbol = symbol;
-  if (symbol.flags & ts14.SymbolFlags.Alias) {
+  if (symbol.flags & ts15.SymbolFlags.Alias) {
     const aliased = checker.getAliasedSymbol(symbol);
     if (aliased && aliased !== symbol) {
       targetSymbol = aliased;
     }
   }
   const declarations = targetSymbol.declarations ?? [];
-  const declaration = targetSymbol.valueDeclaration || declarations.find((d) => d.kind !== ts14.SyntaxKind.ExportSpecifier) || declarations[0];
+  const declaration = targetSymbol.valueDeclaration || declarations.find((d) => d.kind !== ts15.SyntaxKind.ExportSpecifier) || declarations[0];
   if (!declaration) {
     return {
       name,
@@ -6066,7 +6586,7 @@ function extractExportItem(symbol, checker, entryFile, entrySourceFile) {
       reexport: true
     };
   }
-  if (ts14.isSourceFile(declaration)) {
+  if (ts15.isSourceFile(declaration)) {
     return {
       name,
       kind: "namespace",
@@ -6110,36 +6630,6 @@ import * as path10 from "node:path";
 import { SCHEMA_URL, SCHEMA_VERSION } from "@openpkg-ts/spec";
 import ts19 from "typescript";
 
-// src/ast/resolve.ts
-import ts15 from "typescript";
-function isTypeOnlyExport(symbol) {
-  const declarations = symbol.declarations ?? [];
-  for (const decl of declarations) {
-    if (ts15.isExportSpecifier(decl)) {
-      if (decl.isTypeOnly)
-        return true;
-      const exportDecl = decl.parent?.parent;
-      if (exportDecl && ts15.isExportDeclaration(exportDecl) && exportDecl.isTypeOnly) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function resolveExportTarget2(symbol, checker) {
-  let targetSymbol = symbol;
-  const isTypeOnly = isTypeOnlyExport(symbol);
-  if (symbol.flags & ts15.SymbolFlags.Alias) {
-    const aliasTarget = checker.getAliasedSymbol(symbol);
-    if (aliasTarget && aliasTarget !== symbol) {
-      targetSymbol = aliasTarget;
-    }
-  }
-  const declarations = targetSymbol.declarations ?? [];
-  const declaration = targetSymbol.valueDeclaration || declarations.find((decl) => decl.kind !== ts15.SyntaxKind.ExportSpecifier) || declarations[0];
-  return { declaration, targetSymbol, isTypeOnly };
-}
-
 // src/schema/standard-schema.ts
 import { spawn as spawn2, spawnSync as spawnSync2 } from "node:child_process";
 import * as fs5 from "node:fs";
@@ -6770,16 +7260,16 @@ function extractExternalExport(exportName, resolvedModule, program, ctx, visited
   if (!targetExport) {
     return null;
   }
-  let resolvedSymbol = targetExport;
+  let resolvedSymbol2 = targetExport;
   if (targetExport.flags & ts16.SymbolFlags.Alias) {
     const aliased = checker.getAliasedSymbol(targetExport);
     if (aliased && aliased !== targetExport) {
-      resolvedSymbol = aliased;
+      resolvedSymbol2 = aliased;
     }
   }
-  const decl = (resolvedSymbol.declarations ?? [])[0];
+  const decl = (resolvedSymbol2.declarations ?? [])[0];
   const kind = decl ? getExportKind(decl, checker.getTypeAtLocation(decl)) : "variable";
-  const docComment = resolvedSymbol.getDocumentationComment(checker);
+  const docComment = resolvedSymbol2.getDocumentationComment(checker);
   const description = docComment.length > 0 ? docComment.map((c) => c.text).join(`
 `) : undefined;
   const specExport = {
@@ -6794,18 +7284,18 @@ function extractExternalExport(exportName, resolvedModule, program, ctx, visited
     }
   };
   if (kind === "function") {
-    const type = checker.getTypeOfSymbol(resolvedSymbol);
+    const type = checker.getTypeOfSymbol(resolvedSymbol2);
     const callSignatures = type.getCallSignatures();
     if (callSignatures.length > 0) {
       specExport.signatures = buildSignatures(callSignatures, checker, ctx);
     }
   } else if (kind === "interface" || kind === "type" || kind === "class") {
-    const type = checker.getTypeOfSymbol(resolvedSymbol);
+    const type = checker.getTypeOfSymbol(resolvedSymbol2);
     registerReferencedTypes(type, ctx);
     const schema = buildSchema(type, checker, ctx);
     specExport.schema = schema;
   } else if (kind === "variable") {
-    const type = checker.getTypeOfSymbol(resolvedSymbol);
+    const type = checker.getTypeOfSymbol(resolvedSymbol2);
     registerReferencedTypes(type, ctx);
     const schema = buildSchema(type, checker, ctx);
     specExport.schema = schema;
@@ -6996,10 +7486,11 @@ function createExternalExpansionPredicate(opts) {
     return opts.workspacePackages.has(pkg);
   };
   return (symbol) => {
-    const decl = symbol.declarations?.[0];
+    const resolved = resolveAliasSymbol(symbol, opts.checker, undefined, opts.program);
+    const decl = (resolved.declarations ?? symbol.declarations)?.[0];
     if (!decl)
       return false;
-    if (isLibSymbol(symbol))
+    if (isLibSymbol(resolved) || isLibSymbol(symbol))
       return false;
     const pkg = packageNameFromPath(decl.getSourceFile().fileName);
     if (pkg)
@@ -7015,7 +7506,12 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
   const MAX_DEPTH = 30;
   let visits = 0;
   const MAX_VISITS = 50000;
-  const symbolAllowed = createExternalExpansionPredicate(opts);
+  const symbolAllowed = createExternalExpansionPredicate({
+    followExternal: opts.followExternal,
+    workspacePackages: opts.workspacePackages,
+    checker: ctx.typeChecker,
+    program: ctx.program
+  });
   const visit = (type, depth) => {
     if (!type || depth > MAX_DEPTH || visited.has(type))
       return;
@@ -7048,7 +7544,7 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
         visit(t, depth + 1);
       }
     }
-    if (!allowed || !(type.flags & ts18.TypeFlags.Object || type.isClassOrInterface())) {
+    if (!allowed || isDeferredMappedOrConditional(type) || !(type.flags & ts18.TypeFlags.Object || type.isClassOrInterface())) {
       return;
     }
     if (isForeignPackage(symbol, opts.workspacePackages)) {
@@ -7086,14 +7582,8 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
     return "type";
   };
   const resolveAlias = (symbol) => {
-    if (symbol.flags & ts18.SymbolFlags.Alias) {
-      try {
-        return checker.getAliasedSymbol(symbol);
-      } catch {
-        return;
-      }
-    }
-    return symbol;
+    const resolved = resolveAliasSymbol(symbol, checker, undefined, ctx.program);
+    return resolved;
   };
   const symbolByName = new Map;
   const registerTypeSymbol = (symbol) => {
@@ -7494,7 +7984,9 @@ async function extract(options) {
       onTruncation,
       shouldExpandExternal: createExternalExpansionPredicate({
         followExternal,
-        workspacePackages: result.workspacePackages ?? new Map
+        workspacePackages: result.workspacePackages ?? new Map,
+        checker: typeChecker,
+        program
       }),
       workspacePackages: result.workspacePackages ?? new Map
     });
@@ -7512,7 +8004,7 @@ async function extract(options) {
         await new Promise((r) => setImmediate(r));
       }
       try {
-        const { declaration, targetSymbol, isTypeOnly } = resolveExportTarget2(symbol, typeChecker);
+        const { declaration, targetSymbol, isTypeOnly } = resolveExportTarget(symbol, typeChecker, program);
         if (!declaration) {
           let externalPackage;
           const allDecls = [...targetSymbol.declarations ?? [], ...symbol.declarations ?? []];
@@ -7593,6 +8085,13 @@ async function extract(options) {
       workspacePackages: result.workspacePackages ?? new Map,
       entryFile
     });
+    if (ctx.budgetExceeded) {
+      diagnostics.push({
+        message: "Stopped expanding some types after hitting the schema expansion budget",
+        severity: "warning",
+        code: "TYPE_EXPANSION_LIMIT"
+      });
+    }
     {
       const symFlags = ts19.SymbolFlags.Type | ts19.SymbolFlags.Interface | ts19.SymbolFlags.Class;
       const maxPasses = 5;
@@ -7762,6 +8261,15 @@ function serializeDeclaration2(declaration, exportSymbol, exportName, ctx, isTyp
           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)
+              };
+            }
           }
         }
       }
@@ -7946,6 +8454,35 @@ function extractExamples(doc) {
   }
   return examples;
 }
+function callSignaturesForVariable(declaration, ctx) {
+  const checker = ctx.typeChecker;
+  if (declaration.type && ts19.isTypeReferenceNode(declaration.type)) {
+    const nameNode = ts19.isQualifiedName(declaration.type.typeName) ? declaration.type.typeName.right : declaration.type.typeName;
+    const raw = checker.getSymbolAtLocation(nameNode);
+    if (raw) {
+      const symbol = resolveAliasSymbol(raw, checker, undefined, ctx.program);
+      const iface = symbol.declarations?.find((d) => ts19.isInterfaceDeclaration(d));
+      try {
+        const declared = checker.getDeclaredTypeOfSymbol(symbol);
+        const sigs = declared.getCallSignatures();
+        if (sigs.length > 0)
+          return sigs;
+        if (iface) {
+          const fromDecl = checker.getTypeAtLocation(iface).getCallSignatures();
+          if (fromDecl.length > 0)
+            return fromDecl;
+        }
+      } catch {
+        if (iface) {
+          try {
+            return checker.getTypeAtLocation(iface).getCallSignatures();
+          } catch {}
+        }
+      }
+    }
+  }
+  return checker.getTypeAtLocation(declaration).getCallSignatures();
+}
 function withExportName(entry, exportName) {
   if (entry.name === exportName) {
     return entry;
@@ -8522,6 +9059,8 @@ export {
   validateSpec2 as validateSpec,
   valibotAdapter,
   typeboxAdapter,
+  typeNodeOfSignature,
+  typeNodeDefersExpansion,
   toToolSchema,
   toSearchIndexJSON,
   toSearchIndex,
@@ -8550,8 +9089,9 @@ export {
   schemaIsAny,
   resolveTypeRef,
   resolveTarget,
-  resolveExportTarget2 as resolveExportTarget,
+  resolveExportTarget,
   resolveCompiledPath,
+  resolveAliasSymbol,
   renderTypeText,
   registerReferencedTypes,
   registerAdapter,
@@ -8581,6 +9121,7 @@ export {
   isMethod,
   isExported,
   isEntryFilePath,
+  isDeferredMappedOrConditional,
   isBuiltinSymbol,
   isBuiltinGeneric,
   isAnonymous,
@@ -8635,6 +9176,7 @@ export {
   calculateNextVersion,
   bundleRefs,
   buildSignatureString,
+  buildSchemaFromTypeNode,
   buildSchema,
   buildObjectSchema,
   buildFunctionSchema,