@formspec/build 0.1.0-alpha.19 → 0.1.0-alpha.20

package/dist/cli.js

@@ -1289,22 +1289,21 @@ var init_schema2 = __esm({
   }
 });
 
-// src/analyzer/json-utils.ts
-function tryParseJson(text) {
-  try {
-    return JSON.parse(text);
-  } catch {
-    return null;
-  }
-}
-var init_json_utils = __esm({
-  "src/analyzer/json-utils.ts"() {
-    "use strict";
-  }
-});
-
 // src/analyzer/tsdoc-parser.ts
 import * as ts from "typescript";
+import {
+  checkSyntheticTagApplication,
+  extractPathTarget as extractSharedPathTarget,
+  getTagDefinition,
+  hasTypeSemanticCapability,
+  parseConstraintTagValue,
+  parseDefaultValueTagValue,
+  resolveDeclarationPlacement,
+  resolvePathTargetType,
+  sliceCommentSpan,
+  parseCommentBlock,
+  parseTagSyntax
+} from "@formspec/analysis";
 import {
   TSDocParser,
   TSDocConfiguration,
@@ -1350,6 +1349,291 @@ function createFormSpecTSDocConfig(extensionTagNames = []) {
   }
   return config;
 }
+function sharedCommentSyntaxOptions(options, offset) {
+  const extensions = options?.extensionRegistry?.extensions;
+  return {
+    ...offset !== void 0 ? { offset } : {},
+    ...extensions !== void 0 ? { extensions } : {}
+  };
+}
+function sharedTagValueOptions(options) {
+  return {
+    ...options?.extensionRegistry !== void 0 ? { registry: options.extensionRegistry } : {},
+    ...options?.fieldType !== void 0 ? { fieldType: options.fieldType } : {}
+  };
+}
+function buildSupportingDeclarations(sourceFile) {
+  return sourceFile.statements.filter(
+    (statement) => !ts.isImportDeclaration(statement) && !ts.isImportEqualsDeclaration(statement) && !(ts.isExportDeclaration(statement) && statement.moduleSpecifier !== void 0)
+  ).map((statement) => statement.getText(sourceFile));
+}
+function renderSyntheticArgumentExpression(valueKind, argumentText) {
+  const trimmed = argumentText.trim();
+  if (trimmed === "") {
+    return null;
+  }
+  switch (valueKind) {
+    case "number":
+    case "integer":
+    case "signedInteger":
+      return Number.isFinite(Number(trimmed)) ? trimmed : JSON.stringify(trimmed);
+    case "string":
+      return JSON.stringify(argumentText);
+    case "json":
+      try {
+        JSON.parse(trimmed);
+        return `(${trimmed})`;
+      } catch {
+        return JSON.stringify(trimmed);
+      }
+    case "boolean":
+      return trimmed === "true" || trimmed === "false" ? trimmed : JSON.stringify(trimmed);
+    case "condition":
+      return "undefined as unknown as FormSpecCondition";
+    case null:
+      return null;
+    default: {
+      return String(valueKind);
+    }
+  }
+}
+function getArrayElementType(type, checker) {
+  if (!checker.isArrayType(type)) {
+    return null;
+  }
+  return checker.getTypeArguments(type)[0] ?? null;
+}
+function supportsConstraintCapability(type, checker, capability) {
+  if (capability === void 0) {
+    return true;
+  }
+  if (hasTypeSemanticCapability(type, checker, capability)) {
+    return true;
+  }
+  if (capability === "string-like") {
+    const itemType = getArrayElementType(type, checker);
+    return itemType !== null && hasTypeSemanticCapability(itemType, checker, capability);
+  }
+  return false;
+}
+function makeDiagnostic(code, message, provenance) {
+  return {
+    code,
+    message,
+    severity: "error",
+    primaryLocation: provenance,
+    relatedLocations: []
+  };
+}
+function placementLabel(placement) {
+  switch (placement) {
+    case "class":
+      return "class declarations";
+    case "class-field":
+      return "class fields";
+    case "class-method":
+      return "class methods";
+    case "interface":
+      return "interface declarations";
+    case "interface-field":
+      return "interface fields";
+    case "type-alias":
+      return "type aliases";
+    case "type-alias-field":
+      return "type-alias properties";
+    case "variable":
+      return "variables";
+    case "function":
+      return "functions";
+    case "function-parameter":
+      return "function parameters";
+    case "method-parameter":
+      return "method parameters";
+    default: {
+      const exhaustive = placement;
+      return String(exhaustive);
+    }
+  }
+}
+function capabilityLabel(capability) {
+  switch (capability) {
+    case "numeric-comparable":
+      return "number";
+    case "string-like":
+      return "string";
+    case "array-like":
+      return "array";
+    case "enum-member-addressable":
+      return "enum";
+    case "json-like":
+      return "JSON-compatible";
+    case "object-like":
+      return "object";
+    case "condition-like":
+      return "conditional";
+    case void 0:
+      return "compatible";
+    default:
+      return capability;
+  }
+}
+function getBroadenedCustomTypeId(fieldType) {
+  if (fieldType?.kind === "custom") {
+    return fieldType.typeId;
+  }
+  if (fieldType?.kind !== "union") {
+    return void 0;
+  }
+  const customMembers = fieldType.members.filter(
+    (member) => member.kind === "custom"
+  );
+  if (customMembers.length !== 1) {
+    return void 0;
+  }
+  const nonCustomMembers = fieldType.members.filter((member) => member.kind !== "custom");
+  const allOtherMembersAreNull = nonCustomMembers.every(
+    (member) => member.kind === "primitive" && member.primitiveKind === "null"
+  );
+  const customMember = customMembers[0];
+  return allOtherMembersAreNull && customMember !== void 0 ? customMember.typeId : void 0;
+}
+function hasBuiltinConstraintBroadening(tagName, options) {
+  const broadenedTypeId = getBroadenedCustomTypeId(options?.fieldType);
+  return broadenedTypeId !== void 0 && options?.extensionRegistry?.findBuiltinConstraintBroadening(broadenedTypeId, tagName) !== void 0;
+}
+function buildCompilerBackedConstraintDiagnostics(node, sourceFile, tagName, parsedTag, provenance, supportingDeclarations, options) {
+  if (!isBuiltinConstraintName(tagName)) {
+    return [];
+  }
+  const checker = options?.checker;
+  const subjectType = options?.subjectType;
+  if (checker === void 0 || subjectType === void 0) {
+    return [];
+  }
+  const placement = resolveDeclarationPlacement(node);
+  if (placement === null) {
+    return [];
+  }
+  const definition = getTagDefinition(tagName, options?.extensionRegistry?.extensions);
+  if (definition === null) {
+    return [];
+  }
+  if (!definition.placements.includes(placement)) {
+    return [
+      makeDiagnostic(
+        "INVALID_TAG_PLACEMENT",
+        `Tag "@${tagName}" is not allowed on ${placementLabel(placement)}.`,
+        provenance
+      )
+    ];
+  }
+  const target = parsedTag?.target ?? null;
+  const hasBroadening = target === null && hasBuiltinConstraintBroadening(tagName, options);
+  if (target !== null) {
+    if (target.kind !== "path") {
+      return [
+        makeDiagnostic(
+          "UNSUPPORTED_TARGETING_SYNTAX",
+          `Tag "@${tagName}" does not support ${target.kind} targeting syntax.`,
+          provenance
+        )
+      ];
+    }
+    if (!target.valid || target.path === null) {
+      return [
+        makeDiagnostic(
+          "UNSUPPORTED_TARGETING_SYNTAX",
+          `Tag "@${tagName}" has invalid path targeting syntax.`,
+          provenance
+        )
+      ];
+    }
+    const resolution = resolvePathTargetType(subjectType, checker, target.path.segments);
+    if (resolution.kind === "missing-property") {
+      return [
+        makeDiagnostic(
+          "UNKNOWN_PATH_TARGET",
+          `Target "${target.rawText}": path-targeted constraint "${tagName}" references unknown path segment "${resolution.segment}"`,
+          provenance
+        )
+      ];
+    }
+    if (resolution.kind === "unresolvable") {
+      const actualType = checker.typeToString(resolution.type, node, SYNTHETIC_TYPE_FORMAT_FLAGS);
+      return [
+        makeDiagnostic(
+          "TYPE_MISMATCH",
+          `Target "${target.rawText}": path-targeted constraint "${tagName}" is invalid because type "${actualType}" cannot be traversed`,
+          provenance
+        )
+      ];
+    }
+    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
+        )
+      ];
+    }
+  } else 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);
+      return [
+        makeDiagnostic(
+          "TYPE_MISMATCH",
+          `Target "${node.getText(sourceFile)}": constraint "${tagName}" is only valid on ${capabilityLabel(requiredCapability)} targets, but field type is "${actualType}"`,
+          provenance
+        )
+      ];
+    }
+  }
+  const argumentExpression = renderSyntheticArgumentExpression(
+    definition.valueKind,
+    parsedTag?.argumentText ?? ""
+  );
+  if (definition.requiresArgument && argumentExpression === null) {
+    return [];
+  }
+  if (hasBroadening) {
+    return [];
+  }
+  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 = checkSyntheticTagApplication({
+    tagName,
+    placement,
+    hostType: hostTypeText,
+    subjectType: subjectTypeText,
+    ...target?.kind === "path" ? { target: { kind: "path", text: target.rawText } } : {},
+    ...argumentExpression !== null ? { argumentExpression } : {},
+    supportingDeclarations,
+    ...options?.extensionRegistry !== void 0 ? {
+      extensions: options.extensionRegistry.extensions.map((extension) => ({
+        extensionId: extension.extensionId,
+        ...extension.constraintTags !== void 0 ? {
+          constraintTags: extension.constraintTags.map((tag) => ({ tagName: tag.tagName }))
+        } : {}
+      }))
+    } : {}
+  });
+  if (result.diagnostics.length === 0) {
+    return [];
+  }
+  const expectedLabel = definition.valueKind === null ? "compatible argument" : capabilityLabel(definition.valueKind);
+  return [
+    makeDiagnostic(
+      "TYPE_MISMATCH",
+      `Tag "@${tagName}" received an invalid argument for ${expectedLabel}.`,
+      provenance
+    )
+  ];
+}
 function getParser(options) {
   const extensionTagNames = [
     ...options?.extensionRegistry?.extensions.flatMap(
@@ -1365,18 +1649,54 @@ function getParser(options) {
   parserCache.set(cacheKey, parser);
   return parser;
 }
+function getExtensionRegistryCacheKey(registry) {
+  if (registry === void 0) {
+    return "";
+  }
+  return registry.extensions.map(
+    (extension) => JSON.stringify({
+      extensionId: extension.extensionId,
+      typeNames: extension.types?.map((type) => type.typeName) ?? [],
+      constraintTags: extension.constraintTags?.map((tag) => tag.tagName) ?? []
+    })
+  ).join("|");
+}
+function getParseCacheKey(node, file, options) {
+  const sourceFile = node.getSourceFile();
+  const checker = options?.checker;
+  return JSON.stringify({
+    file,
+    sourceFile: sourceFile.fileName,
+    sourceText: sourceFile.text,
+    start: node.getFullStart(),
+    end: node.getEnd(),
+    fieldType: options?.fieldType ?? null,
+    subjectType: checker !== void 0 && options?.subjectType !== void 0 ? checker.typeToString(options.subjectType, node, SYNTHETIC_TYPE_FORMAT_FLAGS) : null,
+    hostType: checker !== void 0 && options?.hostType !== void 0 ? checker.typeToString(options.hostType, node, SYNTHETIC_TYPE_FORMAT_FLAGS) : null,
+    extensions: getExtensionRegistryCacheKey(options?.extensionRegistry)
+  });
+}
 function parseTSDocTags(node, file = "", options) {
+  const cacheKey = getParseCacheKey(node, file, options);
+  const cached = parseResultCache.get(cacheKey);
+  if (cached !== void 0) {
+    return cached;
+  }
   const constraints = [];
   const annotations = [];
+  const diagnostics = [];
   let displayName;
   let description;
   let placeholder;
   let displayNameProvenance;
   let descriptionProvenance;
   let placeholderProvenance;
+  const rawTextTags = [];
   const sourceFile = node.getSourceFile();
   const sourceText = sourceFile.getFullText();
+  const supportingDeclarations = buildSupportingDeclarations(sourceFile);
   const commentRanges = ts.getLeadingCommentRanges(sourceText, node.getFullStart());
+  const rawTextFallbacks = collectRawTextFallbacks(node, file);
   if (commentRanges) {
     for (const range of commentRanges) {
       if (range.kind !== ts.SyntaxKind.MultiLineCommentTrivia) {
@@ -1391,12 +1711,33 @@ function parseTSDocTags(node, file = "", options) {
         TextRange.fromStringRange(sourceText, range.pos, range.end)
       );
       const docComment = parserContext.docComment;
+      const parsedComment = parseCommentBlock(
+        commentText,
+        sharedCommentSyntaxOptions(options, range.pos)
+      );
+      let parsedTagCursor = 0;
+      const nextParsedTag = (normalizedTagName) => {
+        while (parsedTagCursor < parsedComment.tags.length) {
+          const candidate = parsedComment.tags[parsedTagCursor];
+          parsedTagCursor += 1;
+          if (candidate?.normalizedTagName === normalizedTagName) {
+            return candidate;
+          }
+        }
+        return null;
+      };
+      for (const parsedTag of parsedComment.tags) {
+        if (TAGS_REQUIRING_RAW_TEXT.has(parsedTag.normalizedTagName)) {
+          rawTextTags.push({ tag: parsedTag, commentText, commentOffset: range.pos });
+        }
+      }
       for (const block of docComment.customBlocks) {
         const tagName = normalizeConstraintTagName(block.blockTag.tagName.substring(1));
+        const parsedTag = nextParsedTag(tagName);
         if (tagName === "displayName" || tagName === "description" || tagName === "format" || tagName === "placeholder") {
-          const text2 = extractBlockText(block).trim();
+          const text2 = getBestBlockPayloadText(parsedTag, commentText, range.pos, block);
           if (text2 === "") continue;
-          const provenance2 = provenanceForComment(range, sourceFile, file, tagName);
+          const provenance2 = parsedTag !== null ? provenanceForParsedTag(parsedTag, sourceFile, file) : provenanceForComment(range, sourceFile, file, tagName);
           switch (tagName) {
             case "displayName":
               if (!isMemberTargetDisplayName(text2) && displayName === void 0) {
@@ -1426,11 +1767,29 @@ function parseTSDocTags(node, file = "", options) {
           continue;
         }
         if (TAGS_REQUIRING_RAW_TEXT.has(tagName)) continue;
-        const text = extractBlockText(block).trim();
+        const text = getBestBlockPayloadText(parsedTag, commentText, range.pos, block);
         const expectedType = isBuiltinConstraintName(tagName) ? BUILTIN_CONSTRAINT_DEFINITIONS[tagName] : void 0;
         if (text === "" && expectedType !== "boolean") continue;
-        const provenance = provenanceForComment(range, sourceFile, file, tagName);
-        const constraintNode = parseConstraintValue(tagName, text, provenance, options);
+        const provenance = parsedTag !== null ? provenanceForParsedTag(parsedTag, sourceFile, file) : provenanceForComment(range, sourceFile, file, tagName);
+        const compilerDiagnostics = buildCompilerBackedConstraintDiagnostics(
+          node,
+          sourceFile,
+          tagName,
+          parsedTag,
+          provenance,
+          supportingDeclarations,
+          options
+        );
+        if (compilerDiagnostics.length > 0) {
+          diagnostics.push(...compilerDiagnostics);
+          continue;
+        }
+        const constraintNode = parseConstraintTagValue(
+          tagName,
+          text,
+          provenance,
+          sharedTagValueOptions(options)
+        );
         if (constraintNode) {
           constraints.push(constraintNode);
         }
@@ -1484,57 +1843,114 @@ function parseTSDocTags(node, file = "", options) {
       provenance: placeholderProvenance
     });
   }
-  const jsDocTagsAll = ts.getJSDocTags(node);
-  for (const tag of jsDocTagsAll) {
-    const tagName = normalizeConstraintTagName(tag.tagName.text);
-    if (!TAGS_REQUIRING_RAW_TEXT.has(tagName)) continue;
-    const commentText = getTagCommentText(tag);
-    if (commentText === void 0 || commentText.trim() === "") continue;
-    const text = commentText.trim();
-    const provenance = provenanceForJSDocTag(tag, file);
-    if (tagName === "defaultValue") {
-      const defaultValueNode = parseDefaultValueValue(text, provenance);
-      annotations.push(defaultValueNode);
-      continue;
+  if (rawTextTags.length > 0) {
+    for (const rawTextTag of rawTextTags) {
+      const fallbackQueue = rawTextFallbacks.get(rawTextTag.tag.normalizedTagName);
+      const fallback = fallbackQueue?.shift();
+      const text = choosePreferredPayloadText(
+        getSharedPayloadText(rawTextTag.tag, rawTextTag.commentText, rawTextTag.commentOffset),
+        fallback?.text ?? ""
+      );
+      if (text === "") continue;
+      const provenance = provenanceForParsedTag(rawTextTag.tag, sourceFile, file);
+      if (rawTextTag.tag.normalizedTagName === "defaultValue") {
+        const defaultValueNode = parseDefaultValueTagValue(text, provenance);
+        annotations.push(defaultValueNode);
+        continue;
+      }
+      const compilerDiagnostics = buildCompilerBackedConstraintDiagnostics(
+        node,
+        sourceFile,
+        rawTextTag.tag.normalizedTagName,
+        rawTextTag.tag,
+        provenance,
+        supportingDeclarations,
+        options
+      );
+      if (compilerDiagnostics.length > 0) {
+        diagnostics.push(...compilerDiagnostics);
+        continue;
+      }
+      const constraintNode = parseConstraintTagValue(
+        rawTextTag.tag.normalizedTagName,
+        text,
+        provenance,
+        sharedTagValueOptions(options)
+      );
+      if (constraintNode) {
+        constraints.push(constraintNode);
+      }
     }
-    const constraintNode = parseConstraintValue(tagName, text, provenance, options);
-    if (constraintNode) {
-      constraints.push(constraintNode);
+  }
+  for (const [tagName, fallbacks] of rawTextFallbacks) {
+    for (const fallback of fallbacks) {
+      const text = fallback.text.trim();
+      if (text === "") continue;
+      const provenance = fallback.provenance;
+      if (tagName === "defaultValue") {
+        const defaultValueNode = parseDefaultValueTagValue(text, provenance);
+        annotations.push(defaultValueNode);
+        continue;
+      }
+      const compilerDiagnostics = buildCompilerBackedConstraintDiagnostics(
+        node,
+        sourceFile,
+        tagName,
+        null,
+        provenance,
+        supportingDeclarations,
+        options
+      );
+      if (compilerDiagnostics.length > 0) {
+        diagnostics.push(...compilerDiagnostics);
+        continue;
+      }
+      const constraintNode = parseConstraintTagValue(
+        tagName,
+        text,
+        provenance,
+        sharedTagValueOptions(options)
+      );
+      if (constraintNode) {
+        constraints.push(constraintNode);
+      }
     }
   }
-  return { constraints, annotations };
+  const result = { constraints, annotations, diagnostics };
+  parseResultCache.set(cacheKey, result);
+  return result;
 }
 function extractDisplayNameMetadata(node) {
   let displayName;
   const memberDisplayNames = /* @__PURE__ */ new Map();
-  for (const tag of ts.getJSDocTags(node)) {
-    const tagName = normalizeConstraintTagName(tag.tagName.text);
-    if (tagName !== "displayName") continue;
-    const commentText = getTagCommentText(tag);
-    if (commentText === void 0) continue;
-    const text = commentText.trim();
-    if (text === "") continue;
-    const memberTarget = parseMemberTargetDisplayName(text);
-    if (memberTarget) {
-      memberDisplayNames.set(memberTarget.target, memberTarget.label);
-      continue;
+  const sourceFile = node.getSourceFile();
+  const sourceText = sourceFile.getFullText();
+  const commentRanges = ts.getLeadingCommentRanges(sourceText, node.getFullStart());
+  if (commentRanges) {
+    for (const range of commentRanges) {
+      if (range.kind !== ts.SyntaxKind.MultiLineCommentTrivia) continue;
+      const commentText = sourceText.substring(range.pos, range.end);
+      if (!commentText.startsWith("/**")) continue;
+      const parsed = parseCommentBlock(commentText);
+      for (const tag of parsed.tags) {
+        if (tag.normalizedTagName !== "displayName") {
+          continue;
+        }
+        if (tag.target !== null && tag.argumentText !== "") {
+          memberDisplayNames.set(tag.target.rawText, tag.argumentText);
+          continue;
+        }
+        if (tag.argumentText !== "") {
+          displayName ??= tag.argumentText;
+        }
+      }
     }
-    displayName ??= text;
   }
   return {
     ...displayName !== void 0 && { displayName },
     memberDisplayNames
   };
 }
-function extractPathTarget(text) {
-  const trimmed = text.trimStart();
-  const match = /^:([a-zA-Z_]\w*)(?:\s+([\s\S]*))?$/.exec(trimmed);
-  if (!match?.[1]) return null;
-  return {
-    path: { segments: [match[1]] },
-    remainingText: match[2] ?? ""
-  };
-}
 function extractBlockText(block) {
   return extractPlainText(block.content);
 }
@@ -1553,281 +1969,111 @@ function extractPlainText(node) {
   }
   return result;
 }
-function parseConstraintValue(tagName, text, provenance, options) {
-  const customConstraint = parseExtensionConstraintValue(tagName, text, provenance, options);
-  if (customConstraint) {
-    return customConstraint;
-  }
-  if (!isBuiltinConstraintName(tagName)) {
-    return null;
+function choosePreferredPayloadText(primary, fallback) {
+  const preferred = primary.trim();
+  const alternate = fallback.trim();
+  if (preferred === "") return alternate;
+  if (alternate === "") return preferred;
+  if (alternate.includes("\n")) return alternate;
+  if (alternate.length > preferred.length && alternate.startsWith(preferred)) {
+    return alternate;
   }
-  const pathResult = extractPathTarget(text);
-  const effectiveText = pathResult ? pathResult.remainingText : text;
-  const path4 = pathResult?.path;
-  const expectedType = BUILTIN_CONSTRAINT_DEFINITIONS[tagName];
-  if (expectedType === "number") {
-    const value = Number(effectiveText);
-    if (Number.isNaN(value)) {
-      return null;
-    }
-    const numericKind = NUMERIC_CONSTRAINT_MAP[tagName];
-    if (numericKind) {
-      return {
-        kind: "constraint",
-        constraintKind: numericKind,
-        value,
-        ...path4 && { path: path4 },
-        provenance
-      };
-    }
-    const lengthKind = LENGTH_CONSTRAINT_MAP[tagName];
-    if (lengthKind) {
-      return {
-        kind: "constraint",
-        constraintKind: lengthKind,
-        value,
-        ...path4 && { path: path4 },
-        provenance
-      };
-    }
-    return null;
-  }
-  if (expectedType === "boolean") {
-    const trimmed = effectiveText.trim();
-    if (trimmed !== "" && trimmed !== "true") {
-      return null;
-    }
-    if (tagName === "uniqueItems") {
-      return {
-        kind: "constraint",
-        constraintKind: "uniqueItems",
-        value: true,
-        ...path4 && { path: path4 },
-        provenance
-      };
-    }
-    return null;
+  return preferred;
+}
+function getSharedPayloadText(tag, commentText, commentOffset) {
+  if (tag.payloadSpan === null) {
+    return "";
   }
-  if (expectedType === "json") {
-    if (tagName === "const") {
-      const trimmedText = effectiveText.trim();
-      if (trimmedText === "") return null;
-      try {
-        const parsed2 = JSON.parse(trimmedText);
-        return {
-          kind: "constraint",
-          constraintKind: "const",
-          value: parsed2,
-          ...path4 && { path: path4 },
-          provenance
-        };
-      } catch {
-        return {
-          kind: "constraint",
-          constraintKind: "const",
-          value: trimmedText,
-          ...path4 && { path: path4 },
-          provenance
-        };
-      }
-    }
-    const parsed = tryParseJson(effectiveText);
-    if (!Array.isArray(parsed)) {
-      return null;
-    }
-    const members = [];
-    for (const item of parsed) {
-      if (typeof item === "string" || typeof item === "number") {
-        members.push(item);
-      } else if (typeof item === "object" && item !== null && "id" in item) {
-        const id = item["id"];
-        if (typeof id === "string" || typeof id === "number") {
-          members.push(id);
-        }
-      }
-    }
-    return {
-      kind: "constraint",
-      constraintKind: "allowedMembers",
-      members,
-      ...path4 && { path: path4 },
-      provenance
-    };
+  return sliceCommentSpan(commentText, tag.payloadSpan, {
+    offset: commentOffset
+  }).trim();
+}
+function getBestBlockPayloadText(tag, commentText, commentOffset, block) {
+  const sharedText = tag === null ? "" : getSharedPayloadText(tag, commentText, commentOffset);
+  const blockText = extractBlockText(block).replace(/\s+/g, " ").trim();
+  return choosePreferredPayloadText(sharedText, blockText);
+}
+function collectRawTextFallbacks(node, file) {
+  const fallbacks = /* @__PURE__ */ new Map();
+  for (const tag of ts.getJSDocTags(node)) {
+    const tagName = normalizeConstraintTagName(tag.tagName.text);
+    if (!TAGS_REQUIRING_RAW_TEXT.has(tagName)) continue;
+    const commentText = getTagCommentText(tag)?.trim() ?? "";
+    if (commentText === "") continue;
+    const entries = fallbacks.get(tagName) ?? [];
+    entries.push({
+      text: commentText,
+      provenance: provenanceForJSDocTag(tag, file)
+    });
+    fallbacks.set(tagName, entries);
   }
+  return fallbacks;
+}
+function isMemberTargetDisplayName(text) {
+  return parseTagSyntax("displayName", text).target !== null;
+}
+function provenanceForComment(range, sourceFile, file, tagName) {
+  const { line, character } = sourceFile.getLineAndCharacterOfPosition(range.pos);
   return {
-    kind: "constraint",
-    constraintKind: "pattern",
-    pattern: effectiveText,
-    ...path4 && { path: path4 },
-    provenance
+    surface: "tsdoc",
+    file,
+    line: line + 1,
+    column: character,
+    tagName: "@" + tagName
   };
 }
-function parseExtensionConstraintValue(tagName, text, provenance, options) {
-  const pathResult = extractPathTarget(text);
-  const effectiveText = pathResult ? pathResult.remainingText : text;
-  const path4 = pathResult?.path;
-  const registry = options?.extensionRegistry;
-  if (registry === void 0) {
-    return null;
+function provenanceForParsedTag(tag, sourceFile, file) {
+  const { line, character } = sourceFile.getLineAndCharacterOfPosition(tag.tagNameSpan.start);
+  return {
+    surface: "tsdoc",
+    file,
+    line: line + 1,
+    column: character,
+    tagName: "@" + tag.normalizedTagName
+  };
+}
+function provenanceForJSDocTag(tag, file) {
+  const sourceFile = tag.getSourceFile();
+  const { line, character } = sourceFile.getLineAndCharacterOfPosition(tag.getStart());
+  return {
+    surface: "tsdoc",
+    file,
+    line: line + 1,
+    column: character,
+    tagName: "@" + tag.tagName.text
+  };
+}
+function getTagCommentText(tag) {
+  if (tag.comment === void 0) {
+    return void 0;
   }
-  const directTag = registry.findConstraintTag(tagName);
-  if (directTag !== void 0) {
-    return makeCustomConstraintNode(
-      directTag.extensionId,
-      directTag.registration.constraintName,
-      directTag.registration.parseValue(effectiveText),
-      provenance,
-      path4,
-      registry
-    );
-  }
-  if (!isBuiltinConstraintName(tagName)) {
-    return null;
-  }
-  const broadenedTypeId = getBroadenedCustomTypeId(options?.fieldType);
-  if (broadenedTypeId === void 0) {
-    return null;
-  }
-  const broadened = registry.findBuiltinConstraintBroadening(broadenedTypeId, tagName);
-  if (broadened === void 0) {
-    return null;
-  }
-  return makeCustomConstraintNode(
-    broadened.extensionId,
-    broadened.registration.constraintName,
-    broadened.registration.parseValue(effectiveText),
-    provenance,
-    path4,
-    registry
-  );
-}
-function getBroadenedCustomTypeId(fieldType) {
-  if (fieldType?.kind === "custom") {
-    return fieldType.typeId;
-  }
-  if (fieldType?.kind !== "union") {
-    return void 0;
-  }
-  const customMembers = fieldType.members.filter(
-    (member) => member.kind === "custom"
-  );
-  if (customMembers.length !== 1) {
-    return void 0;
-  }
-  const nonCustomMembers = fieldType.members.filter((member) => member.kind !== "custom");
-  const allOtherMembersAreNull = nonCustomMembers.every(
-    (member) => member.kind === "primitive" && member.primitiveKind === "null"
-  );
-  const customMember = customMembers[0];
-  return allOtherMembersAreNull && customMember !== void 0 ? customMember.typeId : void 0;
-}
-function makeCustomConstraintNode(extensionId, constraintName, payload, provenance, path4, registry) {
-  const constraintId = `${extensionId}/${constraintName}`;
-  const registration = registry.findConstraint(constraintId);
-  if (registration === void 0) {
-    throw new Error(
-      `Custom TSDoc tag resolved to unregistered constraint "${constraintId}". Register the constraint before using its tag.`
-    );
-  }
-  return {
-    kind: "constraint",
-    constraintKind: "custom",
-    constraintId,
-    payload,
-    compositionRule: registration.compositionRule,
-    ...path4 && { path: path4 },
-    provenance
-  };
-}
-function parseDefaultValueValue(text, provenance) {
-  const trimmed = text.trim();
-  let value;
-  if (trimmed === "null") {
-    value = null;
-  } else if (trimmed === "true") {
-    value = true;
-  } else if (trimmed === "false") {
-    value = false;
-  } else {
-    const parsed = tryParseJson(trimmed);
-    value = parsed !== null ? parsed : trimmed;
-  }
-  return {
-    kind: "annotation",
-    annotationKind: "defaultValue",
-    value,
-    provenance
-  };
-}
-function isMemberTargetDisplayName(text) {
-  return parseMemberTargetDisplayName(text) !== null;
-}
-function parseMemberTargetDisplayName(text) {
-  const match = /^:([^\s]+)\s+([\s\S]+)$/.exec(text);
-  if (!match?.[1] || !match[2]) return null;
-  return { target: match[1], label: match[2].trim() };
-}
-function provenanceForComment(range, sourceFile, file, tagName) {
-  const { line, character } = sourceFile.getLineAndCharacterOfPosition(range.pos);
-  return {
-    surface: "tsdoc",
-    file,
-    line: line + 1,
-    column: character,
-    tagName: "@" + tagName
-  };
-}
-function provenanceForJSDocTag(tag, file) {
-  const sourceFile = tag.getSourceFile();
-  const { line, character } = sourceFile.getLineAndCharacterOfPosition(tag.getStart());
-  return {
-    surface: "tsdoc",
-    file,
-    line: line + 1,
-    column: character,
-    tagName: "@" + tag.tagName.text
-  };
-}
-function getTagCommentText(tag) {
-  if (tag.comment === void 0) {
-    return void 0;
-  }
-  if (typeof tag.comment === "string") {
-    return tag.comment;
+  if (typeof tag.comment === "string") {
+    return tag.comment;
   }
   return ts.getTextOfJSDocComment(tag.comment);
 }
-var NUMERIC_CONSTRAINT_MAP, LENGTH_CONSTRAINT_MAP, TAGS_REQUIRING_RAW_TEXT, parserCache;
+var TAGS_REQUIRING_RAW_TEXT, SYNTHETIC_TYPE_FORMAT_FLAGS, parserCache, parseResultCache;
 var init_tsdoc_parser = __esm({
   "src/analyzer/tsdoc-parser.ts"() {
     "use strict";
-    init_json_utils();
-    NUMERIC_CONSTRAINT_MAP = {
-      minimum: "minimum",
-      maximum: "maximum",
-      exclusiveMinimum: "exclusiveMinimum",
-      exclusiveMaximum: "exclusiveMaximum",
-      multipleOf: "multipleOf"
-    };
-    LENGTH_CONSTRAINT_MAP = {
-      minLength: "minLength",
-      maxLength: "maxLength",
-      minItems: "minItems",
-      maxItems: "maxItems"
-    };
     TAGS_REQUIRING_RAW_TEXT = /* @__PURE__ */ new Set(["pattern", "enumOptions", "defaultValue"]);
+    SYNTHETIC_TYPE_FORMAT_FLAGS = ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope;
     parserCache = /* @__PURE__ */ new Map();
+    parseResultCache = /* @__PURE__ */ new Map();
   }
 });
 
 // src/analyzer/jsdoc-constraints.ts
 import * as ts2 from "typescript";
+function extractJSDocParseResult(node, file = "", options) {
+  return parseTSDocTags(node, file, options);
+}
 function extractJSDocConstraintNodes(node, file = "", options) {
-  const result = parseTSDocTags(node, file, options);
+  const result = extractJSDocParseResult(node, file, options);
   return [...result.constraints];
 }
 function extractJSDocAnnotationNodes(node, file = "", options) {
-  const result = parseTSDocTags(node, file, options);
+  const result = extractJSDocParseResult(node, file, options);
   return [...result.annotations];
 }
 function extractDefaultValueAnnotation(initializer, file = "") {
@@ -1878,13 +2124,16 @@ function isObjectType(type) {
 function isTypeReference(type) {
   return !!(type.flags & ts3.TypeFlags.Object) && !!(type.objectFlags & ts3.ObjectFlags.Reference);
 }
-function makeParseOptions(extensionRegistry, fieldType) {
-  if (extensionRegistry === void 0 && fieldType === void 0) {
+function makeParseOptions(extensionRegistry, fieldType, checker, subjectType, hostType) {
+  if (extensionRegistry === void 0 && fieldType === void 0 && checker === void 0 && subjectType === void 0 && hostType === void 0) {
     return void 0;
   }
   return {
     ...extensionRegistry !== void 0 && { extensionRegistry },
-    ...fieldType !== void 0 && { fieldType }
+    ...fieldType !== void 0 && { fieldType },
+    ...checker !== void 0 && { checker },
+    ...subjectType !== void 0 && { subjectType },
+    ...hostType !== void 0 && { hostType }
   };
 }
 function analyzeClassToIR(classDecl, checker, file = "", extensionRegistry) {
@@ -1892,11 +2141,15 @@ function analyzeClassToIR(classDecl, checker, file = "", extensionRegistry) {
   const fields = [];
   const fieldLayouts = [];
   const typeRegistry = {};
-  const annotations = extractJSDocAnnotationNodes(
+  const diagnostics = [];
+  const classType = checker.getTypeAtLocation(classDecl);
+  const classDoc = extractJSDocParseResult(
     classDecl,
     file,
-    makeParseOptions(extensionRegistry)
+    makeParseOptions(extensionRegistry, void 0, checker, classType, classType)
   );
+  const annotations = [...classDoc.annotations];
+  diagnostics.push(...classDoc.diagnostics);
   const visiting = /* @__PURE__ */ new Set();
   const instanceMethods = [];
   const staticMethods = [];
@@ -1908,6 +2161,8 @@ function analyzeClassToIR(classDecl, checker, file = "", extensionRegistry) {
         file,
         typeRegistry,
         visiting,
+        diagnostics,
+        classType,
         extensionRegistry
       );
       if (fieldNode) {
@@ -1932,6 +2187,7 @@ function analyzeClassToIR(classDecl, checker, file = "", extensionRegistry) {
     fieldLayouts,
     typeRegistry,
     ...annotations.length > 0 && { annotations },
+    ...diagnostics.length > 0 && { diagnostics },
     instanceMethods,
     staticMethods
   };
@@ -1940,11 +2196,15 @@ function analyzeInterfaceToIR(interfaceDecl, checker, file = "", extensionRegist
   const name = interfaceDecl.name.text;
   const fields = [];
   const typeRegistry = {};
-  const annotations = extractJSDocAnnotationNodes(
+  const diagnostics = [];
+  const interfaceType = checker.getTypeAtLocation(interfaceDecl);
+  const interfaceDoc = extractJSDocParseResult(
     interfaceDecl,
     file,
-    makeParseOptions(extensionRegistry)
+    makeParseOptions(extensionRegistry, void 0, checker, interfaceType, interfaceType)
   );
+  const annotations = [...interfaceDoc.annotations];
+  diagnostics.push(...interfaceDoc.diagnostics);
   const visiting = /* @__PURE__ */ new Set();
   for (const member of interfaceDecl.members) {
     if (ts3.isPropertySignature(member)) {
@@ -1954,6 +2214,8 @@ function analyzeInterfaceToIR(interfaceDecl, checker, file = "", extensionRegist
         file,
         typeRegistry,
         visiting,
+        diagnostics,
+        interfaceType,
         extensionRegistry
       );
       if (fieldNode) {
@@ -1968,6 +2230,7 @@ function analyzeInterfaceToIR(interfaceDecl, checker, file = "", extensionRegist
     fieldLayouts,
     typeRegistry,
     ...annotations.length > 0 && { annotations },
+    ...diagnostics.length > 0 && { diagnostics },
     instanceMethods: [],
     staticMethods: []
   };
@@ -1985,11 +2248,15 @@ function analyzeTypeAliasToIR(typeAlias, checker, file = "", extensionRegistry)
   const name = typeAlias.name.text;
   const fields = [];
   const typeRegistry = {};
-  const annotations = extractJSDocAnnotationNodes(
+  const diagnostics = [];
+  const aliasType = checker.getTypeAtLocation(typeAlias);
+  const typeAliasDoc = extractJSDocParseResult(
     typeAlias,
     file,
-    makeParseOptions(extensionRegistry)
+    makeParseOptions(extensionRegistry, void 0, checker, aliasType, aliasType)
   );
+  const annotations = [...typeAliasDoc.annotations];
+  diagnostics.push(...typeAliasDoc.diagnostics);
   const visiting = /* @__PURE__ */ new Set();
   for (const member of typeAlias.type.members) {
     if (ts3.isPropertySignature(member)) {
@@ -1999,6 +2266,8 @@ function analyzeTypeAliasToIR(typeAlias, checker, file = "", extensionRegistry)
         file,
         typeRegistry,
         visiting,
+        diagnostics,
+        aliasType,
         extensionRegistry
       );
       if (fieldNode) {
@@ -2014,12 +2283,13 @@ function analyzeTypeAliasToIR(typeAlias, checker, file = "", extensionRegistry)
       fieldLayouts: fields.map(() => ({})),
       typeRegistry,
       ...annotations.length > 0 && { annotations },
+      ...diagnostics.length > 0 && { diagnostics },
       instanceMethods: [],
       staticMethods: []
     }
   };
 }
-function analyzeFieldToIR(prop, checker, file, typeRegistry, visiting, extensionRegistry) {
+function analyzeFieldToIR(prop, checker, file, typeRegistry, visiting, diagnostics, hostType, extensionRegistry) {
   if (!ts3.isIdentifier(prop.name)) {
     return null;
   }
@@ -2034,7 +2304,8 @@ function analyzeFieldToIR(prop, checker, file, typeRegistry, visiting, extension
     typeRegistry,
     visiting,
     prop,
-    extensionRegistry
+    extensionRegistry,
+    diagnostics
   );
   const constraints = [];
   if (prop.type && !shouldEmitPrimitiveAliasDefinition(prop.type, checker)) {
@@ -2042,13 +2313,15 @@ function analyzeFieldToIR(prop, checker, file, typeRegistry, visiting, extension
       ...extractTypeAliasConstraintNodes(prop.type, checker, file, extensionRegistry)
     );
   }
-  constraints.push(
-    ...extractJSDocConstraintNodes(prop, file, makeParseOptions(extensionRegistry, type))
+  const docResult = extractJSDocParseResult(
+    prop,
+    file,
+    makeParseOptions(extensionRegistry, type, checker, tsType, hostType)
   );
+  constraints.push(...docResult.constraints);
+  diagnostics.push(...docResult.diagnostics);
   let annotations = [];
-  annotations.push(
-    ...extractJSDocAnnotationNodes(prop, file, makeParseOptions(extensionRegistry, type))
-  );
+  annotations.push(...docResult.annotations);
   const defaultAnnotation = extractDefaultValueAnnotation(prop.initializer, file);
   if (defaultAnnotation && !annotations.some((a) => a.annotationKind === "defaultValue")) {
     annotations.push(defaultAnnotation);
@@ -2064,7 +2337,7 @@ function analyzeFieldToIR(prop, checker, file, typeRegistry, visiting, extension
     provenance
   };
 }
-function analyzeInterfacePropertyToIR(prop, checker, file, typeRegistry, visiting, extensionRegistry) {
+function analyzeInterfacePropertyToIR(prop, checker, file, typeRegistry, visiting, diagnostics, hostType, extensionRegistry) {
   if (!ts3.isIdentifier(prop.name)) {
     return null;
   }
@@ -2079,7 +2352,8 @@ function analyzeInterfacePropertyToIR(prop, checker, file, typeRegistry, visitin
     typeRegistry,
     visiting,
     prop,
-    extensionRegistry
+    extensionRegistry,
+    diagnostics
   );
   const constraints = [];
   if (prop.type && !shouldEmitPrimitiveAliasDefinition(prop.type, checker)) {
@@ -2087,13 +2361,15 @@ function analyzeInterfacePropertyToIR(prop, checker, file, typeRegistry, visitin
       ...extractTypeAliasConstraintNodes(prop.type, checker, file, extensionRegistry)
     );
   }
-  constraints.push(
-    ...extractJSDocConstraintNodes(prop, file, makeParseOptions(extensionRegistry, type))
+  const docResult = extractJSDocParseResult(
+    prop,
+    file,
+    makeParseOptions(extensionRegistry, type, checker, tsType, hostType)
   );
+  constraints.push(...docResult.constraints);
+  diagnostics.push(...docResult.diagnostics);
   let annotations = [];
-  annotations.push(
-    ...extractJSDocAnnotationNodes(prop, file, makeParseOptions(extensionRegistry, type))
-  );
+  annotations.push(...docResult.annotations);
   ({ type, annotations } = applyEnumMemberDisplayNames(type, annotations));
   return {
     kind: "field",
@@ -2222,7 +2498,7 @@ function getTypeNodeRegistrationName(typeNode) {
   }
   return null;
 }
-function resolveTypeNode(type, checker, file, typeRegistry, visiting, sourceNode, extensionRegistry) {
+function resolveTypeNode(type, checker, file, typeRegistry, visiting, sourceNode, extensionRegistry, diagnostics) {
   const customType = resolveRegisteredCustomType(sourceNode, extensionRegistry, checker);
   if (customType) {
     return customType;
@@ -2234,7 +2510,8 @@ function resolveTypeNode(type, checker, file, typeRegistry, visiting, sourceNode
     typeRegistry,
     visiting,
     sourceNode,
-    extensionRegistry
+    extensionRegistry,
+    diagnostics
   );
   if (primitiveAlias) {
     return primitiveAlias;
@@ -2277,7 +2554,8 @@ function resolveTypeNode(type, checker, file, typeRegistry, visiting, sourceNode
       typeRegistry,
       visiting,
       sourceNode,
-      extensionRegistry
+      extensionRegistry,
+      diagnostics
     );
   }
   if (checker.isArrayType(type)) {
@@ -2288,15 +2566,24 @@ function resolveTypeNode(type, checker, file, typeRegistry, visiting, sourceNode
       typeRegistry,
       visiting,
       sourceNode,
-      extensionRegistry
+      extensionRegistry,
+      diagnostics
     );
   }
   if (isObjectType(type)) {
-    return resolveObjectType(type, checker, file, typeRegistry, visiting, extensionRegistry);
+    return resolveObjectType(
+      type,
+      checker,
+      file,
+      typeRegistry,
+      visiting,
+      extensionRegistry,
+      diagnostics
+    );
   }
   return { kind: "primitive", primitiveKind: "string" };
 }
-function tryResolveNamedPrimitiveAlias(type, checker, file, typeRegistry, visiting, sourceNode, extensionRegistry) {
+function tryResolveNamedPrimitiveAlias(type, checker, file, typeRegistry, visiting, sourceNode, extensionRegistry, diagnostics) {
   if (!(type.flags & (ts3.TypeFlags.String | ts3.TypeFlags.Number | ts3.TypeFlags.BigInt | ts3.TypeFlags.BigIntLiteral | ts3.TypeFlags.Boolean | ts3.TypeFlags.Null))) {
     return null;
   }
@@ -2324,7 +2611,8 @@ function tryResolveNamedPrimitiveAlias(type, checker, file, typeRegistry, visiti
         file,
         typeRegistry,
         visiting,
-        extensionRegistry
+        extensionRegistry,
+        diagnostics
       ),
       ...constraints.length > 0 && { constraints },
       ...annotations.length > 0 && { annotations },
@@ -2351,7 +2639,7 @@ function shouldEmitPrimitiveAliasDefinition(typeNode, checker) {
   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));
 }
-function resolveAliasedPrimitiveTarget(type, checker, file, typeRegistry, visiting, extensionRegistry) {
+function resolveAliasedPrimitiveTarget(type, checker, file, typeRegistry, visiting, extensionRegistry, diagnostics) {
   const nestedAliasDecl = type.aliasSymbol?.declarations?.find(ts3.isTypeAliasDeclaration);
   if (nestedAliasDecl !== void 0) {
     return resolveAliasedPrimitiveTarget(
@@ -2360,12 +2648,22 @@ function resolveAliasedPrimitiveTarget(type, checker, file, typeRegistry, visiti
       file,
       typeRegistry,
       visiting,
-      extensionRegistry
+      extensionRegistry,
+      diagnostics
     );
   }
-  return resolveTypeNode(type, checker, file, typeRegistry, visiting, void 0, extensionRegistry);
+  return resolveTypeNode(
+    type,
+    checker,
+    file,
+    typeRegistry,
+    visiting,
+    void 0,
+    extensionRegistry,
+    diagnostics
+  );
 }
-function resolveUnionType(type, checker, file, typeRegistry, visiting, sourceNode, extensionRegistry) {
+function resolveUnionType(type, checker, file, typeRegistry, visiting, sourceNode, extensionRegistry, diagnostics) {
   const typeName = getNamedTypeName(type);
   const namedDecl = getNamedTypeDeclaration(type);
   if (typeName && typeName in typeRegistry) {
@@ -2455,7 +2753,8 @@ function resolveUnionType(type, checker, file, typeRegistry, visiting, sourceNod
       typeRegistry,
       visiting,
       nonNullMembers[0].sourceNode ?? sourceNode,
-      extensionRegistry
+      extensionRegistry,
+      diagnostics
     );
     const result = hasNull ? {
       kind: "union",
@@ -2471,7 +2770,8 @@ function resolveUnionType(type, checker, file, typeRegistry, visiting, sourceNod
       typeRegistry,
       visiting,
       memberSourceNode ?? sourceNode,
-      extensionRegistry
+      extensionRegistry,
+      diagnostics
     )
   );
   if (hasNull) {
@@ -2479,7 +2779,7 @@ function resolveUnionType(type, checker, file, typeRegistry, visiting, sourceNod
   }
   return registerNamed({ kind: "union", members });
 }
-function resolveArrayType(type, checker, file, typeRegistry, visiting, sourceNode, extensionRegistry) {
+function resolveArrayType(type, checker, file, typeRegistry, visiting, sourceNode, extensionRegistry, diagnostics) {
   const typeArgs = isTypeReference(type) ? type.typeArguments : void 0;
   const elementType = typeArgs?.[0];
   const elementSourceNode = extractArrayElementTypeNode(sourceNode, checker);
@@ -2490,11 +2790,12 @@ function resolveArrayType(type, checker, file, typeRegistry, visiting, sourceNod
     typeRegistry,
     visiting,
     elementSourceNode,
-    extensionRegistry
+    extensionRegistry,
+    diagnostics
   ) : { kind: "primitive", primitiveKind: "string" };
   return { kind: "array", items };
 }
-function tryResolveRecordType(type, checker, file, typeRegistry, visiting, extensionRegistry) {
+function tryResolveRecordType(type, checker, file, typeRegistry, visiting, extensionRegistry, diagnostics) {
   if (type.getProperties().length > 0) {
     return null;
   }
@@ -2509,7 +2810,8 @@ function tryResolveRecordType(type, checker, file, typeRegistry, visiting, exten
     typeRegistry,
     visiting,
     void 0,
-    extensionRegistry
+    extensionRegistry,
+    diagnostics
   );
   return { kind: "record", valueType };
 }
@@ -2538,7 +2840,7 @@ function typeNodeContainsReference(type, targetName) {
     }
   }
 }
-function resolveObjectType(type, checker, file, typeRegistry, visiting, extensionRegistry) {
+function resolveObjectType(type, checker, file, typeRegistry, visiting, extensionRegistry, diagnostics) {
   const typeName = getNamedTypeName(type);
   const namedTypeName = typeName ?? void 0;
   const namedDecl = getNamedTypeDeclaration(type);
@@ -2575,7 +2877,8 @@ function resolveObjectType(type, checker, file, typeRegistry, visiting, extensio
     file,
     typeRegistry,
     visiting,
-    extensionRegistry
+    extensionRegistry,
+    diagnostics
   );
   if (recordNode) {
     visiting.delete(type);
@@ -2603,6 +2906,7 @@ function resolveObjectType(type, checker, file, typeRegistry, visiting, extensio
     file,
     typeRegistry,
     visiting,
+    diagnostics ?? [],
     extensionRegistry
   );
   for (const prop of type.getProperties()) {
@@ -2617,7 +2921,8 @@ function resolveObjectType(type, checker, file, typeRegistry, visiting, extensio
       typeRegistry,
       visiting,
       declaration,
-      extensionRegistry
+      extensionRegistry,
+      diagnostics
     );
     const fieldNodeInfo = fieldInfoMap?.get(prop.name);
     properties.push({
@@ -2647,7 +2952,7 @@ function resolveObjectType(type, checker, file, typeRegistry, visiting, extensio
   }
   return objectNode;
 }
-function getNamedTypeFieldNodeInfoMap(type, checker, file, typeRegistry, visiting, extensionRegistry) {
+function getNamedTypeFieldNodeInfoMap(type, checker, file, typeRegistry, visiting, diagnostics, extensionRegistry) {
   const symbols = [type.getSymbol(), type.aliasSymbol].filter(
     (s) => s?.declarations != null && s.declarations.length > 0
   );
@@ -2657,6 +2962,7 @@ function getNamedTypeFieldNodeInfoMap(type, checker, file, typeRegistry, visitin
     const classDecl = declarations.find(ts3.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)) {
           const fieldNode = analyzeFieldToIR(
@@ -2665,6 +2971,8 @@ function getNamedTypeFieldNodeInfoMap(type, checker, file, typeRegistry, visitin
             file,
             typeRegistry,
             visiting,
+            diagnostics,
+            hostType,
             extensionRegistry
           );
           if (fieldNode) {
@@ -2686,6 +2994,8 @@ function getNamedTypeFieldNodeInfoMap(type, checker, file, typeRegistry, visitin
         file,
         typeRegistry,
         visiting,
+        checker.getTypeAtLocation(interfaceDecl),
+        diagnostics,
         extensionRegistry
       );
     }
@@ -2697,6 +3007,8 @@ function getNamedTypeFieldNodeInfoMap(type, checker, file, typeRegistry, visitin
         file,
         typeRegistry,
         visiting,
+        checker.getTypeAtLocation(typeAliasDecl),
+        diagnostics,
         extensionRegistry
       );
     }
@@ -2746,7 +3058,7 @@ function isNullishTypeNode(typeNode) {
   }
   return ts3.isLiteralTypeNode(typeNode) && (typeNode.literal.kind === ts3.SyntaxKind.NullKeyword || typeNode.literal.kind === ts3.SyntaxKind.UndefinedKeyword);
 }
-function buildFieldNodeInfoMap(members, checker, file, typeRegistry, visiting, extensionRegistry) {
+function buildFieldNodeInfoMap(members, checker, file, typeRegistry, visiting, hostType, diagnostics, extensionRegistry) {
   const map = /* @__PURE__ */ new Map();
   for (const member of members) {
     if (ts3.isPropertySignature(member)) {
@@ -2756,6 +3068,8 @@ function buildFieldNodeInfoMap(members, checker, file, typeRegistry, visiting, e
         file,
         typeRegistry,
         visiting,
+        diagnostics,
+        hostType,
         extensionRegistry
       );
       if (fieldNode) {
@@ -3008,760 +3322,44 @@ var init_program = __esm({
 });
 
 // src/validate/constraint-validator.ts
-import { normalizeConstraintTagName as normalizeConstraintTagName2 } from "@formspec/core";
-function addContradiction(ctx, message, primary, related) {
-  ctx.diagnostics.push({
-    code: "CONTRADICTING_CONSTRAINTS",
-    message,
-    severity: "error",
-    primaryLocation: primary,
-    relatedLocations: [related]
-  });
-}
-function addTypeMismatch(ctx, message, primary) {
-  ctx.diagnostics.push({
-    code: "TYPE_MISMATCH",
-    message,
-    severity: "error",
-    primaryLocation: primary,
-    relatedLocations: []
-  });
-}
-function addUnknownExtension(ctx, message, primary) {
-  ctx.diagnostics.push({
-    code: "UNKNOWN_EXTENSION",
-    message,
-    severity: "warning",
-    primaryLocation: primary,
-    relatedLocations: []
-  });
-}
-function addUnknownPathTarget(ctx, message, primary) {
-  ctx.diagnostics.push({
-    code: "UNKNOWN_PATH_TARGET",
-    message,
-    severity: "error",
-    primaryLocation: primary,
-    relatedLocations: []
-  });
-}
-function addConstraintBroadening(ctx, message, primary, related) {
-  ctx.diagnostics.push({
-    code: "CONSTRAINT_BROADENING",
-    message,
-    severity: "error",
-    primaryLocation: primary,
-    relatedLocations: [related]
-  });
-}
-function getExtensionIdFromConstraintId(constraintId) {
-  const separator = constraintId.lastIndexOf("/");
-  if (separator <= 0) {
-    return null;
-  }
-  return constraintId.slice(0, separator);
-}
-function findNumeric(constraints, constraintKind) {
-  return constraints.find((c) => c.constraintKind === constraintKind);
-}
-function findLength(constraints, constraintKind) {
-  return constraints.find((c) => c.constraintKind === constraintKind);
-}
-function findAllowedMembers(constraints) {
-  return constraints.filter(
-    (c) => c.constraintKind === "allowedMembers"
-  );
-}
-function findConstConstraints(constraints) {
-  return constraints.filter(
-    (c) => c.constraintKind === "const"
-  );
-}
-function jsonValueEquals(left, right) {
-  if (left === right) {
-    return true;
-  }
-  if (Array.isArray(left) || Array.isArray(right)) {
-    if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) {
-      return false;
-    }
-    return left.every((item, index) => jsonValueEquals(item, right[index]));
-  }
-  if (isJsonObject(left) || isJsonObject(right)) {
-    if (!isJsonObject(left) || !isJsonObject(right)) {
-      return false;
-    }
-    const leftKeys = Object.keys(left).sort();
-    const rightKeys = Object.keys(right).sort();
-    if (leftKeys.length !== rightKeys.length) {
-      return false;
-    }
-    return leftKeys.every((key, index) => {
-      const rightKey = rightKeys[index];
-      if (rightKey !== key) {
-        return false;
-      }
-      const leftValue = left[key];
-      const rightValue = right[rightKey];
-      return leftValue !== void 0 && rightValue !== void 0 && jsonValueEquals(leftValue, rightValue);
-    });
-  }
-  return false;
-}
-function isJsonObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isOrderedBoundConstraint(constraint) {
-  return constraint.constraintKind === "minimum" || constraint.constraintKind === "exclusiveMinimum" || constraint.constraintKind === "minLength" || constraint.constraintKind === "minItems" || constraint.constraintKind === "maximum" || constraint.constraintKind === "exclusiveMaximum" || constraint.constraintKind === "maxLength" || constraint.constraintKind === "maxItems";
-}
-function pathKey(constraint) {
-  return constraint.path?.segments.join(".") ?? "";
-}
-function orderedBoundFamily(kind) {
-  switch (kind) {
-    case "minimum":
-    case "exclusiveMinimum":
-      return "numeric-lower";
-    case "maximum":
-    case "exclusiveMaximum":
-      return "numeric-upper";
-    case "minLength":
-      return "minLength";
-    case "minItems":
-      return "minItems";
-    case "maxLength":
-      return "maxLength";
-    case "maxItems":
-      return "maxItems";
-    default: {
-      const _exhaustive = kind;
-      return _exhaustive;
-    }
-  }
-}
-function isNumericLowerKind(kind) {
-  return kind === "minimum" || kind === "exclusiveMinimum";
-}
-function isNumericUpperKind(kind) {
-  return kind === "maximum" || kind === "exclusiveMaximum";
-}
-function describeConstraintTag(constraint) {
-  return `@${constraint.constraintKind}`;
-}
-function compareConstraintStrength(current, previous) {
-  const family = orderedBoundFamily(current.constraintKind);
-  if (family === "numeric-lower") {
-    if (!isNumericLowerKind(current.constraintKind) || !isNumericLowerKind(previous.constraintKind)) {
-      throw new Error("numeric-lower family received non-numeric lower-bound constraint");
-    }
-    if (current.value !== previous.value) {
-      return current.value > previous.value ? 1 : -1;
-    }
-    if (current.constraintKind === "exclusiveMinimum" && previous.constraintKind === "minimum") {
-      return 1;
-    }
-    if (current.constraintKind === "minimum" && previous.constraintKind === "exclusiveMinimum") {
-      return -1;
-    }
-    return 0;
-  }
-  if (family === "numeric-upper") {
-    if (!isNumericUpperKind(current.constraintKind) || !isNumericUpperKind(previous.constraintKind)) {
-      throw new Error("numeric-upper family received non-numeric upper-bound constraint");
-    }
-    if (current.value !== previous.value) {
-      return current.value < previous.value ? 1 : -1;
-    }
-    if (current.constraintKind === "exclusiveMaximum" && previous.constraintKind === "maximum") {
-      return 1;
-    }
-    if (current.constraintKind === "maximum" && previous.constraintKind === "exclusiveMaximum") {
-      return -1;
-    }
-    return 0;
-  }
-  switch (family) {
-    case "minLength":
-    case "minItems":
-      if (current.value === previous.value) {
-        return 0;
-      }
-      return current.value > previous.value ? 1 : -1;
-    case "maxLength":
-    case "maxItems":
-      if (current.value === previous.value) {
-        return 0;
-      }
-      return current.value < previous.value ? 1 : -1;
-    default: {
-      const _exhaustive = family;
-      return _exhaustive;
-    }
-  }
-}
-function checkConstraintBroadening(ctx, fieldName, constraints) {
-  const strongestByKey = /* @__PURE__ */ new Map();
-  for (const constraint of constraints) {
-    if (!isOrderedBoundConstraint(constraint)) {
-      continue;
-    }
-    const key = `${orderedBoundFamily(constraint.constraintKind)}:${pathKey(constraint)}`;
-    const previous = strongestByKey.get(key);
-    if (previous === void 0) {
-      strongestByKey.set(key, constraint);
-      continue;
-    }
-    const strength = compareConstraintStrength(constraint, previous);
-    if (strength < 0) {
-      const displayFieldName = formatPathTargetFieldName(
-        fieldName,
-        constraint.path?.segments ?? []
-      );
-      addConstraintBroadening(
-        ctx,
-        `Field "${displayFieldName}": ${describeConstraintTag(constraint)} (${String(constraint.value)}) is broader than earlier ${describeConstraintTag(previous)} (${String(previous.value)}). Constraints can only narrow.`,
-        constraint.provenance,
-        previous.provenance
-      );
-      continue;
-    }
-    if (strength <= 0) {
-      continue;
-    }
-    strongestByKey.set(key, constraint);
-  }
-}
-function compareCustomConstraintStrength(current, previous) {
-  const order = current.comparePayloads(current.constraint.payload, previous.constraint.payload);
-  const equalPayloadTiebreaker = order === 0 ? compareSemanticInclusivity(current.role.inclusive, previous.role.inclusive) : order;
-  switch (current.role.bound) {
-    case "lower":
-      return equalPayloadTiebreaker;
-    case "upper":
-      return equalPayloadTiebreaker === 0 ? 0 : -equalPayloadTiebreaker;
-    case "exact":
-      return order === 0 ? 0 : Number.NaN;
-    default: {
-      const _exhaustive = current.role.bound;
-      return _exhaustive;
-    }
-  }
-}
-function compareSemanticInclusivity(currentInclusive, previousInclusive) {
-  if (currentInclusive === previousInclusive) {
-    return 0;
-  }
-  return currentInclusive ? -1 : 1;
-}
-function customConstraintsContradict(lower, upper) {
-  const order = lower.comparePayloads(lower.constraint.payload, upper.constraint.payload);
-  if (order > 0) {
-    return true;
-  }
-  if (order < 0) {
-    return false;
-  }
-  return !lower.role.inclusive || !upper.role.inclusive;
-}
-function describeCustomConstraintTag(constraint) {
-  return constraint.provenance.tagName ?? constraint.constraintId;
-}
-function checkCustomConstraintSemantics(ctx, fieldName, constraints) {
-  if (ctx.extensionRegistry === void 0) {
-    return;
-  }
-  const strongestByKey = /* @__PURE__ */ new Map();
-  const lowerByFamily = /* @__PURE__ */ new Map();
-  const upperByFamily = /* @__PURE__ */ new Map();
-  for (const constraint of constraints) {
-    if (constraint.constraintKind !== "custom") {
-      continue;
-    }
-    const registration = ctx.extensionRegistry.findConstraint(constraint.constraintId);
-    if (registration?.comparePayloads === void 0 || registration.semanticRole === void 0) {
-      continue;
-    }
-    const entry = {
-      constraint,
-      comparePayloads: registration.comparePayloads,
-      role: registration.semanticRole
-    };
-    const familyKey = `${registration.semanticRole.family}:${pathKey(constraint)}`;
-    const boundKey = `${familyKey}:${registration.semanticRole.bound}`;
-    const previous = strongestByKey.get(boundKey);
-    if (previous !== void 0) {
-      const strength = compareCustomConstraintStrength(entry, previous);
-      if (Number.isNaN(strength)) {
-        addContradiction(
-          ctx,
-          `Field "${formatPathTargetFieldName(fieldName, constraint.path?.segments ?? [])}": ${describeCustomConstraintTag(constraint)} conflicts with ${describeCustomConstraintTag(previous.constraint)}`,
-          constraint.provenance,
-          previous.constraint.provenance
-        );
-        continue;
-      }
-      if (strength < 0) {
-        addConstraintBroadening(
-          ctx,
-          `Field "${formatPathTargetFieldName(fieldName, constraint.path?.segments ?? [])}": ${describeCustomConstraintTag(constraint)} is broader than earlier ${describeCustomConstraintTag(previous.constraint)}. Constraints can only narrow.`,
-          constraint.provenance,
-          previous.constraint.provenance
-        );
-        continue;
-      }
-      if (strength > 0) {
-        strongestByKey.set(boundKey, entry);
-      }
-    } else {
-      strongestByKey.set(boundKey, entry);
-    }
-    if (registration.semanticRole.bound === "lower") {
-      lowerByFamily.set(familyKey, strongestByKey.get(boundKey) ?? entry);
-    } else if (registration.semanticRole.bound === "upper") {
-      upperByFamily.set(familyKey, strongestByKey.get(boundKey) ?? entry);
-    }
-  }
-  for (const [familyKey, lower] of lowerByFamily) {
-    const upper = upperByFamily.get(familyKey);
-    if (upper === void 0) {
-      continue;
-    }
-    if (!customConstraintsContradict(lower, upper)) {
-      continue;
-    }
-    addContradiction(
-      ctx,
-      `Field "${formatPathTargetFieldName(fieldName, lower.constraint.path?.segments ?? [])}": ${describeCustomConstraintTag(lower.constraint)} contradicts ${describeCustomConstraintTag(upper.constraint)}`,
-      lower.constraint.provenance,
-      upper.constraint.provenance
-    );
-  }
-}
-function checkNumericContradictions(ctx, fieldName, constraints) {
-  const min = findNumeric(constraints, "minimum");
-  const max = findNumeric(constraints, "maximum");
-  const exMin = findNumeric(constraints, "exclusiveMinimum");
-  const exMax = findNumeric(constraints, "exclusiveMaximum");
-  if (min !== void 0 && max !== void 0 && min.value > max.value) {
-    addContradiction(
-      ctx,
-      `Field "${fieldName}": minimum (${String(min.value)}) is greater than maximum (${String(max.value)})`,
-      min.provenance,
-      max.provenance
-    );
-  }
-  if (exMin !== void 0 && max !== void 0 && exMin.value >= max.value) {
-    addContradiction(
-      ctx,
-      `Field "${fieldName}": exclusiveMinimum (${String(exMin.value)}) is greater than or equal to maximum (${String(max.value)})`,
-      exMin.provenance,
-      max.provenance
-    );
-  }
-  if (min !== void 0 && exMax !== void 0 && min.value >= exMax.value) {
-    addContradiction(
-      ctx,
-      `Field "${fieldName}": minimum (${String(min.value)}) is greater than or equal to exclusiveMaximum (${String(exMax.value)})`,
-      min.provenance,
-      exMax.provenance
-    );
-  }
-  if (exMin !== void 0 && exMax !== void 0 && exMin.value >= exMax.value) {
-    addContradiction(
-      ctx,
-      `Field "${fieldName}": exclusiveMinimum (${String(exMin.value)}) is greater than or equal to exclusiveMaximum (${String(exMax.value)})`,
-      exMin.provenance,
-      exMax.provenance
-    );
-  }
-}
-function checkLengthContradictions(ctx, fieldName, constraints) {
-  const minLen = findLength(constraints, "minLength");
-  const maxLen = findLength(constraints, "maxLength");
-  if (minLen !== void 0 && maxLen !== void 0 && minLen.value > maxLen.value) {
-    addContradiction(
-      ctx,
-      `Field "${fieldName}": minLength (${String(minLen.value)}) is greater than maxLength (${String(maxLen.value)})`,
-      minLen.provenance,
-      maxLen.provenance
-    );
-  }
-  const minItems = findLength(constraints, "minItems");
-  const maxItems = findLength(constraints, "maxItems");
-  if (minItems !== void 0 && maxItems !== void 0 && minItems.value > maxItems.value) {
-    addContradiction(
-      ctx,
-      `Field "${fieldName}": minItems (${String(minItems.value)}) is greater than maxItems (${String(maxItems.value)})`,
-      minItems.provenance,
-      maxItems.provenance
-    );
-  }
-}
-function checkAllowedMembersContradiction(ctx, fieldName, constraints) {
-  const members = findAllowedMembers(constraints);
-  if (members.length < 2) return;
-  const firstSet = new Set(members[0]?.members ?? []);
-  for (let i = 1; i < members.length; i++) {
-    const current = members[i];
-    if (current === void 0) continue;
-    for (const m of firstSet) {
-      if (!current.members.includes(m)) {
-        firstSet.delete(m);
-      }
-    }
-  }
-  if (firstSet.size === 0) {
-    const first = members[0];
-    const second = members[1];
-    if (first !== void 0 && second !== void 0) {
-      addContradiction(
-        ctx,
-        `Field "${fieldName}": allowedMembers constraints have an empty intersection (no valid values remain)`,
-        first.provenance,
-        second.provenance
-      );
-    }
-  }
-}
-function checkConstContradictions(ctx, fieldName, constraints) {
-  const constConstraints = findConstConstraints(constraints);
-  if (constConstraints.length < 2) return;
-  const first = constConstraints[0];
-  if (first === void 0) return;
-  for (let i = 1; i < constConstraints.length; i++) {
-    const current = constConstraints[i];
-    if (current === void 0) continue;
-    if (jsonValueEquals(first.value, current.value)) {
-      continue;
-    }
-    addContradiction(
-      ctx,
-      `Field "${fieldName}": conflicting @const constraints require both ${JSON.stringify(first.value)} and ${JSON.stringify(current.value)}`,
-      first.provenance,
-      current.provenance
-    );
-  }
-}
-function typeLabel(type) {
-  switch (type.kind) {
-    case "primitive":
-      return type.primitiveKind;
-    case "enum":
-      return "enum";
-    case "array":
-      return "array";
-    case "object":
-      return "object";
-    case "record":
-      return "record";
-    case "union":
-      return "union";
-    case "reference":
-      return `reference(${type.name})`;
-    case "dynamic":
-      return `dynamic(${type.dynamicKind})`;
-    case "custom":
-      return `custom(${type.typeId})`;
-    default: {
-      const _exhaustive = type;
-      return String(_exhaustive);
-    }
-  }
-}
-function dereferenceType(ctx, type) {
-  let current = type;
-  const seen = /* @__PURE__ */ new Set();
-  while (current.kind === "reference") {
-    if (seen.has(current.name)) {
-      return current;
-    }
-    seen.add(current.name);
-    const definition = ctx.typeRegistry[current.name];
-    if (definition === void 0) {
-      return current;
-    }
-    current = definition.type;
-  }
-  return current;
-}
-function collectReferencedTypeConstraints(ctx, type) {
-  const collected = [];
-  let current = type;
-  const seen = /* @__PURE__ */ new Set();
-  while (current.kind === "reference") {
-    if (seen.has(current.name)) {
-      break;
-    }
-    seen.add(current.name);
-    const definition = ctx.typeRegistry[current.name];
-    if (definition === void 0) {
-      break;
-    }
-    if (definition.constraints !== void 0) {
-      collected.push(...definition.constraints);
-    }
-    current = definition.type;
-  }
-  return collected;
-}
-function resolvePathTargetType(ctx, type, segments) {
-  const effectiveType = dereferenceType(ctx, type);
-  if (segments.length === 0) {
-    return { kind: "resolved", type: effectiveType };
-  }
-  if (effectiveType.kind === "array") {
-    return resolvePathTargetType(ctx, effectiveType.items, segments);
-  }
-  if (effectiveType.kind === "object") {
-    const [segment, ...rest] = segments;
-    if (segment === void 0) {
-      throw new Error("Invariant violation: object path traversal requires a segment");
-    }
-    const property = effectiveType.properties.find((prop) => prop.name === segment);
-    if (property === void 0) {
-      return { kind: "missing-property", segment };
-    }
-    return resolvePathTargetType(ctx, property.type, rest);
-  }
-  return { kind: "unresolvable", type: effectiveType };
-}
-function isNullType(type) {
-  return type.kind === "primitive" && type.primitiveKind === "null";
-}
-function collectCustomConstraintCandidateTypes(ctx, type) {
-  const effectiveType = dereferenceType(ctx, type);
-  const candidates = [effectiveType];
-  if (effectiveType.kind === "array") {
-    candidates.push(...collectCustomConstraintCandidateTypes(ctx, effectiveType.items));
-  }
-  if (effectiveType.kind === "union") {
-    const memberTypes = effectiveType.members.map((member) => dereferenceType(ctx, member));
-    const nonNullMembers = memberTypes.filter((member) => !isNullType(member));
-    if (nonNullMembers.length === 1 && nonNullMembers.length < memberTypes.length) {
-      const [nullableMember] = nonNullMembers;
-      if (nullableMember !== void 0) {
-        candidates.push(...collectCustomConstraintCandidateTypes(ctx, nullableMember));
-      }
-    }
-  }
-  return candidates;
-}
-function formatPathTargetFieldName(fieldName, path4) {
-  return path4.length === 0 ? fieldName : `${fieldName}.${path4.join(".")}`;
-}
-function checkConstraintOnType(ctx, fieldName, type, constraint) {
-  const effectiveType = dereferenceType(ctx, type);
-  const isNumber = effectiveType.kind === "primitive" && ["number", "integer", "bigint"].includes(effectiveType.primitiveKind);
-  const isString = effectiveType.kind === "primitive" && effectiveType.primitiveKind === "string";
-  const isArray = effectiveType.kind === "array";
-  const isEnum = effectiveType.kind === "enum";
-  const arrayItemType = effectiveType.kind === "array" ? dereferenceType(ctx, effectiveType.items) : void 0;
-  const isStringArray = arrayItemType?.kind === "primitive" && arrayItemType.primitiveKind === "string";
-  const label = typeLabel(effectiveType);
-  const ck = constraint.constraintKind;
-  switch (ck) {
-    case "minimum":
-    case "maximum":
-    case "exclusiveMinimum":
-    case "exclusiveMaximum":
-    case "multipleOf": {
-      if (!isNumber) {
-        addTypeMismatch(
-          ctx,
-          `Field "${fieldName}": constraint "${ck}" is only valid on number fields, but field type is "${label}"`,
-          constraint.provenance
-        );
-      }
-      break;
-    }
-    case "minLength":
-    case "maxLength":
-    case "pattern": {
-      if (!isString && !isStringArray) {
-        addTypeMismatch(
-          ctx,
-          `Field "${fieldName}": constraint "${ck}" is only valid on string fields or string array items, but field type is "${label}"`,
-          constraint.provenance
-        );
-      }
-      break;
-    }
-    case "minItems":
-    case "maxItems":
-    case "uniqueItems": {
-      if (!isArray) {
-        addTypeMismatch(
-          ctx,
-          `Field "${fieldName}": constraint "${ck}" is only valid on array fields, but field type is "${label}"`,
-          constraint.provenance
-        );
-      }
-      break;
-    }
-    case "allowedMembers": {
-      if (!isEnum) {
-        addTypeMismatch(
-          ctx,
-          `Field "${fieldName}": constraint "allowedMembers" is only valid on enum fields, but field type is "${label}"`,
-          constraint.provenance
-        );
-      }
-      break;
-    }
-    case "const": {
-      const isPrimitiveConstType = effectiveType.kind === "primitive" && ["string", "number", "integer", "bigint", "boolean", "null"].includes(
-        effectiveType.primitiveKind
-      ) || effectiveType.kind === "enum";
-      if (!isPrimitiveConstType) {
-        addTypeMismatch(
-          ctx,
-          `Field "${fieldName}": constraint "const" is only valid on primitive or enum fields, but field type is "${label}"`,
-          constraint.provenance
-        );
-        break;
-      }
-      if (effectiveType.kind === "primitive") {
-        const valueType = constraint.value === null ? "null" : Array.isArray(constraint.value) ? "array" : typeof constraint.value;
-        const expectedValueType = effectiveType.primitiveKind === "integer" || effectiveType.primitiveKind === "bigint" ? "number" : effectiveType.primitiveKind;
-        if (valueType !== expectedValueType) {
-          addTypeMismatch(
-            ctx,
-            `Field "${fieldName}": @const value type "${valueType}" is incompatible with field type "${effectiveType.primitiveKind}"`,
-            constraint.provenance
-          );
-        }
-        break;
-      }
-      const memberValues = effectiveType.members.map((member) => member.value);
-      if (!memberValues.some((member) => jsonValueEquals(member, constraint.value))) {
-        addTypeMismatch(
-          ctx,
-          `Field "${fieldName}": @const value ${JSON.stringify(constraint.value)} is not one of the enum members`,
-          constraint.provenance
-        );
-      }
-      break;
-    }
-    case "custom": {
-      checkCustomConstraint(ctx, fieldName, effectiveType, constraint);
-      break;
-    }
-    default: {
-      const _exhaustive = constraint;
-      throw new Error(
-        `Unhandled constraint kind: ${_exhaustive.constraintKind}`
-      );
-    }
-  }
-}
-function checkTypeApplicability(ctx, fieldName, type, constraints) {
-  for (const constraint of constraints) {
-    if (constraint.path) {
-      const resolution = resolvePathTargetType(ctx, type, constraint.path.segments);
-      const targetFieldName = formatPathTargetFieldName(fieldName, constraint.path.segments);
-      if (resolution.kind === "missing-property") {
-        addUnknownPathTarget(
-          ctx,
-          `Field "${targetFieldName}": path-targeted constraint "${constraint.constraintKind}" references unknown path segment "${resolution.segment}"`,
-          constraint.provenance
-        );
-        continue;
-      }
-      if (resolution.kind === "unresolvable") {
-        addTypeMismatch(
-          ctx,
-          `Field "${targetFieldName}": path-targeted constraint "${constraint.constraintKind}" is invalid because type "${typeLabel(resolution.type)}" cannot be traversed`,
-          constraint.provenance
-        );
-        continue;
-      }
-      checkConstraintOnType(ctx, targetFieldName, resolution.type, constraint);
-      continue;
-    }
-    checkConstraintOnType(ctx, fieldName, type, constraint);
-  }
-}
-function checkCustomConstraint(ctx, fieldName, type, constraint) {
-  if (ctx.extensionRegistry === void 0) return;
-  const registration = ctx.extensionRegistry.findConstraint(constraint.constraintId);
-  if (registration === void 0) {
-    addUnknownExtension(
-      ctx,
-      `Field "${fieldName}": custom constraint "${constraint.constraintId}" is not registered in the extension registry`,
-      constraint.provenance
-    );
-    return;
-  }
-  const candidateTypes = collectCustomConstraintCandidateTypes(ctx, type);
-  const normalizedTagName = constraint.provenance.tagName === void 0 ? void 0 : normalizeConstraintTagName2(constraint.provenance.tagName.replace(/^@/, ""));
-  if (normalizedTagName !== void 0) {
-    const tagRegistration = ctx.extensionRegistry.findConstraintTag(normalizedTagName);
-    const extensionId = getExtensionIdFromConstraintId(constraint.constraintId);
-    if (extensionId !== null && tagRegistration?.extensionId === extensionId && tagRegistration.registration.constraintName === registration.constraintName && !candidateTypes.some(
-      (candidateType) => tagRegistration.registration.isApplicableToType?.(candidateType) !== false
-    )) {
-      addTypeMismatch(
-        ctx,
-        `Field "${fieldName}": custom constraint "${constraint.constraintId}" is not applicable to type "${typeLabel(type)}"`,
-        constraint.provenance
-      );
-      return;
-    }
-  }
-  if (registration.applicableTypes === null) {
-    if (!candidateTypes.some((candidateType) => registration.isApplicableToType?.(candidateType) !== false)) {
-      addTypeMismatch(
-        ctx,
-        `Field "${fieldName}": custom constraint "${constraint.constraintId}" is not applicable to type "${typeLabel(type)}"`,
-        constraint.provenance
-      );
+import {
+  analyzeConstraintTargets
+} from "@formspec/analysis";
+function validateFieldNode(ctx, field) {
+  const analysis = analyzeConstraintTargets(
+    field.name,
+    field.type,
+    field.constraints,
+    ctx.typeRegistry,
+    ctx.extensionRegistry === void 0 ? void 0 : {
+      extensionRegistry: ctx.extensionRegistry
     }
-    return;
-  }
-  const applicableTypes = registration.applicableTypes;
-  const matchesApplicableType = candidateTypes.some(
-    (candidateType) => applicableTypes.includes(candidateType.kind) && registration.isApplicableToType?.(candidateType) !== false
   );
-  if (!matchesApplicableType) {
-    addTypeMismatch(
-      ctx,
-      `Field "${fieldName}": custom constraint "${constraint.constraintId}" is not applicable to type "${typeLabel(type)}"`,
-      constraint.provenance
-    );
-  }
-}
-function validateFieldNode(ctx, field) {
-  validateConstraints(ctx, field.name, field.type, [
-    ...collectReferencedTypeConstraints(ctx, field.type),
-    ...field.constraints
-  ]);
+  ctx.diagnostics.push(...analysis.diagnostics);
   if (field.type.kind === "object") {
-    for (const prop of field.type.properties) {
-      validateObjectProperty(ctx, field.name, prop);
+    for (const property of field.type.properties) {
+      validateObjectProperty(ctx, field.name, property);
     }
   }
 }
-function validateObjectProperty(ctx, parentName, prop) {
-  const qualifiedName = `${parentName}.${prop.name}`;
-  validateConstraints(ctx, qualifiedName, prop.type, [
-    ...collectReferencedTypeConstraints(ctx, prop.type),
-    ...prop.constraints
-  ]);
-  if (prop.type.kind === "object") {
-    for (const nestedProp of prop.type.properties) {
-      validateObjectProperty(ctx, qualifiedName, nestedProp);
+function validateObjectProperty(ctx, parentName, property) {
+  const qualifiedName = `${parentName}.${property.name}`;
+  const analysis = analyzeConstraintTargets(
+    qualifiedName,
+    property.type,
+    property.constraints,
+    ctx.typeRegistry,
+    ctx.extensionRegistry === void 0 ? void 0 : {
+      extensionRegistry: ctx.extensionRegistry
+    }
+  );
+  ctx.diagnostics.push(...analysis.diagnostics);
+  if (property.type.kind === "object") {
+    for (const nestedProperty of property.type.properties) {
+      validateObjectProperty(ctx, qualifiedName, nestedProperty);
     }
   }
 }
-function validateConstraints(ctx, name, type, constraints) {
-  checkNumericContradictions(ctx, name, constraints);
-  checkLengthContradictions(ctx, name, constraints);
-  checkAllowedMembersContradiction(ctx, name, constraints);
-  checkConstContradictions(ctx, name, constraints);
-  checkConstraintBroadening(ctx, name, constraints);
-  checkCustomConstraintSemantics(ctx, name, constraints);
-  checkTypeApplicability(ctx, name, type, constraints);
-}
 function validateElement(ctx, element) {
   switch (element.kind) {
     case "field":
@@ -3778,8 +3376,8 @@ function validateElement(ctx, element) {
       }
       break;
     default: {
-      const _exhaustive = element;
-      throw new Error(`Unhandled element kind: ${_exhaustive.kind}`);
+      const exhaustive = element;
+      throw new Error(`Unhandled element kind: ${String(exhaustive)}`);
     }
   }
 }
@@ -3794,7 +3392,7 @@ function validateIR(ir, options) {
   }
   return {
     diagnostics: ctx.diagnostics,
-    valid: ctx.diagnostics.every((d) => d.severity !== "error")
+    valid: ctx.diagnostics.every((diagnostic) => diagnostic.severity !== "error")
   };
 }
 var init_constraint_validator = __esm({
@@ -3813,6 +3411,12 @@ var init_validate = __esm({
 
 // src/generators/class-schema.ts
 function generateClassSchemas(analysis, source, options) {
+  const errorDiagnostics = analysis.diagnostics?.filter(
+    (diagnostic) => diagnostic.severity === "error"
+  );
+  if (errorDiagnostics !== void 0 && errorDiagnostics.length > 0) {
+    throw new Error(formatValidationError(errorDiagnostics));
+  }
   const ir = canonicalizeTSDoc(analysis, source);
   const validationResult = validateIR(ir, {
     ...options?.extensionRegistry !== void 0 && {