@openpkg-ts/sdk 0.48.0 → 0.48.1

package/dist/index.js

@@ -1300,7 +1300,7 @@ function filterSpec(spec, criteria) {
   };
 }
 // src/primitives/get.ts
-import ts11 from "typescript";
+import ts12 from "typescript";
 
 // src/ast/utils.ts
 import * as path2 from "node:path";
@@ -1846,13 +1846,84 @@ function createProgram(options) {
 }
 
 // src/serializers/classes.ts
-import ts7 from "typescript";
+import ts8 from "typescript";
 
 // src/types/parameters.ts
-import ts4 from "typescript";
+import ts5 from "typescript";
 
 // src/types/schema-builder.ts
+import ts4 from "typescript";
+
+// src/ast/type-identity.ts
+import * as path4 from "node:path";
 import ts3 from "typescript";
+var NODE_MODULES_PKG = /node_modules\/(@[^/]+\/[^/]+|[^/]+)/;
+function packageLabel(fileName, workspacePackages) {
+  const match = fileName.match(NODE_MODULES_PKG);
+  let pkg = match?.[1];
+  if (!pkg) {
+    for (const [name, dir] of workspacePackages) {
+      if (fileName.startsWith(`${path4.resolve(dir)}${path4.sep}`)) {
+        pkg = name;
+        break;
+      }
+    }
+  }
+  return (pkg ?? "local").replace(/^@/, "").replace(/\//g, "-");
+}
+function declKey(symbol, checker) {
+  let resolved = symbol;
+  if (symbol.flags & ts3.SymbolFlags.Alias) {
+    try {
+      resolved = checker.getAliasedSymbol(symbol);
+    } catch {}
+  }
+  const decl = resolved.declarations?.[0];
+  if (!decl)
+    return;
+  return `${decl.getSourceFile().fileName}#${decl.getStart()}`;
+}
+function resolveTypeId(symbol, ctx) {
+  const cached = ctx.typeIds.get(symbol);
+  if (cached)
+    return cached;
+  const key = declKey(symbol, ctx.typeChecker);
+  if (key) {
+    const existing = ctx.declIds.get(key);
+    if (existing) {
+      ctx.typeIds.set(symbol, existing);
+      return existing;
+    }
+  }
+  const claim = (id) => {
+    ctx.typeIds.set(symbol, id);
+    if (key)
+      ctx.declIds.set(key, id);
+    ctx.idOwner.set(id, key ?? id);
+    return id;
+  };
+  const name = symbol.getName();
+  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);
+  let n = 2;
+  while (ctx.idOwner.has(`${name}_${n}`))
+    n++;
+  return claim(`${name}_${n}`);
+}
+function typeRefId(type, ctx) {
+  const symbol = type.aliasSymbol ?? type.getSymbol();
+  if (!symbol)
+    return "";
+  if (!ctx)
+    return symbol.getName();
+  return resolveTypeId(symbol, ctx);
+}
 
 // src/schema/builtins.ts
 var BUILTIN_TYPE_SCHEMAS = {
@@ -1889,11 +1960,11 @@ function escapeRegex(text) {
 }
 function buildTemplatePattern(type) {
   const slotPattern = (slot) => {
-    if (slot.flags & ts3.TypeFlags.NumberLike)
+    if (slot.flags & ts4.TypeFlags.NumberLike)
       return "-?\\d+(?:\\.\\d+)?";
-    if (slot.flags & ts3.TypeFlags.BigIntLike)
+    if (slot.flags & ts4.TypeFlags.BigIntLike)
       return "-?\\d+";
-    if (slot.flags & ts3.TypeFlags.BooleanLike)
+    if (slot.flags & ts4.TypeFlags.BooleanLike)
       return "(?:true|false)";
     return ".*";
   };
@@ -1903,6 +1974,11 @@ function buildTemplatePattern(type) {
   });
   return `${pattern}$`;
 }
+function namedRefId(type, name, ctx) {
+  if (!ctx)
+    return name;
+  return typeRefId(type, ctx) || name;
+}
 function builtinSchema(name) {
   const schema = { ...BUILTIN_TYPE_SCHEMAS[name] ?? { type: "object" } };
   setSchemaExtension(schema, "x-ts-type", name);
@@ -1915,12 +1991,12 @@ function scrubImportQualifiers(text) {
   return text.replace(/import\((?:"[^"]*"|'[^']*')\)\./g, "");
 }
 function renderTypeText(type, checker, enclosing, extraFlags = 0) {
-  return scrubImportQualifiers(checker.typeToString(type, enclosing, ts3.TypeFormatFlags.NoTruncation | extraFlags));
+  return scrubImportQualifiers(checker.typeToString(type, enclosing, ts4.TypeFormatFlags.NoTruncation | extraFlags));
 }
 function stripUndefinedFromType(type, checker) {
   if (!type.isUnion())
     return type;
-  const nonUndefinedTypes = type.types.filter((t) => !(t.flags & ts3.TypeFlags.Undefined));
+  const nonUndefinedTypes = type.types.filter((t) => !(t.flags & ts4.TypeFlags.Undefined));
   if (nonUndefinedTypes.length === 0)
     return type;
   if (nonUndefinedTypes.length === 1)
@@ -1929,13 +2005,13 @@ function stripUndefinedFromType(type, checker) {
 }
 function isReadonlyPropertySymbol(prop) {
   const decls = prop.getDeclarations() ?? [];
-  return decls.some((d) => (ts3.getCombinedModifierFlags(d) & ts3.ModifierFlags.Readonly) !== 0);
+  return decls.some((d) => (ts4.getCombinedModifierFlags(d) & ts4.ModifierFlags.Readonly) !== 0);
 }
 function decoratePropertySchema(schema, prop, propType, checker) {
   if (typeof schema !== "object" || schema === null || Array.isArray(schema))
     return schema;
   const decl = prop.valueDeclaration ?? prop.getDeclarations()?.[0];
-  const optional = !!(prop.flags & ts3.SymbolFlags.Optional);
+  const optional = !!(prop.flags & ts4.SymbolFlags.Optional);
   const textType = optional ? stripUndefinedFromType(propType, checker) : propType;
   const text = renderTypeText(textType, checker, decl);
   const obj = schema;
@@ -1948,13 +2024,13 @@ function decoratePropertySchema(schema, prop, propType, checker) {
   if (isReadonlyPropertySymbol(prop) && !("readOnly" in obj)) {
     result = { ...result, readOnly: true };
   }
-  if (prop.flags & ts3.SymbolFlags.Method && !("x-ts-method" in obj)) {
+  if (prop.flags & ts4.SymbolFlags.Method && !("x-ts-method" in obj)) {
     result = { ...result, "x-ts-method": true };
   }
   return result;
 }
 function shouldEmitAliasTypeText(typeNode) {
-  return !ts3.isTypeLiteralNode(typeNode) && !ts3.isMappedTypeNode(typeNode);
+  return !ts4.isTypeLiteralNode(typeNode) && !ts4.isMappedTypeNode(typeNode);
 }
 var PRIMITIVES = new Set([
   "string",
@@ -2205,7 +2281,7 @@ function buildSchema(type, checker, ctx) {
   return ensureNonEmptySchema(schema, type, checker);
 }
 function buildMaxDepthSchema(type, checker) {
-  if (type.flags & ts3.TypeFlags.TypeParameter && type.isThisType !== true) {
+  if (type.flags & ts4.TypeFlags.TypeParameter && type.isThisType !== true) {
     return { "x-ts-type": checker.typeToString(type) };
   }
   const symbol = type.getSymbol() || type.aliasSymbol;
@@ -2218,19 +2294,19 @@ function buildMaxDepthSchema(type, checker) {
       return { $ref: `#/types/${name}` };
     }
   }
-  if (type.flags & ts3.TypeFlags.String)
+  if (type.flags & ts4.TypeFlags.String)
     return { type: "string" };
-  if (type.flags & ts3.TypeFlags.Number)
+  if (type.flags & ts4.TypeFlags.Number)
     return { type: "number" };
-  if (type.flags & ts3.TypeFlags.Boolean)
+  if (type.flags & ts4.TypeFlags.Boolean)
     return { type: "boolean" };
-  if (type.flags & ts3.TypeFlags.Undefined)
+  if (type.flags & ts4.TypeFlags.Undefined)
     return { type: "undefined" };
-  if (type.flags & ts3.TypeFlags.Null)
+  if (type.flags & ts4.TypeFlags.Null)
     return { type: "null" };
-  if (type.flags & ts3.TypeFlags.Void)
+  if (type.flags & ts4.TypeFlags.Void)
     return { type: "void" };
-  if (type.flags & ts3.TypeFlags.TemplateLiteral) {
+  if (type.flags & ts4.TypeFlags.TemplateLiteral) {
     return {
       type: "string",
       pattern: buildTemplatePattern(type),
@@ -2262,59 +2338,59 @@ function buildSchemaInternal(type, checker, ctx) {
       if (BUILTIN_TYPES.has(name) || isBuiltinGeneric(name)) {
         return builtinSchema(name);
       }
-      return { $ref: `#/types/${name}` };
+      return { $ref: `#/types/${namedRefId(type, name, ctx)}` };
     }
     return { type: checker.typeToString(type) };
   }
-  const addedToVisited = !!(ctx && type.flags & ts3.TypeFlags.Object);
+  const addedToVisited = !!(ctx && type.flags & ts4.TypeFlags.Object);
   if (addedToVisited) {
     ctx.visitedTypes.add(type);
   }
   try {
-    if (type.flags & ts3.TypeFlags.String)
+    if (type.flags & ts4.TypeFlags.String)
       return { type: "string" };
-    if (type.flags & ts3.TypeFlags.Number)
+    if (type.flags & ts4.TypeFlags.Number)
       return { type: "number" };
-    if (type.flags & ts3.TypeFlags.Boolean)
+    if (type.flags & ts4.TypeFlags.Boolean)
       return { type: "boolean" };
-    if (type.flags & ts3.TypeFlags.Undefined)
+    if (type.flags & ts4.TypeFlags.Undefined)
       return { type: "undefined" };
-    if (type.flags & ts3.TypeFlags.Null)
+    if (type.flags & ts4.TypeFlags.Null)
       return { type: "null" };
-    if (type.flags & ts3.TypeFlags.Void)
+    if (type.flags & ts4.TypeFlags.Void)
       return { type: "void" };
-    if (type.flags & ts3.TypeFlags.Any)
+    if (type.flags & ts4.TypeFlags.Any)
       return { type: "any" };
-    if (type.flags & ts3.TypeFlags.Unknown)
+    if (type.flags & ts4.TypeFlags.Unknown)
       return { type: "unknown" };
-    if (type.flags & ts3.TypeFlags.Never)
+    if (type.flags & ts4.TypeFlags.Never)
       return { type: "never" };
-    if (type.flags & ts3.TypeFlags.BigInt)
+    if (type.flags & ts4.TypeFlags.BigInt)
       return { type: "bigint" };
-    if (type.flags & ts3.TypeFlags.ESSymbol)
+    if (type.flags & ts4.TypeFlags.ESSymbol)
       return { type: "symbol" };
     if (type.isThisType === true) {
       const constraint = type.getConstraint?.();
       const symbol2 = constraint?.getSymbol() ?? type.getSymbol();
       if (symbol2 && !isAnonymous(type)) {
         return {
-          $ref: `#/types/${symbol2.getName()}`,
+          $ref: `#/types/${ctx ? resolveTypeId(symbol2, ctx) : symbol2.getName()}`,
           "x-ts-type": "this"
         };
       }
     }
-    if (type.flags & ts3.TypeFlags.TypeParameter) {
+    if (type.flags & ts4.TypeFlags.TypeParameter) {
       return { "x-ts-type": checker.typeToString(type) };
     }
-    if (type.flags & ts3.TypeFlags.StringLiteral) {
+    if (type.flags & ts4.TypeFlags.StringLiteral) {
       const literal = type.value;
       return { type: "string", enum: [literal] };
     }
-    if (type.flags & ts3.TypeFlags.NumberLiteral) {
+    if (type.flags & ts4.TypeFlags.NumberLiteral) {
       const literal = type.value;
       return { type: "number", enum: [literal] };
     }
-    if (type.flags & ts3.TypeFlags.BooleanLiteral) {
+    if (type.flags & ts4.TypeFlags.BooleanLiteral) {
       const typeString2 = checker.typeToString(type);
       return { type: "boolean", enum: [typeString2 === "true"] };
     }
@@ -2322,40 +2398,40 @@ function buildSchemaInternal(type, checker, ctx) {
       const aliasName = type.aliasSymbol.getName();
       if (!aliasName.startsWith("__") && !isPrimitiveName(aliasName)) {
         const packageOrigin = getTypeOrigin(type, checker);
-        const schema = { $ref: `#/types/${aliasName}` };
+        const schema = { $ref: `#/types/${namedRefId(type, aliasName, ctx)}` };
         if (packageOrigin) {
           setSchemaExtension(schema, "x-ts-package", packageOrigin);
         }
         return schema;
       }
     }
-    if (type.flags & ts3.TypeFlags.TemplateLiteral) {
+    if (type.flags & ts4.TypeFlags.TemplateLiteral) {
       return {
         type: "string",
         pattern: buildTemplatePattern(type),
         "x-ts-type": renderTypeText(type, checker)
       };
     }
-    if (type.flags & ts3.TypeFlags.StringMapping) {
+    if (type.flags & ts4.TypeFlags.StringMapping) {
       return { type: "string", "x-ts-type": renderTypeText(type, checker) };
     }
     if (type.isUnion()) {
       const types = type.types;
-      const allStringLiterals = types.every((t) => t.flags & ts3.TypeFlags.StringLiteral);
+      const allStringLiterals = types.every((t) => t.flags & ts4.TypeFlags.StringLiteral);
       if (allStringLiterals) {
         const enumValues = types.map((t) => t.value);
         return { type: "string", enum: enumValues };
       }
-      const allNumberLiterals = types.every((t) => t.flags & ts3.TypeFlags.NumberLiteral);
+      const allNumberLiterals = types.every((t) => t.flags & ts4.TypeFlags.NumberLiteral);
       if (allNumberLiterals) {
         const enumValues = types.map((t) => t.value);
         return { type: "number", enum: enumValues };
       }
-      const allBooleanLiterals = types.every((t) => t.flags & ts3.TypeFlags.BooleanLiteral);
+      const allBooleanLiterals = types.every((t) => t.flags & ts4.TypeFlags.BooleanLiteral);
       if (allBooleanLiterals) {
         return { type: "boolean" };
       }
-      const isBoolLiteral = (t) => !!(t.flags & ts3.TypeFlags.BooleanLiteral);
+      const isBoolLiteral = (t) => !!(t.flags & ts4.TypeFlags.BooleanLiteral);
       let members = types;
       if (types.filter(isBoolLiteral).length === 2) {
         const firstBool = types.findIndex(isBoolLiteral);
@@ -2369,10 +2445,10 @@ function buildSchemaInternal(type, checker, ctx) {
       }
       return { anyOf: members.map(buildBranch) };
     }
-    const isIntersectionType = type.isIntersection() || !!(type.flags & ts3.TypeFlags.Intersection);
+    const isIntersectionType = type.isIntersection() || !!(type.flags & ts4.TypeFlags.Intersection);
     if (isIntersectionType && "types" in type) {
       const intersectionType = type;
-      const filteredTypes = intersectionType.types.filter((t) => !(t.flags & ts3.TypeFlags.Never));
+      const filteredTypes = intersectionType.types.filter((t) => !(t.flags & ts4.TypeFlags.Never));
       if (filteredTypes.length === 0) {
         return { type: "never" };
       }
@@ -2461,7 +2537,7 @@ function buildSchemaInternal(type, checker, ctx) {
         if (ctx) {
           return withDepth(ctx, () => {
             const schema2 = {
-              $ref: `#/types/${name}`,
+              $ref: `#/types/${namedRefId(typeRef.target, name, ctx)}`,
               typeArguments: typeArgs.map((t) => buildSchema(t, checker, ctx))
             };
             if (packageOrigin) {
@@ -2487,7 +2563,7 @@ function buildSchemaInternal(type, checker, ctx) {
       if (BUILTIN_TYPES.has(name)) {
         return builtinSchema(name);
       }
-      if (RESOLVED_UTILITY_TYPES.has(name) && type.flags & ts3.TypeFlags.Object) {
+      if (RESOLVED_UTILITY_TYPES.has(name) && type.flags & ts4.TypeFlags.Object) {
         const props = type.getProperties();
         const hasIndex = checker.getIndexInfosOfType(type).length > 0;
         if (props.length > 0 || hasIndex) {
@@ -2506,7 +2582,7 @@ function buildSchemaInternal(type, checker, ctx) {
         if (ctx) {
           return withDepth(ctx, () => {
             const schema2 = {
-              $ref: `#/types/${name}`,
+              $ref: `#/types/${namedRefId(type, name, ctx)}`,
               typeArguments: aliasTypeArgs.map((t) => buildSchema(t, checker, ctx))
             };
             if (packageOrigin) {
@@ -2525,7 +2601,7 @@ function buildSchemaInternal(type, checker, ctx) {
         return schema;
       }
     }
-    if (type.flags & ts3.TypeFlags.Object) {
+    if (type.flags & ts4.TypeFlags.Object) {
       const callSignatures = type.getCallSignatures();
       if (callSignatures.length > 0) {
         return buildFunctionSchema(callSignatures, checker, ctx);
@@ -2544,17 +2620,17 @@ function buildSchemaInternal(type, checker, ctx) {
       }
       if (!name.startsWith("__")) {
         const packageOrigin = getTypeOrigin(type, checker);
-        const schema = { $ref: `#/types/${name}` };
+        const schema = { $ref: `#/types/${namedRefId(type, name, ctx)}` };
         if (packageOrigin) {
           setSchemaExtension(schema, "x-ts-package", packageOrigin);
         }
         return schema;
       }
     }
-    if (type.flags & ts3.TypeFlags.Object) {
+    if (type.flags & ts4.TypeFlags.Object) {
       const objectType = type;
       const properties = type.getProperties();
-      if (properties.length > 0 || objectType.objectFlags & ts3.ObjectFlags.Anonymous || checker.getIndexInfosOfType(type).length > 0) {
+      if (properties.length > 0 || objectType.objectFlags & ts4.ObjectFlags.Anonymous || checker.getIndexInfosOfType(type).length > 0) {
         return buildObjectSchema(properties, checker, ctx, type);
       }
     }
@@ -2598,8 +2674,8 @@ function buildFunctionSchema(callSignatures, checker, ctx) {
 }
 function buildObjectSchema(properties, checker, ctx, originalType) {
   const isArrayLikeType = originalType ? checker.isArrayType(originalType) || checker.isTupleType(originalType) || originalType.symbol?.getName() === "Array" && isBuiltinSymbol(originalType.symbol) : false;
-  const isStringLikeType = !!(originalType && originalType.flags & ts3.TypeFlags.StringLike);
-  const isNumberLikeType = !!(originalType && originalType.flags & ts3.TypeFlags.NumberLike);
+  const isStringLikeType = !!(originalType && originalType.flags & ts4.TypeFlags.StringLike);
+  const isNumberLikeType = !!(originalType && originalType.flags & ts4.TypeFlags.NumberLike);
   const buildProps = () => {
     const props = {};
     const required = [];
@@ -2616,7 +2692,7 @@ function buildObjectSchema(properties, checker, ctx, originalType) {
       if (isNumberLikeType && NUMBER_PROTOTYPE_METHODS.has(propName)) {
         continue;
       }
-      const isOptionalProp = !!(prop.flags & ts3.SymbolFlags.Optional);
+      const isOptionalProp = !!(prop.flags & ts4.SymbolFlags.Optional);
       const rawPropType = checker.getTypeOfSymbol(prop);
       const propType = isOptionalProp ? stripUndefinedFromType(rawPropType, checker) : rawPropType;
       let propSchema = buildSchema(propType, checker, ctx);
@@ -2634,7 +2710,7 @@ function buildObjectSchema(properties, checker, ctx, originalType) {
       }
       propSchema = decoratePropertySchema(propSchema, prop, propType, checker);
       props[propName] = propSchema;
-      if (!(prop.flags & ts3.SymbolFlags.Optional)) {
+      if (!(prop.flags & ts4.SymbolFlags.Optional)) {
         required.push(propName);
       }
     }
@@ -2644,11 +2720,11 @@ function buildObjectSchema(properties, checker, ctx, originalType) {
       ...required.length > 0 ? { required } : {}
     };
     const indexInfos = originalType ? checker.getIndexInfosOfType(originalType) : [];
-    const stringIndex = indexInfos.find((i) => i.keyType.flags & ts3.TypeFlags.String);
+    const stringIndex = indexInfos.find((i) => i.keyType.flags & ts4.TypeFlags.String);
     if (stringIndex) {
       schema.additionalProperties = buildSchema(stringIndex.type, checker, ctx);
     }
-    const numberIndex = indexInfos.find((i) => i.keyType.flags & ts3.TypeFlags.Number);
+    const numberIndex = indexInfos.find((i) => i.keyType.flags & ts4.TypeFlags.Number);
     if (numberIndex) {
       schema.patternProperties = {
         "^\\d+$": buildSchema(numberIndex.type, checker, ctx)
@@ -2737,7 +2813,7 @@ function deduplicateSchemas(schemas) {
 function findDiscriminatorProperty(unionTypes, checker) {
   const memberProps = [];
   for (const t of unionTypes) {
-    if (t.flags & (ts3.TypeFlags.Null | ts3.TypeFlags.Undefined)) {
+    if (t.flags & (ts4.TypeFlags.Null | ts4.TypeFlags.Undefined)) {
       continue;
     }
     const props = t.getProperties();
@@ -2791,13 +2867,13 @@ function extractParameters(signature, ctx) {
   const { typeChecker: checker } = ctx;
   const result = [];
   const signatureDecl = signature.getDeclaration();
-  const jsdocTags = signatureDecl ? ts4.getJSDocTags(signatureDecl) : [];
+  const jsdocTags = signatureDecl ? ts5.getJSDocTags(signatureDecl) : [];
   for (const param of signature.getParameters()) {
     const decl = param.valueDeclaration;
     if (!decl)
       continue;
     const type = checker.getTypeOfSymbolAtLocation(param, decl);
-    if (decl && ts4.isObjectBindingPattern(decl.name)) {
+    if (decl && ts5.isObjectBindingPattern(decl.name)) {
       const expandedParams = expandBindingPattern(decl, type, jsdocTags, ctx);
       result.push(...expandedParams);
     } else {
@@ -2829,13 +2905,13 @@ function expandBindingPattern(paramDecl, paramType, jsdocTags, ctx) {
   const allProperties = getEffectiveProperties(paramType, checker);
   const inferredAlias = inferParamAlias(jsdocTags);
   for (const element of bindingPattern.elements) {
-    if (!ts4.isBindingElement(element))
+    if (!ts5.isBindingElement(element))
       continue;
-    const propertyName = element.propertyName ? ts4.isIdentifier(element.propertyName) ? element.propertyName.text : element.propertyName.getText() : ts4.isIdentifier(element.name) ? element.name.text : element.name.getText();
+    const propertyName = element.propertyName ? ts5.isIdentifier(element.propertyName) ? element.propertyName.text : element.propertyName.getText() : ts5.isIdentifier(element.name) ? element.name.text : element.name.getText();
     const propSymbol = allProperties.get(propertyName);
     if (!propSymbol)
       continue;
-    const isOptional = !!(propSymbol.flags & ts4.SymbolFlags.Optional) || element.initializer !== undefined;
+    const isOptional = !!(propSymbol.flags & ts5.SymbolFlags.Optional) || element.initializer !== undefined;
     const propType = checker.getTypeOfSymbol(propSymbol);
     const effectiveType = isOptional ? stripUndefinedFromType(propType, checker) : propType;
     registerReferencedTypes(effectiveType, ctx);
@@ -2875,7 +2951,7 @@ function inferParamAlias(jsdocTags) {
   for (const tag of jsdocTags) {
     if (tag.tagName.text !== "param")
       continue;
-    const tagText = typeof tag.comment === "string" ? tag.comment : ts4.getTextOfJSDocComment(tag.comment) ?? "";
+    const tagText = typeof tag.comment === "string" ? tag.comment : ts5.getTextOfJSDocComment(tag.comment) ?? "";
     const paramTag = tag;
     const paramName = paramTag.name?.getText() ?? "";
     if (paramName.includes(".")) {
@@ -2898,22 +2974,22 @@ function inferParamAlias(jsdocTags) {
   return Array.from(counts.entries()).sort((a, b) => b[1] - a[1])[0]?.[0];
 }
 function extractLiteralDefault(initializer) {
-  if (ts4.isStringLiteral(initializer)) {
+  if (ts5.isStringLiteral(initializer)) {
     return { literal: true, value: initializer.text };
   }
-  if (ts4.isNumericLiteral(initializer)) {
+  if (ts5.isNumericLiteral(initializer)) {
     return { literal: true, value: Number(initializer.text) };
   }
-  if (ts4.isPrefixUnaryExpression(initializer) && initializer.operator === ts4.SyntaxKind.MinusToken && ts4.isNumericLiteral(initializer.operand)) {
+  if (ts5.isPrefixUnaryExpression(initializer) && initializer.operator === ts5.SyntaxKind.MinusToken && ts5.isNumericLiteral(initializer.operand)) {
     return { literal: true, value: -Number(initializer.operand.text) };
   }
-  if (initializer.kind === ts4.SyntaxKind.TrueKeyword) {
+  if (initializer.kind === ts5.SyntaxKind.TrueKeyword) {
     return { literal: true, value: true };
   }
-  if (initializer.kind === ts4.SyntaxKind.FalseKeyword) {
+  if (initializer.kind === ts5.SyntaxKind.FalseKeyword) {
     return { literal: true, value: false };
   }
-  if (initializer.kind === ts4.SyntaxKind.NullKeyword) {
+  if (initializer.kind === ts5.SyntaxKind.NullKeyword) {
     return { literal: true, value: null };
   }
   return { literal: false, text: initializer.getText() };
@@ -2934,7 +3010,7 @@ function registerReferencedTypes(type, ctx, depth = 0) {
     return;
   if (ctx.registeredTypes.has(type))
     return;
-  const isPrimitive = type.flags & (ts4.TypeFlags.String | ts4.TypeFlags.Number | ts4.TypeFlags.Boolean | ts4.TypeFlags.Void | ts4.TypeFlags.Undefined | ts4.TypeFlags.Null | ts4.TypeFlags.Any | ts4.TypeFlags.Unknown | ts4.TypeFlags.Never | ts4.TypeFlags.StringLiteral | ts4.TypeFlags.NumberLiteral | ts4.TypeFlags.BooleanLiteral);
+  const isPrimitive = type.flags & (ts5.TypeFlags.String | ts5.TypeFlags.Number | ts5.TypeFlags.Boolean | ts5.TypeFlags.Void | ts5.TypeFlags.Undefined | ts5.TypeFlags.Null | ts5.TypeFlags.Any | ts5.TypeFlags.Unknown | ts5.TypeFlags.Never | ts5.TypeFlags.StringLiteral | ts5.TypeFlags.NumberLiteral | ts5.TypeFlags.BooleanLiteral);
   if (!isPrimitive) {
     ctx.registeredTypes.add(type);
   }
@@ -2960,7 +3036,7 @@ function registerReferencedTypes(type, ctx, depth = 0) {
   if (typeSymbol && ctx.shouldExpandExternal && !typeSymbol.getName().startsWith("__") && !ctx.shouldExpandExternal(typeSymbol)) {
     return;
   }
-  if (type.flags & ts4.TypeFlags.Object) {
+  if (type.flags & ts5.TypeFlags.Object) {
     const props = type.getProperties();
     const limit = ctx.maxProperties;
     if (props.length > limit && ctx.onTruncation) {
@@ -2975,10 +3051,10 @@ function registerReferencedTypes(type, ctx, depth = 0) {
 }
 
 // src/serializers/context.ts
-import ts6 from "typescript";
+import ts7 from "typescript";
 
 // src/ast/registry.ts
-import ts5 from "typescript";
+import ts6 from "typescript";
 var BUILTINS = new Set([
   "Array",
   "ArrayBuffer",
@@ -3082,18 +3158,19 @@ class TypeRegistry {
       return;
     if (name.startsWith("__"))
       return;
-    if (symbol.flags & ts5.SymbolFlags.EnumMember)
+    if (symbol.flags & ts6.SymbolFlags.EnumMember)
       return;
-    if (symbol.flags & ts5.SymbolFlags.TypeParameter)
+    if (symbol.flags & ts6.SymbolFlags.TypeParameter)
       return;
-    if (symbol.flags & ts5.SymbolFlags.Method)
+    if (symbol.flags & ts6.SymbolFlags.Method)
       return;
-    if (symbol.flags & ts5.SymbolFlags.Function)
+    if (symbol.flags & ts6.SymbolFlags.Function)
       return;
     if (isGenericTypeParameter(name))
       return;
-    if (this.has(name))
-      return name;
+    const id = resolveTypeId(symbol, ctx);
+    if (this.has(id))
+      return id;
     if (ctx.shouldExpandExternal && !ctx.shouldExpandExternal(symbol)) {
       const origin = getTypeOrigin(type, ctx.typeChecker);
       const schema = {
@@ -3102,47 +3179,47 @@ class TypeRegistry {
       if (origin)
         schema["x-ts-package"] = origin;
       this.add({
-        id: name,
+        id,
         name,
         kind: "external",
         external: true,
         schema
       });
-      return name;
+      return id;
     }
-    if (this.processing.has(name))
-      return name;
-    this.processing.add(name);
+    if (this.processing.has(id))
+      return id;
+    this.processing.add(id);
     try {
-      const specType = this.buildSpecType(type, symbol, ctx);
+      const specType = this.buildSpecType(type, symbol, id, ctx);
       if (specType) {
         this.add(specType);
         return specType.id;
       }
     } finally {
-      this.processing.delete(name);
+      this.processing.delete(id);
     }
     return;
   }
-  buildSpecType(type, symbol, ctx) {
+  buildSpecType(type, symbol, id, ctx) {
     const name = symbol.getName();
     const decl = symbol.declarations?.[0];
     const checker = ctx.typeChecker;
     let kind = "type";
     const external = decl ? isExternalType(decl) : false;
     if (decl) {
-      if (ts5.isClassDeclaration(decl))
+      if (ts6.isClassDeclaration(decl))
         kind = "class";
-      else if (ts5.isInterfaceDeclaration(decl))
+      else if (ts6.isInterfaceDeclaration(decl))
         kind = "interface";
-      else if (ts5.isEnumDeclaration(decl))
+      else if (ts6.isEnumDeclaration(decl))
         kind = "enum";
     }
     if (external) {
       kind = "external";
     }
     let schema = buildSchema(type, checker, ctx);
-    if (this.isSelfRef(schema, name)) {
+    if (this.isSelfRef(schema, id)) {
       schema = this.resolveSelRefSchema(type, checker, ctx);
     }
     if (kind === "enum") {
@@ -3151,18 +3228,18 @@ class TypeRegistry {
         schema = enumSchema;
       }
     }
-    if (kind === "type" && decl && ts5.isTypeAliasDeclaration(decl) && shouldEmitAliasTypeText(decl.type) && typeof schema === "object" && schema !== null && !("x-ts-type" in schema)) {
-      const text = renderTypeText(type, checker, decl, ts5.TypeFormatFlags.InTypeAlias);
+    if (kind === "type" && decl && ts6.isTypeAliasDeclaration(decl) && shouldEmitAliasTypeText(decl.type) && typeof schema === "object" && schema !== null && !("x-ts-type" in schema)) {
+      const text = renderTypeText(type, checker, decl, ts6.TypeFormatFlags.InTypeAlias);
       if (!PRIMITIVES.has(text) && text !== name) {
         schema["x-ts-type"] = text;
       }
     }
     let typeParameters;
-    if (decl && (ts5.isTypeAliasDeclaration(decl) || ts5.isInterfaceDeclaration(decl) || ts5.isClassDeclaration(decl))) {
+    if (decl && (ts6.isTypeAliasDeclaration(decl) || ts6.isInterfaceDeclaration(decl) || ts6.isClassDeclaration(decl))) {
       typeParameters = extractTypeParameters(decl, checker);
     }
     return {
-      id: name,
+      id,
       name,
       kind,
       ...typeParameters && typeParameters.length > 0 ? { typeParameters } : {},
@@ -3179,14 +3256,14 @@ class TypeRegistry {
   resolveSelRefSchema(type, checker, ctx) {
     if (type.isUnion()) {
       const types = type.types;
-      const allStringLiterals = types.every((t) => t.flags & ts5.TypeFlags.StringLiteral);
+      const allStringLiterals = types.every((t) => t.flags & ts6.TypeFlags.StringLiteral);
       if (allStringLiterals) {
         return {
           type: "string",
           enum: types.map((t) => t.value)
         };
       }
-      const allNumberLiterals = types.every((t) => t.flags & ts5.TypeFlags.NumberLiteral);
+      const allNumberLiterals = types.every((t) => t.flags & ts6.TypeFlags.NumberLiteral);
       if (allNumberLiterals) {
         return {
           type: "number",
@@ -3221,18 +3298,18 @@ class TypeRegistry {
       const elementType = checker.getTypeArguments(type)?.[0];
       return elementType ? { type: "array", items: buildSchema(elementType, checker, ctx) } : { type: "array" };
     }
-    if (type.flags & ts5.TypeFlags.Conditional) {
+    if (type.flags & ts6.TypeFlags.Conditional) {
       return { "x-ts-type": renderTypeText(type, checker) };
     }
     const constraint = checker.getBaseConstraintOfType(type);
-    const primitive = constraint && constraint.flags & ts5.TypeFlags.StringLike ? "string" : constraint && constraint.flags & ts5.TypeFlags.NumberLike ? "number" : constraint && constraint.flags & ts5.TypeFlags.BooleanLike ? "boolean" : undefined;
+    const primitive = constraint && constraint.flags & ts6.TypeFlags.StringLike ? "string" : constraint && constraint.flags & ts6.TypeFlags.NumberLike ? "number" : constraint && constraint.flags & ts6.TypeFlags.BooleanLike ? "boolean" : undefined;
     if (primitive) {
       return { type: primitive, "x-ts-type": renderTypeText(type, checker) };
     }
     return this.buildObjectSchemaFromProperties(type, checker, ctx);
   }
   buildEnumSchema(symbol, checker) {
-    const decl = symbol.declarations?.find(ts5.isEnumDeclaration);
+    const decl = symbol.declarations?.find(ts6.isEnumDeclaration);
     if (!decl)
       return;
     const members = [];
@@ -3259,8 +3336,8 @@ class TypeRegistry {
   buildObjectSchemaFromProperties(type, checker, ctx) {
     const properties = type.getProperties();
     const indexInfos = checker.getIndexInfosOfType(type);
-    const stringIndex = indexInfos.find((i) => i.keyType.flags & ts5.TypeFlags.String);
-    const numberIndex = indexInfos.find((i) => i.keyType.flags & ts5.TypeFlags.Number);
+    const stringIndex = indexInfos.find((i) => i.keyType.flags & ts6.TypeFlags.String);
+    const numberIndex = indexInfos.find((i) => i.keyType.flags & ts6.TypeFlags.Number);
     if (properties.length === 0 && !stringIndex && !numberIndex) {
       return { type: checker.typeToString(type) };
     }
@@ -3268,8 +3345,8 @@ class TypeRegistry {
     const required = [];
     const limit = ctx.maxProperties;
     const isArrayLike = checker.isArrayType(type) || checker.isTupleType(type) || type.symbol?.getName() === "Array" && type.symbol?.getDeclarations()?.[0]?.getSourceFile()?.fileName?.includes("/typescript/lib/lib.");
-    const isStringLike = type.flags & ts5.TypeFlags.StringLike;
-    const isNumberLike = type.flags & ts5.TypeFlags.NumberLike;
+    const isStringLike = type.flags & ts6.TypeFlags.StringLike;
+    const isNumberLike = type.flags & ts6.TypeFlags.NumberLike;
     const included = properties.filter((prop) => {
       const propName = prop.getName();
       if (propName.startsWith("__@"))
@@ -3289,7 +3366,7 @@ class TypeRegistry {
     for (const prop of included.slice(0, limit)) {
       const propName = prop.getName();
       const rawPropType = checker.getTypeOfSymbol(prop);
-      const propType = prop.flags & ts5.SymbolFlags.Optional ? stripUndefinedFromType(rawPropType, checker) : rawPropType;
+      const propType = prop.flags & ts6.SymbolFlags.Optional ? stripUndefinedFromType(rawPropType, checker) : rawPropType;
       this.registerType(propType, ctx);
       let propSchema = buildSchema(propType, checker, ctx);
       const docComment = prop.getDocumentationComment(checker);
@@ -3306,7 +3383,7 @@ class TypeRegistry {
       }
       propSchema = decoratePropertySchema(propSchema, prop, propType, checker);
       props[propName] = propSchema;
-      if (!(prop.flags & ts5.SymbolFlags.Optional)) {
+      if (!(prop.flags & ts6.SymbolFlags.Optional)) {
         required.push(propName);
       }
     }
@@ -3340,7 +3417,11 @@ function createContext(program, sourceFile, options = {}) {
     includePrivate: options.includePrivate ?? false,
     maxProperties: options.maxProperties ?? 500,
     onTruncation: options.onTruncation,
-    shouldExpandExternal: options.shouldExpandExternal
+    shouldExpandExternal: options.shouldExpandExternal,
+    typeIds: new Map,
+    declIds: new Map,
+    idOwner: new Map,
+    workspacePackages: options.workspacePackages ?? new Map
   };
 }
 function getInheritedMembers(classType, ownMemberNames, ctx, isStatic = false) {
@@ -3409,15 +3490,15 @@ function serializeInheritedMember(symbol, inheritedFrom, ctx, isStatic) {
   const type = checker.getTypeOfSymbol(symbol);
   registerReferencedTypes(type, ctx);
   let visibility;
-  if (decl && ts6.canHaveModifiers(decl)) {
-    const modifiers = ts6.getModifiers(decl);
+  if (decl && ts7.canHaveModifiers(decl)) {
+    const modifiers = ts7.getModifiers(decl);
     if (modifiers) {
       for (const mod of modifiers) {
-        if (mod.kind === ts6.SyntaxKind.PrivateKeyword)
+        if (mod.kind === ts7.SyntaxKind.PrivateKeyword)
           visibility = "private";
-        else if (mod.kind === ts6.SyntaxKind.ProtectedKeyword)
+        else if (mod.kind === ts7.SyntaxKind.ProtectedKeyword)
           visibility = "protected";
-        else if (mod.kind === ts6.SyntaxKind.PublicKeyword)
+        else if (mod.kind === ts7.SyntaxKind.PublicKeyword)
           visibility = "public";
       }
     }
@@ -3429,17 +3510,17 @@ function serializeInheritedMember(symbol, inheritedFrom, ctx, isStatic) {
   const callSigs = type.getCallSignatures();
   if (callSigs.length > 0) {
     kind = "method";
-  } else if (ts6.isGetAccessorDeclaration(decl)) {
+  } else if (ts7.isGetAccessorDeclaration(decl)) {
     kind = "getter";
-  } else if (ts6.isSetAccessorDeclaration(decl)) {
+  } else if (ts7.isSetAccessorDeclaration(decl)) {
     kind = "setter";
   }
   const flags = {};
   if (isStatic)
     flags.static = true;
-  if (decl && ts6.canHaveModifiers(decl)) {
-    const modifiers = ts6.getModifiers(decl);
-    if (modifiers?.some((m) => m.kind === ts6.SyntaxKind.ReadonlyKeyword)) {
+  if (decl && ts7.canHaveModifiers(decl)) {
+    const modifiers = ts7.getModifiers(decl);
+    if (modifiers?.some((m) => m.kind === ts7.SyntaxKind.ReadonlyKeyword)) {
       flags.readonly = true;
     }
   }
@@ -3516,11 +3597,11 @@ function serializeClass(node, ctx) {
     const memberName = getMemberName(member);
     if (memberName?.startsWith("#"))
       continue;
-    if (ts7.isPropertyDeclaration(member)) {
+    if (ts8.isPropertyDeclaration(member)) {
       const propMember = serializeProperty(member, ctx);
       if (propMember)
         members.push(propMember);
-    } else if (ts7.isMethodDeclaration(member)) {
+    } else if (ts8.isMethodDeclaration(member)) {
       const methodMember = serializeMethod(member, ctx);
       if (methodMember?.name) {
         if (!methodsByName.has(methodMember.name)) {
@@ -3537,11 +3618,11 @@ function serializeClass(node, ctx) {
           }
         }
       }
-    } else if (ts7.isConstructorDeclaration(member)) {
+    } else if (ts8.isConstructorDeclaration(member)) {
       const ctorSig = serializeConstructor(member, ctx);
       if (ctorSig)
         signatures.push(ctorSig);
-    } else if (ts7.isGetAccessorDeclaration(member) || ts7.isSetAccessorDeclaration(member)) {
+    } else if (ts8.isGetAccessorDeclaration(member) || ts8.isSetAccessorDeclaration(member)) {
       const accessorMember = serializeAccessor(member, ctx);
       if (accessorMember)
         members.push(accessorMember);
@@ -3565,8 +3646,8 @@ function serializeClass(node, ctx) {
   const extendsClause = getExtendsClause(node, checker);
   const implementsClause = getImplementsClause(node, checker);
   const classFlags = {};
-  const classModifiers = ts7.getModifiers(node);
-  if (classModifiers?.some((m) => m.kind === ts7.SyntaxKind.AbstractKeyword)) {
+  const classModifiers = ts8.getModifiers(node);
+  if (classModifiers?.some((m) => m.kind === ts8.SyntaxKind.AbstractKeyword)) {
     classFlags.abstract = true;
   }
   return {
@@ -3587,37 +3668,37 @@ function serializeClass(node, ctx) {
   };
 }
 function getMemberName(member) {
-  if (ts7.isConstructorDeclaration(member))
+  if (ts8.isConstructorDeclaration(member))
     return "constructor";
   if (!member.name)
     return;
-  if (ts7.isIdentifier(member.name))
+  if (ts8.isIdentifier(member.name))
     return member.name.text;
-  if (ts7.isPrivateIdentifier(member.name))
+  if (ts8.isPrivateIdentifier(member.name))
     return member.name.text;
   return member.name.getText();
 }
 function getVisibility(member) {
-  const modifiers = ts7.canHaveModifiers(member) ? ts7.getModifiers(member) : undefined;
+  const modifiers = ts8.canHaveModifiers(member) ? ts8.getModifiers(member) : undefined;
   if (!modifiers)
     return;
   for (const mod of modifiers) {
-    if (mod.kind === ts7.SyntaxKind.PrivateKeyword)
+    if (mod.kind === ts8.SyntaxKind.PrivateKeyword)
       return "private";
-    if (mod.kind === ts7.SyntaxKind.ProtectedKeyword)
+    if (mod.kind === ts8.SyntaxKind.ProtectedKeyword)
       return "protected";
-    if (mod.kind === ts7.SyntaxKind.PublicKeyword)
+    if (mod.kind === ts8.SyntaxKind.PublicKeyword)
       return "public";
   }
   return;
 }
 function isStatic(member) {
-  const modifiers = ts7.canHaveModifiers(member) ? ts7.getModifiers(member) : undefined;
-  return modifiers?.some((m) => m.kind === ts7.SyntaxKind.StaticKeyword) ?? false;
+  const modifiers = ts8.canHaveModifiers(member) ? ts8.getModifiers(member) : undefined;
+  return modifiers?.some((m) => m.kind === ts8.SyntaxKind.StaticKeyword) ?? false;
 }
 function isReadonly(member) {
-  const modifiers = ts7.canHaveModifiers(member) ? ts7.getModifiers(member) : undefined;
-  return modifiers?.some((m) => m.kind === ts7.SyntaxKind.ReadonlyKeyword) ?? false;
+  const modifiers = ts8.canHaveModifiers(member) ? ts8.getModifiers(member) : undefined;
+  return modifiers?.some((m) => m.kind === ts8.SyntaxKind.ReadonlyKeyword) ?? false;
 }
 function serializeProperty(node, ctx) {
   const { typeChecker: checker } = ctx;
@@ -3675,11 +3756,11 @@ function serializeMethod(node, ctx) {
   if (node.asteriskToken)
     flags.generator = true;
   flags.methodSyntax = true;
-  const modifiers = ts7.getModifiers(node);
-  if (modifiers?.some((m) => m.kind === ts7.SyntaxKind.AsyncKeyword)) {
+  const modifiers = ts8.getModifiers(node);
+  if (modifiers?.some((m) => m.kind === ts8.SyntaxKind.AsyncKeyword)) {
     flags.async = true;
   }
-  if (modifiers?.some((m) => m.kind === ts7.SyntaxKind.AbstractKeyword)) {
+  if (modifiers?.some((m) => m.kind === ts8.SyntaxKind.AbstractKeyword)) {
     flags.abstract = true;
   }
   const symbol = checker.getSymbolAtLocation(node.name ?? node);
@@ -3716,7 +3797,7 @@ function serializeConstructorSignature(node, sig, ctx) {
 }
 function serializeInheritedConstructors(node, ctx) {
   const { typeChecker: checker } = ctx;
-  const hasExtends = node.heritageClauses?.some((c) => c.token === ts7.SyntaxKind.ExtendsKeyword);
+  const hasExtends = node.heritageClauses?.some((c) => c.token === ts8.SyntaxKind.ExtendsKeyword);
   if (!hasExtends)
     return [];
   const symbol = checker.getSymbolAtLocation(node.name ?? node);
@@ -3725,11 +3806,11 @@ function serializeInheritedConstructors(node, ctx) {
   const staticType = checker.getTypeOfSymbolAtLocation(symbol, node);
   const ctorSigs = staticType.getConstructSignatures().filter((sig) => {
     const decl = sig.getDeclaration();
-    return decl !== undefined && ts7.isConstructorDeclaration(decl);
+    return decl !== undefined && ts8.isConstructorDeclaration(decl);
   });
   return ctorSigs.map((sig, index) => {
     const decl = sig.getDeclaration();
-    const owner = ts7.isClassLike(decl.parent) ? decl.parent.name?.text : undefined;
+    const owner = ts8.isClassLike(decl.parent) ? decl.parent.name?.text : undefined;
     return {
       ...serializeConstructorSignature(decl, sig, ctx),
       ...owner ? { inheritedFrom: owner } : {},
@@ -3750,12 +3831,12 @@ function serializeAccessor(node, ctx) {
   const type = checker.getTypeAtLocation(node);
   const schema = buildSchema(type, checker, ctx);
   registerReferencedTypes(type, ctx);
-  const kind = ts7.isGetAccessorDeclaration(node) ? "getter" : "setter";
+  const kind = ts8.isGetAccessorDeclaration(node) ? "getter" : "setter";
   const flags = {};
   if (isStatic(node))
     flags.static = true;
   let signatures;
-  if (ts7.isSetAccessorDeclaration(node) && node.parameters.length > 0) {
+  if (ts8.isSetAccessorDeclaration(node) && node.parameters.length > 0) {
     const param = node.parameters[0];
     const paramName = param.name.getText();
     const paramType = checker.getTypeAtLocation(param);
@@ -3787,7 +3868,7 @@ function getExtendsClause(node, checker) {
   if (!node.heritageClauses)
     return;
   for (const clause of node.heritageClauses) {
-    if (clause.token === ts7.SyntaxKind.ExtendsKeyword) {
+    if (clause.token === ts8.SyntaxKind.ExtendsKeyword) {
       const expr = clause.types[0];
       if (expr) {
         const type = checker.getTypeAtLocation(expr);
@@ -3802,7 +3883,7 @@ function getImplementsClause(node, checker) {
   if (!node.heritageClauses)
     return;
   for (const clause of node.heritageClauses) {
-    if (clause.token === ts7.SyntaxKind.ImplementsKeyword) {
+    if (clause.token === ts8.SyntaxKind.ImplementsKeyword) {
       return clause.types.map((expr) => {
         const type = checker.getTypeAtLocation(expr);
         const symbol = type.getSymbol();
@@ -3856,16 +3937,16 @@ function serializeEnum(node, ctx) {
 }
 
 // src/serializers/functions.ts
-import ts8 from "typescript";
+import ts9 from "typescript";
 function buildReturnSchema(sig, ctx) {
   const returnType = ctx.typeChecker.getReturnTypeOfSignature(sig);
   registerReferencedTypes(returnType, ctx);
   const schema = buildSchema(returnType, ctx.typeChecker, ctx);
   const declaration = sig.getDeclaration();
-  if (declaration && ts8.isFunctionLike(declaration) && declaration.type) {
+  if (declaration && ts9.isFunctionLike(declaration) && declaration.type) {
     const returnTypeNode = declaration.type;
-    if (ts8.isTypePredicateNode(returnTypeNode)) {
-      const parameterName = ts8.isIdentifier(returnTypeNode.parameterName) ? returnTypeNode.parameterName.text : returnTypeNode.parameterName.getText();
+    if (ts9.isTypePredicateNode(returnTypeNode)) {
+      const parameterName = ts9.isIdentifier(returnTypeNode.parameterName) ? returnTypeNode.parameterName.text : returnTypeNode.parameterName.getText();
       let predicateTypeSchema = { type: "unknown" };
       if (returnTypeNode.type) {
         const predicateType = ctx.typeChecker.getTypeAtLocation(returnTypeNode.type);
@@ -3909,8 +3990,8 @@ function serializeFunctionExport(node, ctx, nameOverride) {
     };
   });
   const flags = {};
-  const modifiers = ts8.getModifiers(node);
-  if (modifiers?.some((m) => m.kind === ts8.SyntaxKind.AsyncKeyword)) {
+  const modifiers = ts9.getModifiers(node);
+  if (modifiers?.some((m) => m.kind === ts9.SyntaxKind.AsyncKeyword)) {
     flags.async = true;
   }
   if (node.asteriskToken) {
@@ -3932,7 +4013,7 @@ function serializeFunctionExport(node, ctx, nameOverride) {
 }
 
 // src/serializers/interfaces.ts
-import ts9 from "typescript";
+import ts10 from "typescript";
 function serializeInterface(node, ctx) {
   const { typeChecker: checker } = ctx;
   const symbol = checker.getSymbolAtLocation(node.name ?? node);
@@ -3945,11 +4026,11 @@ function serializeInterface(node, ctx) {
   const methodsByName = new Map;
   let callSignatureMember = null;
   for (const member of node.members) {
-    if (ts9.isPropertySignature(member)) {
+    if (ts10.isPropertySignature(member)) {
       const propMember = serializePropertySignature(member, ctx);
       if (propMember)
         members.push(propMember);
-    } else if (ts9.isMethodSignature(member)) {
+    } else if (ts10.isMethodSignature(member)) {
       const methodMember = serializeMethodSignature(member, ctx);
       if (methodMember?.name && methodMember.signatures) {
         const existing = methodsByName.get(methodMember.name);
@@ -3970,7 +4051,7 @@ function serializeInterface(node, ctx) {
           methodsByName.set(methodMember.name, methodMember);
         }
       }
-    } else if (ts9.isCallSignatureDeclaration(member)) {
+    } else if (ts10.isCallSignatureDeclaration(member)) {
       const callSig = serializeCallSignature(member, ctx);
       if (callSig?.signatures) {
         if (callSignatureMember?.signatures) {
@@ -3993,7 +4074,7 @@ function serializeInterface(node, ctx) {
           callSignatureMember = callSig;
         }
       }
-    } else if (ts9.isIndexSignatureDeclaration(member)) {
+    } else if (ts10.isIndexSignatureDeclaration(member)) {
       const indexMember = serializeIndexSignature(member, ctx);
       if (indexMember)
         members.push(indexMember);
@@ -4031,7 +4112,7 @@ function serializePropertySignature(node, ctx) {
   const flags = {};
   if (node.questionToken)
     flags.optional = true;
-  if (node.modifiers?.some((m) => m.kind === ts9.SyntaxKind.ReadonlyKeyword)) {
+  if (node.modifiers?.some((m) => m.kind === ts10.SyntaxKind.ReadonlyKeyword)) {
     flags.readonly = true;
   }
   const symbol = checker.getSymbolAtLocation(node.name);
@@ -4119,7 +4200,7 @@ function getInterfaceExtends(node, checker) {
   if (!node.heritageClauses)
     return;
   for (const clause of node.heritageClauses) {
-    if (clause.token === ts9.SyntaxKind.ExtendsKeyword && clause.types.length > 0) {
+    if (clause.token === ts10.SyntaxKind.ExtendsKeyword && clause.types.length > 0) {
       const names = clause.types.map((expr) => {
         const type = checker.getTypeAtLocation(expr);
         return type.getSymbol()?.getName() ?? expr.expression.getText();
@@ -4131,7 +4212,7 @@ function getInterfaceExtends(node, checker) {
 }
 
 // src/serializers/type-aliases.ts
-import ts10 from "typescript";
+import ts11 from "typescript";
 function buildIntersectionSchemaFromNode(node, ctx) {
   const types = node.types;
   const schemas = [];
@@ -4159,14 +4240,14 @@ function serializeTypeAlias(node, ctx) {
   registerReferencedTypes(type, ctx);
   let schema;
   let members;
-  if (ts10.isIntersectionTypeNode(node.type)) {
+  if (ts11.isIntersectionTypeNode(node.type)) {
     schema = buildIntersectionSchemaFromNode(node.type, ctx);
     if (type.getProperties().length > 0 && type.getCallSignatures().length === 0) {
       members = serializeResolvedMembers(type, node, ctx);
     }
   } else if (isInlineFunctionAlias(node.type) && type.getCallSignatures().length > 0) {
     schema = buildFunctionSchema(type.getCallSignatures(), ctx.typeChecker, ctx);
-  } else if ((ts10.isMappedTypeNode(node.type) || ts10.isConditionalTypeNode(node.type)) && type.getProperties().length > 0 && type.getCallSignatures().length === 0 && !(type.flags & ts10.TypeFlags.Conditional) && !(type.flags & (ts10.TypeFlags.StringLike | ts10.TypeFlags.NumberLike))) {
+  } else if ((ts11.isMappedTypeNode(node.type) || ts11.isConditionalTypeNode(node.type)) && type.getProperties().length > 0 && type.getCallSignatures().length === 0 && !(type.flags & ts11.TypeFlags.Conditional) && !(type.flags & (ts11.TypeFlags.StringLike | ts11.TypeFlags.NumberLike))) {
     schema = buildObjectSchema(type.getProperties(), ctx.typeChecker, ctx, type);
     members = serializeResolvedMembers(type, node, ctx);
   } else {
@@ -4176,7 +4257,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, ts10.TypeFormatFlags.InTypeAlias);
+    const text = renderTypeText(type, ctx.typeChecker, node, ts11.TypeFormatFlags.InTypeAlias);
     if (!PRIMITIVES.has(text) && text !== name) {
       schema["x-ts-type"] = text;
     }
@@ -4197,12 +4278,12 @@ function serializeTypeAlias(node, ctx) {
 }
 function isObjectShapedAlias(type, ctx) {
   const { typeChecker: checker } = ctx;
-  if (!(type.flags & ts10.TypeFlags.Object))
+  if (!(type.flags & ts11.TypeFlags.Object))
     return false;
   if (checker.isArrayType(type) || checker.isTupleType(type))
     return false;
   const objectFlags = type.objectFlags;
-  if (!(objectFlags & ts10.ObjectFlags.Mapped)) {
+  if (!(objectFlags & ts11.ObjectFlags.Mapped)) {
     const targetSymbol = type.target?.getSymbol?.() ?? type.getSymbol();
     if (isBuiltinSymbol(targetSymbol))
       return false;
@@ -4210,19 +4291,19 @@ function isObjectShapedAlias(type, ctx) {
   return type.getProperties().length > 0 && type.getCallSignatures().length === 0;
 }
 function isInlineFunctionAlias(typeNode) {
-  return ts10.isFunctionTypeNode(typeNode) || ts10.isTypeLiteralNode(typeNode) && typeNode.members.some(ts10.isCallSignatureDeclaration);
+  return ts11.isFunctionTypeNode(typeNode) || ts11.isTypeLiteralNode(typeNode) && typeNode.members.some(ts11.isCallSignatureDeclaration);
 }
 function buildConditionalArmDocs(typeNode, checker) {
   const docs = new Map;
-  if (!ts10.isMappedTypeNode(typeNode) || !typeNode.type)
+  if (!ts11.isMappedTypeNode(typeNode) || !typeNode.type)
     return docs;
   const literalKeys = (extendsType) => {
     const keys = [];
     const visit = (n) => {
-      if (ts10.isUnionTypeNode(n)) {
+      if (ts11.isUnionTypeNode(n)) {
         for (const member of n.types)
           visit(member);
-      } else if (ts10.isLiteralTypeNode(n) && ts10.isStringLiteral(n.literal)) {
+      } else if (ts11.isLiteralTypeNode(n) && ts11.isStringLiteral(n.literal)) {
         keys.push(n.literal.text);
       }
     };
@@ -4230,12 +4311,12 @@ function buildConditionalArmDocs(typeNode, checker) {
     return keys;
   };
   const armDoc = (armType) => {
-    if (!ts10.isTypeReferenceNode(armType))
+    if (!ts11.isTypeReferenceNode(armType))
       return;
     const symbol = checker.getSymbolAtLocation(armType.typeName);
     if (!symbol)
       return;
-    const target = symbol.flags & ts10.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+    const target = symbol.flags & ts11.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;
@@ -4244,7 +4325,7 @@ function buildConditionalArmDocs(typeNode, checker) {
     return { deprecated, deprecationReason: reason, description };
   };
   let current = typeNode.type;
-  while (current && ts10.isConditionalTypeNode(current)) {
+  while (current && ts11.isConditionalTypeNode(current)) {
     const doc = armDoc(current.trueType);
     if (doc) {
       for (const key of literalKeys(current.extendsType)) {
@@ -4263,10 +4344,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 & ts10.SymbolFlags.Optional ? stripUndefinedFromType(rawPropType, checker) : rawPropType;
+    const propType = prop.flags & ts11.SymbolFlags.Optional ? stripUndefinedFromType(rawPropType, checker) : rawPropType;
     registerReferencedTypes(propType, ctx);
     const callSigs = propType.getCallSignatures();
-    const isMethodDecl = ts10.isMethodSignature(decl) || ts10.isMethodDeclaration(decl) || ts10.isFunctionDeclaration(decl);
+    const isMethodDecl = ts11.isMethodSignature(decl) || ts11.isMethodDeclaration(decl) || ts11.isFunctionDeclaration(decl);
     const kind = callSigs.length > 0 && isMethodDecl ? "method" : "property";
     let { description, tags } = getJSDocComment(decl, prop, checker);
     let { deprecated, reason: deprecationReason } = isSymbolDeprecated(prop);
@@ -4284,11 +4365,11 @@ function serializeResolvedMembers(type, node, ctx) {
       ({ deprecated, reason: deprecationReason } = isSymbolDeprecated(armAlias));
     }
     const flags = {};
-    if (prop.flags & ts10.SymbolFlags.Optional)
+    if (prop.flags & ts11.SymbolFlags.Optional)
       flags.optional = true;
     if (isReadonlyPropertySymbol(prop))
       flags.readonly = true;
-    if (prop.flags & ts10.SymbolFlags.Method)
+    if (prop.flags & ts11.SymbolFlags.Method)
       flags.methodSyntax = true;
     const schema = kind === "property" ? decoratePropertySchema(buildSchema(propType, checker, ctx), prop, propType, checker) : decoratePropertySchema({ "x-ts-function": true }, prop, propType, checker);
     members.push({
@@ -5066,7 +5147,7 @@ async function getExport(options) {
   ctx.exportedIds = exportedIds;
   try {
     const originalDecls = targetSymbol.declarations ?? [];
-    const isNamespaceExportDecl = originalDecls.some((d) => ts11.isNamespaceExport(d) || ts11.isNamespaceImport(d));
+    const isNamespaceExportDecl = originalDecls.some((d) => ts12.isNamespaceExport(d) || ts12.isNamespaceImport(d));
     if (isNamespaceExportDecl) {
       const spec2 = serializeNamespaceForGet(targetSymbol, exportName, ctx);
       const types2 = ctx.typeRegistry.getAll().map((t) => normalizeType(t));
@@ -5117,42 +5198,42 @@ function resolveExportTarget(symbol, checker) {
   let isTypeOnly = false;
   const declarations = symbol.declarations ?? [];
   for (const decl of declarations) {
-    if (ts11.isExportSpecifier(decl)) {
+    if (ts12.isExportSpecifier(decl)) {
       if (decl.isTypeOnly)
         isTypeOnly = true;
       const exportDecl = decl.parent?.parent;
-      if (exportDecl && ts11.isExportDeclaration(exportDecl) && exportDecl.isTypeOnly) {
+      if (exportDecl && ts12.isExportDeclaration(exportDecl) && exportDecl.isTypeOnly) {
         isTypeOnly = true;
       }
     }
   }
-  if (symbol.flags & ts11.SymbolFlags.Alias) {
+  if (symbol.flags & ts12.SymbolFlags.Alias) {
     const aliased = checker.getAliasedSymbol(symbol);
     if (aliased && aliased !== symbol) {
       resolvedSymbol = aliased;
     }
   }
   const targetDeclarations = resolvedSymbol.declarations ?? [];
-  const declaration = resolvedSymbol.valueDeclaration || targetDeclarations.find((d) => d.kind !== ts11.SyntaxKind.ExportSpecifier) || targetDeclarations[0];
+  const declaration = resolvedSymbol.valueDeclaration || targetDeclarations.find((d) => d.kind !== ts12.SyntaxKind.ExportSpecifier) || targetDeclarations[0];
   return { declaration, resolvedSymbol, isTypeOnly };
 }
 function serializeDeclaration(declaration, _exportSymbol, _targetSymbol, exportName, ctx, isTypeOnly) {
   let result = null;
-  if (ts11.isFunctionDeclaration(declaration)) {
+  if (ts12.isFunctionDeclaration(declaration)) {
     result = serializeFunctionExport(declaration, ctx);
-  } else if (ts11.isClassDeclaration(declaration)) {
+  } else if (ts12.isClassDeclaration(declaration)) {
     result = serializeClass(declaration, ctx);
-  } else if (ts11.isInterfaceDeclaration(declaration)) {
+  } else if (ts12.isInterfaceDeclaration(declaration)) {
     result = serializeInterface(declaration, ctx);
-  } else if (ts11.isTypeAliasDeclaration(declaration)) {
+  } else if (ts12.isTypeAliasDeclaration(declaration)) {
     result = serializeTypeAlias(declaration, ctx);
-  } else if (ts11.isEnumDeclaration(declaration)) {
+  } else if (ts12.isEnumDeclaration(declaration)) {
     result = serializeEnum(declaration, ctx);
-  } else if (ts11.isVariableDeclaration(declaration)) {
+  } else if (ts12.isVariableDeclaration(declaration)) {
     const varStatement = declaration.parent?.parent;
-    if (varStatement && ts11.isVariableStatement(varStatement)) {
-      if (declaration.initializer && (ts11.isArrowFunction(declaration.initializer) || ts11.isFunctionExpression(declaration.initializer))) {
-        const varName = ts11.isIdentifier(declaration.name) ? declaration.name.text : declaration.name.getText();
+    if (varStatement && ts12.isVariableStatement(varStatement)) {
+      if (declaration.initializer && (ts12.isArrowFunction(declaration.initializer) || ts12.isFunctionExpression(declaration.initializer))) {
+        const varName = ts12.isIdentifier(declaration.name) ? declaration.name.text : declaration.name.getText();
         result = serializeFunctionExport(declaration.initializer, ctx, varName);
       } else {
         const checker = ctx.program.getTypeChecker();
@@ -5166,7 +5247,7 @@ function serializeDeclaration(declaration, _exportSymbol, _targetSymbol, exportN
         }
       }
     }
-  } else if (ts11.isNamespaceExport(declaration) || ts11.isModuleDeclaration(declaration) || ts11.isNamespaceImport(declaration) || ts11.isSourceFile(declaration)) {
+  } else if (ts12.isNamespaceExport(declaration) || ts12.isModuleDeclaration(declaration) || ts12.isNamespaceImport(declaration) || ts12.isSourceFile(declaration)) {
     result = serializeNamespaceForGet(_exportSymbol, exportName, ctx);
   }
   if (result) {
@@ -5182,7 +5263,7 @@ function serializeDeclaration(declaration, _exportSymbol, _targetSymbol, exportN
 function serializeNamespaceForGet(symbol, exportName, ctx) {
   const checker = ctx.program.getTypeChecker();
   let targetSymbol = symbol;
-  if (symbol.flags & ts11.SymbolFlags.Alias) {
+  if (symbol.flags & ts12.SymbolFlags.Alias) {
     const aliased = checker.getAliasedSymbol(symbol);
     if (aliased && aliased !== symbol) {
       targetSymbol = aliased;
@@ -5212,7 +5293,7 @@ function serializeNamespaceForGet(symbol, exportName, ctx) {
 }
 function detectExternalPackage(symbol, checker) {
   let targetSymbol = symbol;
-  if (symbol.flags & ts11.SymbolFlags.Alias) {
+  if (symbol.flags & ts12.SymbolFlags.Alias) {
     const aliased = checker.getAliasedSymbol(symbol);
     if (aliased && aliased !== symbol) {
       targetSymbol = aliased;
@@ -5226,9 +5307,9 @@ function detectExternalPackage(symbol, checker) {
       if (match)
         return match[1];
     }
-    if (ts11.isExportSpecifier(decl)) {
+    if (ts12.isExportSpecifier(decl)) {
       const exportDecl = decl.parent?.parent;
-      if (exportDecl && ts11.isExportDeclaration(exportDecl) && exportDecl.moduleSpecifier) {
+      if (exportDecl && ts12.isExportDeclaration(exportDecl) && exportDecl.moduleSpecifier) {
         const moduleText = exportDecl.moduleSpecifier.text;
         if (!moduleText.startsWith(".") && !moduleText.startsWith("/")) {
           return moduleText;
@@ -5239,8 +5320,8 @@ function detectExternalPackage(symbol, checker) {
   return;
 }
 // src/primitives/list.ts
-import * as path4 from "node:path";
-import ts12 from "typescript";
+import * as path5 from "node:path";
+import ts13 from "typescript";
 async function listExports(options) {
   const { entryFile, baseDir, content } = options;
   const errors = [];
@@ -5283,16 +5364,16 @@ async function listExports(options) {
 }
 function extractExportItem(symbol, checker, entryFile, entrySourceFile) {
   const name = symbol.getName();
-  const isReexport = !!(symbol.flags & ts12.SymbolFlags.Alias);
+  const isReexport = !!(symbol.flags & ts13.SymbolFlags.Alias);
   let targetSymbol = symbol;
-  if (symbol.flags & ts12.SymbolFlags.Alias) {
+  if (symbol.flags & ts13.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 !== ts12.SyntaxKind.ExportSpecifier) || declarations[0];
+  const declaration = targetSymbol.valueDeclaration || declarations.find((d) => d.kind !== ts13.SyntaxKind.ExportSpecifier) || declarations[0];
   if (!declaration) {
     return {
       name,
@@ -5302,11 +5383,11 @@ function extractExportItem(symbol, checker, entryFile, entrySourceFile) {
       reexport: true
     };
   }
-  if (ts12.isSourceFile(declaration)) {
+  if (ts13.isSourceFile(declaration)) {
     return {
       name,
       kind: "namespace",
-      file: path4.relative(path4.dirname(entryFile), declaration.fileName),
+      file: path5.relative(path5.dirname(entryFile), declaration.fileName),
       line: 1,
       reexport: true
     };
@@ -5320,7 +5401,7 @@ function extractExportItem(symbol, checker, entryFile, entrySourceFile) {
   return {
     name,
     kind,
-    file: path4.relative(path4.dirname(entryFile), sourceFile.fileName),
+    file: path5.relative(path5.dirname(entryFile), sourceFile.fileName),
     line: line + 1,
     ...description ? { description } : {},
     ...deprecated ? { deprecated: true } : {},
@@ -5341,21 +5422,21 @@ function getDescriptionPreview(symbol, checker) {
   return `${firstLine.slice(0, 77)}...`;
 }
 // src/builder/spec-builder.ts
-import * as fs7 from "node:fs";
+import * as fs6 from "node:fs";
 import * as path9 from "node:path";
 import { SCHEMA_URL, SCHEMA_VERSION } from "@openpkg-ts/spec";
-import ts17 from "typescript";
+import ts18 from "typescript";
 
 // src/ast/resolve.ts
-import ts13 from "typescript";
+import ts14 from "typescript";
 function isTypeOnlyExport(symbol) {
   const declarations = symbol.declarations ?? [];
   for (const decl of declarations) {
-    if (ts13.isExportSpecifier(decl)) {
+    if (ts14.isExportSpecifier(decl)) {
       if (decl.isTypeOnly)
         return true;
       const exportDecl = decl.parent?.parent;
-      if (exportDecl && ts13.isExportDeclaration(exportDecl) && exportDecl.isTypeOnly) {
+      if (exportDecl && ts14.isExportDeclaration(exportDecl) && exportDecl.isTypeOnly) {
         return true;
       }
     }
@@ -5365,14 +5446,14 @@ function isTypeOnlyExport(symbol) {
 function resolveExportTarget2(symbol, checker) {
   let targetSymbol = symbol;
   const isTypeOnly = isTypeOnlyExport(symbol);
-  if (symbol.flags & ts13.SymbolFlags.Alias) {
+  if (symbol.flags & ts14.SymbolFlags.Alias) {
     const aliasTarget = checker.getAliasedSymbol(symbol);
     if (aliasTarget && aliasTarget !== symbol) {
       targetSymbol = aliasTarget;
     }
   }
   const declarations = targetSymbol.declarations ?? [];
-  const declaration = targetSymbol.valueDeclaration || declarations.find((decl) => decl.kind !== ts13.SyntaxKind.ExportSpecifier) || declarations[0];
+  const declaration = targetSymbol.valueDeclaration || declarations.find((decl) => decl.kind !== ts14.SyntaxKind.ExportSpecifier) || declarations[0];
   return { declaration, targetSymbol, isTypeOnly };
 }
 
@@ -5380,7 +5461,7 @@ function resolveExportTarget2(symbol, checker) {
 import { spawn, spawnSync } from "node:child_process";
 import * as fs4 from "node:fs";
 import * as os from "node:os";
-import * as path5 from "node:path";
+import * as path6 from "node:path";
 var MAX_BUFFER_SIZE = 10 * 1024 * 1024;
 function isStandardJSONSchema(obj) {
   if (typeof obj !== "object" || obj === null)
@@ -5639,16 +5720,16 @@ async function extractStandardSchemasFromTs(tsFilePath, options = {}) {
     return result;
   }
   const tempDir = os.tmpdir();
-  const workerPath = path5.join(tempDir, `openpkg-extract-worker-${Date.now()}.ts`);
+  const workerPath = path6.join(tempDir, `openpkg-extract-worker-${Date.now()}.ts`);
   try {
     fs4.writeFileSync(workerPath, TS_WORKER_SCRIPT);
     const optionsJson = JSON.stringify({ target, libraryOptions });
     const args = [...runtime.args, workerPath, tsFilePath, optionsJson];
-    return await new Promise((resolve2) => {
+    return await new Promise((resolve3) => {
       const child = spawn(runtime.cmd, args, {
         timeout,
         stdio: ["ignore", "pipe", "pipe"],
-        cwd: path5.dirname(tsFilePath)
+        cwd: path6.dirname(tsFilePath)
       });
       let stdout = "";
       let stderr = "";
@@ -5680,14 +5761,14 @@ async function extractStandardSchemasFromTs(tsFilePath, options = {}) {
         }
         if (code !== 0) {
           result.errors.push(`Extraction failed (${runtime.name}): ${stderr || `exit code ${code}`}`);
-          resolve2(result);
+          resolve3(result);
           return;
         }
         try {
           const parsed = JSON.parse(stdout);
           if (!parsed.success) {
             result.errors.push(`Extraction failed: ${parsed.error}`);
-            resolve2(result);
+            resolve3(result);
             return;
           }
           for (const item of parsed.results) {
@@ -5722,7 +5803,7 @@ async function extractStandardSchemasFromTs(tsFilePath, options = {}) {
             message: "stderr exceeded 10MB buffer limit"
           });
         }
-        resolve2(result);
+        resolve3(result);
       });
       child.on("error", (err) => {
         try {
@@ -5733,7 +5814,7 @@ async function extractStandardSchemasFromTs(tsFilePath, options = {}) {
           }
         }
         result.errors.push(`Subprocess error: ${err.message}`);
-        resolve2(result);
+        resolve3(result);
       });
     });
   } catch (e) {
@@ -5749,7 +5830,7 @@ async function extractStandardSchemasFromTs(tsFilePath, options = {}) {
   }
 }
 function readTsconfigOutDir(baseDir) {
-  const tsconfigPath = path5.join(baseDir, "tsconfig.json");
+  const tsconfigPath = path6.join(baseDir, "tsconfig.json");
   try {
     if (!fs4.existsSync(tsconfigPath)) {
       return null;
@@ -5764,7 +5845,7 @@ function readTsconfigOutDir(baseDir) {
   return null;
 }
 function resolveCompiledPath(tsPath, baseDir) {
-  const relativePath = path5.relative(baseDir, tsPath);
+  const relativePath = path6.relative(baseDir, tsPath);
   const withoutExt = relativePath.replace(/\.tsx?$/, "");
   const srcPrefix = withoutExt.replace(/^src\//, "");
   const tsconfigOutDir = readTsconfigOutDir(baseDir);
@@ -5772,7 +5853,7 @@ function resolveCompiledPath(tsPath, baseDir) {
   const candidates = [];
   if (tsconfigOutDir) {
     for (const ext of extensions) {
-      candidates.push(path5.join(baseDir, tsconfigOutDir, `${srcPrefix}${ext}`));
+      candidates.push(path6.join(baseDir, tsconfigOutDir, `${srcPrefix}${ext}`));
     }
   }
   const commonOutDirs = ["dist", "build", "lib", "out"];
@@ -5780,17 +5861,17 @@ function resolveCompiledPath(tsPath, baseDir) {
     if (outDir === tsconfigOutDir)
       continue;
     for (const ext of extensions) {
-      candidates.push(path5.join(baseDir, outDir, `${srcPrefix}${ext}`));
+      candidates.push(path6.join(baseDir, outDir, `${srcPrefix}${ext}`));
     }
   }
   for (const ext of extensions) {
-    candidates.push(path5.join(baseDir, `${withoutExt}${ext}`));
+    candidates.push(path6.join(baseDir, `${withoutExt}${ext}`));
   }
   const workspaceMatch = baseDir.match(/^(.+\/packages\/[^/]+)$/);
   if (workspaceMatch) {
     const pkgRoot = workspaceMatch[1];
     for (const ext of extensions) {
-      candidates.push(path5.join(pkgRoot, "dist", `${srcPrefix}${ext}`));
+      candidates.push(path6.join(pkgRoot, "dist", `${srcPrefix}${ext}`));
     }
   }
   for (const candidate of candidates) {
@@ -5812,7 +5893,7 @@ async function extractStandardSchemas(compiledJsPath, options = {}) {
     return result;
   }
   const optionsJson = JSON.stringify({ target, libraryOptions });
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const child = spawn("node", ["-e", WORKER_SCRIPT, compiledJsPath, optionsJson], {
       timeout,
       stdio: ["ignore", "pipe", "pipe"]
@@ -5840,14 +5921,14 @@ async function extractStandardSchemas(compiledJsPath, options = {}) {
     child.on("close", (code) => {
       if (code !== 0) {
         result.errors.push(`Extraction process failed: ${stderr || `exit code ${code}`}`);
-        resolve2(result);
+        resolve3(result);
         return;
       }
       try {
         const parsed = JSON.parse(stdout);
         if (!parsed.success) {
           result.errors.push(`Extraction failed: ${parsed.error}`);
-          resolve2(result);
+          resolve3(result);
           return;
         }
         for (const item of parsed.results) {
@@ -5882,11 +5963,11 @@ async function extractStandardSchemas(compiledJsPath, options = {}) {
           message: "stderr exceeded 10MB buffer limit"
         });
       }
-      resolve2(result);
+      resolve3(result);
     });
     child.on("error", (err) => {
       result.errors.push(`Subprocess error: ${err.message}`);
-      resolve2(result);
+      resolve3(result);
     });
   });
 }
@@ -5924,9 +6005,9 @@ async function extractStandardSchemasFromProject(entryFile, baseDir, options = {
 
 // src/builder/external-resolver.ts
 import * as fs5 from "node:fs";
-import * as path6 from "node:path";
+import * as path7 from "node:path";
 import picomatch from "picomatch";
-import ts14 from "typescript";
+import ts15 from "typescript";
 function matchesExternalPattern(packageName, include, exclude) {
   if (!include?.length)
     return false;
@@ -5942,7 +6023,7 @@ function matchesExternalPattern(packageName, include, exclude) {
   return true;
 }
 function resolveExternalModule(moduleSpecifier, containingFile, compilerOptions) {
-  const resolved = ts14.resolveModuleName(moduleSpecifier, containingFile, compilerOptions, ts14.sys);
+  const resolved = ts15.resolveModuleName(moduleSpecifier, containingFile, compilerOptions, ts15.sys);
   if (!resolved.resolvedModule) {
     return null;
   }
@@ -5958,11 +6039,11 @@ function findPackageJson(resolvedPath, packageName) {
   const isScoped = packageName.startsWith("@");
   const packageParts = isScoped ? packageName.split("/").slice(0, 2) : [packageName.split("/")[0]];
   const packageDir = packageParts.join("/");
-  let dir = path6.dirname(resolvedPath);
+  let dir = path7.dirname(resolvedPath);
   const maxDepth = 10;
   for (let i = 0;i < maxDepth; i++) {
     if (dir.endsWith(`node_modules/${packageDir}`)) {
-      const pkgPath = path6.join(dir, "package.json");
+      const pkgPath = path7.join(dir, "package.json");
       if (fs5.existsSync(pkgPath)) {
         try {
           return JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
@@ -5971,7 +6052,7 @@ function findPackageJson(resolvedPath, packageName) {
         }
       }
     }
-    const parent = path6.dirname(dir);
+    const parent = path7.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -6007,7 +6088,7 @@ function extractExternalExport(exportName, resolvedModule, program, ctx, visited
     return null;
   }
   let resolvedSymbol = targetExport;
-  if (targetExport.flags & ts14.SymbolFlags.Alias) {
+  if (targetExport.flags & ts15.SymbolFlags.Alias) {
     const aliased = checker.getAliasedSymbol(targetExport);
     if (aliased && aliased !== targetExport) {
       resolvedSymbol = aliased;
@@ -6078,7 +6159,7 @@ function mergeRuntimeSchemas(staticExports, runtimeSchemas) {
 }
 
 // src/builder/type-cache.ts
-import ts15 from "typescript";
+import ts16 from "typescript";
 
 // src/utils/cache-manager.ts
 class CacheManager {
@@ -6185,10 +6266,10 @@ function findTypeDefinition(typeName, program, sourceFile) {
   return typeDefinitionCache.getOrCompute(typeName, () => {
     const checker = program.getTypeChecker();
     const findInNode = (node) => {
-      if ((ts15.isInterfaceDeclaration(node) || ts15.isTypeAliasDeclaration(node) || ts15.isClassDeclaration(node) || ts15.isEnumDeclaration(node)) && node.name?.text === typeName) {
+      if ((ts16.isInterfaceDeclaration(node) || ts16.isTypeAliasDeclaration(node) || ts16.isClassDeclaration(node) || ts16.isEnumDeclaration(node)) && node.name?.text === typeName) {
         return node.getSourceFile().fileName;
       }
-      return ts15.forEachChild(node, findInNode);
+      return ts16.forEachChild(node, findInNode);
     };
     const entryResult = findInNode(sourceFile);
     if (entryResult)
@@ -6200,14 +6281,14 @@ function findTypeDefinition(typeName, program, sourceFile) {
           return result;
       }
     }
-    const symbol = checker.resolveName(typeName, sourceFile, ts15.SymbolFlags.Type, false);
+    const symbol = checker.resolveName(typeName, sourceFile, ts16.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, ts15.SymbolFlags.Type, false);
+    const symbol = checker.resolveName(typeName, sourceFile, ts16.SymbolFlags.Type, false);
     if (!symbol)
       return false;
     return symbol.getJsDocTags().some((tag) => tag.name === "internal");
@@ -6215,21 +6296,8 @@ function hasInternalTag(typeName, program, sourceFile) {
 }
 
 // src/builder/type-expansion.ts
-import * as fs6 from "node:fs";
-import * as path7 from "node:path";
-import ts16 from "typescript";
-function findPackageDir(fromFile) {
-  let dir = path7.dirname(path7.resolve(fromFile));
-  while (true) {
-    if (fs6.existsSync(path7.join(dir, "package.json")))
-      return dir;
-    const parent = path7.dirname(dir);
-    if (parent === dir)
-      return;
-    dir = parent;
-  }
-}
-var NODE_MODULES_PKG = /node_modules\/(@[^/]+\/[^/]+|[^/]+)/;
+import ts17 from "typescript";
+var NODE_MODULES_PKG2 = /node_modules\/(@[^/]+\/[^/]+|[^/]+)/;
 function isLibFile(fileName) {
   return fileName.includes("/typescript/lib/lib.") || fileName.includes("\\typescript\\lib\\lib.");
 }
@@ -6256,7 +6324,7 @@ function createExternalExpansionPredicate(opts) {
     const fileName = decl.getSourceFile().fileName;
     if (isLibFile(fileName))
       return false;
-    const match = fileName.match(NODE_MODULES_PKG);
+    const match = fileName.match(NODE_MODULES_PKG2);
     if (match)
       return packageAllowed(match[1]);
     return true;
@@ -6268,20 +6336,6 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
   const checker = ctx.typeChecker;
   const visited = new Set;
   const MAX_DEPTH = 30;
-  const entryPackageDir = findPackageDir(opts.entryFile);
-  const packageLabel = (fileName) => {
-    const match = fileName.match(NODE_MODULES_PKG);
-    let pkg = match?.[1];
-    if (!pkg) {
-      for (const [name, dir] of opts.workspacePackages) {
-        if (fileName.startsWith(`${path7.resolve(dir)}${path7.sep}`)) {
-          pkg = name;
-          break;
-        }
-      }
-    }
-    return (pkg ?? "local").replace(/^@/, "").replace(/\//g, "-");
-  };
   const symbolAllowed = createExternalExpansionPredicate(opts);
   const visit = (type, depth) => {
     if (!type || depth > MAX_DEPTH || visited.has(type))
@@ -6311,7 +6365,7 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
         visit(t, depth + 1);
       }
     }
-    if (!allowed || !(type.flags & ts16.TypeFlags.Object || type.isClassOrInterface())) {
+    if (!allowed || !(type.flags & ts17.TypeFlags.Object || type.isClassOrInterface())) {
       return;
     }
     if (type.isClassOrInterface()) {
@@ -6334,19 +6388,19 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
       visit(info.type, depth + 1);
     }
   };
-  const TYPE_SYMBOL_FLAGS = ts16.SymbolFlags.Interface | ts16.SymbolFlags.TypeAlias | ts16.SymbolFlags.Class | ts16.SymbolFlags.RegularEnum | ts16.SymbolFlags.ConstEnum;
+  const TYPE_SYMBOL_FLAGS = ts17.SymbolFlags.Interface | ts17.SymbolFlags.TypeAlias | ts17.SymbolFlags.Class | ts17.SymbolFlags.RegularEnum | ts17.SymbolFlags.ConstEnum;
   const visitedSymbols = new Set;
   const symbolKind = (symbol) => {
-    if (symbol.flags & ts16.SymbolFlags.Interface)
+    if (symbol.flags & ts17.SymbolFlags.Interface)
       return "interface";
-    if (symbol.flags & ts16.SymbolFlags.Class)
+    if (symbol.flags & ts17.SymbolFlags.Class)
       return "class";
-    if (symbol.flags & (ts16.SymbolFlags.RegularEnum | ts16.SymbolFlags.ConstEnum))
+    if (symbol.flags & (ts17.SymbolFlags.RegularEnum | ts17.SymbolFlags.ConstEnum))
       return "enum";
     return "type";
   };
   const resolveAlias = (symbol) => {
-    if (symbol.flags & ts16.SymbolFlags.Alias) {
+    if (symbol.flags & ts17.SymbolFlags.Alias) {
       try {
         return checker.getAliasedSymbol(symbol);
       } catch {
@@ -6368,37 +6422,16 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
       walkDeclarations(symbol);
       return;
     }
-    if (ctx.typeRegistry.has(name)) {
-      const prior = symbolByName.get(name);
-      if (prior !== symbol) {
-        const declFile = symbol.declarations?.[0]?.getSourceFile().fileName ?? "";
-        const foreign = !!entryPackageDir && !declFile.startsWith(`${entryPackageDir}${path7.sep}`);
-        if (prior !== undefined || foreign) {
-          const scopedId = `${packageLabel(declFile)}.${name}`;
-          if (!ctx.typeRegistry.has(scopedId)) {
-            const declared2 = checker.getDeclaredTypeOfSymbol(symbol);
-            const schema = ensureNonEmptySchema(buildSchema(declared2, checker, ctx), declared2, checker);
-            const selfRef = JSON.stringify(schema) === JSON.stringify({ $ref: `#/types/${name}` });
-            if (!selfRef && JSON.stringify(ctx.typeRegistry.get(name)?.schema) !== JSON.stringify(schema)) {
-              ctx.typeRegistry.add({
-                id: scopedId,
-                name,
-                kind: symbolKind(symbol),
-                schema
-              });
-              visit(declared2, 0);
-            }
-          }
-        }
-      }
+    const id = resolveTypeId(symbol, ctx);
+    if (ctx.typeRegistry.has(id)) {
       walkDeclarations(symbol);
       return;
     }
     const declared = checker.getDeclaredTypeOfSymbol(symbol);
     ctx.typeRegistry.registerType(declared, ctx);
-    if (!ctx.typeRegistry.has(name)) {
+    if (!ctx.typeRegistry.has(id)) {
       ctx.typeRegistry.add({
-        id: name,
+        id,
         name,
         kind: symbolKind(symbol),
         schema: ensureNonEmptySchema(buildSchema(declared, checker, ctx), declared, checker)
@@ -6419,7 +6452,7 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
     const target = symbol && resolveAlias(symbol);
     if (!target || visitedSymbols.has(target))
       return;
-    if (!(target.flags & (ts16.SymbolFlags.ValueModule | ts16.SymbolFlags.NamespaceModule)))
+    if (!(target.flags & (ts17.SymbolFlags.ValueModule | ts17.SymbolFlags.NamespaceModule)))
       return;
     if (!symbolAllowed(target))
       return;
@@ -6434,22 +6467,22 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
     }
   };
   const walkNode = (node) => {
-    if (ts16.isTypeReferenceNode(node)) {
+    if (ts17.isTypeReferenceNode(node)) {
       handleRef(node.typeName);
-      if (ts16.isQualifiedName(node.typeName)) {
+      if (ts17.isQualifiedName(node.typeName)) {
         handleNamespaceRef(node.typeName.left);
       }
-    } else if (ts16.isExpressionWithTypeArguments(node)) {
+    } else if (ts17.isExpressionWithTypeArguments(node)) {
       handleRef(node.expression);
-    } else if (ts16.isTypeQueryNode(node)) {
+    } else if (ts17.isTypeQueryNode(node)) {
       handleRef(node.exprName);
-      if (ts16.isQualifiedName(node.exprName)) {
+      if (ts17.isQualifiedName(node.exprName)) {
         handleRef(node.exprName.left);
         handleNamespaceRef(node.exprName.left);
       }
-    } else if (ts16.isImportTypeNode(node) && node.qualifier) {
+    } else if (ts17.isImportTypeNode(node) && node.qualifier) {
       handleRef(node.qualifier);
-      if (ts16.isQualifiedName(node.qualifier)) {
+      if (ts17.isQualifiedName(node.qualifier)) {
         handleNamespaceRef(node.qualifier.left);
       }
     }
@@ -6465,7 +6498,7 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
   };
   for (const exportSymbol of exportedSymbols) {
     let target = exportSymbol;
-    if (exportSymbol.flags & ts16.SymbolFlags.Alias) {
+    if (exportSymbol.flags & ts17.SymbolFlags.Alias) {
       try {
         target = checker.getAliasedSymbol(exportSymbol);
       } catch {
@@ -6798,7 +6831,8 @@ async function extract(options) {
       shouldExpandExternal: createExternalExpansionPredicate({
         followExternal: options.followExternal,
         workspacePackages: result.workspacePackages ?? new Map
-      })
+      }),
+      workspacePackages: result.workspacePackages ?? new Map
     });
     ctx.exportedIds = exportedIds;
     const filteredSymbols = exportedSymbols.filter((s) => shouldIncludeExport(s.getName(), only, ignore));
@@ -6827,9 +6861,9 @@ async function extract(options) {
                 break;
               }
             }
-            if (ts17.isExportSpecifier(decl)) {
+            if (ts18.isExportSpecifier(decl)) {
               const exportDecl = decl.parent?.parent;
-              if (exportDecl && ts17.isExportDeclaration(exportDecl) && exportDecl.moduleSpecifier) {
+              if (exportDecl && ts18.isExportDeclaration(exportDecl) && exportDecl.moduleSpecifier) {
                 const moduleText = exportDecl.moduleSpecifier.getText().slice(1, -1);
                 if (!moduleText.startsWith(".") && !moduleText.startsWith("/")) {
                   externalPackage = moduleText;
@@ -6898,7 +6932,7 @@ async function extract(options) {
       entryFile
     });
     {
-      const symFlags = ts17.SymbolFlags.Type | ts17.SymbolFlags.Interface | ts17.SymbolFlags.Class;
+      const symFlags = ts18.SymbolFlags.Type | ts18.SymbolFlags.Interface | ts18.SymbolFlags.Class;
       const maxPasses = 5;
       for (let pass = 0;pass < maxPasses; pass++) {
         const allRefs = new Map;
@@ -7045,21 +7079,21 @@ async function extract(options) {
 }
 function serializeDeclaration2(declaration, exportSymbol, exportName, ctx, isTypeOnly = false) {
   let result = null;
-  if (ts17.isFunctionDeclaration(declaration)) {
+  if (ts18.isFunctionDeclaration(declaration)) {
     result = serializeFunctionExport(declaration, ctx);
-  } else if (ts17.isClassDeclaration(declaration)) {
+  } else if (ts18.isClassDeclaration(declaration)) {
     result = serializeClass(declaration, ctx);
-  } else if (ts17.isInterfaceDeclaration(declaration)) {
+  } else if (ts18.isInterfaceDeclaration(declaration)) {
     result = serializeInterface(declaration, ctx);
-  } else if (ts17.isTypeAliasDeclaration(declaration)) {
+  } else if (ts18.isTypeAliasDeclaration(declaration)) {
     result = serializeTypeAlias(declaration, ctx);
-  } else if (ts17.isEnumDeclaration(declaration)) {
+  } else if (ts18.isEnumDeclaration(declaration)) {
     result = serializeEnum(declaration, ctx);
-  } else if (ts17.isVariableDeclaration(declaration)) {
+  } else if (ts18.isVariableDeclaration(declaration)) {
     const varStatement = declaration.parent?.parent;
-    if (varStatement && ts17.isVariableStatement(varStatement)) {
-      if (declaration.initializer && (ts17.isArrowFunction(declaration.initializer) || ts17.isFunctionExpression(declaration.initializer))) {
-        const varName = ts17.isIdentifier(declaration.name) ? declaration.name.text : declaration.name.getText();
+    if (varStatement && ts18.isVariableStatement(varStatement)) {
+      if (declaration.initializer && (ts18.isArrowFunction(declaration.initializer) || ts18.isFunctionExpression(declaration.initializer))) {
+        const varName = ts18.isIdentifier(declaration.name) ? declaration.name.text : declaration.name.getText();
         result = serializeFunctionExport(declaration.initializer, ctx, varName);
       } else {
         result = serializeVariable(declaration, varStatement, ctx);
@@ -7071,7 +7105,7 @@ function serializeDeclaration2(declaration, exportSymbol, exportName, ctx, isTyp
         }
       }
     }
-  } else if (ts17.isNamespaceExport(declaration) || ts17.isModuleDeclaration(declaration) || ts17.isNamespaceImport(declaration) || ts17.isSourceFile(declaration)) {
+  } else if (ts18.isNamespaceExport(declaration) || ts18.isModuleDeclaration(declaration) || ts18.isNamespaceImport(declaration) || ts18.isSourceFile(declaration)) {
     try {
       result = serializeNamespaceExport(exportSymbol, exportName, ctx);
     } catch {
@@ -7107,7 +7141,7 @@ function serializeNamespaceExport(symbol, exportName, ctx) {
   const members = [];
   const checker = ctx.program.getTypeChecker();
   let targetSymbol = symbol;
-  if (symbol.flags & ts17.SymbolFlags.Alias) {
+  if (symbol.flags & ts18.SymbolFlags.Alias) {
     const aliased = checker.getAliasedSymbol(symbol);
     if (aliased && aliased !== symbol) {
       targetSymbol = aliased;
@@ -7134,31 +7168,31 @@ function serializeNamespaceExport(symbol, exportName, ctx) {
 function serializeNamespaceMember(symbol, memberName, ctx) {
   const checker = ctx.program.getTypeChecker();
   let targetSymbol = symbol;
-  if (symbol.flags & ts17.SymbolFlags.Alias) {
+  if (symbol.flags & ts18.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 !== ts17.SyntaxKind.ExportSpecifier) || declarations[0];
+  const declaration = targetSymbol.valueDeclaration || declarations.find((d) => d.kind !== ts18.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 (ts17.isFunctionDeclaration(declaration) || ts17.isFunctionExpression(declaration)) {
+  if (ts18.isFunctionDeclaration(declaration) || ts18.isFunctionExpression(declaration)) {
     kind = "function";
-  } else if (ts17.isClassDeclaration(declaration)) {
+  } else if (ts18.isClassDeclaration(declaration)) {
     kind = "class";
-  } else if (ts17.isInterfaceDeclaration(declaration)) {
+  } else if (ts18.isInterfaceDeclaration(declaration)) {
     kind = "interface";
-  } else if (ts17.isTypeAliasDeclaration(declaration)) {
+  } else if (ts18.isTypeAliasDeclaration(declaration)) {
     kind = "type";
-  } else if (ts17.isEnumDeclaration(declaration)) {
+  } else if (ts18.isEnumDeclaration(declaration)) {
     kind = "enum";
-  } else if (ts17.isVariableDeclaration(declaration)) {
+  } else if (ts18.isVariableDeclaration(declaration)) {
     if (callSignatures.length > 0) {
       kind = "function";
     }
@@ -7189,11 +7223,11 @@ function getJSDocFromExportSymbol(symbol) {
   const examples = [];
   const decl = symbol.declarations?.[0];
   if (decl) {
-    const exportDecl = ts17.isNamespaceExport(decl) ? decl.parent : decl;
-    if (exportDecl && ts17.isExportDeclaration(exportDecl)) {
-      const jsDocs = ts17.getJSDocCommentsAndTags(exportDecl);
+    const exportDecl = ts18.isNamespaceExport(decl) ? decl.parent : decl;
+    if (exportDecl && ts18.isExportDeclaration(exportDecl)) {
+      const jsDocs = ts18.getJSDocCommentsAndTags(exportDecl);
       for (const doc of jsDocs) {
-        if (ts17.isJSDoc(doc) && doc.comment) {
+        if (ts18.isJSDoc(doc) && doc.comment) {
           const commentText = typeof doc.comment === "string" ? doc.comment : doc.comment.map((c) => ("text" in c) ? c.text : "").join("");
           if (commentText) {
             return {
@@ -7291,8 +7325,8 @@ async function getPackageMeta(entryFile, baseDir) {
   while (dir !== path9.dirname(dir)) {
     const pkgPath = path9.join(dir, "package.json");
     try {
-      if (fs7.existsSync(pkgPath)) {
-        const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
+      if (fs6.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
         return {
           name: pkg.name ?? path9.basename(dir),
           version: pkg.version,
@@ -7787,12 +7821,12 @@ function toToolSchema(exp, spec, options) {
   };
 }
 // src/types/utils.ts
-import ts18 from "typescript";
+import ts19 from "typescript";
 function isExported(node) {
   const modifiers = node.modifiers;
   if (!modifiers)
     return false;
-  return modifiers.some((m) => m.kind === ts18.SyntaxKind.ExportKeyword);
+  return modifiers.some((m) => m.kind === ts19.SyntaxKind.ExportKeyword);
 }
 function getNodeName(node) {
   if ("name" in node && node.name) {