npm - @openpkg-ts/sdk - Versions diffs - 0.48.0 → 0.49.0 - Mend

@openpkg-ts/sdk 0.48.0 → 0.49.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/dist/index.js CHANGED Viewed

@@ -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,28 @@ 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 writtenTypeText(typeNode) {
+  if (!typeNode)
+    return;
+  if (!ts4.isTypeReferenceNode(typeNode) && !ts4.isUnionTypeNode(typeNode))
+    return;
+  try {
+    const text = scrubImportQualifiers(typeNode.getText().replace(/\s+/g, " ").replace(/^\|\s*/, "").trim());
+    return text.length > 0 ? text : undefined;
+  } catch {
+    return;
+  }
+}
+function declaredTypeNode(decl) {
+  const withType = decl;
+  return withType?.type;
 }
 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 +2021,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;
@@ -1944,17 +2036,26 @@ function decoratePropertySchema(schema, prop, propType, checker) {
   let result = obj;
   if (!derivable && !("x-ts-type" in obj)) {
     result = { ...result, "x-ts-type": text };
+    const declared = writtenTypeText(declaredTypeNode(decl));
+    if (declared && declared !== text && !PRIMITIVES.has(declared) && !("x-ts-declared" in obj)) {
+      result = { ...result, "x-ts-declared": declared };
+    }
   }
   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);
+  if (ts4.isMappedTypeNode(typeNode))
+    return false;
+  if (ts4.isTypeLiteralNode(typeNode)) {
+    return typeNode.members.length > 0 && typeNode.members.every((m) => ts4.isIndexSignatureDeclaration(m));
+  }
+  return true;
 }
 var PRIMITIVES = new Set([
   "string",
@@ -2205,7 +2306,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 +2319,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 +2363,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 +2423,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 +2470,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 +2562,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 +2588,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 +2607,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 +2626,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 +2645,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 +2699,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 +2717,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 +2735,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 +2745,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 +2838,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 +2892,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 +2930,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 +2976,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 +2999,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 +3035,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 +3061,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 +3076,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 +3183,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 +3204,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 +3253,22 @@ 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;
+        const declared = writtenTypeText(declaredTypeNode(decl));
+        if (declared && declared !== text && !PRIMITIVES.has(declared)) {
+          schema["x-ts-declared"] = declared;
+        }
       }
     }
     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 +3285,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 +3327,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 +3365,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 +3374,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 +3395,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 +3412,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 +3446,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 +3519,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 +3539,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 +3626,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 +3647,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 +3675,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 +3697,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 +3785,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 +3826,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 +3835,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 +3860,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 +3897,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 +3912,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();
@@ -3833,13 +3943,16 @@ function serializeEnum(node, ctx) {
     } else if (member.initializer) {
       schema = { type: member.initializer.getText() };
     }
-    const { description: memberDesc } = getJSDocComment(member);
+    const { description: memberDesc, tags: memberTags } = getJSDocComment(member);
+    const { deprecated: deprecated2, reason: deprecationReason2 } = isSymbolDeprecated(memberSymbol);
     return {
       id: memberName,
       name: memberName,
       kind: "enum-member",
       ...schema ? { schema } : {},
-      ...memberDesc ? { description: memberDesc } : {}
+      ...memberDesc ? { description: memberDesc } : {},
+      ...memberTags.length > 0 ? { tags: memberTags } : {},
+      ...deprecated2 ? { deprecated: true, deprecationReason: deprecationReason2 } : {}
     };
   });
   return {
@@ -3856,16 +3969,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 +4022,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 +4045,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 +4058,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 +4083,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 +4106,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 +4144,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 +4232,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 +4244,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 +4272,17 @@ 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))) {
+    if (type.getProperties().length > 0) {
+      members = serializeResolvedMembers(type, node, ctx);
+    }
+  } else if ((ts11.isMappedTypeNode(node.type) || ts11.isConditionalTypeNode(node.type)) && type.getProperties().length > 0 && type.getCallSignatures().length === 0 && !(type.flags & ts11.TypeFlags.Conditional) && !(type.flags & (ts11.TypeFlags.StringLike | ts11.TypeFlags.NumberLike))) {
     schema = buildObjectSchema(type.getProperties(), ctx.typeChecker, ctx, type);
     members = serializeResolvedMembers(type, node, ctx);
   } else {
@@ -4176,9 +4292,13 @@ 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;
+      const declared = writtenTypeText(declaredTypeNode(node));
+      if (declared && declared !== text && !PRIMITIVES.has(declared)) {
+        schema["x-ts-declared"] = declared;
+      }
     }
   }
   return {
@@ -4197,12 +4317,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 +4330,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 +4350,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 +4364,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 +4383,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 +4404,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 +5186,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 +5237,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 +5286,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 +5302,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 +5332,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 +5346,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 +5359,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 +5403,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 +5422,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 +5440,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 +5461,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 +5485,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 +5500,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 +5759,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 +5800,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 +5842,7 @@ async function extractStandardSchemasFromTs(tsFilePath, options = {}) {
             message: "stderr exceeded 10MB buffer limit"
           });
         }
-        resolve2(result);
+        resolve3(result);
       });
       child.on("error", (err) => {
         try {
@@ -5733,7 +5853,7 @@ async function extractStandardSchemasFromTs(tsFilePath, options = {}) {
           }
         }
         result.errors.push(`Subprocess error: ${err.message}`);
-        resolve2(result);
+        resolve3(result);
       });
     });
   } catch (e) {
@@ -5749,7 +5869,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 +5884,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 +5892,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 +5900,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 +5932,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 +5960,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 +6002,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 +6044,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 +6062,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 +6078,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 +6091,7 @@ function findPackageJson(resolvedPath, packageName) {
         }
       }
     }
-    const parent = path6.dirname(dir);
+    const parent = path7.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -6007,7 +6127,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 +6198,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 +6305,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 +6320,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 +6335,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 +6363,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 +6375,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 +6404,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 +6427,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 +6461,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 +6491,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 +6506,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 +6537,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 +6870,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 +6900,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 +6971,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 +7118,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 +7144,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 +7180,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 +7207,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 +7262,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 +7364,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 +7860,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) {
@@ -7803,6 +7876,7 @@ function getNodeName(node) {
 }
 export {
   zodAdapter,
+  writtenTypeText,
   withDescription,
   withDeprecated,
   validateSpec2 as validateSpec,
@@ -7908,6 +7982,7 @@ export {
   detectTsRuntime,
   deduplicateSchemas,
   decoratePropertySchema,
+  declaredTypeNode,
   createProgram,
   createDocs,
   categorizeBreakingChanges,