@openpkg-ts/sdk 0.54.7 → 0.54.9

package/dist/index.js

@@ -1781,7 +1781,7 @@ function filterSpec(spec, criteria) {
   };
 }
 // src/primitives/get.ts
-import ts14 from "typescript";
+import ts16 from "typescript";
 
 // src/ast/type-identity.ts
 import * as path3 from "node:path";
@@ -1830,6 +1830,18 @@ function declKey(symbol, checker) {
     return;
   return `${decl.getSourceFile().fileName}#${decl.getStart()}`;
 }
+function fileLabel(fileName) {
+  const base = path3.basename(fileName).replace(/(\.d)?\.[cm]?[tj]sx?$/, "");
+  return base === "index" ? path3.basename(path3.dirname(fileName)) || base : base;
+}
+function namespaceLabel(decl) {
+  const names = [];
+  for (let node = decl?.parent;node; node = node.parent) {
+    if (ts.isModuleDeclaration(node) && ts.isIdentifier(node.name))
+      names.unshift(node.name.text);
+  }
+  return names.length > 0 ? names.join(".") : undefined;
+}
 function resolveTypeId(symbol, ctx) {
   const cached = ctx.typeIds.get(symbol);
   if (cached)
@@ -1853,16 +1865,49 @@ function resolveTypeId(symbol, ctx) {
   const owner = ctx.idOwner.get(name);
   if (!owner || owner === key)
     return claim(name);
-  const file = symbol.declarations?.[0]?.getSourceFile().fileName ?? "";
-  const scoped = `${packageLabel(file, ctx.workspacePackages)}.${name}`;
-  const scopedOwner = ctx.idOwner.get(scoped);
-  if (!scopedOwner || scopedOwner === key)
-    return claim(scoped);
+  const decl = symbol.declarations?.[0];
+  const file = decl?.getSourceFile().fileName ?? "";
+  const pkg = packageLabel(file, ctx.workspacePackages);
+  const ownerFile = owner.includes("#") ? owner.slice(0, owner.lastIndexOf("#")) : "";
+  const scopes = pkg === packageLabel(ownerFile, ctx.workspacePackages) ? [] : [pkg];
+  const namespace = namespaceLabel(decl);
+  if (namespace)
+    scopes.push(namespace);
+  if (file)
+    scopes.push(fileLabel(file));
+  for (const scope of scopes) {
+    const scoped = `${scope}.${name}`;
+    const scopedOwner = ctx.idOwner.get(scoped);
+    if (!scopedOwner || scopedOwner === key)
+      return claim(scoped);
+  }
   let n = 2;
   while (ctx.idOwner.has(`${name}_${n}`))
     n++;
   return claim(`${name}_${n}`);
 }
+var EXPORTABLE_TYPE_FLAGS = ts.SymbolFlags.Interface | ts.SymbolFlags.TypeAlias | ts.SymbolFlags.Class | ts.SymbolFlags.RegularEnum | ts.SymbolFlags.ConstEnum;
+function claimExportedTypeIds(exportedSymbols, ctx) {
+  const renamed = [];
+  for (const exported of exportedSymbols) {
+    let target = exported;
+    if (exported.flags & ts.SymbolFlags.Alias) {
+      try {
+        target = ctx.typeChecker.getAliasedSymbol(exported);
+      } catch {
+        continue;
+      }
+    }
+    if (!(target.flags & EXPORTABLE_TYPE_FLAGS))
+      continue;
+    if (target.getName() === exported.getName())
+      resolveTypeId(target, ctx);
+    else
+      renamed.push(target);
+  }
+  for (const target of renamed)
+    resolveTypeId(target, ctx);
+}
 function typeRefId(type, ctx) {
   const symbol = type.aliasSymbol ?? type.getSymbol();
   if (!symbol)
@@ -2450,6 +2495,15 @@ function discoverAmbientTypePackages(baseDir) {
   }
   return found;
 }
+function resolutionFor(module) {
+  if (module === ts3.ModuleKind.NodeNext)
+    return ts3.ModuleResolutionKind.NodeNext;
+  if (module >= ts3.ModuleKind.Node16 && module < ts3.ModuleKind.NodeNext)
+    return ts3.ModuleResolutionKind.Node16;
+  if (module >= ts3.ModuleKind.ES2015)
+    return ts3.ModuleResolutionKind.Bundler;
+  return;
+}
 function createProgram(options) {
   const { content } = options;
   const entryFile = path5.resolve(options.entryFile);
@@ -2465,7 +2519,7 @@ function createProgram(options) {
     const parsedConfig = ts3.parseJsonConfigFileContent(configFile.config, ts3.sys, path5.dirname(configPath));
     compilerOptions = { ...compilerOptions, ...parsedConfig.options };
     if (parsedConfig.options.module !== undefined && parsedConfig.options.moduleResolution === undefined) {
-      delete compilerOptions.moduleResolution;
+      compilerOptions.moduleResolution = resolutionFor(parsedConfig.options.module);
     }
     additionalRootFiles = resolveProjectReferences(configPath, parsedConfig);
     let sourceFiles = parsedConfig.fileNames.filter((f) => !f.includes(".test.") && !f.includes(".spec.") && !f.includes("/dist/") && !f.includes("/node_modules/"));
@@ -2546,7 +2600,7 @@ function createProgram(options) {
 }
 
 // src/serializers/classes.ts
-import ts9 from "typescript";
+import ts10 from "typescript";
 
 // src/types/parameters.ts
 import ts6 from "typescript";
@@ -2841,20 +2895,22 @@ function buildSchemaFromTypeNode(node, checker, ctx) {
       let refId = name;
       if (symbol && ctx) {
         try {
-          refId = namedRefId(checker.getDeclaredTypeOfSymbol(symbol), name, ctx);
+          refId = typeRefId(checker.getDeclaredTypeOfSymbol(symbol), ctx) || (symbol.flags & ts5.SymbolFlags.TypeAlias ? resolveTypeId(symbol, ctx) : name);
         } catch {
           refId = name;
         }
       }
       return withArgs({ $ref: `#/types/${refId}` });
     }
-    return { "x-ts-type": scrubImportQualifiers(node.getText()) };
+    return {
+      "x-ts-type": scrubImportQualifiers(node.getText().replace(/\s+/g, " "))
+    };
   }
   const t = checker.getTypeFromTypeNode(node);
   if (!(t.flags & ts5.TypeFlags.Any)) {
     return buildSchema(t, checker, ctx);
   }
-  return { "x-ts-type": scrubImportQualifiers(node.getText()) };
+  return { "x-ts-type": scrubImportQualifiers(node.getText().replace(/\s+/g, " ")) };
 }
 function stripUndefinedFromType(type, checker) {
   if (!type.isUnion())
@@ -3038,7 +3094,20 @@ function typeNodeDefersExpansion(node, checker, program) {
   const symbol = resolveAliasSymbol(raw, checker, undefined, program);
   return shouldDeferAlias(symbol);
 }
-function cheapTypeText(type, _checker, typeNode) {
+function isStaleTypeParameterNode(type, checker, typeNode) {
+  if (type.flags & ts5.TypeFlags.TypeParameter)
+    return false;
+  if (!ts5.isTypeReferenceNode(typeNode) || !ts5.isIdentifier(typeNode.typeName))
+    return false;
+  const symbol = checker.getSymbolAtLocation(typeNode.typeName);
+  return !!symbol && (symbol.flags & ts5.SymbolFlags.TypeParameter) !== 0;
+}
+function cheapTypeText(type, checker, typeNode) {
+  if (typeNode && isStaleTypeParameterNode(type, checker, typeNode)) {
+    const argument = type.aliasSymbol?.getName() ?? type.getSymbol()?.getName();
+    if (argument && !argument.startsWith("__") && !isBuiltinGeneric(argument))
+      return argument;
+  }
   if (typeNode) {
     try {
       const text = scrubImportQualifiers(typeNode.getText().replace(/\s+/g, " ").trim());
@@ -3329,10 +3398,10 @@ function buildSchema(type, checker, ctx, typeNode) {
   const schema = buildSchemaInternal(type, checker, ctx, typeNode);
   return ensureNonEmptySchema(schema, type, checker);
 }
-function buildMaxDepthSchema(type, checker, typeNode) {
+function buildMaxDepthSchema(type, checker, typeNode, ctx) {
   if (type.flags & ts5.TypeFlags.Any) {
     if (typeNode)
-      return buildSchemaFromTypeNode(typeNode, checker);
+      return buildSchemaFromTypeNode(typeNode, checker, ctx);
     return { "x-ts-type": checker.typeToString(type) };
   }
   if (type.flags & ts5.TypeFlags.TypeParameter && !isFluentThisType(type)) {
@@ -3345,7 +3414,7 @@ function buildMaxDepthSchema(type, checker, typeNode) {
       return builtinSchema(name);
     }
     if (!name.startsWith("__") && !isPrimitiveName(name)) {
-      return { $ref: `#/types/${name}` };
+      return { $ref: `#/types/${ctx ? resolveTypeId(symbol, ctx) : name}` };
     }
   }
   if (type.flags & ts5.TypeFlags.String)
@@ -3368,18 +3437,18 @@ function buildMaxDepthSchema(type, checker, typeNode) {
     };
   }
   if (type.isUnion()) {
-    const schemas = type.types.map((t) => buildMaxDepthSchema(t, checker));
+    const schemas = type.types.map((t) => buildMaxDepthSchema(t, checker, undefined, ctx));
     return { anyOf: schemas };
   }
   if (type.isIntersection()) {
-    const schemas = type.types.map((t) => buildMaxDepthSchema(t, checker));
+    const schemas = type.types.map((t) => buildMaxDepthSchema(t, checker, undefined, ctx));
     return { allOf: schemas };
   }
   return { type: checker.typeToString(type) };
 }
 function buildSchemaInternal(type, checker, ctx, typeNode) {
   if (isAtMaxDepth(ctx)) {
-    return buildMaxDepthSchema(type, checker, typeNode);
+    return buildMaxDepthSchema(type, checker, typeNode, ctx);
   }
   if (ctx) {
     ctx.schemaOps += 1;
@@ -3721,7 +3790,8 @@ function buildFunctionSchema(callSignatures, checker, ctx) {
         return {
           name: param.getName(),
           schema: buildSchema(effectiveType, checker, ctx, decl.type),
-          required: !isOptional
+          required: !isOptional && !decl.dotDotDotToken,
+          ...decl.dotDotDotToken ? { rest: true } : {}
         };
       });
       const returnType = checker.getReturnTypeOfSignature(sig);
@@ -3947,6 +4017,7 @@ function extractParameters(signature, ctx) {
       result.push(...expandedParams);
     } else {
       const isOptional = !!decl?.questionToken || !!decl?.initializer;
+      const isRest = !!decl.dotDotDotToken;
       const paramName = param.getName();
       const description = getParamDescription(paramName, jsdocTags);
       const schema = defer ? buildSchemaFromTypeNode(decl.type, checker, ctx) : buildSchema(isOptional ? stripUndefinedFromType(type, checker) : type, checker, ctx, decl.type);
@@ -3956,7 +4027,8 @@ function extractParameters(signature, ctx) {
       const paramResult = {
         name: paramName,
         schema,
-        required: !isOptional
+        required: !isOptional && !isRest,
+        ...isRest ? { rest: true } : {}
       };
       if (description) {
         paramResult.description = description;
@@ -4561,7 +4633,7 @@ function walkBaseTypes(type, ownMemberNames, inherited, inheritedNames, visited,
         continue;
       if (propName.startsWith("#") || propName.startsWith("__"))
         continue;
-      const member = serializeInheritedMember(prop, baseName, ctx, isStatic);
+      const member = serializeInheritedMember(prop, declaringTypeName(prop) ?? baseName, ctx, isStatic);
       if (member) {
         inherited.push(member);
         inheritedNames.add(propName);
@@ -4570,6 +4642,12 @@ function walkBaseTypes(type, ownMemberNames, inherited, inheritedNames, visited,
     walkBaseTypes(baseType, ownMemberNames, inherited, inheritedNames, visited, ctx, isStatic);
   }
 }
+function declaringTypeName(prop) {
+  const parent = prop.declarations?.[0]?.parent;
+  if (!parent || !(ts8.isClassLike(parent) || ts8.isInterfaceDeclaration(parent)))
+    return;
+  return parent.name?.text;
+}
 function getStaticMembers(classType, checker) {
   const symbol = classType.getSymbol();
   if (!symbol)
@@ -4583,6 +4661,15 @@ function getStaticMembers(classType, checker) {
     return name !== "prototype" && name !== "constructor" && !name.startsWith("__");
   });
 }
+function inheritedMethodSchema(symbol, type, ctx) {
+  if (!ctx.budgetExceeded) {
+    return decoratePropertySchema({ "x-ts-function": true }, symbol, type, ctx.typeChecker);
+  }
+  return {
+    "x-ts-function": true,
+    ...symbol.flags & ts8.SymbolFlags.Method ? { "x-ts-method": true } : {}
+  };
+}
 function serializeInheritedMember(symbol, inheritedFrom, ctx, isStatic) {
   const { typeChecker: checker } = ctx;
   const name = symbol.getName();
@@ -4590,8 +4677,12 @@ function serializeInheritedMember(symbol, inheritedFrom, ctx, isStatic) {
   const decl = declarations[0];
   if (!decl)
     return null;
-  const type = checker.getTypeOfSymbol(symbol);
-  registerReferencedTypes(type, ctx);
+  const isOptional = !!(symbol.flags & ts8.SymbolFlags.Optional);
+  const rawType = checker.getTypeOfSymbol(symbol);
+  const type = isOptional ? stripUndefinedFromType(rawType, checker) : rawType;
+  const registerTypes = !ctx.budgetExceeded;
+  if (registerTypes)
+    registerReferencedTypes(type, ctx);
   let visibility;
   if (decl && ts8.canHaveModifiers(decl)) {
     const modifiers = ts8.getModifiers(decl);
@@ -4609,6 +4700,7 @@ function serializeInheritedMember(symbol, inheritedFrom, ctx, isStatic) {
   if (visibility === "private")
     return null;
   const { description, tags, inlineTags } = getJSDocComment(decl);
+  const { deprecated, reason: deprecationReason } = isSymbolDeprecated(symbol);
   let kind = "property";
   const callSigs = type.getCallSignatures();
   if (callSigs.length > 0) {
@@ -4621,6 +4713,8 @@ function serializeInheritedMember(symbol, inheritedFrom, ctx, isStatic) {
   const flags = {};
   if (isStatic)
     flags.static = true;
+  if (isOptional)
+    flags.optional = true;
   if (decl && ts8.canHaveModifiers(decl)) {
     const modifiers = ts8.getModifiers(decl);
     if (modifiers?.some((m) => m.kind === ts8.SyntaxKind.ReadonlyKeyword)) {
@@ -4632,7 +4726,8 @@ function serializeInheritedMember(symbol, inheritedFrom, ctx, isStatic) {
     signatures = callSigs.map((sig, index) => {
       const params = extractParameters(sig, ctx);
       const returnType = checker.getReturnTypeOfSignature(sig);
-      registerReferencedTypes(returnType, ctx);
+      if (registerTypes)
+        registerReferencedTypes(returnType, ctx);
       const sigDoc = getJSDocForSignature(sig, checker);
       return {
         parameters: params.length > 0 ? params : undefined,
@@ -4653,20 +4748,25 @@ function serializeInheritedMember(symbol, inheritedFrom, ctx, isStatic) {
     description,
     tags: tags.length > 0 ? tags : undefined,
     visibility,
-    schema: kind !== "method" ? buildSchema(type, checker, ctx, declaredTypeNode(decl)) : decoratePropertySchema({ "x-ts-function": true }, symbol, type, checker),
+    schema: kind !== "method" ? buildSchema(type, checker, ctx, declaredTypeNode(decl)) : inheritedMethodSchema(symbol, type, ctx),
     signatures,
     flags: Object.keys(flags).length > 0 ? flags : undefined,
-    ...inlineTags ? { inlineTags } : {}
+    ...inlineTags ? { inlineTags } : {},
+    ...deprecated ? { deprecated: true, deprecationReason } : {}
   };
 }
 
 // src/serializers/shared.ts
+import ts9 from "typescript";
 function extractExportMetadata(node, symbol, checker, jsdocNode) {
   const { deprecated, reason: deprecationReason } = isSymbolDeprecated(symbol);
   const { description, tags, examples, inlineTags } = getJSDocComment(jsdocNode ?? node, symbol, checker);
   const source = getSourceLocation(node, node.getSourceFile());
   return { description, tags, examples, source, deprecated, deprecationReason, inlineTags };
 }
+function anonymousDefaultName(node) {
+  return ts9.getCombinedModifierFlags(node) & ts9.ModifierFlags.Default ? "default" : undefined;
+}
 function buildSignatures(callSignatures, checker, ctx) {
   return callSignatures.map((sig, index) => {
     const params = extractParameters(sig, ctx);
@@ -4691,7 +4791,7 @@ function buildSignatures(callSignatures, checker, ctx) {
 function serializeClass(node, ctx) {
   const { typeChecker: checker } = ctx;
   const symbol = checker.getSymbolAtLocation(node.name ?? node);
-  const name = symbol?.getName() ?? node.name?.getText();
+  const name = symbol?.getName() ?? node.name?.getText() ?? anonymousDefaultName(node);
   if (!name)
     return null;
   const { description, tags, examples, source, deprecated, deprecationReason, inlineTags } = extractExportMetadata(node, symbol, checker);
@@ -4703,11 +4803,11 @@ function serializeClass(node, ctx) {
     const memberName = getMemberName(member);
     if (memberName?.startsWith("#"))
       continue;
-    if (ts9.isPropertyDeclaration(member)) {
+    if (ts10.isPropertyDeclaration(member)) {
       const propMember = serializeProperty(member, ctx);
       if (propMember)
         members.push(propMember);
-    } else if (ts9.isMethodDeclaration(member)) {
+    } else if (ts10.isMethodDeclaration(member)) {
       const methodMember = serializeMethod(member, ctx);
       if (methodMember?.name) {
         if (!methodsByName.has(methodMember.name)) {
@@ -4724,11 +4824,11 @@ function serializeClass(node, ctx) {
           }
         }
       }
-    } else if (ts9.isConstructorDeclaration(member)) {
+    } else if (ts10.isConstructorDeclaration(member)) {
       const ctorSig = serializeConstructor(member, ctx);
       if (ctorSig)
         signatures.push(ctorSig);
-    } else if (ts9.isGetAccessorDeclaration(member) || ts9.isSetAccessorDeclaration(member)) {
+    } else if (ts10.isGetAccessorDeclaration(member) || ts10.isSetAccessorDeclaration(member)) {
       const accessorMember = serializeAccessor(member, ctx);
       if (accessorMember)
         members.push(accessorMember);
@@ -4752,8 +4852,8 @@ function serializeClass(node, ctx) {
   const extendsClause = getExtendsClause(node, checker);
   const implementsClause = getImplementsClause(node, checker);
   const classFlags = {};
-  const classModifiers = ts9.getModifiers(node);
-  if (classModifiers?.some((m) => m.kind === ts9.SyntaxKind.AbstractKeyword)) {
+  const classModifiers = ts10.getModifiers(node);
+  if (classModifiers?.some((m) => m.kind === ts10.SyntaxKind.AbstractKeyword)) {
     classFlags.abstract = true;
   }
   return {
@@ -4775,37 +4875,37 @@ function serializeClass(node, ctx) {
   };
 }
 function getMemberName(member) {
-  if (ts9.isConstructorDeclaration(member))
+  if (ts10.isConstructorDeclaration(member))
     return "constructor";
   if (!member.name)
     return;
-  if (ts9.isIdentifier(member.name))
+  if (ts10.isIdentifier(member.name))
     return member.name.text;
-  if (ts9.isPrivateIdentifier(member.name))
+  if (ts10.isPrivateIdentifier(member.name))
     return member.name.text;
   return member.name.getText();
 }
 function getVisibility(member) {
-  const modifiers = ts9.canHaveModifiers(member) ? ts9.getModifiers(member) : undefined;
+  const modifiers = ts10.canHaveModifiers(member) ? ts10.getModifiers(member) : undefined;
   if (!modifiers)
     return;
   for (const mod of modifiers) {
-    if (mod.kind === ts9.SyntaxKind.PrivateKeyword)
+    if (mod.kind === ts10.SyntaxKind.PrivateKeyword)
       return "private";
-    if (mod.kind === ts9.SyntaxKind.ProtectedKeyword)
+    if (mod.kind === ts10.SyntaxKind.ProtectedKeyword)
       return "protected";
-    if (mod.kind === ts9.SyntaxKind.PublicKeyword)
+    if (mod.kind === ts10.SyntaxKind.PublicKeyword)
       return "public";
   }
   return;
 }
 function isStatic(member) {
-  const modifiers = ts9.canHaveModifiers(member) ? ts9.getModifiers(member) : undefined;
-  return modifiers?.some((m) => m.kind === ts9.SyntaxKind.StaticKeyword) ?? false;
+  const modifiers = ts10.canHaveModifiers(member) ? ts10.getModifiers(member) : undefined;
+  return modifiers?.some((m) => m.kind === ts10.SyntaxKind.StaticKeyword) ?? false;
 }
 function isReadonly(member) {
-  const modifiers = ts9.canHaveModifiers(member) ? ts9.getModifiers(member) : undefined;
-  return modifiers?.some((m) => m.kind === ts9.SyntaxKind.ReadonlyKeyword) ?? false;
+  const modifiers = ts10.canHaveModifiers(member) ? ts10.getModifiers(member) : undefined;
+  return modifiers?.some((m) => m.kind === ts10.SyntaxKind.ReadonlyKeyword) ?? false;
 }
 function serializeProperty(node, ctx) {
   const { typeChecker: checker } = ctx;
@@ -4864,11 +4964,11 @@ function serializeMethod(node, ctx) {
   if (node.asteriskToken)
     flags.generator = true;
   flags.methodSyntax = true;
-  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 (modifiers?.some((m) => m.kind === ts9.SyntaxKind.AbstractKeyword)) {
+  if (modifiers?.some((m) => m.kind === ts10.SyntaxKind.AbstractKeyword)) {
     flags.abstract = true;
   }
   const symbol = checker.getSymbolAtLocation(node.name ?? node);
@@ -4894,8 +4994,18 @@ function serializeConstructor(node, ctx) {
     return null;
   return serializeConstructorSignature(node, sig, ctx);
 }
+function serializeConstructSignatures(sigs, ctx) {
+  return sigs.map((sig, index) => {
+    const typeParameters = extractTypeParametersFromSignature(sig, ctx.typeChecker);
+    return {
+      ...serializeConstructorSignature(sig.getDeclaration(), sig, ctx),
+      ...typeParameters ? { typeParameters } : {},
+      ...sigs.length > 1 ? { overloadIndex: index } : {}
+    };
+  });
+}
 function serializeConstructorSignature(node, sig, ctx) {
-  const { description, tags, examples, inlineTags } = getJSDocComment(node);
+  const { description, tags, examples, inlineTags } = node ? getJSDocComment(node) : { description: undefined, tags: [], examples: [], inlineTags: undefined };
   const params = extractParameters(sig, ctx);
   return {
     description,
@@ -4907,7 +5017,7 @@ function serializeConstructorSignature(node, sig, ctx) {
 }
 function serializeInheritedConstructors(node, ctx) {
   const { typeChecker: checker } = ctx;
-  const hasExtends = node.heritageClauses?.some((c) => c.token === ts9.SyntaxKind.ExtendsKeyword);
+  const hasExtends = node.heritageClauses?.some((c) => c.token === ts10.SyntaxKind.ExtendsKeyword);
   if (!hasExtends)
     return [];
   const symbol = checker.getSymbolAtLocation(node.name ?? node);
@@ -4916,11 +5026,11 @@ function serializeInheritedConstructors(node, ctx) {
   const staticType = checker.getTypeOfSymbolAtLocation(symbol, node);
   const ctorSigs = staticType.getConstructSignatures().filter((sig) => {
     const decl = sig.getDeclaration();
-    return decl !== undefined && ts9.isConstructorDeclaration(decl);
+    return decl !== undefined && ts10.isConstructorDeclaration(decl);
   });
   return ctorSigs.map((sig, index) => {
     const decl = sig.getDeclaration();
-    const owner = ts9.isClassLike(decl.parent) ? decl.parent.name?.text : undefined;
+    const owner = ts10.isClassLike(decl.parent) ? decl.parent.name?.text : undefined;
     return {
       ...serializeConstructorSignature(decl, sig, ctx),
       ...owner ? { inheritedFrom: owner } : {},
@@ -4939,14 +5049,14 @@ function serializeAccessor(node, ctx) {
     return null;
   }
   const type = checker.getTypeAtLocation(node);
-  const schema = buildSchema(type, checker, ctx, ts9.isGetAccessorDeclaration(node) ? node.type : undefined);
+  const schema = buildSchema(type, checker, ctx, ts10.isGetAccessorDeclaration(node) ? node.type : undefined);
   registerReferencedTypes(type, ctx);
-  const kind = ts9.isGetAccessorDeclaration(node) ? "getter" : "setter";
+  const kind = ts10.isGetAccessorDeclaration(node) ? "getter" : "setter";
   const flags = {};
   if (isStatic(node))
     flags.static = true;
   let signatures;
-  if (ts9.isSetAccessorDeclaration(node) && node.parameters.length > 0) {
+  if (ts10.isSetAccessorDeclaration(node) && node.parameters.length > 0) {
     const param = node.parameters[0];
     const paramName = param.name.getText();
     const paramType = checker.getTypeAtLocation(param);
@@ -4979,7 +5089,7 @@ function getExtendsClause(node, checker) {
   if (!node.heritageClauses)
     return;
   for (const clause of node.heritageClauses) {
-    if (clause.token === ts9.SyntaxKind.ExtendsKeyword) {
+    if (clause.token === ts10.SyntaxKind.ExtendsKeyword) {
       const expr = clause.types[0];
       if (expr) {
         const type = checker.getTypeAtLocation(expr);
@@ -4994,7 +5104,7 @@ function getImplementsClause(node, checker) {
   if (!node.heritageClauses)
     return;
   for (const clause of node.heritageClauses) {
-    if (clause.token === ts9.SyntaxKind.ImplementsKeyword) {
+    if (clause.token === ts10.SyntaxKind.ImplementsKeyword) {
       return clause.types.map((expr) => {
         const type = checker.getTypeAtLocation(expr);
         const symbol = type.getSymbol();
@@ -5057,16 +5167,16 @@ function serializeEnum(node, ctx) {
 }
 
 // src/serializers/functions.ts
-import ts10 from "typescript";
+import ts11 from "typescript";
 function buildReturnSchema(sig, ctx) {
   const returnType = ctx.typeChecker.getReturnTypeOfSignature(sig);
   registerReferencedTypes(returnType, ctx);
   const schema = buildSchema(returnType, ctx.typeChecker, ctx, typeNodeOfSignature(sig));
   const declaration = sig.getDeclaration();
-  if (declaration && ts10.isFunctionLike(declaration) && declaration.type) {
+  if (declaration && ts11.isFunctionLike(declaration) && declaration.type) {
     const returnTypeNode = declaration.type;
-    if (ts10.isTypePredicateNode(returnTypeNode)) {
-      const parameterName = ts10.isIdentifier(returnTypeNode.parameterName) ? returnTypeNode.parameterName.text : returnTypeNode.parameterName.getText();
+    if (ts11.isTypePredicateNode(returnTypeNode)) {
+      const parameterName = ts11.isIdentifier(returnTypeNode.parameterName) ? returnTypeNode.parameterName.text : returnTypeNode.parameterName.getText();
       let predicateTypeSchema = { type: "unknown" };
       if (returnTypeNode.type) {
         const predicateType = ctx.typeChecker.getTypeAtLocation(returnTypeNode.type);
@@ -5087,10 +5197,10 @@ function buildReturnSchema(sig, ctx) {
   return { schema };
 }
 function functionSignatureDecls(node, ctx) {
-  if (!ts10.isFunctionDeclaration(node) || !node.name)
+  if (!ts11.isFunctionDeclaration(node) || !node.name)
     return [node];
   const symbol = ctx.typeChecker.getSymbolAtLocation(node.name);
-  const fns = (symbol?.declarations ?? []).filter(ts10.isFunctionDeclaration);
+  const fns = (symbol?.declarations ?? []).filter(ts11.isFunctionDeclaration);
   const overloads = fns.filter((d) => !d.body);
   return overloads.length > 0 ? overloads : [node];
 }
@@ -5122,14 +5232,15 @@ function schemaFromTypeNode(node, ctx) {
   return buildSchema(ctx.typeChecker.getTypeFromTypeNode(node), ctx.typeChecker, ctx, node);
 }
 function parametersFromAst(decl, ctx) {
-  const jsdocTags = ts10.getJSDocTags(decl);
+  const jsdocTags = ts11.getJSDocTags(decl);
   return decl.parameters.map((p) => {
-    const name = ts10.isIdentifier(p.name) ? p.name.text : p.name.getText();
+    const name = ts11.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
+      required: !isOptional && !p.dotDotDotToken,
+      ...p.dotDotDotToken ? { rest: true } : {}
     };
     const description = getParamDescription(name, jsdocTags);
     if (description)
@@ -5137,11 +5248,10 @@ function parametersFromAst(decl, ctx) {
     return param;
   });
 }
-function signaturesFromAst(node, ctx) {
-  const decls = functionSignatureDecls(node, ctx);
+function signaturesFromAst(decls, 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 sigTypeParams = ts11.isFunctionDeclaration(decl) || ts11.isArrowFunction(decl) || ts11.isFunctionExpression(decl) || ts11.isFunctionTypeNode(decl) ? extractTypeParameters(decl, ctx.typeChecker) : undefined;
     const returns = { schema: schemaFromTypeNode(decl.type, ctx) };
     return {
       parameters: parametersFromAst(decl, ctx),
@@ -5154,9 +5264,7 @@ function signaturesFromAst(node, ctx) {
     };
   });
 }
-function signaturesFromChecker(node, ctx) {
-  const type = ctx.typeChecker.getTypeAtLocation(node);
-  const callSignatures = type.getCallSignatures();
+function signaturesFromChecker(callSignatures, ctx) {
   return callSignatures.map((sig, index) => {
     const sigDoc = getJSDocForSignature(sig, ctx.typeChecker);
     const sigTypeParams = extractTypeParametersFromSignature(sig, ctx.typeChecker);
@@ -5171,17 +5279,31 @@ function signaturesFromChecker(node, ctx) {
     };
   });
 }
-function serializeFunctionExport(node, ctx, nameOverride) {
+function unwrapParens(node) {
+  return ts11.isParenthesizedTypeNode(node) ? unwrapParens(node.type) : node;
+}
+function signaturesFromDeclaredType(typeNode, ctx) {
+  const inner = unwrapParens(typeNode);
+  if (ts11.isFunctionTypeNode(inner) && signatureDeclDefers(inner, ctx)) {
+    return signaturesFromAst([inner], ctx);
+  }
+  if (typeNodeDefersExpansion(inner, ctx.typeChecker, ctx.program))
+    return;
+  const callSignatures = ctx.typeChecker.getTypeFromTypeNode(inner).getCallSignatures();
+  return callSignatures.length > 0 ? signaturesFromChecker(callSignatures, ctx) : undefined;
+}
+function serializeFunctionExport(node, ctx, nameOverride, declaredType, jsdocNode) {
   const symbol = ctx.typeChecker.getSymbolAtLocation(node.name ?? node);
-  const name = nameOverride ?? symbol?.getName() ?? node.name?.getText();
+  const name = nameOverride ?? symbol?.getName() ?? node.name?.getText() ?? anonymousDefaultName(node);
   if (!name)
     return null;
-  const { description, tags, examples, source, deprecated, deprecationReason, inlineTags } = extractExportMetadata(node, symbol, ctx.typeChecker);
-  const typeParameters = extractTypeParameters(node, ctx.typeChecker);
-  const signatures = anySignatureDefers(node, ctx) ? signaturesFromAst(node, ctx) : signaturesFromChecker(node, ctx);
+  const { description, tags, examples, source, deprecated, deprecationReason, inlineTags } = extractExportMetadata(node, symbol, ctx.typeChecker, jsdocNode);
+  const declaredFn = declaredType && unwrapParens(declaredType);
+  const typeParameters = extractTypeParameters(declaredFn && ts11.isFunctionTypeNode(declaredFn) ? declaredFn : node, ctx.typeChecker);
+  const signatures = (declaredType && signaturesFromDeclaredType(declaredType, ctx)) ?? (anySignatureDefers(node, ctx) ? signaturesFromAst(functionSignatureDecls(node, ctx), ctx) : signaturesFromChecker(ctx.typeChecker.getTypeAtLocation(node).getCallSignatures(), ctx));
   const flags = {};
-  const modifiers = ts10.getModifiers(node);
-  if (modifiers?.some((m) => m.kind === ts10.SyntaxKind.AsyncKeyword)) {
+  const modifiers = ts11.getModifiers(node);
+  if (modifiers?.some((m) => m.kind === ts11.SyntaxKind.AsyncKeyword)) {
     flags.async = true;
   }
   if (node.asteriskToken) {
@@ -5204,7 +5326,7 @@ function serializeFunctionExport(node, ctx, nameOverride) {
 }
 
 // src/serializers/interfaces.ts
-import ts11 from "typescript";
+import ts12 from "typescript";
 function serializeInterface(node, ctx) {
   const { typeChecker: checker } = ctx;
   const symbol = checker.getSymbolAtLocation(node.name ?? node);
@@ -5213,15 +5335,35 @@ function serializeInterface(node, ctx) {
     return null;
   const { description, tags, examples, source, deprecated, deprecationReason, inlineTags } = extractExportMetadata(node, symbol, checker);
   const typeParameters = extractTypeParameters(node, checker);
+  const { members, callSignatureMember } = serializeTypeElements(node.members, ctx);
+  const extendsClause = getInterfaceExtends(node, checker);
+  const exportSignatures = callSignatureMember?.signatures && callSignatureMember.signatures.length > 0 ? callSignatureMember.signatures : undefined;
+  return {
+    id: name,
+    name,
+    kind: "interface",
+    description,
+    tags,
+    source,
+    typeParameters,
+    members: members.length > 0 ? members : undefined,
+    signatures: exportSignatures,
+    extends: extendsClause,
+    ...deprecated ? { deprecated: true, deprecationReason } : {},
+    ...examples.length > 0 ? { examples } : {},
+    ...inlineTags ? { inlineTags } : {}
+  };
+}
+function serializeTypeElements(elements, ctx) {
   const members = [];
   const methodsByName = new Map;
   let callSignatureMember = null;
-  for (const member of node.members) {
-    if (ts11.isPropertySignature(member)) {
+  for (const member of elements) {
+    if (ts12.isPropertySignature(member)) {
       const propMember = serializePropertySignature(member, ctx);
       if (propMember)
         members.push(propMember);
-    } else if (ts11.isMethodSignature(member)) {
+    } else if (ts12.isMethodSignature(member)) {
       const methodMember = serializeMethodSignature(member, ctx);
       if (methodMember?.name && methodMember.signatures) {
         const existing = methodsByName.get(methodMember.name);
@@ -5242,7 +5384,7 @@ function serializeInterface(node, ctx) {
           methodsByName.set(methodMember.name, methodMember);
         }
       }
-    } else if (ts11.isCallSignatureDeclaration(member)) {
+    } else if (ts12.isCallSignatureDeclaration(member)) {
       const callSig = serializeCallSignature(member, ctx);
       if (callSig?.signatures) {
         if (callSignatureMember?.signatures) {
@@ -5265,7 +5407,7 @@ function serializeInterface(node, ctx) {
           callSignatureMember = callSig;
         }
       }
-    } else if (ts11.isIndexSignatureDeclaration(member)) {
+    } else if (ts12.isIndexSignatureDeclaration(member)) {
       const indexMember = serializeIndexSignature(member, ctx);
       if (indexMember)
         members.push(indexMember);
@@ -5275,22 +5417,31 @@ function serializeInterface(node, ctx) {
     members.push(callSignatureMember);
   }
   members.push(...methodsByName.values());
-  const extendsClause = getInterfaceExtends(node, checker);
-  const exportSignatures = callSignatureMember?.signatures && callSignatureMember.signatures.length > 0 ? callSignatureMember.signatures : undefined;
+  return { members, callSignatureMember };
+}
+function serializeMergedTypeSide(symbol, ctx) {
+  const { typeChecker: checker } = ctx;
+  const declarations = symbol.declarations ?? [];
+  const interfaces = declarations.filter(ts12.isInterfaceDeclaration);
+  const alias = declarations.find(ts12.isTypeAliasDeclaration);
+  const typeDecl = interfaces[0] ?? alias;
+  if (!typeDecl)
+    return;
+  const elements = interfaces.length > 0 ? interfaces.flatMap((decl) => [...decl.members]) : alias && ts12.isTypeLiteralNode(alias.type) ? [...alias.type.members] : [];
+  const { members } = serializeTypeElements(elements, ctx);
+  if (interfaces.length > 0) {
+    const ownNames = new Set(members.flatMap((m) => m.name ? [m.name] : []));
+    members.push(...getInheritedMembers(checker.getDeclaredTypeOfSymbol(symbol), ownNames, ctx, false));
+  }
+  if (members.length === 0)
+    return;
+  const { description, tags } = getJSDocComment(typeDecl);
   return {
-    id: name,
-    name,
-    kind: "interface",
+    members,
+    extends: interfaces.map((decl) => getInterfaceExtends(decl, checker)).find(Boolean),
+    typeParameters: extractTypeParameters(typeDecl, checker),
     description,
-    tags,
-    source,
-    typeParameters,
-    members: members.length > 0 ? members : undefined,
-    signatures: exportSignatures,
-    extends: extendsClause,
-    ...deprecated ? { deprecated: true, deprecationReason } : {},
-    ...examples.length > 0 ? { examples } : {},
-    ...inlineTags ? { inlineTags } : {}
+    tags
   };
 }
 function serializePropertySignature(node, ctx) {
@@ -5304,7 +5455,7 @@ function serializePropertySignature(node, ctx) {
   const flags = {};
   if (node.questionToken)
     flags.optional = true;
-  if (node.modifiers?.some((m) => m.kind === ts11.SyntaxKind.ReadonlyKeyword)) {
+  if (node.modifiers?.some((m) => m.kind === ts12.SyntaxKind.ReadonlyKeyword)) {
     flags.readonly = true;
   }
   const symbol = checker.getSymbolAtLocation(node.name);
@@ -5327,7 +5478,8 @@ function serializeMethodSignature(node, ctx) {
   const { typeChecker: checker } = ctx;
   const name = node.name.getText();
   const { description, tags, inlineTags } = getJSDocComment(node);
-  const type = checker.getTypeAtLocation(node);
+  const rawType = checker.getTypeAtLocation(node);
+  const type = node.questionToken ? stripUndefinedFromType(rawType, checker) : rawType;
   const callSignatures = type.getCallSignatures();
   const signatures = buildSignatures(callSignatures, checker, ctx);
   const flags = {};
@@ -5396,7 +5548,7 @@ function getInterfaceExtends(node, checker) {
   if (!node.heritageClauses)
     return;
   for (const clause of node.heritageClauses) {
-    if (clause.token === ts11.SyntaxKind.ExtendsKeyword && clause.types.length > 0) {
+    if (clause.token === ts12.SyntaxKind.ExtendsKeyword && clause.types.length > 0) {
       const names = clause.types.map((expr) => {
         const type = checker.getTypeAtLocation(expr);
         return type.getSymbol()?.getName() ?? expr.expression.getText();
@@ -5408,7 +5560,7 @@ function getInterfaceExtends(node, checker) {
 }
 
 // src/serializers/type-aliases.ts
-import ts12 from "typescript";
+import ts13 from "typescript";
 function buildIntersectionSchemaFromNode(node, ctx) {
   const types = node.types;
   const schemas = [];
@@ -5436,7 +5588,7 @@ function serializeTypeAlias(node, ctx) {
   registerReferencedTypes(type, ctx);
   let schema;
   let members;
-  if (ts12.isIntersectionTypeNode(node.type)) {
+  if (ts13.isIntersectionTypeNode(node.type)) {
     schema = buildIntersectionSchemaFromNode(node.type, ctx);
     if (type.getProperties().length > 0 && type.getCallSignatures().length === 0) {
       members = serializeResolvedMembers(type, node, ctx);
@@ -5446,7 +5598,7 @@ function serializeTypeAlias(node, ctx) {
     if (type.getProperties().length > 0) {
       members = serializeResolvedMembers(type, node, ctx);
     }
-  } 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))) {
+  } else if ((ts13.isMappedTypeNode(node.type) || ts13.isConditionalTypeNode(node.type)) && type.getProperties().length > 0 && type.getCallSignatures().length === 0 && !(type.flags & ts13.TypeFlags.Conditional) && !(type.flags & (ts13.TypeFlags.StringLike | ts13.TypeFlags.NumberLike))) {
     schema = buildObjectSchema(type.getProperties(), ctx.typeChecker, ctx, type);
     members = serializeResolvedMembers(type, node, ctx);
   } else {
@@ -5456,7 +5608,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, ts12.TypeFormatFlags.InTypeAlias);
+    const text = renderTypeText(type, ctx.typeChecker, node, ts13.TypeFormatFlags.InTypeAlias);
     if (!PRIMITIVES.has(text) && text !== name) {
       schema["x-ts-type"] = text;
       const declared = writtenTypeText(declaredTypeNode(node));
@@ -5482,12 +5634,12 @@ function serializeTypeAlias(node, ctx) {
 }
 function isObjectShapedAlias(type, ctx) {
   const { typeChecker: checker } = ctx;
-  if (!(type.flags & ts12.TypeFlags.Object))
+  if (!(type.flags & ts13.TypeFlags.Object))
     return false;
   if (checker.isArrayType(type) || checker.isTupleType(type))
     return false;
   const objectFlags = type.objectFlags;
-  if (!(objectFlags & ts12.ObjectFlags.Mapped)) {
+  if (!(objectFlags & ts13.ObjectFlags.Mapped)) {
     const targetSymbol = type.target?.getSymbol?.() ?? type.getSymbol();
     if (isBuiltinSymbol(targetSymbol))
       return false;
@@ -5495,19 +5647,19 @@ function isObjectShapedAlias(type, ctx) {
   return type.getProperties().length > 0 && type.getCallSignatures().length === 0;
 }
 function isInlineFunctionAlias(typeNode) {
-  return ts12.isFunctionTypeNode(typeNode) || ts12.isTypeLiteralNode(typeNode) && typeNode.members.some(ts12.isCallSignatureDeclaration);
+  return ts13.isFunctionTypeNode(typeNode) || ts13.isTypeLiteralNode(typeNode) && typeNode.members.some(ts13.isCallSignatureDeclaration);
 }
 function buildConditionalArmDocs(typeNode, checker) {
   const docs = new Map;
-  if (!ts12.isMappedTypeNode(typeNode) || !typeNode.type)
+  if (!ts13.isMappedTypeNode(typeNode) || !typeNode.type)
     return docs;
   const literalKeys = (extendsType) => {
     const keys = [];
     const visit = (n) => {
-      if (ts12.isUnionTypeNode(n)) {
+      if (ts13.isUnionTypeNode(n)) {
         for (const member of n.types)
           visit(member);
-      } else if (ts12.isLiteralTypeNode(n) && ts12.isStringLiteral(n.literal)) {
+      } else if (ts13.isLiteralTypeNode(n) && ts13.isStringLiteral(n.literal)) {
         keys.push(n.literal.text);
       }
     };
@@ -5515,12 +5667,12 @@ function buildConditionalArmDocs(typeNode, checker) {
     return keys;
   };
   const armDoc = (armType) => {
-    if (!ts12.isTypeReferenceNode(armType))
+    if (!ts13.isTypeReferenceNode(armType))
       return;
     const symbol = checker.getSymbolAtLocation(armType.typeName);
     if (!symbol)
       return;
-    const target = symbol.flags & ts12.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+    const target = symbol.flags & ts13.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;
@@ -5529,7 +5681,7 @@ function buildConditionalArmDocs(typeNode, checker) {
     return { deprecated, deprecationReason: reason, description };
   };
   let current = typeNode.type;
-  while (current && ts12.isConditionalTypeNode(current)) {
+  while (current && ts13.isConditionalTypeNode(current)) {
     const doc = armDoc(current.trueType);
     if (doc) {
       for (const key of literalKeys(current.extendsType)) {
@@ -5548,10 +5700,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 & ts12.SymbolFlags.Optional ? stripUndefinedFromType(rawPropType, checker) : rawPropType;
+    const propType = prop.flags & ts13.SymbolFlags.Optional ? stripUndefinedFromType(rawPropType, checker) : rawPropType;
     registerReferencedTypes(propType, ctx);
     const callSigs = propType.getCallSignatures();
-    const isMethodDecl = ts12.isMethodSignature(decl) || ts12.isMethodDeclaration(decl) || ts12.isFunctionDeclaration(decl);
+    const isMethodDecl = ts13.isMethodSignature(decl) || ts13.isMethodDeclaration(decl) || ts13.isFunctionDeclaration(decl);
     const kind = callSigs.length > 0 && isMethodDecl ? "method" : "property";
     let { description, tags } = getJSDocComment(decl, prop, checker);
     let { deprecated, reason: deprecationReason } = isSymbolDeprecated(prop);
@@ -5569,11 +5721,11 @@ function serializeResolvedMembers(type, node, ctx) {
       ({ deprecated, reason: deprecationReason } = isSymbolDeprecated(armAlias));
     }
     const flags = {};
-    if (prop.flags & ts12.SymbolFlags.Optional)
+    if (prop.flags & ts13.SymbolFlags.Optional)
       flags.optional = true;
     if (isReadonlyPropertySymbol(prop))
       flags.readonly = true;
-    if (prop.flags & ts12.SymbolFlags.Method)
+    if (prop.flags & ts13.SymbolFlags.Method)
       flags.methodSyntax = true;
     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);
@@ -5592,14 +5744,17 @@ function serializeResolvedMembers(type, node, ctx) {
   return members;
 }
 
+// src/serializers/variables.ts
+import ts15 from "typescript";
+
 // src/schema/registry.ts
-import ts13 from "typescript";
+import ts14 from "typescript";
 function isTypeReference(type) {
-  return !!(type.flags & ts13.TypeFlags.Object && type.objectFlags && type.objectFlags & ts13.ObjectFlags.Reference);
+  return !!(type.flags & ts14.TypeFlags.Object && type.objectFlags && type.objectFlags & ts14.ObjectFlags.Reference);
 }
 function getNonNullableType(type) {
   if (type.isUnion()) {
-    const nonNullable = type.types.filter((t) => !(t.flags & ts13.TypeFlags.Undefined) && !(t.flags & ts13.TypeFlags.Null));
+    const nonNullable = type.types.filter((t) => !(t.flags & ts14.TypeFlags.Undefined) && !(t.flags & ts14.TypeFlags.Null));
     if (nonNullable.length === 1) {
       return nonNullable[0];
     }
@@ -5762,12 +5917,17 @@ function serializeVariable(node, statement, ctx) {
   const name = symbol?.getName() ?? node.name.getText();
   if (!name)
     return null;
-  const { description, tags, examples, source, deprecated, deprecationReason, inlineTags } = extractExportMetadata(node, symbol, ctx.typeChecker, statement);
-  const type = ctx.typeChecker.getTypeAtLocation(node);
+  return serializeValue(name, node, symbol, statement, ctx.typeChecker.getTypeAtLocation(node), ts15.isVariableDeclaration(node) ? node.type : undefined, ctx);
+}
+function serializeDefaultExpression(node, symbol, type, ctx) {
+  return serializeValue(symbol.getName(), node.expression, symbol, node, type, undefined, ctx);
+}
+function serializeValue(name, node, symbol, jsdocNode, type, typeNode, ctx) {
+  const { description, tags, examples, source, deprecated, deprecationReason, inlineTags } = extractExportMetadata(node, symbol, ctx.typeChecker, jsdocNode);
   const schemaExtraction = extractSchemaType(type, ctx.typeChecker);
   const typeToSerialize = schemaExtraction?.outputType ?? type;
   registerReferencedTypes(typeToSerialize, ctx);
-  const schema = buildSchema(typeToSerialize, ctx.typeChecker, ctx, node.type);
+  const schema = buildSchema(typeToSerialize, ctx.typeChecker, ctx, typeNode);
   const flags = schemaExtraction ? {
     schemaLibrary: schemaExtraction.adapter.id,
     ...schemaExtraction.inputType && schemaExtraction.inputType !== schemaExtraction.outputType ? { hasTransform: true } : {}
@@ -6353,9 +6513,10 @@ async function getExport(options) {
   }
   const ctx = createContext(program, sourceFile, { maxTypeDepth });
   ctx.exportedIds = exportedIds;
+  claimExportedTypeIds(exportedSymbols, ctx);
   try {
     const originalDecls = targetSymbol.declarations ?? [];
-    const isNamespaceExportDecl = originalDecls.some((d) => ts14.isNamespaceExport(d) || ts14.isNamespaceImport(d));
+    const isNamespaceExportDecl = originalDecls.some((d) => ts16.isNamespaceExport(d) || ts16.isNamespaceImport(d));
     if (isNamespaceExportDecl) {
       const spec2 = serializeNamespaceForGet(targetSymbol, exportName, ctx);
       const types2 = ctx.typeRegistry.getAll().map((t) => normalizeType(t));
@@ -6406,42 +6567,42 @@ function resolveExportTarget2(symbol, checker) {
   let isTypeOnly = false;
   const declarations = symbol.declarations ?? [];
   for (const decl of declarations) {
-    if (ts14.isExportSpecifier(decl)) {
+    if (ts16.isExportSpecifier(decl)) {
       if (decl.isTypeOnly)
         isTypeOnly = true;
       const exportDecl = decl.parent?.parent;
-      if (exportDecl && ts14.isExportDeclaration(exportDecl) && exportDecl.isTypeOnly) {
+      if (exportDecl && ts16.isExportDeclaration(exportDecl) && exportDecl.isTypeOnly) {
         isTypeOnly = true;
       }
     }
   }
-  if (symbol.flags & ts14.SymbolFlags.Alias) {
+  if (symbol.flags & ts16.SymbolFlags.Alias) {
     const aliased = checker.getAliasedSymbol(symbol);
     if (aliased && aliased !== symbol) {
       resolvedSymbol2 = aliased;
     }
   }
   const targetDeclarations = resolvedSymbol2.declarations ?? [];
-  const declaration = resolvedSymbol2.valueDeclaration || targetDeclarations.find((d) => d.kind !== ts14.SyntaxKind.ExportSpecifier) || targetDeclarations[0];
+  const declaration = resolvedSymbol2.valueDeclaration || targetDeclarations.find((d) => d.kind !== ts16.SyntaxKind.ExportSpecifier) || targetDeclarations[0];
   return { declaration, resolvedSymbol: resolvedSymbol2, isTypeOnly };
 }
 function serializeDeclaration(declaration, _exportSymbol, _targetSymbol, exportName, ctx, isTypeOnly) {
   let result = null;
-  if (ts14.isFunctionDeclaration(declaration)) {
+  if (ts16.isFunctionDeclaration(declaration)) {
     result = serializeFunctionExport(declaration, ctx);
-  } else if (ts14.isClassDeclaration(declaration)) {
+  } else if (ts16.isClassDeclaration(declaration)) {
     result = serializeClass(declaration, ctx);
-  } else if (ts14.isInterfaceDeclaration(declaration)) {
+  } else if (ts16.isInterfaceDeclaration(declaration)) {
     result = serializeInterface(declaration, ctx);
-  } else if (ts14.isTypeAliasDeclaration(declaration)) {
+  } else if (ts16.isTypeAliasDeclaration(declaration)) {
     result = serializeTypeAlias(declaration, ctx);
-  } else if (ts14.isEnumDeclaration(declaration)) {
+  } else if (ts16.isEnumDeclaration(declaration)) {
     result = serializeEnum(declaration, ctx);
-  } else if (ts14.isVariableDeclaration(declaration)) {
+  } else if (ts16.isVariableDeclaration(declaration)) {
     const varStatement = declaration.parent?.parent;
-    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();
+    if (varStatement && ts16.isVariableStatement(varStatement)) {
+      if (declaration.initializer && (ts16.isArrowFunction(declaration.initializer) || ts16.isFunctionExpression(declaration.initializer))) {
+        const varName = ts16.isIdentifier(declaration.name) ? declaration.name.text : declaration.name.getText();
         result = serializeFunctionExport(declaration.initializer, ctx, varName);
       } else {
         const checker = ctx.program.getTypeChecker();
@@ -6455,7 +6616,7 @@ function serializeDeclaration(declaration, _exportSymbol, _targetSymbol, exportN
         }
       }
     }
-  } else if (ts14.isNamespaceExport(declaration) || ts14.isModuleDeclaration(declaration) || ts14.isNamespaceImport(declaration) || ts14.isSourceFile(declaration)) {
+  } else if (ts16.isNamespaceExport(declaration) || ts16.isModuleDeclaration(declaration) || ts16.isNamespaceImport(declaration) || ts16.isSourceFile(declaration)) {
     result = serializeNamespaceForGet(_exportSymbol, exportName, ctx);
   }
   if (result) {
@@ -6471,7 +6632,7 @@ function serializeDeclaration(declaration, _exportSymbol, _targetSymbol, exportN
 function serializeNamespaceForGet(symbol, exportName, ctx) {
   const checker = ctx.program.getTypeChecker();
   let targetSymbol = symbol;
-  if (symbol.flags & ts14.SymbolFlags.Alias) {
+  if (symbol.flags & ts16.SymbolFlags.Alias) {
     const aliased = checker.getAliasedSymbol(symbol);
     if (aliased && aliased !== symbol) {
       targetSymbol = aliased;
@@ -6501,7 +6662,7 @@ function serializeNamespaceForGet(symbol, exportName, ctx) {
 }
 function detectExternalPackage(symbol, checker) {
   let targetSymbol = symbol;
-  if (symbol.flags & ts14.SymbolFlags.Alias) {
+  if (symbol.flags & ts16.SymbolFlags.Alias) {
     const aliased = checker.getAliasedSymbol(symbol);
     if (aliased && aliased !== symbol) {
       targetSymbol = aliased;
@@ -6513,9 +6674,9 @@ function detectExternalPackage(symbol, checker) {
     const pkg = sf && packageNameFromPath(sf.fileName);
     if (pkg)
       return pkg;
-    if (ts14.isExportSpecifier(decl)) {
+    if (ts16.isExportSpecifier(decl)) {
       const exportDecl = decl.parent?.parent;
-      if (exportDecl && ts14.isExportDeclaration(exportDecl) && exportDecl.moduleSpecifier) {
+      if (exportDecl && ts16.isExportDeclaration(exportDecl) && exportDecl.moduleSpecifier) {
         const moduleText = exportDecl.moduleSpecifier.text;
         if (!moduleText.startsWith(".") && !moduleText.startsWith("/")) {
           return moduleText;
@@ -6527,7 +6688,7 @@ function detectExternalPackage(symbol, checker) {
 }
 // src/primitives/list.ts
 import * as path6 from "node:path";
-import ts15 from "typescript";
+import ts17 from "typescript";
 async function listExports(options) {
   const { entryFile, baseDir, content } = options;
   const errors = [];
@@ -6570,16 +6731,16 @@ async function listExports(options) {
 }
 function extractExportItem(symbol, checker, entryFile, entrySourceFile) {
   const name = symbol.getName();
-  const isReexport = !!(symbol.flags & ts15.SymbolFlags.Alias);
+  const isReexport = !!(symbol.flags & ts17.SymbolFlags.Alias);
   let targetSymbol = symbol;
-  if (symbol.flags & ts15.SymbolFlags.Alias) {
+  if (symbol.flags & ts17.SymbolFlags.Alias) {
     const aliased = checker.getAliasedSymbol(symbol);
     if (aliased && aliased !== symbol) {
       targetSymbol = aliased;
     }
   }
   const declarations = targetSymbol.declarations ?? [];
-  const declaration = targetSymbol.valueDeclaration || declarations.find((d) => d.kind !== ts15.SyntaxKind.ExportSpecifier) || declarations[0];
+  const declaration = targetSymbol.valueDeclaration || declarations.find((d) => d.kind !== ts17.SyntaxKind.ExportSpecifier) || declarations[0];
   if (!declaration) {
     return {
       name,
@@ -6589,7 +6750,7 @@ function extractExportItem(symbol, checker, entryFile, entrySourceFile) {
       reexport: true
     };
   }
-  if (ts15.isSourceFile(declaration)) {
+  if (ts17.isSourceFile(declaration)) {
     return {
       name,
       kind: "namespace",
@@ -6631,7 +6792,7 @@ function getDescriptionPreview(symbol, checker) {
 import * as fs7 from "node:fs";
 import * as path10 from "node:path";
 import { SCHEMA_URL, SCHEMA_VERSION } from "@openpkg-ts/spec";
-import ts19 from "typescript";
+import ts21 from "typescript";
 
 // src/schema/standard-schema.ts
 import { spawn as spawn2, spawnSync as spawnSync2 } from "node:child_process";
@@ -7183,7 +7344,7 @@ async function extractStandardSchemasFromProject(entryFile, baseDir, options = {
 import * as fs6 from "node:fs";
 import * as path8 from "node:path";
 import picomatch2 from "picomatch";
-import ts16 from "typescript";
+import ts18 from "typescript";
 function matchesExternalPattern(packageName, include, exclude) {
   if (!include?.length)
     return false;
@@ -7199,7 +7360,7 @@ function matchesExternalPattern(packageName, include, exclude) {
   return true;
 }
 function resolveExternalModule(moduleSpecifier, containingFile, compilerOptions) {
-  const resolved = ts16.resolveModuleName(moduleSpecifier, containingFile, compilerOptions, ts16.sys);
+  const resolved = ts18.resolveModuleName(moduleSpecifier, containingFile, compilerOptions, ts18.sys);
   if (!resolved.resolvedModule) {
     return null;
   }
@@ -7264,7 +7425,7 @@ function extractExternalExport(exportName, resolvedModule, program, ctx, visited
     return null;
   }
   let resolvedSymbol2 = targetExport;
-  if (targetExport.flags & ts16.SymbolFlags.Alias) {
+  if (targetExport.flags & ts18.SymbolFlags.Alias) {
     const aliased = checker.getAliasedSymbol(targetExport);
     if (aliased && aliased !== targetExport) {
       resolvedSymbol2 = aliased;
@@ -7335,7 +7496,7 @@ function mergeRuntimeSchemas(staticExports, runtimeSchemas) {
 }
 
 // src/builder/type-cache.ts
-import ts17 from "typescript";
+import ts19 from "typescript";
 
 // src/utils/cache-manager.ts
 class CacheManager {
@@ -7442,10 +7603,10 @@ function findTypeDefinition(typeName, program, sourceFile) {
   return typeDefinitionCache.getOrCompute(typeName, () => {
     const checker = program.getTypeChecker();
     const findInNode = (node) => {
-      if ((ts17.isInterfaceDeclaration(node) || ts17.isTypeAliasDeclaration(node) || ts17.isClassDeclaration(node) || ts17.isEnumDeclaration(node)) && node.name?.text === typeName) {
+      if ((ts19.isInterfaceDeclaration(node) || ts19.isTypeAliasDeclaration(node) || ts19.isClassDeclaration(node) || ts19.isEnumDeclaration(node)) && node.name?.text === typeName) {
         return node.getSourceFile().fileName;
       }
-      return ts17.forEachChild(node, findInNode);
+      return ts19.forEachChild(node, findInNode);
     };
     const entryResult = findInNode(sourceFile);
     if (entryResult)
@@ -7457,14 +7618,14 @@ function findTypeDefinition(typeName, program, sourceFile) {
           return result;
       }
     }
-    const symbol = checker.resolveName(typeName, sourceFile, ts17.SymbolFlags.Type, false);
+    const symbol = checker.resolveName(typeName, sourceFile, ts19.SymbolFlags.Type, false);
     return symbol?.declarations?.[0]?.getSourceFile().fileName;
   });
 }
 function hasInternalTag(typeName, program, sourceFile) {
   return internalTagCache.getOrCompute(typeName, () => {
     const checker = program.getTypeChecker();
-    const symbol = checker.resolveName(typeName, sourceFile, ts17.SymbolFlags.Type, false);
+    const symbol = checker.resolveName(typeName, sourceFile, ts19.SymbolFlags.Type, false);
     if (!symbol)
       return false;
     return symbol.getJsDocTags().some((tag) => tag.name === "internal");
@@ -7472,7 +7633,7 @@ function hasInternalTag(typeName, program, sourceFile) {
 }
 
 // src/builder/type-expansion.ts
-import ts18 from "typescript";
+import ts20 from "typescript";
 function createExternalExpansionPredicate(opts) {
   const matchesEntry = (entry, pkg) => {
     if (!entry.includes("*"))
@@ -7526,7 +7687,7 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
     const symbol = type.aliasSymbol ?? type.getSymbol();
     const named = !!symbol && !symbol.getName().startsWith("__");
     const allowed = !named || !symbol || symbolAllowed(symbol);
-    if (named && allowed && symbol && !ctx.exportedIds.has(symbol.getName())) {
+    if (named && allowed && symbol && !isExportedType(symbol)) {
       ctx.typeRegistry.registerType(type, ctx);
       const name = symbol.getName();
       if (!symbolByName.has(name)) {
@@ -7547,7 +7708,7 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
         visit(t, depth + 1);
       }
     }
-    if (!allowed || isDeferredMappedOrConditional(type) || !(type.flags & ts18.TypeFlags.Object || type.isClassOrInterface())) {
+    if (!allowed || isDeferredMappedOrConditional(type) || !(type.flags & ts20.TypeFlags.Object || type.isClassOrInterface())) {
       return;
     }
     if (isForeignPackage(symbol, opts.workspacePackages)) {
@@ -7573,14 +7734,20 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
       visit(info.type, depth + 1);
     }
   };
-  const TYPE_SYMBOL_FLAGS = ts18.SymbolFlags.Interface | ts18.SymbolFlags.TypeAlias | ts18.SymbolFlags.Class | ts18.SymbolFlags.RegularEnum | ts18.SymbolFlags.ConstEnum;
+  const TYPE_SYMBOL_FLAGS = ts20.SymbolFlags.Interface | ts20.SymbolFlags.TypeAlias | ts20.SymbolFlags.Class | ts20.SymbolFlags.RegularEnum | ts20.SymbolFlags.ConstEnum;
+  const isExportedType = (symbol) => {
+    const name = symbol.getName();
+    if (!ctx.exportedIds.has(name))
+      return false;
+    return !(symbol.flags & TYPE_SYMBOL_FLAGS) || resolveTypeId(symbol, ctx) === name;
+  };
   const visitedSymbols = new Set;
   const symbolKind = (symbol) => {
-    if (symbol.flags & ts18.SymbolFlags.Interface)
+    if (symbol.flags & ts20.SymbolFlags.Interface)
       return "interface";
-    if (symbol.flags & ts18.SymbolFlags.Class)
+    if (symbol.flags & ts20.SymbolFlags.Class)
       return "class";
-    if (symbol.flags & (ts18.SymbolFlags.RegularEnum | ts18.SymbolFlags.ConstEnum))
+    if (symbol.flags & (ts20.SymbolFlags.RegularEnum | ts20.SymbolFlags.ConstEnum))
       return "enum";
     return "type";
   };
@@ -7588,6 +7755,7 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
     const resolved = resolveAliasSymbol(symbol, checker, undefined, ctx.program);
     return resolved;
   };
+  const writtenWhenAny = (symbol, declared) => declared.flags & ts20.TypeFlags.Any ? symbol.declarations?.find(ts20.isTypeAliasDeclaration)?.type : undefined;
   const symbolByName = new Map;
   const registerTypeSymbol = (symbol) => {
     const name = symbol.getName();
@@ -7597,7 +7765,7 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
       return;
     if (!symbolAllowed(symbol))
       return;
-    if (ctx.exportedIds.has(name)) {
+    if (isExportedType(symbol)) {
       walkDeclarations(symbol);
       return;
     }
@@ -7613,7 +7781,7 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
         id,
         name,
         kind: symbolKind(symbol),
-        schema: ensureNonEmptySchema(buildSchema(declared, checker, ctx), declared, checker)
+        schema: ensureNonEmptySchema(buildSchema(declared, checker, ctx, writtenWhenAny(symbol, declared)), declared, checker)
       });
     }
     symbolByName.set(name, symbol);
@@ -7631,7 +7799,7 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
     const target = symbol && resolveAlias(symbol);
     if (!target || visitedSymbols.has(target))
       return;
-    if (!(target.flags & (ts18.SymbolFlags.ValueModule | ts18.SymbolFlags.NamespaceModule)))
+    if (!(target.flags & (ts20.SymbolFlags.ValueModule | ts20.SymbolFlags.NamespaceModule)))
       return;
     if (!symbolAllowed(target))
       return;
@@ -7648,22 +7816,22 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
     }
   };
   const walkNode = (node) => {
-    if (ts18.isTypeReferenceNode(node)) {
+    if (ts20.isTypeReferenceNode(node)) {
       handleRef(node.typeName);
-      if (ts18.isQualifiedName(node.typeName)) {
+      if (ts20.isQualifiedName(node.typeName)) {
         handleNamespaceRef(node.typeName.left);
       }
-    } else if (ts18.isExpressionWithTypeArguments(node)) {
+    } else if (ts20.isExpressionWithTypeArguments(node)) {
       handleRef(node.expression);
-    } else if (ts18.isTypeQueryNode(node)) {
+    } else if (ts20.isTypeQueryNode(node)) {
       handleRef(node.exprName);
-      if (ts18.isQualifiedName(node.exprName)) {
+      if (ts20.isQualifiedName(node.exprName)) {
         handleRef(node.exprName.left);
         handleNamespaceRef(node.exprName.left);
       }
-    } else if (ts18.isImportTypeNode(node) && node.qualifier) {
+    } else if (ts20.isImportTypeNode(node) && node.qualifier) {
       handleRef(node.qualifier);
-      if (ts18.isQualifiedName(node.qualifier)) {
+      if (ts20.isQualifiedName(node.qualifier)) {
         handleNamespaceRef(node.qualifier.left);
       }
     }
@@ -7679,7 +7847,7 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
   };
   for (const exportSymbol of exportedSymbols) {
     let target = exportSymbol;
-    if (exportSymbol.flags & ts18.SymbolFlags.Alias) {
+    if (exportSymbol.flags & ts20.SymbolFlags.Alias) {
       try {
         target = checker.getAliasedSymbol(exportSymbol);
       } catch {
@@ -7979,6 +8147,7 @@ async function extract(options) {
         ...included ? {} : { skipReason: "filtered" }
       });
     }
+    const mergedTypeSides = [];
     const followExternal = options.followExternal;
     const ctx = createContext(program, sourceFile, {
       maxTypeDepth,
@@ -7994,6 +8163,7 @@ async function extract(options) {
       workspacePackages: result.workspacePackages ?? new Map
     });
     ctx.exportedIds = exportedIds;
+    claimExportedTypeIds(exportedSymbols, ctx);
     const filteredSymbols = exportedSymbols.filter((s) => shouldIncludeExport(s.getName(), only, ignore));
     const total = filteredSymbols.length;
     for (let i = 0;i < filteredSymbols.length; i++) {
@@ -8018,9 +8188,9 @@ async function extract(options) {
               externalPackage = pkg;
               break;
             }
-            if (ts19.isExportSpecifier(decl)) {
+            if (ts21.isExportSpecifier(decl)) {
               const exportDecl = decl.parent?.parent;
-              if (exportDecl && ts19.isExportDeclaration(exportDecl) && exportDecl.moduleSpecifier) {
+              if (exportDecl && ts21.isExportDeclaration(exportDecl) && exportDecl.moduleSpecifier) {
                 const moduleText = exportDecl.moduleSpecifier.getText().slice(1, -1);
                 if (!moduleText.startsWith(".") && !moduleText.startsWith("/")) {
                   externalPackage = moduleText;
@@ -8063,6 +8233,14 @@ async function extract(options) {
         }
         const exp = serializeDeclaration2(declaration, symbol, exportName, ctx, isTypeOnly);
         if (exp) {
+          const typeSide = mergedTypeSideOf(exp, declaration, targetSymbol, ctx);
+          if (typeSide) {
+            mergedTypeSides.push({
+              index: exports.length,
+              symbol: typeSide,
+              ontoClass: ts21.isClassDeclaration(declaration)
+            });
+          }
           exports.push(exp);
           tracker.status = "success";
           tracker.kind = exp.kind;
@@ -8081,6 +8259,9 @@ async function extract(options) {
         });
       }
     }
+    for (const { index, symbol, ontoClass } of mergedTypeSides) {
+      exports[index] = withMergedTypeSide(exports[index], symbol, ctx, ontoClass);
+    }
     const verification = buildVerificationSummary(exportedSymbols.length, exports.length, exportTracker);
     const meta = await getPackageMeta(entryFile, baseDir);
     expandReachableTypes(filteredSymbols, ctx, {
@@ -8096,7 +8277,7 @@ async function extract(options) {
       });
     }
     {
-      const symFlags = ts19.SymbolFlags.Type | ts19.SymbolFlags.Interface | ts19.SymbolFlags.Class;
+      const symFlags = ts21.SymbolFlags.Type | ts21.SymbolFlags.Interface | ts21.SymbolFlags.Class;
       const maxPasses = 5;
       for (let pass = 0;pass < maxPasses; pass++) {
         const allRefs = new Map;
@@ -8242,42 +8423,39 @@ async function extract(options) {
 }
 function serializeDeclaration2(declaration, exportSymbol, exportName, ctx, isTypeOnly = false) {
   let result = null;
-  if (ts19.isFunctionDeclaration(declaration)) {
+  if (ts21.isFunctionDeclaration(declaration)) {
     result = serializeFunctionExport(declaration, ctx);
-  } else if (ts19.isClassDeclaration(declaration)) {
+  } else if (ts21.isClassDeclaration(declaration)) {
     result = serializeClass(declaration, ctx);
-  } else if (ts19.isInterfaceDeclaration(declaration)) {
+  } else if (ts21.isInterfaceDeclaration(declaration)) {
     result = serializeInterface(declaration, ctx);
-  } else if (ts19.isTypeAliasDeclaration(declaration)) {
+  } else if (ts21.isTypeAliasDeclaration(declaration)) {
     result = serializeTypeAlias(declaration, ctx);
-  } else if (ts19.isEnumDeclaration(declaration)) {
+  } else if (ts21.isEnumDeclaration(declaration)) {
     result = serializeEnum(declaration, ctx);
-  } else if (ts19.isVariableDeclaration(declaration)) {
-    const varStatement = declaration.parent?.parent;
-    if (varStatement && ts19.isVariableStatement(varStatement)) {
-      if (declaration.initializer && (ts19.isArrowFunction(declaration.initializer) || ts19.isFunctionExpression(declaration.initializer))) {
-        const varName = ts19.isIdentifier(declaration.name) ? declaration.name.text : declaration.name.getText();
-        result = serializeFunctionExport(declaration.initializer, ctx, varName);
+  } else if (ts21.isVariableDeclaration(declaration) || ts21.isBindingElement(declaration)) {
+    const varStatement = variableStatementOf(declaration);
+    if (varStatement) {
+      if (ts21.isVariableDeclaration(declaration) && declaration.initializer && (ts21.isArrowFunction(declaration.initializer) || ts21.isFunctionExpression(declaration.initializer))) {
+        const varName = ts21.isIdentifier(declaration.name) ? declaration.name.text : declaration.name.getText();
+        result = serializeFunctionExport(declaration.initializer, ctx, varName, declaration.type);
       } else {
         result = serializeVariable(declaration, varStatement, ctx);
         if (result?.kind === "variable") {
           const type = ctx.typeChecker.getTypeAtLocation(declaration);
-          if (type.getConstructSignatures().length > 0) {
-            result = { ...result, kind: "class" };
-          } else {
-            const callSigs = callSignaturesForVariable(declaration, ctx);
-            if (callSigs.length > 0) {
-              result = {
-                ...result,
-                kind: "function",
-                signatures: buildSignatures(callSigs, ctx.typeChecker, ctx)
-              };
-            }
-          }
+          result = withCallableKind(result, type, callSignaturesForVariable(declaration, ctx), ctx);
         }
       }
     }
-  } else if (ts19.isNamespaceExport(declaration) || ts19.isModuleDeclaration(declaration) || ts19.isNamespaceImport(declaration) || ts19.isSourceFile(declaration)) {
+  } else if (ts21.isExportAssignment(declaration) && !declaration.isExportEquals) {
+    const expression = skipOuterExpressions(declaration.expression);
+    if (ts21.isArrowFunction(expression) || ts21.isFunctionExpression(expression)) {
+      result = serializeFunctionExport(expression, ctx, exportName, undefined, declaration);
+    } else {
+      const type = ctx.typeChecker.getTypeOfSymbol(exportSymbol);
+      result = withCallableKind(serializeDefaultExpression(declaration, exportSymbol, type, ctx), type, type.getCallSignatures(), ctx);
+    }
+  } else if (ts21.isNamespaceExport(declaration) || ts21.isModuleDeclaration(declaration) || ts21.isNamespaceImport(declaration) || ts21.isSourceFile(declaration)) {
     try {
       result = serializeNamespaceExport(exportSymbol, exportName, ctx);
     } catch {
@@ -8293,6 +8471,9 @@ function serializeDeclaration2(declaration, exportSymbol, exportName, ctx, isTyp
   }
   if (result) {
     result = withExportName(result, exportName);
+    const localName = exportName === "default" && defaultLocalName(declaration, exportSymbol);
+    if (localName)
+      result = { ...result, localName };
     if (isTypeOnly) {
       result = {
         ...result,
@@ -8314,7 +8495,7 @@ function serializeNamespaceExport(symbol, exportName, ctx) {
   const members = [];
   const checker = ctx.program.getTypeChecker();
   let targetSymbol = symbol;
-  if (symbol.flags & ts19.SymbolFlags.Alias) {
+  if (symbol.flags & ts21.SymbolFlags.Alias) {
     const aliased = checker.getAliasedSymbol(symbol);
     if (aliased && aliased !== symbol) {
       targetSymbol = aliased;
@@ -8342,31 +8523,31 @@ function serializeNamespaceExport(symbol, exportName, ctx) {
 function serializeNamespaceMember(symbol, memberName, ctx) {
   const checker = ctx.program.getTypeChecker();
   let targetSymbol = symbol;
-  if (symbol.flags & ts19.SymbolFlags.Alias) {
+  if (symbol.flags & ts21.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 !== ts19.SyntaxKind.ExportSpecifier) || declarations[0];
+  const declaration = targetSymbol.valueDeclaration || declarations.find((d) => d.kind !== ts21.SyntaxKind.ExportSpecifier) || declarations[0];
   if (!declaration)
     return null;
   const type = checker.getTypeAtLocation(declaration);
   const callSignatures = type.getCallSignatures();
   const { deprecated } = isSymbolDeprecated(targetSymbol);
   let kind = "variable";
-  if (ts19.isFunctionDeclaration(declaration) || ts19.isFunctionExpression(declaration)) {
+  if (ts21.isFunctionDeclaration(declaration) || ts21.isFunctionExpression(declaration)) {
     kind = "function";
-  } else if (ts19.isClassDeclaration(declaration)) {
+  } else if (ts21.isClassDeclaration(declaration)) {
     kind = "class";
-  } else if (ts19.isInterfaceDeclaration(declaration)) {
+  } else if (ts21.isInterfaceDeclaration(declaration)) {
     kind = "interface";
-  } else if (ts19.isTypeAliasDeclaration(declaration)) {
+  } else if (ts21.isTypeAliasDeclaration(declaration)) {
     kind = "type";
-  } else if (ts19.isEnumDeclaration(declaration)) {
+  } else if (ts21.isEnumDeclaration(declaration)) {
     kind = "enum";
-  } else if (ts19.isVariableDeclaration(declaration)) {
+  } else if (ts21.isVariableDeclaration(declaration)) {
     if (callSignatures.length > 0) {
       kind = "function";
     }
@@ -8397,18 +8578,18 @@ function serializeNamespaceMember(symbol, memberName, ctx) {
 function flattenJSDocComment(comment) {
   if (comment === undefined)
     return "";
-  return typeof comment === "string" ? comment : ts19.getTextOfJSDocComment(comment) ?? "";
+  return typeof comment === "string" ? comment : ts21.getTextOfJSDocComment(comment) ?? "";
 }
 function getJSDocFromExportSymbol(symbol) {
   const tags = [];
   const examples = [];
   const decl = symbol.declarations?.[0];
   if (decl) {
-    const exportDecl = ts19.isNamespaceExport(decl) ? decl.parent : decl;
-    if (exportDecl && ts19.isExportDeclaration(exportDecl)) {
-      const jsDocs = ts19.getJSDocCommentsAndTags(exportDecl);
+    const exportDecl = ts21.isNamespaceExport(decl) ? decl.parent : decl;
+    if (exportDecl && ts21.isExportDeclaration(exportDecl)) {
+      const jsDocs = ts21.getJSDocCommentsAndTags(exportDecl);
       for (const doc of jsDocs) {
-        if (ts19.isJSDoc(doc) && doc.comment) {
+        if (ts21.isJSDoc(doc) && doc.comment) {
           const commentText = flattenJSDocComment(doc.comment);
           if (commentText) {
             return {
@@ -8457,14 +8638,45 @@ function extractExamples(doc) {
   }
   return examples;
 }
+function variableStatementOf(declaration) {
+  let node = declaration;
+  while (ts21.isBindingElement(node) || ts21.isBindingName(node))
+    node = node.parent;
+  const statement = node.parent?.parent;
+  return statement && ts21.isVariableStatement(statement) ? statement : undefined;
+}
+function skipOuterExpressions(expression) {
+  let node = expression;
+  while (ts21.isParenthesizedExpression(node) || ts21.isAsExpression(node) || ts21.isSatisfiesExpression(node) || ts21.isTypeAssertionExpression(node) || ts21.isNonNullExpression(node)) {
+    node = node.expression;
+  }
+  return node;
+}
+function withCallableKind(entry, type, callSigs, ctx) {
+  const constructSigs = type.getConstructSignatures();
+  if (constructSigs.length > 0) {
+    return {
+      ...entry,
+      kind: "class",
+      signatures: serializeConstructSignatures(constructSigs, ctx)
+    };
+  }
+  if (callSigs.length === 0)
+    return entry;
+  return {
+    ...entry,
+    kind: "function",
+    signatures: buildSignatures(callSigs, ctx.typeChecker, ctx)
+  };
+}
 function callSignaturesForVariable(declaration, ctx) {
   const checker = ctx.typeChecker;
-  if (declaration.type && ts19.isTypeReferenceNode(declaration.type)) {
-    const nameNode = ts19.isQualifiedName(declaration.type.typeName) ? declaration.type.typeName.right : declaration.type.typeName;
+  if (ts21.isVariableDeclaration(declaration) && declaration.type && ts21.isTypeReferenceNode(declaration.type)) {
+    const nameNode = ts21.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));
+      const iface = symbol.declarations?.find((d) => ts21.isInterfaceDeclaration(d));
       try {
         const declared = checker.getDeclaredTypeOfSymbol(symbol);
         const sigs = declared.getCallSignatures();
@@ -8486,6 +8698,59 @@ function callSignaturesForVariable(declaration, ctx) {
   }
   return checker.getTypeAtLocation(declaration).getCallSignatures();
 }
+function defaultLocalName(declaration, exportSymbol) {
+  const declared = ts21.getNameOfDeclaration(declaration);
+  if (declared && ts21.isIdentifier(declared) && declared.text !== "default")
+    return declared.text;
+  for (const decl of exportSymbol.declarations ?? []) {
+    if (ts21.isExportAssignment(decl) && ts21.isIdentifier(decl.expression)) {
+      return decl.expression.text;
+    }
+    if (ts21.isExportSpecifier(decl) && decl.propertyName && ts21.isIdentifier(decl.propertyName)) {
+      if (decl.propertyName.text !== "default")
+        return decl.propertyName.text;
+    }
+  }
+  return;
+}
+function isValueDeclaration(declaration) {
+  return ts21.isVariableDeclaration(declaration) || ts21.isBindingElement(declaration) || ts21.isFunctionDeclaration(declaration);
+}
+function hasTypeSide(symbol) {
+  return (symbol.flags & (ts21.SymbolFlags.Interface | ts21.SymbolFlags.TypeAlias)) !== 0;
+}
+function mergedTypeSideOf(exp, declaration, symbol, ctx) {
+  if (ts21.isClassDeclaration(declaration)) {
+    return symbol.flags & ts21.SymbolFlags.Interface ? symbol : undefined;
+  }
+  if (exp.members || !isValueDeclaration(declaration))
+    return;
+  if (hasTypeSide(symbol))
+    return symbol;
+  if (exp.kind !== "class")
+    return;
+  const [construct] = ctx.typeChecker.getTypeAtLocation(declaration).getConstructSignatures();
+  const instance = construct?.getReturnType();
+  const constructed = instance && (instance.aliasSymbol ?? instance.getSymbol());
+  if (!constructed || !hasTypeSide(constructed))
+    return;
+  if (ctx.shouldExpandExternal && !ctx.shouldExpandExternal(constructed))
+    return;
+  return constructed;
+}
+function withMergedTypeSide(entry, symbol, ctx, ontoClass) {
+  const typeSide = serializeMergedTypeSide(symbol, ctx);
+  if (!typeSide)
+    return entry;
+  const { members, description, tags, ...instanceType } = typeSide;
+  const own = new Set(entry.members?.map((m) => m.name));
+  return {
+    ...entry,
+    members: [...entry.members ?? [], ...(members ?? []).filter((m) => !own.has(m.name))],
+    ...entry.kind === "class" && !ontoClass ? instanceType : {},
+    ...entry.description ? {} : { description, tags: [...entry.tags ?? [], ...tags ?? []] }
+  };
+}
 function withExportName(entry, exportName) {
   if (entry.name === exportName) {
     return entry;
@@ -9002,7 +9267,7 @@ function toToolSchema(exp, spec, options) {
   const required = [];
   for (const param of sig.parameters ?? []) {
     let paramSchema = normalizeSchema(param.schema);
-    if (param.rest) {
+    if (param.rest && paramSchema.type !== "array") {
       paramSchema = { type: "array", items: paramSchema };
     }
     if (param.description && !paramSchema.description) {
@@ -9040,12 +9305,12 @@ function toToolSchema(exp, spec, options) {
   };
 }
 // src/types/utils.ts
-import ts20 from "typescript";
+import ts22 from "typescript";
 function isExported(node) {
   const modifiers = node.modifiers;
   if (!modifiers)
     return false;
-  return modifiers.some((m) => m.kind === ts20.SyntaxKind.ExportKeyword);
+  return modifiers.some((m) => m.kind === ts22.SyntaxKind.ExportKeyword);
 }
 function getNodeName(node) {
   if ("name" in node && node.name) {