@formspec/build 0.1.0-alpha.49 → 0.1.0-alpha.50

package/dist/index.js

@@ -2166,24 +2166,24 @@ var jsonSchema7Schema = z3.lazy(
 );
 
 // src/generators/class-schema.ts
-import * as ts6 from "typescript";
+import * as ts8 from "typescript";
 
 // src/analyzer/program.ts
-import * as ts4 from "typescript";
+import * as ts6 from "typescript";
 import * as path from "path";
 
 // src/analyzer/class-analyzer.ts
-import * as ts3 from "typescript";
+import * as ts5 from "typescript";
 import {
   analyzeMetadataForNodeWithChecker,
   parseCommentBlock
 } from "@formspec/analysis/internal";
 
 // src/analyzer/jsdoc-constraints.ts
-import * as ts2 from "typescript";
+import * as ts4 from "typescript";
 
 // src/analyzer/tsdoc-parser.ts
-import * as ts from "typescript";
+import * as ts3 from "typescript";
 import {
   checkSyntheticTagApplication,
   choosePreferredPayloadText,
@@ -2205,13 +2205,132 @@ import {
   isBuiltinConstraintName
 } from "@formspec/core/internals";
 import "@formspec/core/internals";
+
+// src/extensions/resolve-custom-type.ts
+import * as ts2 from "typescript";
+import { stripNullishUnion } from "@formspec/analysis/internal";
+
+// src/extensions/ts-type-utils.ts
+import * as ts from "typescript";
+function collectBrandIdentifiers(type) {
+  if (!type.isIntersection()) {
+    return [];
+  }
+  const brands = [];
+  for (const prop of type.getProperties()) {
+    const decl = prop.valueDeclaration ?? prop.declarations?.[0];
+    if (decl === void 0) continue;
+    if (!ts.isPropertySignature(decl) && !ts.isPropertyDeclaration(decl)) continue;
+    if (!ts.isComputedPropertyName(decl.name)) continue;
+    if (!ts.isIdentifier(decl.name.expression)) continue;
+    brands.push(decl.name.expression.text);
+  }
+  return brands;
+}
+function resolveCanonicalSymbol(type, checker) {
+  const raw = type.aliasSymbol ?? type.getSymbol();
+  if (raw === void 0) return void 0;
+  return raw.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(raw) : raw;
+}
+function extractTypeNodeFromSource(sourceNode) {
+  if (ts.isPropertyDeclaration(sourceNode) || ts.isPropertySignature(sourceNode) || ts.isParameter(sourceNode) || ts.isTypeAliasDeclaration(sourceNode)) {
+    return sourceNode.type;
+  }
+  if (ts.isTypeNode(sourceNode)) {
+    return sourceNode;
+  }
+  return void 0;
+}
+function resolveAliasedSymbol(symbol, checker) {
+  if (symbol === void 0) return void 0;
+  return symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+}
+function getTypeAliasDeclarationFromTypeReference(typeNode, checker) {
+  const symbol = checker.getSymbolAtLocation(typeNode.typeName);
+  return resolveAliasedSymbol(symbol, checker)?.declarations?.find(ts.isTypeAliasDeclaration);
+}
+
+// src/extensions/resolve-custom-type.ts
+function getTypeNodeRegistrationName(typeNode) {
+  if (ts2.isTypeReferenceNode(typeNode)) {
+    return ts2.isIdentifier(typeNode.typeName) ? typeNode.typeName.text : typeNode.typeName.right.text;
+  }
+  if (ts2.isParenthesizedTypeNode(typeNode)) {
+    return getTypeNodeRegistrationName(typeNode.type);
+  }
+  if (typeNode.kind === ts2.SyntaxKind.BigIntKeyword || typeNode.kind === ts2.SyntaxKind.StringKeyword || typeNode.kind === ts2.SyntaxKind.NumberKeyword || typeNode.kind === ts2.SyntaxKind.BooleanKeyword) {
+    return typeNode.getText();
+  }
+  return null;
+}
+function resolveByNameFromTypeNode(typeNode, registry, checker) {
+  if (ts2.isParenthesizedTypeNode(typeNode)) {
+    return resolveByNameFromTypeNode(typeNode.type, registry, checker);
+  }
+  const typeName = getTypeNodeRegistrationName(typeNode);
+  if (typeName !== null) {
+    const byName = registry.findTypeByName(typeName);
+    if (byName !== void 0) {
+      return byName;
+    }
+  }
+  if (ts2.isTypeReferenceNode(typeNode) && ts2.isIdentifier(typeNode.typeName)) {
+    const aliasDecl = getTypeAliasDeclarationFromTypeReference(typeNode, checker);
+    if (aliasDecl !== void 0) {
+      return resolveByNameFromTypeNode(aliasDecl.type, registry, checker);
+    }
+  }
+  return null;
+}
+function resolveCustomTypeFromTsType(type, checker, registry, sourceNode) {
+  if (registry === void 0) {
+    return null;
+  }
+  const stripped = stripNullishUnion(type);
+  if (sourceNode !== void 0) {
+    const typeNode = extractTypeNodeFromSource(sourceNode);
+    if (typeNode !== void 0) {
+      const byName = resolveByNameFromTypeNode(typeNode, registry, checker);
+      if (byName !== null) {
+        return byName;
+      }
+    }
+  } else {
+    const typeName = (stripped.aliasSymbol ?? stripped.getSymbol())?.getName();
+    if (typeName !== void 0) {
+      const byName = registry.findTypeByName(typeName);
+      if (byName !== void 0) {
+        return byName;
+      }
+    }
+  }
+  const canonical = resolveCanonicalSymbol(stripped, checker);
+  if (canonical !== void 0) {
+    const bySymbol = registry.findTypeBySymbol(canonical);
+    if (bySymbol !== void 0) {
+      return bySymbol;
+    }
+  }
+  for (const brand of collectBrandIdentifiers(stripped)) {
+    const byBrand = registry.findTypeByBrand(brand);
+    if (byBrand !== void 0) {
+      return byBrand;
+    }
+  }
+  return null;
+}
+function customTypeIdFromLookup(result) {
+  return `${result.extensionId}/${result.registration.typeName}`;
+}
+
+// src/analyzer/tsdoc-parser.ts
 function sharedTagValueOptions(options) {
   return {
     ...options?.extensionRegistry !== void 0 ? { registry: options.extensionRegistry } : {},
     ...options?.fieldType !== void 0 ? { fieldType: options.fieldType } : {}
   };
 }
-var SYNTHETIC_TYPE_FORMAT_FLAGS = ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope;
+var SYNTHETIC_TYPE_FORMAT_FLAGS = ts3.TypeFormatFlags.NoTruncation | ts3.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope;
 function getExtensionTypeNames(registry) {
   if (registry === void 0) {
     return /* @__PURE__ */ new Set();
@@ -2225,23 +2344,23 @@ function getExtensionTypeNames(registry) {
 function collectImportedNames(sourceFile) {
   const importedNames = /* @__PURE__ */ new Set();
   for (const statement of sourceFile.statements) {
-    if (ts.isImportDeclaration(statement) && statement.importClause !== void 0) {
+    if (ts3.isImportDeclaration(statement) && statement.importClause !== void 0) {
       const clause = statement.importClause;
       if (clause.name !== void 0) {
         importedNames.add(clause.name.text);
       }
       if (clause.namedBindings !== void 0) {
-        if (ts.isNamedImports(clause.namedBindings)) {
+        if (ts3.isNamedImports(clause.namedBindings)) {
           for (const specifier of clause.namedBindings.elements) {
             importedNames.add(specifier.name.text);
           }
-        } else if (ts.isNamespaceImport(clause.namedBindings)) {
+        } else if (ts3.isNamespaceImport(clause.namedBindings)) {
           importedNames.add(clause.namedBindings.name.text);
         }
       }
       continue;
     }
-    if (ts.isImportEqualsDeclaration(statement)) {
+    if (ts3.isImportEqualsDeclaration(statement)) {
       importedNames.add(statement.name.text);
     }
   }
@@ -2249,13 +2368,13 @@ function collectImportedNames(sourceFile) {
 }
 function isNonReferenceIdentifier(node) {
   const parent = node.parent;
-  if ((ts.isBindingElement(parent) || ts.isClassDeclaration(parent) || ts.isEnumDeclaration(parent) || ts.isEnumMember(parent) || ts.isFunctionDeclaration(parent) || ts.isFunctionExpression(parent) || ts.isImportClause(parent) || ts.isImportEqualsDeclaration(parent) || ts.isImportSpecifier(parent) || ts.isInterfaceDeclaration(parent) || ts.isMethodDeclaration(parent) || ts.isMethodSignature(parent) || ts.isModuleDeclaration(parent) || ts.isNamespaceExport(parent) || ts.isNamespaceImport(parent) || ts.isParameter(parent) || ts.isPropertyDeclaration(parent) || ts.isPropertySignature(parent) || ts.isSetAccessorDeclaration(parent) || ts.isGetAccessorDeclaration(parent) || ts.isTypeAliasDeclaration(parent) || ts.isTypeParameterDeclaration(parent) || ts.isVariableDeclaration(parent)) && parent.name === node) {
+  if ((ts3.isBindingElement(parent) || ts3.isClassDeclaration(parent) || ts3.isEnumDeclaration(parent) || ts3.isEnumMember(parent) || ts3.isFunctionDeclaration(parent) || ts3.isFunctionExpression(parent) || ts3.isImportClause(parent) || ts3.isImportEqualsDeclaration(parent) || ts3.isImportSpecifier(parent) || ts3.isInterfaceDeclaration(parent) || ts3.isMethodDeclaration(parent) || ts3.isMethodSignature(parent) || ts3.isModuleDeclaration(parent) || ts3.isNamespaceExport(parent) || ts3.isNamespaceImport(parent) || ts3.isParameter(parent) || ts3.isPropertyDeclaration(parent) || ts3.isPropertySignature(parent) || ts3.isSetAccessorDeclaration(parent) || ts3.isGetAccessorDeclaration(parent) || ts3.isTypeAliasDeclaration(parent) || ts3.isTypeParameterDeclaration(parent) || ts3.isVariableDeclaration(parent)) && parent.name === node) {
     return true;
   }
-  if ((ts.isPropertyAssignment(parent) || ts.isPropertyAccessExpression(parent)) && parent.name === node) {
+  if ((ts3.isPropertyAssignment(parent) || ts3.isPropertyAccessExpression(parent)) && parent.name === node) {
     return true;
   }
-  if (ts.isQualifiedName(parent) && parent.right === node) {
+  if (ts3.isQualifiedName(parent) && parent.right === node) {
     return true;
   }
   return false;
@@ -2269,11 +2388,11 @@ function statementReferencesImportedName(statement, importedNames) {
     if (referencesImportedName) {
       return;
     }
-    if (ts.isIdentifier(node) && importedNames.has(node.text) && !isNonReferenceIdentifier(node)) {
+    if (ts3.isIdentifier(node) && importedNames.has(node.text) && !isNonReferenceIdentifier(node)) {
       referencesImportedName = true;
       return;
     }
-    ts.forEachChild(node, visit);
+    ts3.forEachChild(node, visit);
   };
   visit(statement);
   return referencesImportedName;
@@ -2284,9 +2403,9 @@ function buildSupportingDeclarations(sourceFile, extensionTypeNames) {
     [...importedNames].filter((name) => !extensionTypeNames.has(name))
   );
   return sourceFile.statements.filter((statement) => {
-    if (ts.isImportDeclaration(statement)) return false;
-    if (ts.isImportEqualsDeclaration(statement)) return false;
-    if (ts.isExportDeclaration(statement) && statement.moduleSpecifier !== void 0)
+    if (ts3.isImportDeclaration(statement)) return false;
+    if (ts3.isImportEqualsDeclaration(statement)) return false;
+    if (ts3.isExportDeclaration(statement) && statement.moduleSpecifier !== void 0)
       return false;
     if (statementReferencesImportedName(statement, importedNamesToSkip)) {
       return false;
@@ -2384,7 +2503,7 @@ function stripHintNullishUnion(type) {
     return type;
   }
   const nonNullish = type.types.filter(
-    (member) => (member.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) === 0
+    (member) => (member.flags & (ts3.TypeFlags.Null | ts3.TypeFlags.Undefined)) === 0
   );
   if (nonNullish.length === 1 && nonNullish[0] !== void 0) {
     return nonNullish[0];
@@ -2400,10 +2519,10 @@ function isUserEmittableHintProperty(property, declaration) {
   }
   if ("name" in declaration && declaration.name !== void 0) {
     const name = declaration.name;
-    if (ts.isComputedPropertyName(name) || ts.isPrivateIdentifier(name)) {
+    if (ts3.isComputedPropertyName(name) || ts3.isPrivateIdentifier(name)) {
       return false;
     }
-    if (!ts.isIdentifier(name) && !ts.isStringLiteral(name) && !ts.isNumericLiteral(name)) {
+    if (!ts3.isIdentifier(name) && !ts3.isStringLiteral(name) && !ts3.isNumericLiteral(name)) {
       return false;
     }
   }
@@ -2575,7 +2694,8 @@ function buildCompilerBackedConstraintDiagnostics(node, sourceFile, tagName, par
     ];
   }
   const target = parsedTag?.target ?? null;
-  const hasBroadening = target === null && hasBuiltinConstraintBroadening(tagName, options);
+  let evaluatedType = subjectType;
+  let targetLabel = node.getText(sourceFile);
   if (target !== null) {
     if (target.kind !== "path") {
       return [
@@ -2615,29 +2735,30 @@ function buildCompilerBackedConstraintDiagnostics(node, sourceFile, tagName, par
         )
       ];
     }
-    const requiredCapability = definition.capabilities[0];
-    if (requiredCapability !== void 0 && !supportsConstraintCapability(resolution.type, checker, requiredCapability)) {
-      const actualType = checker.typeToString(resolution.type, node, SYNTHETIC_TYPE_FORMAT_FLAGS);
-      return [
-        makeDiagnostic(
-          "TYPE_MISMATCH",
-          `Target "${target.rawText}": constraint "${tagName}" is only valid on ${capabilityLabel(requiredCapability)} targets, but field type is "${actualType}"`,
-          provenance
-        )
-      ];
+    evaluatedType = resolution.type;
+    targetLabel = target.rawText;
+  }
+  const hasBroadening = (() => {
+    if (target === null) {
+      return hasBuiltinConstraintBroadening(tagName, options);
     }
-  } else if (!hasBroadening) {
+    const registry = options?.extensionRegistry;
+    if (registry === void 0) return false;
+    const resolved = resolveCustomTypeFromTsType(evaluatedType, checker, registry);
+    return resolved !== null && registry.findBuiltinConstraintBroadening(customTypeIdFromLookup(resolved), tagName) !== void 0;
+  })();
+  if (!hasBroadening) {
     const requiredCapability = definition.capabilities[0];
-    if (requiredCapability !== void 0 && !supportsConstraintCapability(subjectType, checker, requiredCapability)) {
-      const actualType = checker.typeToString(subjectType, node, SYNTHETIC_TYPE_FORMAT_FLAGS);
-      const baseMessage = `Target "${node.getText(sourceFile)}": constraint "${tagName}" is only valid on ${capabilityLabel(requiredCapability)} targets, but field type is "${actualType}"`;
-      const hint = buildPathTargetHint(
+    if (requiredCapability !== void 0 && !supportsConstraintCapability(evaluatedType, checker, requiredCapability)) {
+      const actualType = checker.typeToString(evaluatedType, node, SYNTHETIC_TYPE_FORMAT_FLAGS);
+      const baseMessage = `Target "${targetLabel}": constraint "${tagName}" is only valid on ${capabilityLabel(requiredCapability)} targets, but field type is "${actualType}"`;
+      const hint = target === null ? buildPathTargetHint(
         subjectType,
         checker,
         requiredCapability,
         tagName,
         parsedTag?.argumentText
-      );
+      ) : null;
       return [
         makeDiagnostic(
           "TYPE_MISMATCH",
@@ -2771,12 +2892,12 @@ function parseTSDocTags(node, file = "", options) {
   const sourceText = sourceFile.getFullText();
   const extensionTypeNames = getExtensionTypeNames(options?.extensionRegistry);
   const supportingDeclarations = buildSupportingDeclarations(sourceFile, extensionTypeNames);
-  const commentRanges = ts.getLeadingCommentRanges(sourceText, node.getFullStart());
+  const commentRanges = ts3.getLeadingCommentRanges(sourceText, node.getFullStart());
   const rawTextFallbacks = collectRawTextFallbacks(node, file);
   const extensionTagNames = getExtensionTagNames(options);
   if (commentRanges) {
     for (const range of commentRanges) {
-      if (range.kind !== ts.SyntaxKind.MultiLineCommentTrivia) {
+      if (range.kind !== ts3.SyntaxKind.MultiLineCommentTrivia) {
         continue;
       }
       const commentText = sourceText.substring(range.pos, range.end);
@@ -2933,10 +3054,10 @@ function extractDisplayNameMetadata(node) {
   const memberDisplayNames = /* @__PURE__ */ new Map();
   const sourceFile = node.getSourceFile();
   const sourceText = sourceFile.getFullText();
-  const commentRanges = ts.getLeadingCommentRanges(sourceText, node.getFullStart());
+  const commentRanges = ts3.getLeadingCommentRanges(sourceText, node.getFullStart());
   if (commentRanges) {
     for (const range of commentRanges) {
-      if (range.kind !== ts.SyntaxKind.MultiLineCommentTrivia) continue;
+      if (range.kind !== ts3.SyntaxKind.MultiLineCommentTrivia) continue;
       const commentText = sourceText.substring(range.pos, range.end);
       if (!commentText.startsWith("/**")) continue;
       const unified = parseUnifiedComment(commentText);
@@ -2961,7 +3082,7 @@ function extractDisplayNameMetadata(node) {
 }
 function collectRawTextFallbacks(node, file) {
   const fallbacks = /* @__PURE__ */ new Map();
-  for (const tag of ts.getJSDocTags(node)) {
+  for (const tag of ts3.getJSDocTags(node)) {
     const tagName = normalizeConstraintTagName2(tag.tagName.text);
     if (!TAGS_REQUIRING_RAW_TEXT.has(tagName)) continue;
     const commentText = getTagCommentText(tag)?.trim() ?? "";
@@ -3016,7 +3137,7 @@ function getTagCommentText(tag) {
   if (typeof tag.comment === "string") {
     return tag.comment;
   }
-  return ts.getTextOfJSDocComment(tag.comment);
+  return ts3.getTextOfJSDocComment(tag.comment);
 }
 
 // src/analyzer/jsdoc-constraints.ts
@@ -3034,18 +3155,18 @@ function extractJSDocAnnotationNodes(node, file = "", options) {
 function extractDefaultValueAnnotation(initializer, file = "") {
   if (!initializer) return null;
   let value;
-  if (ts2.isStringLiteral(initializer)) {
+  if (ts4.isStringLiteral(initializer)) {
     value = initializer.text;
-  } else if (ts2.isNumericLiteral(initializer)) {
+  } else if (ts4.isNumericLiteral(initializer)) {
     value = Number(initializer.text);
-  } else if (initializer.kind === ts2.SyntaxKind.TrueKeyword) {
+  } else if (initializer.kind === ts4.SyntaxKind.TrueKeyword) {
     value = true;
-  } else if (initializer.kind === ts2.SyntaxKind.FalseKeyword) {
+  } else if (initializer.kind === ts4.SyntaxKind.FalseKeyword) {
     value = false;
-  } else if (initializer.kind === ts2.SyntaxKind.NullKeyword) {
+  } else if (initializer.kind === ts4.SyntaxKind.NullKeyword) {
     value = null;
-  } else if (ts2.isPrefixUnaryExpression(initializer)) {
-    if (initializer.operator === ts2.SyntaxKind.MinusToken && ts2.isNumericLiteral(initializer.operand)) {
+  } else if (ts4.isPrefixUnaryExpression(initializer)) {
+    if (initializer.operator === ts4.SyntaxKind.MinusToken && ts4.isNumericLiteral(initializer.operand)) {
       value = -Number(initializer.operand.text);
     }
   }
@@ -3067,93 +3188,38 @@ function extractDefaultValueAnnotation(initializer, file = "") {
 
 // src/analyzer/class-analyzer.ts
 function isObjectType(type) {
-  return !!(type.flags & ts3.TypeFlags.Object);
+  return !!(type.flags & ts5.TypeFlags.Object);
 }
 function isIntersectionType(type) {
-  return !!(type.flags & ts3.TypeFlags.Intersection);
-}
-function collectBrandIdentifiers(type) {
-  if (!type.isIntersection()) {
-    return [];
-  }
-  const brands = [];
-  for (const prop of type.getProperties()) {
-    const decl = prop.valueDeclaration ?? prop.declarations?.[0];
-    if (decl === void 0) continue;
-    if (!ts3.isPropertySignature(decl) && !ts3.isPropertyDeclaration(decl)) continue;
-    if (!ts3.isComputedPropertyName(decl.name)) continue;
-    if (!ts3.isIdentifier(decl.name.expression)) continue;
-    brands.push(decl.name.expression.text);
-  }
-  return brands;
-}
-function resolveCanonicalSymbol(type, checker) {
-  const raw = type.aliasSymbol ?? type.getSymbol();
-  if (raw === void 0) return void 0;
-  return raw.flags & ts3.SymbolFlags.Alias ? checker.getAliasedSymbol(raw) : raw;
-}
-function resolveSymbolBasedCustomType(type, extensionRegistry, checker) {
-  if (extensionRegistry === void 0) {
-    return null;
-  }
-  const canonical = resolveCanonicalSymbol(type, checker);
-  if (canonical === void 0) {
-    return null;
-  }
-  const registration = extensionRegistry.findTypeBySymbol(canonical);
-  if (registration === void 0) {
-    return null;
-  }
-  return {
-    kind: "custom",
-    typeId: `${registration.extensionId}/${registration.registration.typeName}`,
-    payload: null
-  };
+  return !!(type.flags & ts5.TypeFlags.Intersection);
 }
 function isIntegerBrandedType(type) {
   if (!type.isIntersection()) {
     return false;
   }
-  const hasNumberBase = type.types.some((member) => !!(member.flags & ts3.TypeFlags.Number));
+  const hasNumberBase = type.types.some((member) => !!(member.flags & ts5.TypeFlags.Number));
   if (!hasNumberBase) {
     return false;
   }
   return collectBrandIdentifiers(type).includes("__integerBrand");
 }
-function resolveBrandedCustomType(type, extensionRegistry) {
-  if (extensionRegistry === void 0) {
-    return null;
-  }
-  for (const brand of collectBrandIdentifiers(type)) {
-    const registration = extensionRegistry.findTypeByBrand(brand);
-    if (registration === void 0) {
-      continue;
-    }
-    return {
-      kind: "custom",
-      typeId: `${registration.extensionId}/${registration.registration.typeName}`,
-      payload: null
-    };
-  }
-  return null;
-}
 function isResolvableObjectLikeAliasTypeNode(typeNode) {
-  if (ts3.isParenthesizedTypeNode(typeNode)) {
+  if (ts5.isParenthesizedTypeNode(typeNode)) {
     return isResolvableObjectLikeAliasTypeNode(typeNode.type);
   }
-  if (ts3.isTypeLiteralNode(typeNode) || ts3.isTypeReferenceNode(typeNode)) {
+  if (ts5.isTypeLiteralNode(typeNode) || ts5.isTypeReferenceNode(typeNode)) {
     return true;
   }
-  return ts3.isIntersectionTypeNode(typeNode) && typeNode.types.length > 0 && typeNode.types.every((member) => isResolvableObjectLikeAliasTypeNode(member));
+  return ts5.isIntersectionTypeNode(typeNode) && typeNode.types.length > 0 && typeNode.types.every((member) => isResolvableObjectLikeAliasTypeNode(member));
 }
 function isSemanticallyPlainObjectLikeType(type, checker) {
   if (isIntersectionType(type)) {
     return type.types.length > 0 && type.types.every((member) => isSemanticallyPlainObjectLikeType(member, checker));
   }
-  return isObjectType(type) && checker.getSignaturesOfType(type, ts3.SignatureKind.Call).length === 0 && checker.getSignaturesOfType(type, ts3.SignatureKind.Construct).length === 0 && !checker.isArrayType(type) && !checker.isTupleType(type);
+  return isObjectType(type) && checker.getSignaturesOfType(type, ts5.SignatureKind.Call).length === 0 && checker.getSignaturesOfType(type, ts5.SignatureKind.Construct).length === 0 && !checker.isArrayType(type) && !checker.isTupleType(type);
 }
 function isTypeReference(type) {
-  return !!(type.flags & ts3.TypeFlags.Object) && !!(type.objectFlags & ts3.ObjectFlags.Reference);
+  return !!(type.flags & ts5.TypeFlags.Object) && !!(type.objectFlags & ts5.ObjectFlags.Reference);
 }
 var RESOLVING_TYPE_PLACEHOLDER = {
   kind: "object",
@@ -3218,7 +3284,7 @@ function resolveNodeMetadata(metadataPolicy, declarationKind, logicalName, node,
 function analyzeDeclarationRootInfo(declaration, checker, file = "", extensionRegistry, metadataPolicy) {
   const normalizedMetadataPolicy = createAnalyzerMetadataPolicy(metadataPolicy);
   const declarationType = checker.getTypeAtLocation(declaration);
-  const logicalName = ts3.isClassDeclaration(declaration) ? declaration.name?.text ?? "AnonymousClass" : declaration.name.text;
+  const logicalName = ts5.isClassDeclaration(declaration) ? declaration.name?.text ?? "AnonymousClass" : declaration.name.text;
   const docResult = extractJSDocParseResult(
     declaration,
     file,
@@ -3266,7 +3332,7 @@ function analyzeClassToIR(classDecl, checker, file = "", extensionRegistry, meta
   const instanceMethods = [];
   const staticMethods = [];
   for (const member of classDecl.members) {
-    if (ts3.isPropertyDeclaration(member)) {
+    if (ts5.isPropertyDeclaration(member)) {
       const fieldNode = analyzeFieldToIR(
         member,
         checker,
@@ -3282,10 +3348,10 @@ function analyzeClassToIR(classDecl, checker, file = "", extensionRegistry, meta
         fields.push(fieldNode);
         fieldLayouts.push({});
       }
-    } else if (ts3.isMethodDeclaration(member)) {
+    } else if (ts5.isMethodDeclaration(member)) {
       const methodInfo = analyzeMethod(member, checker);
       if (methodInfo) {
-        const isStatic = member.modifiers?.some((m) => m.kind === ts3.SyntaxKind.StaticKeyword);
+        const isStatic = member.modifiers?.some((m) => m.kind === ts5.SyntaxKind.StaticKeyword);
         if (isStatic) {
           staticMethods.push(methodInfo);
         } else {
@@ -3348,7 +3414,7 @@ function analyzeInterfaceToIR(interfaceDecl, checker, file = "", extensionRegist
   diagnostics.push(...interfaceDoc.diagnostics);
   const visiting = /* @__PURE__ */ new Set();
   for (const member of interfaceDecl.members) {
-    if (ts3.isPropertySignature(member)) {
+    if (ts5.isPropertySignature(member)) {
       const fieldNode = analyzeInterfacePropertyToIR(
         member,
         checker,
@@ -3406,7 +3472,7 @@ function analyzeTypeAliasToIR(typeAlias, checker, file = "", extensionRegistry,
   if (members === null) {
     const sourceFile = typeAlias.getSourceFile();
     const { line } = sourceFile.getLineAndCharacterOfPosition(typeAlias.getStart());
-    const kindDesc = ts3.SyntaxKind[typeAlias.type.kind] ?? "unknown";
+    const kindDesc = ts5.SyntaxKind[typeAlias.type.kind] ?? "unknown";
     return {
       ok: false,
       kind: "not-object-like",
@@ -3441,7 +3507,7 @@ function analyzeTypeAliasToIR(typeAlias, checker, file = "", extensionRegistry,
   diagnostics.push(...typeAliasDoc.diagnostics);
   const visiting = /* @__PURE__ */ new Set();
   for (const member of members) {
-    if (ts3.isPropertySignature(member)) {
+    if (ts5.isPropertySignature(member)) {
       const fieldNode = analyzeInterfacePropertyToIR(
         member,
         checker,
@@ -3508,13 +3574,13 @@ function makeAnalysisDiagnostic(code, message, primaryLocation, relatedLocations
 function getLeadingParsedTags(node) {
   const sourceFile = node.getSourceFile();
   const sourceText = sourceFile.getFullText();
-  const commentRanges = ts3.getLeadingCommentRanges(sourceText, node.getFullStart());
+  const commentRanges = ts5.getLeadingCommentRanges(sourceText, node.getFullStart());
   if (commentRanges === void 0) {
     return [];
   }
   const parsedTags = [];
   for (const range of commentRanges) {
-    if (range.kind !== ts3.SyntaxKind.MultiLineCommentTrivia) {
+    if (range.kind !== ts5.SyntaxKind.MultiLineCommentTrivia) {
       continue;
     }
     const commentText = sourceText.slice(range.pos, range.end);
@@ -3532,19 +3598,19 @@ function resolveDiscriminatorProperty(node, checker, fieldName) {
     return null;
   }
   const declaration = propertySymbol.valueDeclaration ?? propertySymbol.declarations?.find(
-    (candidate) => ts3.isPropertyDeclaration(candidate) || ts3.isPropertySignature(candidate)
+    (candidate) => ts5.isPropertyDeclaration(candidate) || ts5.isPropertySignature(candidate)
   ) ?? propertySymbol.declarations?.[0];
   return {
     declaration,
     type: checker.getTypeOfSymbolAtLocation(propertySymbol, declaration ?? node),
-    optional: !!(propertySymbol.flags & ts3.SymbolFlags.Optional) || declaration !== void 0 && "questionToken" in declaration && declaration.questionToken !== void 0
+    optional: !!(propertySymbol.flags & ts5.SymbolFlags.Optional) || declaration !== void 0 && "questionToken" in declaration && declaration.questionToken !== void 0
   };
 }
 function isLocalTypeParameterName(node, typeParameterName) {
   return node.typeParameters?.some((typeParameter) => typeParameter.name.text === typeParameterName) ?? false;
 }
 function isNullishSemanticType(type) {
-  if (type.flags & (ts3.TypeFlags.Null | ts3.TypeFlags.Undefined | ts3.TypeFlags.Void | ts3.TypeFlags.Unknown | ts3.TypeFlags.Any)) {
+  if (type.flags & (ts5.TypeFlags.Null | ts5.TypeFlags.Undefined | ts5.TypeFlags.Void | ts5.TypeFlags.Unknown | ts5.TypeFlags.Any)) {
     return true;
   }
   return type.isUnion() && type.types.some((member) => isNullishSemanticType(member));
@@ -3554,7 +3620,7 @@ function isStringLikeSemanticType(type, checker, seen = /* @__PURE__ */ new Set(
     return false;
   }
   seen.add(type);
-  if (type.flags & ts3.TypeFlags.StringLike) {
+  if (type.flags & ts5.TypeFlags.StringLike) {
     return true;
   }
   if (type.isUnion()) {
@@ -3567,13 +3633,13 @@ function isStringLikeSemanticType(type, checker, seen = /* @__PURE__ */ new Set(
   return false;
 }
 function getObjectLikeTypeAliasMembers(typeNode) {
-  if (ts3.isParenthesizedTypeNode(typeNode)) {
+  if (ts5.isParenthesizedTypeNode(typeNode)) {
     return getObjectLikeTypeAliasMembers(typeNode.type);
   }
-  if (ts3.isTypeLiteralNode(typeNode)) {
+  if (ts5.isTypeLiteralNode(typeNode)) {
     return [...typeNode.members];
   }
-  if (ts3.isIntersectionTypeNode(typeNode)) {
+  if (ts5.isIntersectionTypeNode(typeNode)) {
     const members = [];
     for (const intersectionMember of typeNode.types) {
       const resolvedMembers = getObjectLikeTypeAliasMembers(intersectionMember);
@@ -3736,7 +3802,7 @@ function resolveLiteralDiscriminatorPropertyValue(boundType, propertyName, check
   }
   if (propertyType.isUnion()) {
     const nonNullMembers = propertyType.types.filter(
-      (member) => !(member.flags & (ts3.TypeFlags.Null | ts3.TypeFlags.Undefined))
+      (member) => !(member.flags & (ts5.TypeFlags.Null | ts5.TypeFlags.Undefined))
     );
     if (nonNullMembers.length > 0 && nonNullMembers.every((member) => member.isStringLiteral())) {
       diagnostics.push(
@@ -3785,13 +3851,13 @@ function resolveNamedDiscriminatorDeclaration(type, checker, seen = /* @__PURE__
   seen.add(type);
   const symbol = type.aliasSymbol ?? type.getSymbol();
   if (symbol !== void 0) {
-    const aliased = symbol.flags & ts3.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : void 0;
+    const aliased = symbol.flags & ts5.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : void 0;
     const targetSymbol = aliased ?? symbol;
     const declaration = targetSymbol.declarations?.find(
-      (candidate) => ts3.isClassDeclaration(candidate) || ts3.isInterfaceDeclaration(candidate) || ts3.isTypeAliasDeclaration(candidate) || ts3.isEnumDeclaration(candidate)
+      (candidate) => ts5.isClassDeclaration(candidate) || ts5.isInterfaceDeclaration(candidate) || ts5.isTypeAliasDeclaration(candidate) || ts5.isEnumDeclaration(candidate)
     );
     if (declaration !== void 0) {
-      if (ts3.isTypeAliasDeclaration(declaration) && ts3.isTypeReferenceNode(declaration.type) && checker.getTypeFromTypeNode(declaration.type) !== type) {
+      if (ts5.isTypeAliasDeclaration(declaration) && ts5.isTypeReferenceNode(declaration.type) && checker.getTypeFromTypeNode(declaration.type) !== type) {
         return resolveNamedDiscriminatorDeclaration(
           checker.getTypeFromTypeNode(declaration.type),
           checker,
@@ -3819,7 +3885,7 @@ function resolveDiscriminatorValue(boundType, fieldName, checker, provenance, di
   }
   if (boundType.isUnion()) {
     const nonNullMembers = boundType.types.filter(
-      (member) => !(member.flags & (ts3.TypeFlags.Null | ts3.TypeFlags.Undefined))
+      (member) => !(member.flags & (ts5.TypeFlags.Null | ts5.TypeFlags.Undefined))
     );
     if (nonNullMembers.every((member) => member.isStringLiteral())) {
       diagnostics.push(
@@ -3864,7 +3930,7 @@ function resolveDiscriminatorValue(boundType, fieldName, checker, provenance, di
   return null;
 }
 function getDeclarationName(node) {
-  if (ts3.isClassDeclaration(node) || ts3.isInterfaceDeclaration(node) || ts3.isTypeAliasDeclaration(node) || ts3.isEnumDeclaration(node)) {
+  if (ts5.isClassDeclaration(node) || ts5.isInterfaceDeclaration(node) || ts5.isTypeAliasDeclaration(node) || ts5.isEnumDeclaration(node)) {
     return node.name?.text ?? "anonymous";
   }
   return "anonymous";
@@ -3919,11 +3985,11 @@ function extractReferenceTypeArguments(type, checker, file, typeRegistry, visiti
   if (sourceTypeNode === void 0) {
     return [];
   }
-  const unwrapParentheses = (typeNode) => ts3.isParenthesizedTypeNode(typeNode) ? unwrapParentheses(typeNode.type) : typeNode;
+  const unwrapParentheses = (typeNode) => ts5.isParenthesizedTypeNode(typeNode) ? unwrapParentheses(typeNode.type) : typeNode;
   const directTypeNode = unwrapParentheses(sourceTypeNode);
-  const referenceTypeNode = ts3.isTypeReferenceNode(directTypeNode) ? directTypeNode : (() => {
+  const referenceTypeNode = ts5.isTypeReferenceNode(directTypeNode) ? directTypeNode : (() => {
     const resolvedTypeNode = resolveAliasedTypeNode(directTypeNode, checker);
-    return ts3.isTypeReferenceNode(resolvedTypeNode) ? resolvedTypeNode : null;
+    return ts5.isTypeReferenceNode(resolvedTypeNode) ? resolvedTypeNode : null;
   })();
   if (referenceTypeNode?.typeArguments === void 0) {
     return [];
@@ -3978,7 +4044,7 @@ function applyDiscriminatorToObjectProperties(properties, node, subjectType, che
   );
 }
 function analyzeFieldToIR(prop, checker, file, typeRegistry, visiting, diagnostics, hostType, metadataPolicy, extensionRegistry) {
-  if (!ts3.isIdentifier(prop.name)) {
+  if (!ts5.isIdentifier(prop.name)) {
     return null;
   }
   const name = prop.name.text;
@@ -4105,7 +4171,7 @@ function findDuplicateObjectLikeTypeAliasPropertyNames(members) {
   const seen = /* @__PURE__ */ new Set();
   const duplicates = /* @__PURE__ */ new Set();
   for (const member of members) {
-    if (!ts3.isPropertySignature(member)) {
+    if (!ts5.isPropertySignature(member)) {
       continue;
     }
     const name = getAnalyzableObjectLikePropertyName(member.name);
@@ -4121,7 +4187,7 @@ function findDuplicateObjectLikeTypeAliasPropertyNames(members) {
   return [...duplicates].sort();
 }
 function getAnalyzableObjectLikePropertyName(name) {
-  if (ts3.isIdentifier(name) || ts3.isStringLiteral(name) || ts3.isNumericLiteral(name)) {
+  if (ts5.isIdentifier(name) || ts5.isStringLiteral(name) || ts5.isNumericLiteral(name)) {
     return name.text;
   }
   return null;
@@ -4188,74 +4254,20 @@ function parseEnumMemberDisplayName(value) {
   if (label === "") return null;
   return { value: match[1], label };
 }
-function resolveRegisteredCustomType(sourceNode, extensionRegistry, checker) {
-  if (sourceNode === void 0 || extensionRegistry === void 0) {
-    return null;
-  }
-  const typeNode = extractTypeNodeFromSource(sourceNode);
-  if (typeNode === void 0) {
-    return null;
-  }
-  return resolveRegisteredCustomTypeFromTypeNode(typeNode, extensionRegistry, checker);
-}
-function resolveRegisteredCustomTypeFromTypeNode(typeNode, extensionRegistry, checker) {
-  if (ts3.isParenthesizedTypeNode(typeNode)) {
-    return resolveRegisteredCustomTypeFromTypeNode(typeNode.type, extensionRegistry, checker);
-  }
-  const typeName = getTypeNodeRegistrationName(typeNode);
-  if (typeName === null) {
-    return null;
-  }
-  const registration = extensionRegistry.findTypeByName(typeName);
-  if (registration !== void 0) {
+function resolveTypeNode(type, checker, file, typeRegistry, visiting, sourceNode, metadataPolicy = createAnalyzerMetadataPolicy(void 0), extensionRegistry, diagnostics) {
+  const customTypeLookup = resolveCustomTypeFromTsType(
+    type,
+    checker,
+    extensionRegistry,
+    sourceNode
+  );
+  if (customTypeLookup !== null) {
     return {
       kind: "custom",
-      typeId: `${registration.extensionId}/${registration.registration.typeName}`,
+      typeId: customTypeIdFromLookup(customTypeLookup),
       payload: null
     };
   }
-  if (ts3.isTypeReferenceNode(typeNode) && ts3.isIdentifier(typeNode.typeName)) {
-    const aliasDecl = getTypeAliasDeclarationFromTypeReference(typeNode, checker);
-    if (aliasDecl !== void 0) {
-      return resolveRegisteredCustomTypeFromTypeNode(aliasDecl.type, extensionRegistry, checker);
-    }
-  }
-  return null;
-}
-function extractTypeNodeFromSource(sourceNode) {
-  if (ts3.isPropertyDeclaration(sourceNode) || ts3.isPropertySignature(sourceNode) || ts3.isParameter(sourceNode) || ts3.isTypeAliasDeclaration(sourceNode)) {
-    return sourceNode.type;
-  }
-  if (ts3.isTypeNode(sourceNode)) {
-    return sourceNode;
-  }
-  return void 0;
-}
-function getTypeNodeRegistrationName(typeNode) {
-  if (ts3.isTypeReferenceNode(typeNode)) {
-    return ts3.isIdentifier(typeNode.typeName) ? typeNode.typeName.text : typeNode.typeName.right.text;
-  }
-  if (ts3.isParenthesizedTypeNode(typeNode)) {
-    return getTypeNodeRegistrationName(typeNode.type);
-  }
-  if (typeNode.kind === ts3.SyntaxKind.BigIntKeyword || typeNode.kind === ts3.SyntaxKind.StringKeyword || typeNode.kind === ts3.SyntaxKind.NumberKeyword || typeNode.kind === ts3.SyntaxKind.BooleanKeyword) {
-    return typeNode.getText();
-  }
-  return null;
-}
-function resolveTypeNode(type, checker, file, typeRegistry, visiting, sourceNode, metadataPolicy = createAnalyzerMetadataPolicy(void 0), extensionRegistry, diagnostics) {
-  const customType = resolveRegisteredCustomType(sourceNode, extensionRegistry, checker);
-  if (customType) {
-    return customType;
-  }
-  const symbolCustomType = resolveSymbolBasedCustomType(type, extensionRegistry, checker);
-  if (symbolCustomType) {
-    return symbolCustomType;
-  }
-  const brandedCustomType = resolveBrandedCustomType(type, extensionRegistry);
-  if (brandedCustomType) {
-    return brandedCustomType;
-  }
   const primitiveAlias = tryResolveNamedPrimitiveAlias(
     type,
     checker,
@@ -4273,25 +4285,25 @@ function resolveTypeNode(type, checker, file, typeRegistry, visiting, sourceNode
   if (isIntegerBrandedType(type)) {
     return { kind: "primitive", primitiveKind: "integer" };
   }
-  if (type.flags & ts3.TypeFlags.String) {
+  if (type.flags & ts5.TypeFlags.String) {
     return { kind: "primitive", primitiveKind: "string" };
   }
-  if (type.flags & ts3.TypeFlags.Number) {
+  if (type.flags & ts5.TypeFlags.Number) {
     return { kind: "primitive", primitiveKind: "number" };
   }
-  if (type.flags & (ts3.TypeFlags.BigInt | ts3.TypeFlags.BigIntLiteral)) {
+  if (type.flags & (ts5.TypeFlags.BigInt | ts5.TypeFlags.BigIntLiteral)) {
     return { kind: "primitive", primitiveKind: "bigint" };
   }
-  if (type.flags & ts3.TypeFlags.Boolean) {
+  if (type.flags & ts5.TypeFlags.Boolean) {
     return { kind: "primitive", primitiveKind: "boolean" };
   }
-  if (type.flags & ts3.TypeFlags.Null) {
+  if (type.flags & ts5.TypeFlags.Null) {
     return { kind: "primitive", primitiveKind: "null" };
   }
-  if (type.flags & ts3.TypeFlags.Undefined) {
+  if (type.flags & ts5.TypeFlags.Undefined) {
     return { kind: "primitive", primitiveKind: "null" };
   }
-  if (type.flags & ts3.TypeFlags.Void) {
+  if (type.flags & ts5.TypeFlags.Void) {
     return { kind: "primitive", primitiveKind: "null" };
   }
   if (type.isStringLiteral()) {
@@ -4378,10 +4390,10 @@ function resolveTypeNode(type, checker, file, typeRegistry, visiting, sourceNode
   return { kind: "primitive", primitiveKind: "string" };
 }
 function tryResolveNamedPrimitiveAlias(type, checker, file, typeRegistry, visiting, sourceNode, metadataPolicy = createAnalyzerMetadataPolicy(void 0), extensionRegistry, diagnostics) {
-  if (!(type.flags & (ts3.TypeFlags.String | ts3.TypeFlags.Number | ts3.TypeFlags.BigInt | ts3.TypeFlags.BigIntLiteral | ts3.TypeFlags.Boolean | ts3.TypeFlags.Null)) && !isIntegerBrandedType(type)) {
+  if (!(type.flags & (ts5.TypeFlags.String | ts5.TypeFlags.Number | ts5.TypeFlags.BigInt | ts5.TypeFlags.BigIntLiteral | ts5.TypeFlags.Boolean | ts5.TypeFlags.Null)) && !isIntegerBrandedType(type)) {
     return null;
   }
-  const aliasDecl = type.aliasSymbol?.declarations?.find(ts3.isTypeAliasDeclaration) ?? getReferencedTypeAliasDeclaration(sourceNode, checker);
+  const aliasDecl = type.aliasSymbol?.declarations?.find(ts5.isTypeAliasDeclaration) ?? getReferencedTypeAliasDeclaration(sourceNode, checker);
   if (!aliasDecl) {
     return null;
   }
@@ -4431,14 +4443,14 @@ function tryResolveNamedPrimitiveAlias(type, checker, file, typeRegistry, visiti
   return { kind: "reference", name: aliasName, typeArguments: [] };
 }
 function getReferencedTypeAliasDeclaration(sourceNode, checker) {
-  const typeNode = sourceNode && (ts3.isPropertyDeclaration(sourceNode) || ts3.isPropertySignature(sourceNode) || ts3.isParameter(sourceNode)) ? sourceNode.type : void 0;
-  if (!typeNode || !ts3.isTypeReferenceNode(typeNode)) {
+  const typeNode = sourceNode && (ts5.isPropertyDeclaration(sourceNode) || ts5.isPropertySignature(sourceNode) || ts5.isParameter(sourceNode)) ? sourceNode.type : void 0;
+  if (!typeNode || !ts5.isTypeReferenceNode(typeNode)) {
     return void 0;
   }
   return getTypeAliasDeclarationFromTypeReference(typeNode, checker);
 }
 function shouldEmitPrimitiveAliasDefinition(typeNode, checker) {
-  if (!ts3.isTypeReferenceNode(typeNode)) {
+  if (!ts5.isTypeReferenceNode(typeNode)) {
     return false;
   }
   const aliasDecl = getTypeAliasDeclarationFromTypeReference(typeNode, checker);
@@ -4446,10 +4458,10 @@ function shouldEmitPrimitiveAliasDefinition(typeNode, checker) {
     return false;
   }
   const resolved = checker.getTypeFromTypeNode(aliasDecl.type);
-  return !!(resolved.flags & (ts3.TypeFlags.String | ts3.TypeFlags.Number | ts3.TypeFlags.BigInt | ts3.TypeFlags.BigIntLiteral | ts3.TypeFlags.Boolean | ts3.TypeFlags.Null));
+  return !!(resolved.flags & (ts5.TypeFlags.String | ts5.TypeFlags.Number | ts5.TypeFlags.BigInt | ts5.TypeFlags.BigIntLiteral | ts5.TypeFlags.Boolean | ts5.TypeFlags.Null));
 }
 function resolveAliasedPrimitiveTarget(type, checker, file, typeRegistry, visiting, metadataPolicy = createAnalyzerMetadataPolicy(void 0), extensionRegistry, diagnostics, visitedAliases = /* @__PURE__ */ new Set()) {
-  const nestedAliasDecl = type.aliasSymbol?.declarations?.find(ts3.isTypeAliasDeclaration);
+  const nestedAliasDecl = type.aliasSymbol?.declarations?.find(ts5.isTypeAliasDeclaration);
   if (nestedAliasDecl !== void 0 && !visitedAliases.has(nestedAliasDecl)) {
     visitedAliases.add(nestedAliasDecl);
     return resolveAliasedPrimitiveTarget(
@@ -4467,19 +4479,19 @@ function resolveAliasedPrimitiveTarget(type, checker, file, typeRegistry, visiti
   if (isIntegerBrandedType(type)) {
     return { kind: "primitive", primitiveKind: "integer" };
   }
-  if (type.flags & ts3.TypeFlags.String) {
+  if (type.flags & ts5.TypeFlags.String) {
     return { kind: "primitive", primitiveKind: "string" };
   }
-  if (type.flags & ts3.TypeFlags.Number) {
+  if (type.flags & ts5.TypeFlags.Number) {
     return { kind: "primitive", primitiveKind: "number" };
   }
-  if (type.flags & (ts3.TypeFlags.BigInt | ts3.TypeFlags.BigIntLiteral)) {
+  if (type.flags & (ts5.TypeFlags.BigInt | ts5.TypeFlags.BigIntLiteral)) {
     return { kind: "primitive", primitiveKind: "bigint" };
   }
-  if (type.flags & ts3.TypeFlags.Boolean) {
+  if (type.flags & ts5.TypeFlags.Boolean) {
     return { kind: "primitive", primitiveKind: "boolean" };
   }
-  if (type.flags & ts3.TypeFlags.Null) {
+  if (type.flags & ts5.TypeFlags.Null) {
     return { kind: "primitive", primitiveKind: "null" };
   }
   return resolveTypeNode(
@@ -4506,13 +4518,13 @@ function resolveUnionType(type, checker, file, typeRegistry, visiting, sourceNod
     (memberTypeNode) => !isNullishTypeNode(resolveAliasedTypeNode(memberTypeNode, checker))
   );
   const nonNullTypes = allTypes.filter(
-    (memberType) => !(memberType.flags & (ts3.TypeFlags.Null | ts3.TypeFlags.Undefined))
+    (memberType) => !(memberType.flags & (ts5.TypeFlags.Null | ts5.TypeFlags.Undefined))
   );
   const nonNullMembers = nonNullTypes.map((memberType, index) => ({
     memberType,
     sourceNode: nonNullSourceNodes.length === nonNullTypes.length ? nonNullSourceNodes[index] : void 0
   }));
-  const hasNull = allTypes.some((t) => t.flags & ts3.TypeFlags.Null);
+  const hasNull = allTypes.some((t) => t.flags & ts5.TypeFlags.Null);
   const memberDisplayNames = /* @__PURE__ */ new Map();
   if (namedDecl) {
     for (const [value, label] of extractDisplayNameMetadata(namedDecl).memberDisplayNames) {
@@ -4555,7 +4567,7 @@ function resolveUnionType(type, checker, file, typeRegistry, visiting, sourceNod
     const displayName = memberDisplayNames.get(String(value));
     return displayName !== void 0 ? { value, displayName } : { value };
   });
-  const isBooleanUnion2 = nonNullTypes.length === 2 && nonNullTypes.every((t) => t.flags & ts3.TypeFlags.BooleanLiteral);
+  const isBooleanUnion2 = nonNullTypes.length === 2 && nonNullTypes.every((t) => t.flags & ts5.TypeFlags.BooleanLiteral);
   if (isBooleanUnion2) {
     const boolNode = { kind: "primitive", primitiveKind: "boolean" };
     const result = hasNull ? {
@@ -4647,7 +4659,7 @@ function tryResolveRecordType(type, checker, file, typeRegistry, visiting, metad
   if (type.getProperties().length > 0) {
     return null;
   }
-  const indexInfo = checker.getIndexInfoOfType(type, ts3.IndexKind.String);
+  const indexInfo = checker.getIndexInfoOfType(type, ts5.IndexKind.String);
   if (!indexInfo) {
     return null;
   }
@@ -4695,10 +4707,10 @@ function shouldEmitResolvedObjectProperty(property, declaration) {
   }
   if (declaration !== void 0 && "name" in declaration && declaration.name !== void 0) {
     const name = declaration.name;
-    if (ts3.isComputedPropertyName(name) || ts3.isPrivateIdentifier(name)) {
+    if (ts5.isComputedPropertyName(name) || ts5.isPrivateIdentifier(name)) {
       return false;
     }
-    if (!ts3.isIdentifier(name) && !ts3.isStringLiteral(name) && !ts3.isNumericLiteral(name)) {
+    if (!ts5.isIdentifier(name) && !ts5.isStringLiteral(name) && !ts5.isNumericLiteral(name)) {
       return false;
     }
   }
@@ -4824,7 +4836,7 @@ function resolveObjectType(type, checker, file, typeRegistry, visiting, sourceNo
     if (!declaration) continue;
     if (!shouldEmitResolvedObjectProperty(prop, declaration)) continue;
     const propType = checker.getTypeOfSymbolAtLocation(prop, declaration);
-    const optional = !!(prop.flags & ts3.SymbolFlags.Optional);
+    const optional = !!(prop.flags & ts5.SymbolFlags.Optional);
     const propTypeNode = resolveTypeNode(
       propType,
       checker,
@@ -4837,7 +4849,7 @@ function resolveObjectType(type, checker, file, typeRegistry, visiting, sourceNo
       collectedDiagnostics
     );
     const fieldNodeInfo = fieldInfoMap?.get(prop.name);
-    const inlineFieldNodeInfo = fieldNodeInfo === void 0 ? ts3.isPropertySignature(declaration) ? analyzeInterfacePropertyToIR(
+    const inlineFieldNodeInfo = fieldNodeInfo === void 0 ? ts5.isPropertySignature(declaration) ? analyzeInterfacePropertyToIR(
       declaration,
       checker,
       file,
@@ -4847,7 +4859,7 @@ function resolveObjectType(type, checker, file, typeRegistry, visiting, sourceNo
       type,
       metadataPolicy,
       extensionRegistry
-    ) : ts3.isPropertyDeclaration(declaration) ? analyzeFieldToIR(
+    ) : ts5.isPropertyDeclaration(declaration) ? analyzeFieldToIR(
       declaration,
       checker,
       file,
@@ -4875,7 +4887,7 @@ function resolveObjectType(type, checker, file, typeRegistry, visiting, sourceNo
   visiting.delete(type);
   const objectNode = {
     kind: "object",
-    properties: namedDecl !== void 0 && (ts3.isClassDeclaration(namedDecl) || ts3.isInterfaceDeclaration(namedDecl) || ts3.isTypeAliasDeclaration(namedDecl)) ? applyDiscriminatorToObjectProperties(
+    properties: namedDecl !== void 0 && (ts5.isClassDeclaration(namedDecl) || ts5.isInterfaceDeclaration(namedDecl) || ts5.isTypeAliasDeclaration(namedDecl)) ? applyDiscriminatorToObjectProperties(
       properties,
       namedDecl,
       type,
@@ -4923,12 +4935,12 @@ function getNamedTypeFieldNodeInfoMap(type, checker, file, typeRegistry, visitin
   for (const symbol of symbols) {
     const declarations = symbol.declarations;
     if (!declarations) continue;
-    const classDecl = declarations.find(ts3.isClassDeclaration);
+    const classDecl = declarations.find(ts5.isClassDeclaration);
     if (classDecl) {
       const map = /* @__PURE__ */ new Map();
       const hostType = checker.getTypeAtLocation(classDecl);
       for (const member of classDecl.members) {
-        if (ts3.isPropertyDeclaration(member) && ts3.isIdentifier(member.name)) {
+        if (ts5.isPropertyDeclaration(member) && ts5.isIdentifier(member.name)) {
           const fieldNode = analyzeFieldToIR(
             member,
             checker,
@@ -4952,7 +4964,7 @@ function getNamedTypeFieldNodeInfoMap(type, checker, file, typeRegistry, visitin
       }
       return map;
     }
-    const interfaceDecl = declarations.find(ts3.isInterfaceDeclaration);
+    const interfaceDecl = declarations.find(ts5.isInterfaceDeclaration);
     if (interfaceDecl) {
       return buildFieldNodeInfoMap(
         interfaceDecl.members,
@@ -4966,7 +4978,7 @@ function getNamedTypeFieldNodeInfoMap(type, checker, file, typeRegistry, visitin
         extensionRegistry
       );
     }
-    const typeAliasDecl = declarations.find(ts3.isTypeAliasDeclaration);
+    const typeAliasDecl = declarations.find(ts5.isTypeAliasDeclaration);
     const typeAliasMembers = typeAliasDecl === void 0 ? null : getObjectLikeTypeAliasMembers(typeAliasDecl.type);
     if (typeAliasDecl && typeAliasMembers !== null) {
       return buildFieldNodeInfoMap(
@@ -4990,10 +5002,10 @@ function extractArrayElementTypeNode(sourceNode, checker) {
     return void 0;
   }
   const resolvedTypeNode = resolveAliasedTypeNode(typeNode, checker);
-  if (ts3.isArrayTypeNode(resolvedTypeNode)) {
+  if (ts5.isArrayTypeNode(resolvedTypeNode)) {
     return resolvedTypeNode.elementType;
   }
-  if (ts3.isTypeReferenceNode(resolvedTypeNode) && ts3.isIdentifier(resolvedTypeNode.typeName) && resolvedTypeNode.typeName.text === "Array" && resolvedTypeNode.typeArguments?.[0]) {
+  if (ts5.isTypeReferenceNode(resolvedTypeNode) && ts5.isIdentifier(resolvedTypeNode.typeName) && resolvedTypeNode.typeName.text === "Array" && resolvedTypeNode.typeArguments?.[0]) {
     return resolvedTypeNode.typeArguments[0];
   }
   return void 0;
@@ -5004,13 +5016,13 @@ function extractUnionMemberTypeNodes(sourceNode, checker) {
     return [];
   }
   const resolvedTypeNode = resolveAliasedTypeNode(typeNode, checker);
-  return ts3.isUnionTypeNode(resolvedTypeNode) ? [...resolvedTypeNode.types] : [];
+  return ts5.isUnionTypeNode(resolvedTypeNode) ? [...resolvedTypeNode.types] : [];
 }
 function resolveAliasedTypeNode(typeNode, checker, visited = /* @__PURE__ */ new Set()) {
-  if (ts3.isParenthesizedTypeNode(typeNode)) {
+  if (ts5.isParenthesizedTypeNode(typeNode)) {
     return resolveAliasedTypeNode(typeNode.type, checker, visited);
   }
-  if (!ts3.isTypeReferenceNode(typeNode) || !ts3.isIdentifier(typeNode.typeName)) {
+  if (!ts5.isTypeReferenceNode(typeNode) || !ts5.isIdentifier(typeNode.typeName)) {
     return typeNode;
   }
   const aliasDecl = getTypeAliasDeclarationFromTypeReference(typeNode, checker);
@@ -5021,15 +5033,15 @@ function resolveAliasedTypeNode(typeNode, checker, visited = /* @__PURE__ */ new
   return resolveAliasedTypeNode(aliasDecl.type, checker, visited);
 }
 function isNullishTypeNode(typeNode) {
-  if (typeNode.kind === ts3.SyntaxKind.NullKeyword || typeNode.kind === ts3.SyntaxKind.UndefinedKeyword) {
+  if (typeNode.kind === ts5.SyntaxKind.NullKeyword || typeNode.kind === ts5.SyntaxKind.UndefinedKeyword) {
     return true;
   }
-  return ts3.isLiteralTypeNode(typeNode) && (typeNode.literal.kind === ts3.SyntaxKind.NullKeyword || typeNode.literal.kind === ts3.SyntaxKind.UndefinedKeyword);
+  return ts5.isLiteralTypeNode(typeNode) && (typeNode.literal.kind === ts5.SyntaxKind.NullKeyword || typeNode.literal.kind === ts5.SyntaxKind.UndefinedKeyword);
 }
 function buildFieldNodeInfoMap(members, checker, file, typeRegistry, visiting, metadataPolicy, hostType, diagnostics, extensionRegistry) {
   const map = /* @__PURE__ */ new Map();
   for (const member of members) {
-    if (ts3.isPropertySignature(member)) {
+    if (ts5.isPropertySignature(member)) {
       const fieldNode = analyzeInterfacePropertyToIR(
         member,
         checker,
@@ -5055,17 +5067,16 @@ function buildFieldNodeInfoMap(members, checker, file, typeRegistry, visiting, m
 }
 var MAX_ALIAS_CHAIN_DEPTH = 8;
 function extractTypeAliasConstraintNodes(typeNode, checker, file, extensionRegistry, depth = 0) {
-  if (!ts3.isTypeReferenceNode(typeNode)) return [];
+  if (!ts5.isTypeReferenceNode(typeNode)) return [];
   if (depth >= MAX_ALIAS_CHAIN_DEPTH) {
     const aliasName = typeNode.typeName.getText();
     throw new Error(
       `Type alias chain exceeds maximum depth of ${String(MAX_ALIAS_CHAIN_DEPTH)} at alias "${aliasName}" in ${file}. Simplify the alias chain or check for circular references.`
     );
   }
-  const symbol = checker.getSymbolAtLocation(typeNode.typeName);
-  const aliasDecl = getAliasedTypeAliasDeclaration(symbol, checker);
+  const aliasDecl = getTypeAliasDeclarationFromTypeReference(typeNode, checker);
   if (!aliasDecl) return [];
-  if (ts3.isTypeLiteralNode(aliasDecl.type)) return [];
+  if (ts5.isTypeLiteralNode(aliasDecl.type)) return [];
   const aliasFieldType = resolveTypeNode(
     checker.getTypeAtLocation(aliasDecl.type),
     checker,
@@ -5086,18 +5097,6 @@ function extractTypeAliasConstraintNodes(typeNode, checker, file, extensionRegis
   );
   return constraints;
 }
-function getAliasedSymbol(symbol, checker) {
-  if (symbol === void 0) {
-    return void 0;
-  }
-  return symbol.flags & ts3.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
-}
-function getAliasedTypeAliasDeclaration(symbol, checker) {
-  return getAliasedSymbol(symbol, checker)?.declarations?.find(ts3.isTypeAliasDeclaration);
-}
-function getTypeAliasDeclarationFromTypeReference(typeNode, checker) {
-  return getAliasedTypeAliasDeclaration(checker.getSymbolAtLocation(typeNode.typeName), checker);
-}
 function provenanceForNode(node, file) {
   const sourceFile = node.getSourceFile();
   const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
@@ -5121,14 +5120,14 @@ function getNamedTypeName(type) {
   const symbol = type.getSymbol();
   if (symbol?.declarations) {
     const decl = symbol.declarations[0];
-    if (decl && (ts3.isClassDeclaration(decl) || ts3.isInterfaceDeclaration(decl) || ts3.isTypeAliasDeclaration(decl))) {
-      const name = ts3.isClassDeclaration(decl) ? decl.name?.text : decl.name.text;
+    if (decl && (ts5.isClassDeclaration(decl) || ts5.isInterfaceDeclaration(decl) || ts5.isTypeAliasDeclaration(decl))) {
+      const name = ts5.isClassDeclaration(decl) ? decl.name?.text : decl.name.text;
       if (name) return name;
     }
   }
   const aliasSymbol = type.aliasSymbol;
   if (aliasSymbol?.declarations) {
-    const aliasDecl = aliasSymbol.declarations.find(ts3.isTypeAliasDeclaration);
+    const aliasDecl = aliasSymbol.declarations.find(ts5.isTypeAliasDeclaration);
     if (aliasDecl) {
       return aliasDecl.name.text;
     }
@@ -5139,24 +5138,24 @@ function getNamedTypeDeclaration(type) {
   const symbol = type.getSymbol();
   if (symbol?.declarations) {
     const decl = symbol.declarations[0];
-    if (decl && (ts3.isClassDeclaration(decl) || ts3.isInterfaceDeclaration(decl) || ts3.isTypeAliasDeclaration(decl))) {
+    if (decl && (ts5.isClassDeclaration(decl) || ts5.isInterfaceDeclaration(decl) || ts5.isTypeAliasDeclaration(decl))) {
       return decl;
     }
   }
   const aliasSymbol = type.aliasSymbol;
   if (aliasSymbol?.declarations) {
-    return aliasSymbol.declarations.find(ts3.isTypeAliasDeclaration);
+    return aliasSymbol.declarations.find(ts5.isTypeAliasDeclaration);
   }
   return void 0;
 }
 function analyzeMethod(method, checker) {
-  if (!ts3.isIdentifier(method.name)) {
+  if (!ts5.isIdentifier(method.name)) {
     return null;
   }
   const name = method.name.text;
   const parameters = [];
   for (const param of method.parameters) {
-    if (ts3.isIdentifier(param.name)) {
+    if (ts5.isIdentifier(param.name)) {
       const paramInfo = analyzeParameter(param, checker);
       parameters.push(paramInfo);
     }
@@ -5167,7 +5166,7 @@ function analyzeMethod(method, checker) {
   return { name, parameters, returnTypeNode, returnType };
 }
 function analyzeParameter(param, checker) {
-  const name = ts3.isIdentifier(param.name) ? param.name.text : "param";
+  const name = ts5.isIdentifier(param.name) ? param.name.text : "param";
   const typeNode = param.type;
   const type = checker.getTypeAtLocation(param);
   const formSpecExportName = detectFormSpecReference(typeNode);
@@ -5176,15 +5175,15 @@ function analyzeParameter(param, checker) {
 }
 function detectFormSpecReference(typeNode) {
   if (!typeNode) return null;
-  if (!ts3.isTypeReferenceNode(typeNode)) return null;
-  const typeName = ts3.isIdentifier(typeNode.typeName) ? typeNode.typeName.text : ts3.isQualifiedName(typeNode.typeName) ? typeNode.typeName.right.text : null;
+  if (!ts5.isTypeReferenceNode(typeNode)) return null;
+  const typeName = ts5.isIdentifier(typeNode.typeName) ? typeNode.typeName.text : ts5.isQualifiedName(typeNode.typeName) ? typeNode.typeName.right.text : null;
   if (typeName !== "InferSchema" && typeName !== "InferFormSchema") return null;
   const typeArg = typeNode.typeArguments?.[0];
-  if (!typeArg || !ts3.isTypeQueryNode(typeArg)) return null;
-  if (ts3.isIdentifier(typeArg.exprName)) {
+  if (!typeArg || !ts5.isTypeQueryNode(typeArg)) return null;
+  if (ts5.isIdentifier(typeArg.exprName)) {
     return typeArg.exprName.text;
   }
-  if (ts3.isQualifiedName(typeArg.exprName)) {
+  if (ts5.isQualifiedName(typeArg.exprName)) {
     return typeArg.exprName.right.text;
   }
   return null;
@@ -5206,23 +5205,23 @@ function createProgramContextFromProgram(program, filePath) {
 function createProgramContext(filePath, additionalFiles) {
   const absolutePath = path.resolve(filePath);
   const fileDir = path.dirname(absolutePath);
-  const configPath = ts4.findConfigFile(fileDir, ts4.sys.fileExists.bind(ts4.sys), "tsconfig.json");
+  const configPath = ts6.findConfigFile(fileDir, ts6.sys.fileExists.bind(ts6.sys), "tsconfig.json");
   let compilerOptions;
   let fileNames;
   if (configPath) {
-    const configFile = ts4.readConfigFile(configPath, ts4.sys.readFile.bind(ts4.sys));
+    const configFile = ts6.readConfigFile(configPath, ts6.sys.readFile.bind(ts6.sys));
     if (configFile.error) {
       throw new Error(
-        `Error reading tsconfig.json: ${ts4.flattenDiagnosticMessageText(configFile.error.messageText, "\n")}`
+        `Error reading tsconfig.json: ${ts6.flattenDiagnosticMessageText(configFile.error.messageText, "\n")}`
       );
     }
-    const parsed = ts4.parseJsonConfigFileContent(
+    const parsed = ts6.parseJsonConfigFileContent(
       configFile.config,
-      ts4.sys,
+      ts6.sys,
       path.dirname(configPath)
     );
     if (parsed.errors.length > 0) {
-      const errorMessages = parsed.errors.map((e) => ts4.flattenDiagnosticMessageText(e.messageText, "\n")).join("\n");
+      const errorMessages = parsed.errors.map((e) => ts6.flattenDiagnosticMessageText(e.messageText, "\n")).join("\n");
       throw new Error(`Error parsing tsconfig.json: ${errorMessages}`);
     }
     compilerOptions = parsed.options;
@@ -5230,9 +5229,9 @@ function createProgramContext(filePath, additionalFiles) {
     fileNames = [.../* @__PURE__ */ new Set([...parsed.fileNames, absolutePath, ...normalizedAdditional])];
   } else {
     compilerOptions = {
-      target: ts4.ScriptTarget.ES2022,
-      module: ts4.ModuleKind.NodeNext,
-      moduleResolution: ts4.ModuleResolutionKind.NodeNext,
+      target: ts6.ScriptTarget.ES2022,
+      module: ts6.ModuleKind.NodeNext,
+      moduleResolution: ts6.ModuleResolutionKind.NodeNext,
       strict: true,
       skipLibCheck: true,
       declaration: true
@@ -5240,7 +5239,7 @@ function createProgramContext(filePath, additionalFiles) {
     const normalizedAdditional = (additionalFiles ?? []).map((f) => path.resolve(f));
     fileNames = [.../* @__PURE__ */ new Set([absolutePath, ...normalizedAdditional])];
   }
-  const program = ts4.createProgram(fileNames, compilerOptions);
+  const program = ts6.createProgram(fileNames, compilerOptions);
   const sourceFile = program.getSourceFile(absolutePath);
   if (!sourceFile) {
     throw new Error(`Could not find source file: ${absolutePath}`);
@@ -5259,19 +5258,19 @@ function findNodeByName(sourceFile, name, predicate, getName) {
       result = node;
       return;
     }
-    ts4.forEachChild(node, visit);
+    ts6.forEachChild(node, visit);
   }
   visit(sourceFile);
   return result;
 }
 function findClassByName(sourceFile, className) {
-  return findNodeByName(sourceFile, className, ts4.isClassDeclaration, (n) => n.name?.text);
+  return findNodeByName(sourceFile, className, ts6.isClassDeclaration, (n) => n.name?.text);
 }
 function findInterfaceByName(sourceFile, interfaceName) {
-  return findNodeByName(sourceFile, interfaceName, ts4.isInterfaceDeclaration, (n) => n.name.text);
+  return findNodeByName(sourceFile, interfaceName, ts6.isInterfaceDeclaration, (n) => n.name.text);
 }
 function findTypeAliasByName(sourceFile, aliasName) {
-  return findNodeByName(sourceFile, aliasName, ts4.isTypeAliasDeclaration, (n) => n.name.text);
+  return findNodeByName(sourceFile, aliasName, ts6.isTypeAliasDeclaration, (n) => n.name.text);
 }
 function getResolvedObjectRootType(rootType, typeRegistry) {
   if (rootType.kind === "object") {
@@ -5311,22 +5310,22 @@ function createResolvedObjectAliasAnalysis(name, rootType, typeRegistry, rootInf
   };
 }
 function containsTypeReferenceInObjectLikeAlias(typeNode) {
-  if (ts4.isParenthesizedTypeNode(typeNode)) {
+  if (ts6.isParenthesizedTypeNode(typeNode)) {
     return containsTypeReferenceInObjectLikeAlias(typeNode.type);
   }
-  if (ts4.isTypeReferenceNode(typeNode)) {
+  if (ts6.isTypeReferenceNode(typeNode)) {
     return true;
   }
-  return ts4.isIntersectionTypeNode(typeNode) && typeNode.types.some((member) => containsTypeReferenceInObjectLikeAlias(member));
+  return ts6.isIntersectionTypeNode(typeNode) && typeNode.types.some((member) => containsTypeReferenceInObjectLikeAlias(member));
 }
 function collectFallbackAliasMemberPropertyNames(typeNode, checker) {
-  if (ts4.isParenthesizedTypeNode(typeNode)) {
+  if (ts6.isParenthesizedTypeNode(typeNode)) {
     return collectFallbackAliasMemberPropertyNames(typeNode.type, checker);
   }
-  if (ts4.isTypeLiteralNode(typeNode)) {
+  if (ts6.isTypeLiteralNode(typeNode)) {
     const propertyNames = [];
     for (const member of typeNode.members) {
-      if (!ts4.isPropertySignature(member)) {
+      if (!ts6.isPropertySignature(member)) {
         continue;
       }
       const propertyName = getAnalyzableObjectLikePropertyName(member.name);
@@ -5336,13 +5335,13 @@ function collectFallbackAliasMemberPropertyNames(typeNode, checker) {
     }
     return propertyNames;
   }
-  if (ts4.isTypeReferenceNode(typeNode)) {
+  if (ts6.isTypeReferenceNode(typeNode)) {
     return checker.getTypeFromTypeNode(typeNode).getProperties().map((property) => property.getName());
   }
   return null;
 }
 function findFallbackAliasDuplicatePropertyNames(typeNode, checker) {
-  if (!ts4.isIntersectionTypeNode(typeNode)) {
+  if (!ts6.isIntersectionTypeNode(typeNode)) {
     return [];
   }
   const seen = /* @__PURE__ */ new Set();
@@ -5543,7 +5542,7 @@ function makeFileProvenance(filePath) {
 }
 
 // src/extensions/symbol-registry.ts
-import * as ts5 from "typescript";
+import * as ts7 from "typescript";
 import * as path2 from "path";
 function buildSymbolMapFromConfig(configPath, program, checker, extensionRegistry) {
   const symbolMap = /* @__PURE__ */ new Map();
@@ -5553,10 +5552,10 @@ function buildSymbolMapFromConfig(configPath, program, checker, extensionRegistr
     return symbolMap;
   }
   function visit(node) {
-    if (ts5.isCallExpression(node) && isDefineCustomTypeCall(node, checker)) {
+    if (ts7.isCallExpression(node) && isDefineCustomTypeCall(node, checker)) {
       processDefineCustomTypeCall(node);
     }
-    ts5.forEachChild(node, visit);
+    ts7.forEachChild(node, visit);
   }
   function processDefineCustomTypeCall(call) {
     const typeArgNode = call.typeArguments?.[0];
@@ -5564,7 +5563,7 @@ function buildSymbolMapFromConfig(configPath, program, checker, extensionRegistr
       return;
     }
     const resolvedType = checker.getTypeFromTypeNode(typeArgNode);
-    const canonical = resolveCanonicalSymbol2(resolvedType, checker);
+    const canonical = resolveCanonicalSymbol(resolvedType, checker);
     if (canonical === void 0) {
       return;
     }
@@ -5593,7 +5592,7 @@ function isDefineCustomTypeCall(node, checker) {
   if (node.typeArguments === void 0 || node.typeArguments.length === 0) return false;
   const callSymbol = checker.getSymbolAtLocation(node.expression);
   if (callSymbol !== void 0) {
-    const resolved = callSymbol.flags & ts5.SymbolFlags.Alias ? checker.getAliasedSymbol(callSymbol) : callSymbol;
+    const resolved = callSymbol.flags & ts7.SymbolFlags.Alias ? checker.getAliasedSymbol(callSymbol) : callSymbol;
     const decl = resolved.declarations?.[0];
     if (decl !== void 0) {
       const sourceFile = decl.getSourceFile().fileName.replace(/\\/g, "/");
@@ -5601,29 +5600,24 @@ function isDefineCustomTypeCall(node, checker) {
       (sourceFile.includes("@formspec/core") || sourceFile.includes("/packages/core/"));
     }
   }
-  return ts5.isIdentifier(node.expression) && node.expression.text === "defineCustomType";
-}
-function resolveCanonicalSymbol2(type, checker) {
-  const raw = type.aliasSymbol ?? type.getSymbol();
-  if (raw === void 0) return void 0;
-  return raw.flags & ts5.SymbolFlags.Alias ? checker.getAliasedSymbol(raw) : raw;
+  return ts7.isIdentifier(node.expression) && node.expression.text === "defineCustomType";
 }
 function extractTypeNameFromCallArg(call) {
   const arg = call.arguments[0];
-  if (arg === void 0 || !ts5.isObjectLiteralExpression(arg)) {
+  if (arg === void 0 || !ts7.isObjectLiteralExpression(arg)) {
     return null;
   }
   const typeNameProp = arg.properties.find(
-    (p) => ts5.isPropertyAssignment(p) && ts5.isIdentifier(p.name) && p.name.text === "typeName"
+    (p) => ts7.isPropertyAssignment(p) && ts7.isIdentifier(p.name) && p.name.text === "typeName"
   );
-  if (typeNameProp === void 0 || !ts5.isStringLiteral(typeNameProp.initializer)) {
+  if (typeNameProp === void 0 || !ts7.isStringLiteral(typeNameProp.initializer)) {
     return null;
   }
   return typeNameProp.initializer.text;
 }
 function extractEnclosingExtensionId(call, checker) {
-  for (let node = call.parent; !ts5.isSourceFile(node); node = node.parent) {
-    if (ts5.isCallExpression(node) && isDefineExtensionCall(node, checker)) {
+  for (let node = call.parent; !ts7.isSourceFile(node); node = node.parent) {
+    if (ts7.isCallExpression(node) && isDefineExtensionCall(node, checker)) {
       return extractExtensionIdFromCallArg(node);
     }
   }
@@ -5632,24 +5626,24 @@ function extractEnclosingExtensionId(call, checker) {
 function isDefineExtensionCall(node, checker) {
   const callSymbol = checker.getSymbolAtLocation(node.expression);
   if (callSymbol !== void 0) {
-    const resolved = callSymbol.flags & ts5.SymbolFlags.Alias ? checker.getAliasedSymbol(callSymbol) : callSymbol;
+    const resolved = callSymbol.flags & ts7.SymbolFlags.Alias ? checker.getAliasedSymbol(callSymbol) : callSymbol;
     const decl = resolved.declarations?.[0];
     if (decl !== void 0) {
       const sourceFile = decl.getSourceFile().fileName.replace(/\\/g, "/");
       return resolved.name === "defineExtension" && (sourceFile.includes("@formspec/core") || sourceFile.includes("/packages/core/"));
     }
   }
-  return ts5.isIdentifier(node.expression) && node.expression.text === "defineExtension";
+  return ts7.isIdentifier(node.expression) && node.expression.text === "defineExtension";
 }
 function extractExtensionIdFromCallArg(call) {
   const arg = call.arguments[0];
-  if (arg === void 0 || !ts5.isObjectLiteralExpression(arg)) {
+  if (arg === void 0 || !ts7.isObjectLiteralExpression(arg)) {
     return null;
   }
   const prop = arg.properties.find(
-    (p) => ts5.isPropertyAssignment(p) && ts5.isIdentifier(p.name) && p.name.text === "extensionId"
+    (p) => ts7.isPropertyAssignment(p) && ts7.isIdentifier(p.name) && p.name.text === "extensionId"
   );
-  if (prop === void 0 || !ts5.isStringLiteral(prop.initializer)) {
+  if (prop === void 0 || !ts7.isStringLiteral(prop.initializer)) {
     return null;
   }
   return prop.initializer.text;
@@ -5911,7 +5905,7 @@ function generateSchemasBatch(options) {
   return options.targets.map((target) => {
     let ctx;
     try {
-      const cacheKey = ts6.sys.useCaseSensitiveFileNames ? target.filePath : target.filePath.toLowerCase();
+      const cacheKey = ts8.sys.useCaseSensitiveFileNames ? target.filePath : target.filePath.toLowerCase();
       const cachedContext = contextCache.get(cacheKey);
       if (cachedContext === void 0) {
         const additionalFiles = options.configPath !== void 0 ? [options.configPath] : void 0;
@@ -6067,7 +6061,7 @@ function createProgramContextFailureDiagnostic(filePath, error) {
 }
 
 // src/static-build.ts
-import * as ts7 from "typescript";
+import * as ts9 from "typescript";
 function toStaticBuildContext(context) {
   return context;
 }
@@ -6082,7 +6076,7 @@ function getModuleSymbol(context) {
   return context.checker.getSymbolAtLocation(context.sourceFile) ?? sourceFileWithSymbol.symbol;
 }
 function isSchemaSourceDeclaration(declaration) {
-  return ts7.isClassDeclaration(declaration) || ts7.isInterfaceDeclaration(declaration) || ts7.isTypeAliasDeclaration(declaration);
+  return ts9.isClassDeclaration(declaration) || ts9.isInterfaceDeclaration(declaration) || ts9.isTypeAliasDeclaration(declaration);
 }
 function resolveModuleExport(context, exportName = "default") {
   const moduleSymbol = getModuleSymbol(context);
@@ -6093,14 +6087,14 @@ function resolveModuleExport(context, exportName = "default") {
   if (exportSymbol === null) {
     return null;
   }
-  return exportSymbol.flags & ts7.SymbolFlags.Alias ? context.checker.getAliasedSymbol(exportSymbol) : exportSymbol;
+  return exportSymbol.flags & ts9.SymbolFlags.Alias ? context.checker.getAliasedSymbol(exportSymbol) : exportSymbol;
 }
 function resolveModuleExportDeclaration(context, exportName = "default") {
   return resolveModuleExport(context, exportName)?.declarations?.find(isSchemaSourceDeclaration) ?? null;
 }
 
 // src/generators/discovered-schema.ts
-import * as ts8 from "typescript";
+import * as ts10 from "typescript";
 import { analyzeMetadataForNodeWithChecker as analyzeMetadataForNodeWithChecker2 } from "@formspec/analysis/internal";
 import { IR_VERSION as IR_VERSION3 } from "@formspec/core/internals";
 function toDiscoveredTypeSchemas(result, resolvedMetadata) {
@@ -6110,17 +6104,17 @@ function toDiscoveredTypeSchemas(result, resolvedMetadata) {
   };
 }
 function isNamedTypeDeclaration(declaration) {
-  return ts8.isClassDeclaration(declaration) || ts8.isInterfaceDeclaration(declaration) || ts8.isTypeAliasDeclaration(declaration);
+  return ts10.isClassDeclaration(declaration) || ts10.isInterfaceDeclaration(declaration) || ts10.isTypeAliasDeclaration(declaration);
 }
 function hasConcreteTypeArguments(type, checker) {
   if ("aliasTypeArguments" in type && Array.isArray(type.aliasTypeArguments) && type.aliasTypeArguments.length > 0) {
     return true;
   }
-  if ((type.flags & ts8.TypeFlags.Object) === 0) {
+  if ((type.flags & ts10.TypeFlags.Object) === 0) {
     return false;
   }
   const objectType = type;
-  if ((objectType.objectFlags & ts8.ObjectFlags.Reference) === 0) {
+  if ((objectType.objectFlags & ts10.ObjectFlags.Reference) === 0) {
     return false;
   }
   return checker.getTypeArguments(objectType).length > 0;
@@ -6133,13 +6127,13 @@ function getNamedTypeDeclaration2(type) {
       return declaration;
     }
   }
-  const aliasDeclaration = type.aliasSymbol?.declarations?.find(ts8.isTypeAliasDeclaration);
+  const aliasDeclaration = type.aliasSymbol?.declarations?.find(ts10.isTypeAliasDeclaration);
   return aliasDeclaration;
 }
 function getFallbackName(sourceNode, fallback = "AnonymousType") {
   if (sourceNode !== void 0 && "name" in sourceNode) {
     const namedNode = sourceNode;
-    if (namedNode.name !== void 0 && ts8.isIdentifier(namedNode.name)) {
+    if (namedNode.name !== void 0 && ts10.isIdentifier(namedNode.name)) {
       return namedNode.name.text;
     }
   }
@@ -6361,7 +6355,7 @@ function generateSchemasFromResolvedType(options, skipNamedDeclaration = false,
 function generateSchemasFromDeclaration(options) {
   const filePath = options.declaration.getSourceFile().fileName;
   const resolved = resolveStaticOptions(options);
-  if (ts8.isClassDeclaration(options.declaration)) {
+  if (ts10.isClassDeclaration(options.declaration)) {
     return generateSchemasFromAnalysis(
       analyzeClassToIR(
         options.declaration,
@@ -6375,7 +6369,7 @@ function generateSchemasFromDeclaration(options) {
       resolved
     );
   }
-  if (ts8.isInterfaceDeclaration(options.declaration)) {
+  if (ts10.isInterfaceDeclaration(options.declaration)) {
     return generateSchemasFromAnalysis(
       analyzeInterfaceToIR(
         options.declaration,
@@ -6389,7 +6383,7 @@ function generateSchemasFromDeclaration(options) {
       resolved
     );
   }
-  if (ts8.isTypeAliasDeclaration(options.declaration)) {
+  if (ts10.isTypeAliasDeclaration(options.declaration)) {
     const analyzedAlias = analyzeTypeAliasToIR(
       options.declaration,
       options.context.checker,
@@ -6448,7 +6442,7 @@ function generateSchemasFromReturnType(options) {
   const returnType = signature !== void 0 ? options.context.checker.getReturnTypeOfSignature(signature) : options.context.checker.getTypeAtLocation(options.declaration);
   const type = unwrapPromiseType(options.context.checker, returnType);
   const sourceNode = type !== returnType ? unwrapPromiseTypeNode(options.declaration.type) ?? options.declaration.type ?? options.declaration : options.declaration.type ?? options.declaration;
-  const fallbackName = options.declaration.name !== void 0 && ts8.isIdentifier(options.declaration.name) ? `${options.declaration.name.text}ReturnType` : "ReturnType";
+  const fallbackName = options.declaration.name !== void 0 && ts10.isIdentifier(options.declaration.name) ? `${options.declaration.name.text}ReturnType` : "ReturnType";
   return generateSchemasFromResolvedType({
     ...options,
     type,
@@ -6495,14 +6489,14 @@ function unwrapPromiseTypeNode(typeNode) {
   if (typeNode === void 0) {
     return void 0;
   }
-  if (ts8.isParenthesizedTypeNode(typeNode)) {
+  if (ts10.isParenthesizedTypeNode(typeNode)) {
     const unwrapped = unwrapPromiseTypeNode(typeNode.type);
     return unwrapped ?? typeNode;
   }
   return isPromiseTypeReferenceNode(typeNode) ? typeNode.typeArguments[0] : typeNode;
 }
 function isPromiseTypeReferenceNode(typeNode) {
-  return ts8.isTypeReferenceNode(typeNode) && ts8.isIdentifier(typeNode.typeName) && typeNode.typeName.text === "Promise" && typeNode.typeArguments !== void 0 && typeNode.typeArguments.length > 0;
+  return ts10.isTypeReferenceNode(typeNode) && ts10.isIdentifier(typeNode.typeName) && typeNode.typeName.text === "Promise" && typeNode.typeArguments !== void 0 && typeNode.typeArguments.length > 0;
 }
 
 // src/generators/mixed-authoring.ts