npm - @formspec/build - Versions diffs - 0.1.0-alpha.49 → 0.1.0-alpha.50 - Mend

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

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 (20) hide show

package/dist/analyzer/class-analyzer.d.ts.map +1 -1
package/dist/analyzer/tsdoc-parser.d.ts.map +1 -1
package/dist/cli.cjs +381 -374
package/dist/cli.cjs.map +1 -1
package/dist/cli.js +339 -334
package/dist/cli.js.map +1 -1
package/dist/extensions/resolve-custom-type.d.ts +37 -0
package/dist/extensions/resolve-custom-type.d.ts.map +1 -0
package/dist/extensions/symbol-registry.d.ts.map +1 -1
package/dist/extensions/ts-type-utils.d.ts +40 -0
package/dist/extensions/ts-type-utils.d.ts.map +1 -0
package/dist/index.cjs +359 -365
package/dist/index.cjs.map +1 -1
package/dist/index.js +328 -334
package/dist/index.js.map +1 -1
package/dist/internals.cjs +332 -333
package/dist/internals.cjs.map +1 -1
package/dist/internals.js +297 -298
package/dist/internals.js.map +1 -1
package/package.json +2 -2

package/dist/cli.cjs CHANGED Viewed

@@ -2292,6 +2292,134 @@ var init_schema2 = __esm({
   }
 });
+// src/extensions/ts-type-utils.ts
+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);
+}
+var ts;
+var init_ts_type_utils = __esm({
+  "src/extensions/ts-type-utils.ts"() {
+    "use strict";
+    ts = __toESM(require("typescript"), 1);
+  }
+});
+// 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 = (0, import_internal2.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}`;
+}
+var ts2, import_internal2;
+var init_resolve_custom_type = __esm({
+  "src/extensions/resolve-custom-type.ts"() {
+    "use strict";
+    ts2 = __toESM(require("typescript"), 1);
+    import_internal2 = require("@formspec/analysis/internal");
+    init_ts_type_utils();
+  }
+});
 // src/analyzer/tsdoc-parser.ts
 function sharedTagValueOptions(options) {
   return {
@@ -2312,23 +2440,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);
     }
   }
@@ -2336,13 +2464,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;
@@ -2356,11 +2484,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;
@@ -2371,9 +2499,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;
@@ -2405,7 +2533,7 @@ function processConstraintTag(tagName, text, parsedTag, provenance, node, source
     pushUniqueCompilerDiagnostics(diagnostics, compilerDiagnostics);
     return;
   }
-  const constraintNode = (0, import_internal2.parseConstraintTagValue)(
+  const constraintNode = (0, import_internal3.parseConstraintTagValue)(
     tagName,
     text,
     provenance,
@@ -2455,12 +2583,12 @@ function supportsConstraintCapability(type, checker, capability) {
   if (capability === void 0) {
     return true;
   }
-  if ((0, import_internal2.hasTypeSemanticCapability)(type, checker, capability)) {
+  if ((0, import_internal3.hasTypeSemanticCapability)(type, checker, capability)) {
     return true;
   }
   if (capability === "string-like") {
     const itemType = getArrayElementType(type, checker);
-    return itemType !== null && (0, import_internal2.hasTypeSemanticCapability)(itemType, checker, capability);
+    return itemType !== null && (0, import_internal3.hasTypeSemanticCapability)(itemType, checker, capability);
   }
   return false;
 }
@@ -2469,7 +2597,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];
@@ -2485,10 +2613,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;
     }
   }
@@ -2504,7 +2632,7 @@ function collectObjectSubfieldCandidates(type, checker, capability) {
     if (isCallableType(stripped)) {
       return;
     }
-    if (!(0, import_internal2.hasTypeSemanticCapability)(stripped, checker, "object-like")) {
+    if (!(0, import_internal3.hasTypeSemanticCapability)(stripped, checker, "object-like")) {
       return;
     }
     for (const property of stripped.getProperties()) {
@@ -2522,7 +2650,7 @@ function collectObjectSubfieldCandidates(type, checker, capability) {
         continue;
       }
       const strippedPropertyType = stripHintNullishUnion(propertyType);
-      if (!isCallableType(strippedPropertyType) && (0, import_internal2.hasTypeSemanticCapability)(strippedPropertyType, checker, "object-like")) {
+      if (!isCallableType(strippedPropertyType) && (0, import_internal3.hasTypeSemanticCapability)(strippedPropertyType, checker, "object-like")) {
         visit(strippedPropertyType, path5, depth + 1);
       }
     }
@@ -2531,7 +2659,7 @@ function collectObjectSubfieldCandidates(type, checker, capability) {
   return out;
 }
 function buildPathTargetHint(subjectType, checker, capability, tagName, argumentText) {
-  if (!(0, import_internal2.hasTypeSemanticCapability)(subjectType, checker, "object-like")) {
+  if (!(0, import_internal3.hasTypeSemanticCapability)(subjectType, checker, "object-like")) {
     return null;
   }
   const candidates = collectObjectSubfieldCandidates(subjectType, checker, capability);
@@ -2642,11 +2770,11 @@ function buildCompilerBackedConstraintDiagnostics(node, sourceFile, tagName, par
   if (checker === void 0 || subjectType === void 0) {
     return [];
   }
-  const placement = (0, import_internal2.resolveDeclarationPlacement)(node);
+  const placement = (0, import_internal3.resolveDeclarationPlacement)(node);
   if (placement === null) {
     return [];
   }
-  const definition = (0, import_internal2.getTagDefinition)(tagName, options?.extensionRegistry?.extensions);
+  const definition = (0, import_internal3.getTagDefinition)(tagName, options?.extensionRegistry?.extensions);
   if (definition === null) {
     return [];
   }
@@ -2660,7 +2788,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 [
@@ -2680,7 +2809,7 @@ function buildCompilerBackedConstraintDiagnostics(node, sourceFile, tagName, par
         )
       ];
     }
-    const resolution = (0, import_internal2.resolvePathTargetType)(subjectType, checker, target.path.segments);
+    const resolution = (0, import_internal3.resolvePathTargetType)(subjectType, checker, target.path.segments);
     if (resolution.kind === "missing-property") {
       return [
         makeDiagnostic(
@@ -2700,29 +2829,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",
@@ -2745,7 +2875,7 @@ function buildCompilerBackedConstraintDiagnostics(node, sourceFile, tagName, par
   const subjectTypeText = checker.typeToString(subjectType, node, SYNTHETIC_TYPE_FORMAT_FLAGS);
   const hostType = options?.hostType ?? subjectType;
   const hostTypeText = checker.typeToString(hostType, node, SYNTHETIC_TYPE_FORMAT_FLAGS);
-  const result = (0, import_internal2.checkSyntheticTagApplication)({
+  const result = (0, import_internal3.checkSyntheticTagApplication)({
     tagName,
     placement,
     hostType: hostTypeText,
@@ -2795,10 +2925,10 @@ function buildCompilerBackedConstraintDiagnostics(node, sourceFile, tagName, par
 function getExtensionTagNames(options) {
   return [
     ...options?.extensionRegistry?.extensions.flatMap(
-      (extension) => (extension.constraintTags ?? []).map((tag) => (0, import_internal2.normalizeFormSpecTagName)(tag.tagName))
+      (extension) => (extension.constraintTags ?? []).map((tag) => (0, import_internal3.normalizeFormSpecTagName)(tag.tagName))
     ) ?? [],
     ...options?.extensionRegistry?.extensions.flatMap(
-      (extension) => (extension.metadataSlots ?? []).map((slot) => (0, import_internal2.normalizeFormSpecTagName)(slot.tagName))
+      (extension) => (extension.metadataSlots ?? []).map((slot) => (0, import_internal3.normalizeFormSpecTagName)(slot.tagName))
     ) ?? []
   ].sort();
 }
@@ -2810,9 +2940,9 @@ function getExtensionRegistryCacheKey(registry) {
     (extension) => JSON.stringify({
       extensionId: extension.extensionId,
       typeNames: extension.types?.map((type) => type.typeName) ?? [],
-      constraintTags: extension.constraintTags?.map((tag) => (0, import_internal2.normalizeFormSpecTagName)(tag.tagName)) ?? [],
+      constraintTags: extension.constraintTags?.map((tag) => (0, import_internal3.normalizeFormSpecTagName)(tag.tagName)) ?? [],
       metadataSlots: extension.metadataSlots?.map((slot) => ({
-        tagName: (0, import_internal2.normalizeFormSpecTagName)(slot.tagName),
+        tagName: (0, import_internal3.normalizeFormSpecTagName)(slot.tagName),
         declarationKinds: [...slot.declarationKinds].sort(),
         allowBare: slot.allowBare !== false,
         qualifiers: (slot.qualifiers ?? []).map((qualifier) => ({
@@ -2855,12 +2985,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);
@@ -2868,7 +2998,7 @@ function parseTSDocTags(node, file = "", options) {
         continue;
       }
       const extensions = options?.extensionRegistry?.extensions;
-      const unified = (0, import_internal2.parseUnifiedComment)(commentText, {
+      const unified = (0, import_internal3.parseUnifiedComment)(commentText, {
         offset: range.pos,
         extensionTagNames,
         ...extensions !== void 0 ? { extensions } : {}
@@ -2903,13 +3033,13 @@ function parseTSDocTags(node, file = "", options) {
           }
           continue;
         }
-        if (import_internal2.TAGS_REQUIRING_RAW_TEXT.has(tagName)) {
+        if (import_internal3.TAGS_REQUIRING_RAW_TEXT.has(tagName)) {
           const fallback = rawTextFallbacks.get(tagName)?.shift();
-          const text2 = (0, import_internal2.choosePreferredPayloadText)(tag.resolvedPayloadText, fallback?.text ?? "");
+          const text2 = (0, import_internal3.choosePreferredPayloadText)(tag.resolvedPayloadText, fallback?.text ?? "");
           if (text2 === "") continue;
           const provenance2 = provenanceForParsedTag(tag, sourceFile, file);
           if (tagName === "defaultValue") {
-            annotations.push((0, import_internal2.parseDefaultValueTagValue)(text2, provenance2));
+            annotations.push((0, import_internal3.parseDefaultValueTagValue)(text2, provenance2));
             continue;
           }
           processConstraintTag(
@@ -2991,7 +3121,7 @@ function parseTSDocTags(node, file = "", options) {
       if (text === "") continue;
       const provenance = fallback.provenance;
       if (tagName === "defaultValue") {
-        annotations.push((0, import_internal2.parseDefaultValueTagValue)(text, provenance));
+        annotations.push((0, import_internal3.parseDefaultValueTagValue)(text, provenance));
         continue;
       }
       processConstraintTag(
@@ -3017,13 +3147,13 @@ 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 = (0, import_internal2.parseUnifiedComment)(commentText);
+      const unified = (0, import_internal3.parseUnifiedComment)(commentText);
       for (const tag of unified.tags) {
         if (tag.normalizedTagName !== "displayName") {
           continue;
@@ -3045,9 +3175,9 @@ 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 = (0, import_internals4.normalizeConstraintTagName)(tag.tagName.text);
-    if (!import_internal2.TAGS_REQUIRING_RAW_TEXT.has(tagName)) continue;
+    if (!import_internal3.TAGS_REQUIRING_RAW_TEXT.has(tagName)) continue;
     const commentText = getTagCommentText(tag)?.trim() ?? "";
     if (commentText === "") continue;
     const entries = fallbacks.get(tagName) ?? [];
@@ -3060,7 +3190,7 @@ function collectRawTextFallbacks(node, file) {
   return fallbacks;
 }
 function isMemberTargetDisplayName(text) {
-  return (0, import_internal2.parseTagSyntax)("displayName", text).target !== null;
+  return (0, import_internal3.parseTagSyntax)("displayName", text).target !== null;
 }
 function provenanceForComment(range, sourceFile, file, tagName) {
   const { line, character } = sourceFile.getLineAndCharacterOfPosition(range.pos);
@@ -3100,17 +3230,18 @@ function getTagCommentText(tag) {
   if (typeof tag.comment === "string") {
     return tag.comment;
   }
-  return ts.getTextOfJSDocComment(tag.comment);
+  return ts3.getTextOfJSDocComment(tag.comment);
 }
-var ts, import_internal2, import_internals4, import_internals5, SYNTHETIC_TYPE_FORMAT_FLAGS, MAX_HINT_CANDIDATES, MAX_HINT_DEPTH, parseResultCache;
+var ts3, import_internal3, import_internals4, import_internals5, SYNTHETIC_TYPE_FORMAT_FLAGS, MAX_HINT_CANDIDATES, MAX_HINT_DEPTH, parseResultCache;
 var init_tsdoc_parser = __esm({
   "src/analyzer/tsdoc-parser.ts"() {
     "use strict";
-    ts = __toESM(require("typescript"), 1);
-    import_internal2 = require("@formspec/analysis/internal");
+    ts3 = __toESM(require("typescript"), 1);
+    import_internal3 = require("@formspec/analysis/internal");
     import_internals4 = require("@formspec/core/internals");
     import_internals5 = require("@formspec/core/internals");
-    SYNTHETIC_TYPE_FORMAT_FLAGS = ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope;
+    init_resolve_custom_type();
+    SYNTHETIC_TYPE_FORMAT_FLAGS = ts3.TypeFormatFlags.NoTruncation | ts3.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope;
     MAX_HINT_CANDIDATES = 5;
     MAX_HINT_DEPTH = 3;
     parseResultCache = /* @__PURE__ */ new Map();
@@ -3132,18 +3263,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);
     }
   }
@@ -3162,104 +3293,49 @@ function extractDefaultValueAnnotation(initializer, file = "") {
     }
   };
 }
-var ts2;
+var ts4;
 var init_jsdoc_constraints = __esm({
   "src/analyzer/jsdoc-constraints.ts"() {
     "use strict";
-    ts2 = __toESM(require("typescript"), 1);
+    ts4 = __toESM(require("typescript"), 1);
     init_tsdoc_parser();
   }
 });
 // 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);
 }
 function makeParseOptions(extensionRegistry, fieldType, checker, subjectType, hostType) {
   if (extensionRegistry === void 0 && fieldType === void 0 && checker === void 0 && subjectType === void 0 && hostType === void 0) {
@@ -3281,7 +3357,7 @@ function createAnalyzerMetadataPolicy(input, discriminator) {
   };
 }
 function resolveNodeMetadata(metadataPolicy, declarationKind, logicalName, node, checker, extensionRegistry, buildContext) {
-  const analysis = (0, import_internal3.analyzeMetadataForNodeWithChecker)({
+  const analysis = (0, import_internal4.analyzeMetadataForNodeWithChecker)({
     checker,
     node,
     logicalName,
@@ -3319,7 +3395,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,
@@ -3367,7 +3443,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,
@@ -3383,10 +3459,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 {
@@ -3449,7 +3525,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,
@@ -3507,7 +3583,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",
@@ -3542,7 +3618,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,
@@ -3609,20 +3685,20 @@ 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);
     if (!commentText.startsWith("/**")) {
       continue;
     }
-    parsedTags.push(...(0, import_internal3.parseCommentBlock)(commentText, { offset: range.pos }).tags);
+    parsedTags.push(...(0, import_internal4.parseCommentBlock)(commentText, { offset: range.pos }).tags);
   }
   return parsedTags;
 }
@@ -3633,19 +3709,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));
@@ -3655,7 +3731,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()) {
@@ -3668,13 +3744,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);
@@ -3837,7 +3913,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(
@@ -3886,13 +3962,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,
@@ -3920,7 +3996,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(
@@ -3965,7 +4041,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";
@@ -4020,11 +4096,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 [];
@@ -4079,7 +4155,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;
@@ -4206,7 +4282,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);
@@ -4222,7 +4298,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;
@@ -4289,74 +4365,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,
@@ -4374,25 +4396,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()) {
@@ -4479,10 +4501,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;
   }
@@ -4532,14 +4554,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);
@@ -4547,10 +4569,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(
@@ -4568,19 +4590,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(
@@ -4607,13 +4629,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) {
@@ -4656,7 +4678,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 ? {
@@ -4748,7 +4770,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;
   }
@@ -4796,10 +4818,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;
     }
   }
@@ -4925,7 +4947,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,
@@ -4938,7 +4960,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,
@@ -4948,7 +4970,7 @@ function resolveObjectType(type, checker, file, typeRegistry, visiting, sourceNo
       type,
       metadataPolicy,
       extensionRegistry
-    ) : ts3.isPropertyDeclaration(declaration) ? analyzeFieldToIR(
+    ) : ts5.isPropertyDeclaration(declaration) ? analyzeFieldToIR(
       declaration,
       checker,
       file,
@@ -4976,7 +4998,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,
@@ -5024,12 +5046,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,
@@ -5053,7 +5075,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,
@@ -5067,7 +5089,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(
@@ -5091,10 +5113,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;
@@ -5105,13 +5127,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);
@@ -5122,15 +5144,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,
@@ -5155,17 +5177,16 @@ function buildFieldNodeInfoMap(members, checker, file, typeRegistry, visiting, m
   return map;
 }
 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,
@@ -5186,18 +5207,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());
@@ -5221,14 +5230,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;
     }
@@ -5239,24 +5248,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);
     }
@@ -5267,7 +5276,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);
@@ -5276,27 +5285,29 @@ 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;
 }
-var ts3, import_internal3, RESOLVING_TYPE_PLACEHOLDER, MAX_ALIAS_CHAIN_DEPTH;
+var ts5, import_internal4, RESOLVING_TYPE_PLACEHOLDER, MAX_ALIAS_CHAIN_DEPTH;
 var init_class_analyzer = __esm({
   "src/analyzer/class-analyzer.ts"() {
     "use strict";
-    ts3 = __toESM(require("typescript"), 1);
-    import_internal3 = require("@formspec/analysis/internal");
+    ts5 = __toESM(require("typescript"), 1);
+    import_internal4 = require("@formspec/analysis/internal");
     init_jsdoc_constraints();
     init_tsdoc_parser();
+    init_resolve_custom_type();
+    init_ts_type_utils();
     init_metadata();
     RESOLVING_TYPE_PLACEHOLDER = {
       kind: "object",
@@ -5323,23 +5334,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;
@@ -5347,9 +5358,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
@@ -5357,7 +5368,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}`);
@@ -5376,19 +5387,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") {
@@ -5428,22 +5439,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);
@@ -5453,13 +5464,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();
@@ -5658,11 +5669,11 @@ function makeFileProvenance(filePath) {
     column: 0
   };
 }
-var ts4, path;
+var ts6, path;
 var init_program = __esm({
   "src/analyzer/program.ts"() {
     "use strict";
-    ts4 = __toESM(require("typescript"), 1);
+    ts6 = __toESM(require("typescript"), 1);
     path = __toESM(require("path"), 1);
     init_class_analyzer();
   }
@@ -5677,10 +5688,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];
@@ -5688,7 +5699,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;
     }
@@ -5717,7 +5728,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, "/");
@@ -5725,29 +5736,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);
     }
   }
@@ -5756,24 +5762,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;
@@ -5791,18 +5797,19 @@ function findRegistrationByTypeName(registry, typeName) {
   }
   return void 0;
 }
-var ts5, path2;
+var ts7, path2;
 var init_symbol_registry = __esm({
   "src/extensions/symbol-registry.ts"() {
     "use strict";
-    ts5 = __toESM(require("typescript"), 1);
+    ts7 = __toESM(require("typescript"), 1);
     path2 = __toESM(require("path"), 1);
+    init_ts_type_utils();
   }
 });
 // src/validate/constraint-validator.ts
 function validateFieldNode(ctx, field) {
-  const analysis = (0, import_internal4.analyzeConstraintTargets)(
+  const analysis = (0, import_internal5.analyzeConstraintTargets)(
     field.name,
     field.type,
     field.constraints,
@@ -5820,7 +5827,7 @@ function validateFieldNode(ctx, field) {
 }
 function validateObjectProperty(ctx, parentName, property) {
   const qualifiedName = `${parentName}.${property.name}`;
-  const analysis = (0, import_internal4.analyzeConstraintTargets)(
+  const analysis = (0, import_internal5.analyzeConstraintTargets)(
     qualifiedName,
     property.type,
     property.constraints,
@@ -5871,11 +5878,11 @@ function validateIR(ir, options) {
     valid: ctx.diagnostics.every((diagnostic) => diagnostic.severity !== "error")
   };
 }
-var import_internal4;
+var import_internal5;
 var init_constraint_validator = __esm({
   "src/validate/constraint-validator.ts"() {
     "use strict";
-    import_internal4 = require("@formspec/analysis/internal");
+    import_internal5 = require("@formspec/analysis/internal");
   }
 });
@@ -6057,7 +6064,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;
@@ -6211,11 +6218,11 @@ function createProgramContextFailureDiagnostic(filePath, error) {
     relatedLocations: []
   };
 }
-var ts6;
+var ts8;
 var init_class_schema = __esm({
   "src/generators/class-schema.ts"() {
     "use strict";
-    ts6 = __toESM(require("typescript"), 1);
+    ts8 = __toESM(require("typescript"), 1);
     init_program();
     init_class_analyzer();
     init_canonicalize();
@@ -6242,7 +6249,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);
@@ -6253,16 +6260,16 @@ 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;
 }
-var ts7;
+var ts9;
 var init_static_build = __esm({
   "src/static-build.ts"() {
     "use strict";
-    ts7 = __toESM(require("typescript"), 1);
+    ts9 = __toESM(require("typescript"), 1);
     init_program();
   }
 });
@@ -6275,17 +6282,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;
@@ -6298,13 +6305,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;
     }
   }
@@ -6526,7 +6533,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,
@@ -6540,7 +6547,7 @@ function generateSchemasFromDeclaration(options) {
       resolved
     );
   }
-  if (ts8.isInterfaceDeclaration(options.declaration)) {
+  if (ts10.isInterfaceDeclaration(options.declaration)) {
     return generateSchemasFromAnalysis(
       analyzeInterfaceToIR(
         options.declaration,
@@ -6554,7 +6561,7 @@ function generateSchemasFromDeclaration(options) {
       resolved
     );
   }
-  if (ts8.isTypeAliasDeclaration(options.declaration)) {
+  if (ts10.isTypeAliasDeclaration(options.declaration)) {
     const analyzedAlias = analyzeTypeAliasToIR(
       options.declaration,
       options.context.checker,
@@ -6613,7 +6620,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,
@@ -6623,7 +6630,7 @@ function generateSchemasFromReturnType(options) {
 }
 function resolveDeclarationMetadata(options) {
   const resolved = resolveStaticOptions(options);
-  const analysis = (0, import_internal5.analyzeMetadataForNodeWithChecker)({
+  const analysis = (0, import_internal6.analyzeMetadataForNodeWithChecker)({
     checker: options.context.checker,
     node: options.declaration,
     metadata: resolved.metadata,
@@ -6660,21 +6667,21 @@ 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;
 }
-var ts8, import_internal5, import_internals6;
+var ts10, import_internal6, import_internals6;
 var init_discovered_schema = __esm({
   "src/generators/discovered-schema.ts"() {
     "use strict";
-    ts8 = __toESM(require("typescript"), 1);
-    import_internal5 = require("@formspec/analysis/internal");
+    ts10 = __toESM(require("typescript"), 1);
+    import_internal6 = require("@formspec/analysis/internal");
     init_class_analyzer();
     init_class_schema();
     init_ir_generator();