@openpkg-ts/sdk 0.54.6 → 0.54.8

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";
@@ -2450,6 +2450,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);
@@ -2464,6 +2473,9 @@ function createProgram(options) {
     const configFile = ts3.readConfigFile(configPath, ts3.sys.readFile);
     const parsedConfig = ts3.parseJsonConfigFileContent(configFile.config, ts3.sys, path5.dirname(configPath));
     compilerOptions = { ...compilerOptions, ...parsedConfig.options };
+    if (parsedConfig.options.module !== undefined && parsedConfig.options.moduleResolution === undefined) {
+      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/"));
     if (/\.d\.[cm]?ts$/.test(entryFile)) {
@@ -2543,7 +2555,7 @@ function createProgram(options) {
 }
 
 // src/serializers/classes.ts
-import ts9 from "typescript";
+import ts10 from "typescript";
 
 // src/types/parameters.ts
 import ts6 from "typescript";
@@ -3718,7 +3730,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);
@@ -3944,6 +3957,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);
@@ -3953,7 +3967,8 @@ function extractParameters(signature, ctx) {
       const paramResult = {
         name: paramName,
         schema,
-        required: !isOptional
+        required: !isOptional && !isRest,
+        ...isRest ? { rest: true } : {}
       };
       if (description) {
         paramResult.description = description;
@@ -4558,7 +4573,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);
@@ -4567,6 +4582,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)
@@ -4580,6 +4601,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();
@@ -4587,8 +4617,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);
@@ -4606,6 +4640,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) {
@@ -4618,6 +4653,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)) {
@@ -4629,7 +4666,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,
@@ -4650,20 +4688,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);
@@ -4688,7 +4731,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);
@@ -4700,11 +4743,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)) {
@@ -4721,11 +4764,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);
@@ -4749,8 +4792,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 {
@@ -4772,37 +4815,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;
@@ -4861,11 +4904,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);
@@ -4904,7 +4947,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);
@@ -4913,11 +4956,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 } : {},
@@ -4936,14 +4979,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);
@@ -4976,7 +5019,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);
@@ -4991,7 +5034,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();
@@ -5054,16 +5097,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);
@@ -5084,10 +5127,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];
 }
@@ -5119,14 +5162,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)
@@ -5134,11 +5178,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),
@@ -5151,9 +5194,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);
@@ -5168,17 +5209,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) {
   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 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) {
@@ -5201,7 +5256,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);
@@ -5210,15 +5265,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);
@@ -5239,7 +5314,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) {
@@ -5262,7 +5337,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);
@@ -5272,22 +5347,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) {
@@ -5301,7 +5385,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);
@@ -5324,7 +5408,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 = {};
@@ -5393,7 +5478,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();
@@ -5405,7 +5490,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 = [];
@@ -5433,7 +5518,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);
@@ -5443,7 +5528,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 {
@@ -5453,7 +5538,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));
@@ -5479,12 +5564,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;
@@ -5492,19 +5577,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);
       }
     };
@@ -5512,12 +5597,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;
@@ -5526,7 +5611,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)) {
@@ -5545,10 +5630,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);
@@ -5566,11 +5651,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);
@@ -5589,14 +5674,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];
     }
@@ -5764,7 +5852,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, node.type);
+  const schema = buildSchema(typeToSerialize, ctx.typeChecker, ctx, ts15.isVariableDeclaration(node) ? node.type : undefined);
   const flags = schemaExtraction ? {
     schemaLibrary: schemaExtraction.adapter.id,
     ...schemaExtraction.inputType && schemaExtraction.inputType !== schemaExtraction.outputType ? { hasTransform: true } : {}
@@ -6352,7 +6440,7 @@ async function getExport(options) {
   ctx.exportedIds = exportedIds;
   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));
@@ -6403,42 +6491,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();
@@ -6452,7 +6540,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) {
@@ -6468,7 +6556,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;
@@ -6498,7 +6586,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;
@@ -6510,9 +6598,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;
@@ -6524,7 +6612,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 = [];
@@ -6567,16 +6655,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,
@@ -6586,7 +6674,7 @@ function extractExportItem(symbol, checker, entryFile, entrySourceFile) {
       reexport: true
     };
   }
-  if (ts15.isSourceFile(declaration)) {
+  if (ts17.isSourceFile(declaration)) {
     return {
       name,
       kind: "namespace",
@@ -6628,7 +6716,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";
@@ -7180,7 +7268,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;
@@ -7196,7 +7284,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;
   }
@@ -7261,7 +7349,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;
@@ -7332,7 +7420,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 {
@@ -7439,10 +7527,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)
@@ -7454,14 +7542,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");
@@ -7469,7 +7557,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("*"))
@@ -7544,7 +7632,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)) {
@@ -7570,14 +7658,14 @@ 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 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";
   };
@@ -7628,7 +7716,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;
@@ -7645,22 +7733,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);
       }
     }
@@ -7676,7 +7764,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 {
@@ -7976,6 +8064,7 @@ async function extract(options) {
         ...included ? {} : { skipReason: "filtered" }
       });
     }
+    const mergedTypeSides = [];
     const followExternal = options.followExternal;
     const ctx = createContext(program, sourceFile, {
       maxTypeDepth,
@@ -8015,9 +8104,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;
@@ -8060,6 +8149,9 @@ async function extract(options) {
         }
         const exp = serializeDeclaration2(declaration, symbol, exportName, ctx, isTypeOnly);
         if (exp) {
+          if (!exp.members && isValueDeclaration(declaration) && hasTypeSide(targetSymbol)) {
+            mergedTypeSides.push({ index: exports.length, symbol: targetSymbol });
+          }
           exports.push(exp);
           tracker.status = "success";
           tracker.kind = exp.kind;
@@ -8078,6 +8170,9 @@ async function extract(options) {
         });
       }
     }
+    for (const { index, symbol } of mergedTypeSides) {
+      exports[index] = withMergedTypeSide(exports[index], symbol, ctx);
+    }
     const verification = buildVerificationSummary(exportedSymbols.length, exports.length, exportTracker);
     const meta = await getPackageMeta(entryFile, baseDir);
     expandReachableTypes(filteredSymbols, ctx, {
@@ -8093,7 +8188,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;
@@ -8239,22 +8334,22 @@ 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") {
@@ -8274,7 +8369,7 @@ function serializeDeclaration2(declaration, exportSymbol, exportName, ctx, isTyp
         }
       }
     }
-  } else if (ts19.isNamespaceExport(declaration) || ts19.isModuleDeclaration(declaration) || ts19.isNamespaceImport(declaration) || ts19.isSourceFile(declaration)) {
+  } else if (ts21.isNamespaceExport(declaration) || ts21.isModuleDeclaration(declaration) || ts21.isNamespaceImport(declaration) || ts21.isSourceFile(declaration)) {
     try {
       result = serializeNamespaceExport(exportSymbol, exportName, ctx);
     } catch {
@@ -8290,6 +8385,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,
@@ -8311,7 +8409,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;
@@ -8339,31 +8437,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";
     }
@@ -8394,18 +8492,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 {
@@ -8454,14 +8552,21 @@ 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 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();
@@ -8483,6 +8588,39 @@ 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 withMergedTypeSide(entry, symbol, ctx) {
+  const typeSide = serializeMergedTypeSide(symbol, ctx);
+  if (!typeSide)
+    return entry;
+  const { members, description, tags, ...instanceType } = typeSide;
+  return {
+    ...entry,
+    members,
+    ...entry.kind === "class" ? instanceType : {},
+    ...entry.description ? {} : { description, tags: [...entry.tags ?? [], ...tags ?? []] }
+  };
+}
 function withExportName(entry, exportName) {
   if (entry.name === exportName) {
     return entry;
@@ -8999,7 +9137,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) {
@@ -9037,12 +9175,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) {