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

package/dist/browser.cjs

@@ -1181,760 +1181,42 @@ var jsonSchema7Schema = import_zod3.z.lazy(
 );
 
 // src/validate/constraint-validator.ts
-var import_core3 = require("@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, path) {
-  return path.length === 0 ? fieldName : `${fieldName}.${path.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 : (0, import_core3.normalizeConstraintTagName)(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
-      );
+var import_analysis = require("@formspec/analysis");
+function validateFieldNode(ctx, field) {
+  const analysis = (0, import_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 = (0, import_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":
@@ -1951,8 +1233,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)}`);
     }
   }
 }
@@ -1967,7 +1249,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")
   };
 }