@formspec/build 0.1.0-alpha.15 → 0.1.0-alpha.17

package/dist/browser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../src/browser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,EAEL,KAAK,yBAAyB,EAC/B,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EACL,KAAK,cAAc,EACpB,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAGrD,YAAY,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AACpE,YAAY,EAAE,+BAA+B,EAAE,MAAM,+BAA+B,CAAC;AACrF,YAAY,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAE5E,YAAY,EACV,WAAW,EACX,cAAc,EACd,mBAAmB,EACnB,wBAAwB,GACzB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAChF,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAChE,YAAY,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,YAAY,EACV,QAAQ,EACR,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,WAAW,EACX,cAAc,EACd,QAAQ,EACR,YAAY,EACZ,IAAI,EACJ,UAAU,EACV,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EACL,gBAAgB,EAChB,yBAAyB,EACzB,mBAAmB,EACnB,0BAA0B,EAC1B,UAAU,EACV,aAAa,EACb,oBAAoB,EACpB,sBAAsB,EACtB,iBAAiB,EACjB,oBAAoB,EACpB,cAAc,EACd,kBAAkB,EAClB,qBAAqB,EACrB,QAAQ,IAAI,cAAc,GAC3B,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAGlF,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AACzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAG5D,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AAGjF,OAAO,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAChE,YAAY,EACV,oBAAoB,EACpB,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,oCAAoC,CAAC;AAE5C;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,yCAAyC;IACzC,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC,yCAAyC;IACzC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;CAC7B;AAED;;;;;GAKG;AACH,MAAM,MAAM,uBAAuB,GAAG,yBAAyB,CAAC;AAEhE;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,SAAS,WAAW,EAAE,EAC/D,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,EACjB,OAAO,CAAC,EAAE,uBAAuB,GAChC,WAAW,CAKb"}
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../src/browser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,EAAsB,KAAK,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAEhG,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,+BAA+B,CAAC;AACpE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAGrD,YAAY,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AACpE,YAAY,EAAE,+BAA+B,EAAE,MAAM,+BAA+B,CAAC;AACrF,YAAY,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAE5E,YAAY,EACV,WAAW,EACX,cAAc,EACd,mBAAmB,EACnB,wBAAwB,GACzB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAChF,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAChE,YAAY,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,YAAY,EACV,QAAQ,EACR,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,WAAW,EACX,cAAc,EACd,QAAQ,EACR,YAAY,EACZ,IAAI,EACJ,UAAU,EACV,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EACL,gBAAgB,EAChB,yBAAyB,EACzB,mBAAmB,EACnB,0BAA0B,EAC1B,UAAU,EACV,aAAa,EACb,oBAAoB,EACpB,sBAAsB,EACtB,iBAAiB,EACjB,oBAAoB,EACpB,cAAc,EACd,kBAAkB,EAClB,qBAAqB,EACrB,QAAQ,IAAI,cAAc,GAC3B,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAGlF,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AACzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAG5D,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AAGjF,OAAO,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAChE,YAAY,EACV,oBAAoB,EACpB,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,oCAAoC,CAAC;AAE5C;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,yCAAyC;IACzC,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC,yCAAyC;IACzC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;CAC7B;AAED;;;;;GAKG;AACH,MAAM,MAAM,uBAAuB,GAAG,yBAAyB,CAAC;AAEhE;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,SAAS,WAAW,EAAE,EAC/D,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,EACjB,OAAO,CAAC,EAAE,uBAAuB,GAChC,WAAW,CAKb"}

package/dist/browser.js

@@ -330,6 +330,9 @@ function generateJsonSchemaFromIR(ir, options) {
   const ctx = makeContext(options);
   for (const [name, typeDef] of Object.entries(ir.typeRegistry)) {
     ctx.defs[name] = generateTypeNode(typeDef.type, ctx);
+    if (typeDef.annotations && typeDef.annotations.length > 0) {
+      applyAnnotations(ctx.defs[name], typeDef.annotations, ctx);
+    }
   }
   const properties = {};
   const required = [];
@@ -341,6 +344,9 @@ function generateJsonSchemaFromIR(ir, options) {
     properties,
     ...uniqueRequired.length > 0 && { required: uniqueRequired }
   };
+  if (ir.annotations && ir.annotations.length > 0) {
+    applyAnnotations(result, ir.annotations, ctx);
+  }
   if (Object.keys(ctx.defs).length > 0) {
     result.$defs = ctx.defs;
   }
@@ -370,22 +376,51 @@ function collectFields(elements, properties, required, ctx) {
 }
 function generateFieldSchema(field, ctx) {
   const schema = generateTypeNode(field.type, ctx);
+  const itemStringSchema = schema.type === "array" && schema.items?.type === "string" ? schema.items : void 0;
   const directConstraints = [];
+  const itemConstraints = [];
   const pathConstraints = [];
   for (const c of field.constraints) {
     if (c.path) {
       pathConstraints.push(c);
+    } else if (itemStringSchema !== void 0 && isStringItemConstraint(c)) {
+      itemConstraints.push(c);
     } else {
       directConstraints.push(c);
     }
   }
   applyConstraints(schema, directConstraints, ctx);
-  applyAnnotations(schema, field.annotations, ctx);
+  if (itemStringSchema !== void 0) {
+    applyConstraints(itemStringSchema, itemConstraints, ctx);
+  }
+  const rootAnnotations = [];
+  const itemAnnotations = [];
+  for (const annotation of field.annotations) {
+    if (itemStringSchema !== void 0 && annotation.annotationKind === "format") {
+      itemAnnotations.push(annotation);
+    } else {
+      rootAnnotations.push(annotation);
+    }
+  }
+  applyAnnotations(schema, rootAnnotations, ctx);
+  if (itemStringSchema !== void 0) {
+    applyAnnotations(itemStringSchema, itemAnnotations, ctx);
+  }
   if (pathConstraints.length === 0) {
     return schema;
   }
   return applyPathTargetedConstraints(schema, pathConstraints, ctx);
 }
+function isStringItemConstraint(constraint) {
+  switch (constraint.constraintKind) {
+    case "minLength":
+    case "maxLength":
+    case "pattern":
+      return true;
+    default:
+      return false;
+  }
+}
 function applyPathTargetedConstraints(schema, pathConstraints, ctx) {
   if (schema.type === "array" && schema.items) {
     schema.items = applyPathTargetedConstraints(schema.items, pathConstraints, ctx);
@@ -603,6 +638,9 @@ function applyConstraints(schema, constraints, ctx) {
       case "uniqueItems":
         schema.uniqueItems = constraint.value;
         break;
+      case "const":
+        schema.const = constraint.value;
+        break;
       case "allowedMembers":
         break;
       case "custom":
@@ -627,8 +665,14 @@ function applyAnnotations(schema, annotations, ctx) {
       case "defaultValue":
         schema.default = annotation.value;
         break;
+      case "format":
+        schema.format = annotation.value;
+        break;
       case "deprecated":
         schema.deprecated = true;
+        if (annotation.message !== void 0 && annotation.message !== "") {
+          schema["x-formspec-deprecation-description"] = annotation.message;
+        }
         break;
       case "placeholder":
         break;
@@ -660,7 +704,12 @@ function applyCustomConstraint(schema, constraint, ctx) {
       `Cannot generate JSON Schema for custom constraint "${constraint.constraintId}" without a matching extension registration`
     );
   }
-  Object.assign(schema, registration.toJsonSchema(constraint.payload, ctx.vendorPrefix));
+  assignVendorPrefixedExtensionKeywords(
+    schema,
+    registration.toJsonSchema(constraint.payload, ctx.vendorPrefix),
+    ctx.vendorPrefix,
+    `custom constraint "${constraint.constraintId}"`
+  );
 }
 function applyCustomAnnotation(schema, annotation, ctx) {
   const registration = ctx.extensionRegistry?.findAnnotation(annotation.annotationId);
@@ -672,7 +721,22 @@ function applyCustomAnnotation(schema, annotation, ctx) {
   if (registration.toJsonSchema === void 0) {
     return;
   }
-  Object.assign(schema, registration.toJsonSchema(annotation.value, ctx.vendorPrefix));
+  assignVendorPrefixedExtensionKeywords(
+    schema,
+    registration.toJsonSchema(annotation.value, ctx.vendorPrefix),
+    ctx.vendorPrefix,
+    `custom annotation "${annotation.annotationId}"`
+  );
+}
+function assignVendorPrefixedExtensionKeywords(schema, extensionSchema, vendorPrefix, source) {
+  for (const [key, value] of Object.entries(extensionSchema)) {
+    if (!key.startsWith(`${vendorPrefix}-`)) {
+      throw new Error(
+        `Cannot apply ${source}: extension hooks may only emit "${vendorPrefix}-*" JSON Schema keywords`
+      );
+    }
+    schema[key] = value;
+  }
 }
 
 // src/json-schema/generator.ts
@@ -816,25 +880,31 @@ function createShowRule(fieldName, value) {
     }
   };
 }
+function flattenConditionSchema(scope, schema) {
+  if (schema.allOf === void 0) {
+    if (scope === "#") {
+      return [schema];
+    }
+    const fieldName = scope.replace("#/properties/", "");
+    return [
+      {
+        properties: {
+          [fieldName]: schema
+        }
+      }
+    ];
+  }
+  return schema.allOf.flatMap((member) => flattenConditionSchema(scope, member));
+}
 function combineRules(parentRule, childRule) {
-  const parentCondition = parentRule.condition;
-  const childCondition = childRule.condition;
   return {
     effect: "SHOW",
     condition: {
       scope: "#",
       schema: {
         allOf: [
-          {
-            properties: {
-              [parentCondition.scope.replace("#/properties/", "")]: parentCondition.schema
-            }
-          },
-          {
-            properties: {
-              [childCondition.scope.replace("#/properties/", "")]: childCondition.schema
-            }
-          }
+          ...flattenConditionSchema(parentRule.condition.scope, parentRule.condition.schema),
+          ...flattenConditionSchema(childRule.condition.scope, childRule.condition.schema)
         ]
       }
     }
@@ -842,10 +912,14 @@ function combineRules(parentRule, childRule) {
 }
 function fieldNodeToControl(field, parentRule) {
   const displayNameAnnotation = field.annotations.find((a) => a.annotationKind === "displayName");
+  const placeholderAnnotation = field.annotations.find((a) => a.annotationKind === "placeholder");
   const control = {
     type: "Control",
     scope: fieldToScope(field.name),
     ...displayNameAnnotation !== void 0 && { label: displayNameAnnotation.value },
+    ...placeholderAnnotation !== void 0 && {
+      options: { placeholder: placeholderAnnotation.value }
+    },
     ...parentRule !== void 0 && { rule: parentRule }
   };
   return control;
@@ -911,7 +985,10 @@ function getSchemaExtension(schema, key) {
 // src/extensions/registry.ts
 function createExtensionRegistry(extensions) {
   const typeMap = /* @__PURE__ */ new Map();
+  const typeNameMap = /* @__PURE__ */ new Map();
   const constraintMap = /* @__PURE__ */ new Map();
+  const constraintTagMap = /* @__PURE__ */ new Map();
+  const builtinBroadeningMap = /* @__PURE__ */ new Map();
   const annotationMap = /* @__PURE__ */ new Map();
   for (const ext of extensions) {
     if (ext.types !== void 0) {
@@ -921,6 +998,27 @@ function createExtensionRegistry(extensions) {
           throw new Error(`Duplicate custom type ID: "${qualifiedId}"`);
         }
         typeMap.set(qualifiedId, type);
+        for (const sourceTypeName of type.tsTypeNames ?? [type.typeName]) {
+          if (typeNameMap.has(sourceTypeName)) {
+            throw new Error(`Duplicate custom type source name: "${sourceTypeName}"`);
+          }
+          typeNameMap.set(sourceTypeName, {
+            extensionId: ext.extensionId,
+            registration: type
+          });
+        }
+        if (type.builtinConstraintBroadenings !== void 0) {
+          for (const broadening of type.builtinConstraintBroadenings) {
+            const key = `${qualifiedId}:${broadening.tagName}`;
+            if (builtinBroadeningMap.has(key)) {
+              throw new Error(`Duplicate built-in constraint broadening: "${key}"`);
+            }
+            builtinBroadeningMap.set(key, {
+              extensionId: ext.extensionId,
+              registration: broadening
+            });
+          }
+        }
       }
     }
     if (ext.constraints !== void 0) {
@@ -932,6 +1030,17 @@ function createExtensionRegistry(extensions) {
         constraintMap.set(qualifiedId, constraint);
       }
     }
+    if (ext.constraintTags !== void 0) {
+      for (const tag of ext.constraintTags) {
+        if (constraintTagMap.has(tag.tagName)) {
+          throw new Error(`Duplicate custom constraint tag: "@${tag.tagName}"`);
+        }
+        constraintTagMap.set(tag.tagName, {
+          extensionId: ext.extensionId,
+          registration: tag
+        });
+      }
+    }
     if (ext.annotations !== void 0) {
       for (const annotation of ext.annotations) {
         const qualifiedId = `${ext.extensionId}/${annotation.annotationName}`;
@@ -945,7 +1054,10 @@ function createExtensionRegistry(extensions) {
   return {
     extensions,
     findType: (typeId) => typeMap.get(typeId),
+    findTypeByName: (typeName) => typeNameMap.get(typeName),
     findConstraint: (constraintId) => constraintMap.get(constraintId),
+    findConstraintTag: (tagName) => constraintTagMap.get(tagName),
+    findBuiltinConstraintBroadening: (typeId, tagName) => builtinBroadeningMap.get(`${typeId}:${tagName}`),
     findAnnotation: (annotationId) => annotationMap.get(annotationId)
   };
 }
@@ -1013,6 +1125,7 @@ var jsonSchema7Schema = z3.lazy(
 );
 
 // src/validate/constraint-validator.ts
+import { normalizeConstraintTagName } from "@formspec/core";
 function addContradiction(ctx, message, primary, related) {
   ctx.diagnostics.push({
     code: "CONTRADICTING_CONSTRAINTS",
@@ -1040,6 +1153,15 @@ function addUnknownExtension(ctx, message, 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",
@@ -1049,6 +1171,13 @@ function addConstraintBroadening(ctx, message, primary, related) {
     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);
 }
@@ -1060,6 +1189,45 @@ function findAllowedMembers(constraints) {
     (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";
 }
@@ -1180,6 +1348,112 @@ function checkConstraintBroadening(ctx, fieldName, constraints) {
     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");
@@ -1266,6 +1540,25 @@ function checkAllowedMembersContradiction(ctx, fieldName, constraints) {
     }
   }
 }
+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":
@@ -1338,6 +1631,8 @@ function checkConstraintOnType(ctx, fieldName, type, constraint) {
   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) {
@@ -1358,10 +1653,10 @@ function checkConstraintOnType(ctx, fieldName, type, constraint) {
     case "minLength":
     case "maxLength":
     case "pattern": {
-      if (!isString) {
+      if (!isString && !isStringArray) {
         addTypeMismatch(
           ctx,
-          `Field "${fieldName}": constraint "${ck}" is only valid on string fields, but field type is "${label}"`,
+          `Field "${fieldName}": constraint "${ck}" is only valid on string fields or string array items, but field type is "${label}"`,
           constraint.provenance
         );
       }
@@ -1389,6 +1684,37 @@ function checkConstraintOnType(ctx, fieldName, type, constraint) {
       }
       break;
     }
+    case "const": {
+      const isPrimitiveConstType = effectiveType.kind === "primitive" && ["string", "number", "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;
+        if (valueType !== effectiveType.primitiveKind) {
+          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;
@@ -1407,9 +1733,9 @@ function checkTypeApplicability(ctx, fieldName, type, constraints) {
       const resolution = resolvePathTargetType(ctx, type, constraint.path.segments);
       const targetFieldName = formatPathTargetFieldName(fieldName, constraint.path.segments);
       if (resolution.kind === "missing-property") {
-        addTypeMismatch(
+        addUnknownPathTarget(
           ctx,
-          `Field "${fieldName}": path-targeted constraint "${constraint.constraintKind}" references unknown path segment "${resolution.segment}"`,
+          `Field "${targetFieldName}": path-targeted constraint "${constraint.constraintKind}" references unknown path segment "${resolution.segment}"`,
           constraint.provenance
         );
         continue;
@@ -1439,8 +1765,30 @@ function checkCustomConstraint(ctx, fieldName, type, constraint) {
     );
     return;
   }
-  if (registration.applicableTypes === null) return;
-  if (!registration.applicableTypes.includes(type.kind)) {
+  const normalizedTagName = constraint.provenance.tagName === void 0 ? void 0 : 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 && tagRegistration.registration.isApplicableToType?.(type) === false) {
+      addTypeMismatch(
+        ctx,
+        `Field "${fieldName}": custom constraint "${constraint.constraintId}" is not applicable to type "${typeLabel(type)}"`,
+        constraint.provenance
+      );
+      return;
+    }
+  }
+  if (registration.applicableTypes === null) {
+    if (registration.isApplicableToType?.(type) === false) {
+      addTypeMismatch(
+        ctx,
+        `Field "${fieldName}": custom constraint "${constraint.constraintId}" is not applicable to type "${typeLabel(type)}"`,
+        constraint.provenance
+      );
+    }
+    return;
+  }
+  if (!registration.applicableTypes.includes(type.kind) || registration.isApplicableToType?.(type) === false) {
     addTypeMismatch(
       ctx,
       `Field "${fieldName}": custom constraint "${constraint.constraintId}" is not applicable to type "${typeLabel(type)}"`,
@@ -1469,7 +1817,9 @@ 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) {