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

package/dist/browser.js

@@ -177,7 +177,7 @@ function canonicalizeArrayField(field) {
   const itemsType = {
     kind: "object",
     properties: itemProperties,
-    additionalProperties: false
+    additionalProperties: true
   };
   const type = { kind: "array", items: itemsType };
   const constraints = [];
@@ -212,7 +212,7 @@ function canonicalizeObjectField(field) {
   const type = {
     kind: "object",
     properties,
-    additionalProperties: false
+    additionalProperties: true
   };
   return buildFieldNode(field.name, type, field.required, buildAnnotations(field.label));
 }
@@ -313,11 +313,21 @@ function buildObjectProperties(elements, insideConditional = false) {
 import { IR_VERSION as IR_VERSION2 } from "@formspec/core";
 
 // src/json-schema/ir-generator.ts
-function makeContext() {
-  return { defs: {} };
+function makeContext(options) {
+  const vendorPrefix = options?.vendorPrefix ?? "x-formspec";
+  if (!vendorPrefix.startsWith("x-")) {
+    throw new Error(
+      `Invalid vendorPrefix "${vendorPrefix}". Extension JSON Schema keywords must start with "x-".`
+    );
+  }
+  return {
+    defs: {},
+    extensionRegistry: options?.extensionRegistry,
+    vendorPrefix
+  };
 }
-function generateJsonSchemaFromIR(ir) {
-  const ctx = makeContext();
+function generateJsonSchemaFromIR(ir, options) {
+  const ctx = makeContext(options);
   for (const [name, typeDef] of Object.entries(ir.typeRegistry)) {
     ctx.defs[name] = generateTypeNode(typeDef.type, ctx);
   }
@@ -360,8 +370,70 @@ function collectFields(elements, properties, required, ctx) {
 }
 function generateFieldSchema(field, ctx) {
   const schema = generateTypeNode(field.type, ctx);
-  applyConstraints(schema, field.constraints);
-  applyAnnotations(schema, field.annotations);
+  const directConstraints = [];
+  const pathConstraints = [];
+  for (const c of field.constraints) {
+    if (c.path) {
+      pathConstraints.push(c);
+    } else {
+      directConstraints.push(c);
+    }
+  }
+  applyConstraints(schema, directConstraints, ctx);
+  applyAnnotations(schema, field.annotations, ctx);
+  if (pathConstraints.length === 0) {
+    return schema;
+  }
+  return applyPathTargetedConstraints(schema, pathConstraints, ctx);
+}
+function applyPathTargetedConstraints(schema, pathConstraints, ctx) {
+  if (schema.type === "array" && schema.items) {
+    schema.items = applyPathTargetedConstraints(schema.items, pathConstraints, ctx);
+    return schema;
+  }
+  const byTarget = /* @__PURE__ */ new Map();
+  for (const c of pathConstraints) {
+    const target = c.path?.segments[0];
+    if (!target) continue;
+    const group = byTarget.get(target) ?? [];
+    group.push(c);
+    byTarget.set(target, group);
+  }
+  const propertyOverrides = {};
+  for (const [target, constraints] of byTarget) {
+    const subSchema = {};
+    applyConstraints(subSchema, constraints, ctx);
+    propertyOverrides[target] = subSchema;
+  }
+  if (schema.$ref) {
+    const { $ref, ...rest } = schema;
+    const refPart = { $ref };
+    const overridePart = {
+      properties: propertyOverrides,
+      ...rest
+    };
+    return { allOf: [refPart, overridePart] };
+  }
+  if (schema.type === "object" && schema.properties) {
+    const missingOverrides = {};
+    for (const [target, overrideSchema] of Object.entries(propertyOverrides)) {
+      if (schema.properties[target]) {
+        Object.assign(schema.properties[target], overrideSchema);
+      } else {
+        missingOverrides[target] = overrideSchema;
+      }
+    }
+    if (Object.keys(missingOverrides).length === 0) {
+      return schema;
+    }
+    return {
+      allOf: [schema, { properties: missingOverrides }]
+    };
+  }
+  if (schema.allOf) {
+    schema.allOf = [...schema.allOf, { properties: propertyOverrides }];
+    return schema;
+  }
   return schema;
 }
 function generateTypeNode(type, ctx) {
@@ -374,6 +446,8 @@ function generateTypeNode(type, ctx) {
       return generateArrayType(type, ctx);
     case "object":
       return generateObjectType(type, ctx);
+    case "record":
+      return generateRecordType(type, ctx);
     case "union":
       return generateUnionType(type, ctx);
     case "reference":
@@ -381,7 +455,7 @@ function generateTypeNode(type, ctx) {
     case "dynamic":
       return generateDynamicType(type);
     case "custom":
-      return generateCustomType(type);
+      return generateCustomType(type, ctx);
     default: {
       const _exhaustive = type;
       return _exhaustive;
@@ -430,16 +504,27 @@ function generateObjectType(type, ctx) {
   }
   return schema;
 }
+function generateRecordType(type, ctx) {
+  return {
+    type: "object",
+    additionalProperties: generateTypeNode(type.valueType, ctx)
+  };
+}
 function generatePropertySchema(prop, ctx) {
   const schema = generateTypeNode(prop.type, ctx);
-  applyConstraints(schema, prop.constraints);
-  applyAnnotations(schema, prop.annotations);
+  applyConstraints(schema, prop.constraints, ctx);
+  applyAnnotations(schema, prop.annotations, ctx);
   return schema;
 }
 function generateUnionType(type, ctx) {
   if (isBooleanUnion(type)) {
     return { type: "boolean" };
   }
+  if (isNullableUnion(type)) {
+    return {
+      oneOf: type.members.map((m) => generateTypeNode(m, ctx))
+    };
+  }
   return {
     anyOf: type.members.map((m) => generateTypeNode(m, ctx))
   };
@@ -449,6 +534,13 @@ function isBooleanUnion(type) {
   const kinds = type.members.map((m) => m.kind);
   return kinds.every((k) => k === "primitive") && type.members.every((m) => m.kind === "primitive" && m.primitiveKind === "boolean");
 }
+function isNullableUnion(type) {
+  if (type.members.length !== 2) return false;
+  const nullCount = type.members.filter(
+    (m) => m.kind === "primitive" && m.primitiveKind === "null"
+  ).length;
+  return nullCount === 1;
+}
 function generateReferenceType(type) {
   return { $ref: `#/$defs/${type.name}` };
 }
@@ -469,10 +561,7 @@ function generateDynamicType(type) {
     "x-formspec-schemaSource": type.sourceKey
   };
 }
-function generateCustomType(_type) {
-  return { type: "object" };
-}
-function applyConstraints(schema, constraints) {
+function applyConstraints(schema, constraints, ctx) {
   for (const constraint of constraints) {
     switch (constraint.constraintKind) {
       case "minimum":
@@ -517,6 +606,7 @@ function applyConstraints(schema, constraints) {
       case "allowedMembers":
         break;
       case "custom":
+        applyCustomConstraint(schema, constraint, ctx);
         break;
       default: {
         const _exhaustive = constraint;
@@ -525,7 +615,7 @@ function applyConstraints(schema, constraints) {
     }
   }
 }
-function applyAnnotations(schema, annotations) {
+function applyAnnotations(schema, annotations, ctx) {
   for (const annotation of annotations) {
     switch (annotation.annotationKind) {
       case "displayName":
@@ -545,6 +635,7 @@ function applyAnnotations(schema, annotations) {
       case "formatHint":
         break;
       case "custom":
+        applyCustomAnnotation(schema, annotation, ctx);
         break;
       default: {
         const _exhaustive = annotation;
@@ -553,11 +644,41 @@ function applyAnnotations(schema, annotations) {
     }
   }
 }
+function generateCustomType(type, ctx) {
+  const registration = ctx.extensionRegistry?.findType(type.typeId);
+  if (registration === void 0) {
+    throw new Error(
+      `Cannot generate JSON Schema for custom type "${type.typeId}" without a matching extension registration`
+    );
+  }
+  return registration.toJsonSchema(type.payload, ctx.vendorPrefix);
+}
+function applyCustomConstraint(schema, constraint, ctx) {
+  const registration = ctx.extensionRegistry?.findConstraint(constraint.constraintId);
+  if (registration === void 0) {
+    throw new Error(
+      `Cannot generate JSON Schema for custom constraint "${constraint.constraintId}" without a matching extension registration`
+    );
+  }
+  Object.assign(schema, registration.toJsonSchema(constraint.payload, ctx.vendorPrefix));
+}
+function applyCustomAnnotation(schema, annotation, ctx) {
+  const registration = ctx.extensionRegistry?.findAnnotation(annotation.annotationId);
+  if (registration === void 0) {
+    throw new Error(
+      `Cannot generate JSON Schema for custom annotation "${annotation.annotationId}" without a matching extension registration`
+    );
+  }
+  if (registration.toJsonSchema === void 0) {
+    return;
+  }
+  Object.assign(schema, registration.toJsonSchema(annotation.value, ctx.vendorPrefix));
+}
 
 // src/json-schema/generator.ts
-function generateJsonSchema(form) {
+function generateJsonSchema(form, options) {
   const ir = canonicalizeChainDSL(form);
-  return generateJsonSchemaFromIR(ir);
+  return generateJsonSchemaFromIR(ir, options);
 }
 
 // src/ui-schema/schema.ts
@@ -787,6 +908,48 @@ function getSchemaExtension(schema, key) {
   return schema[key];
 }
 
+// src/extensions/registry.ts
+function createExtensionRegistry(extensions) {
+  const typeMap = /* @__PURE__ */ new Map();
+  const constraintMap = /* @__PURE__ */ new Map();
+  const annotationMap = /* @__PURE__ */ new Map();
+  for (const ext of extensions) {
+    if (ext.types !== void 0) {
+      for (const type of ext.types) {
+        const qualifiedId = `${ext.extensionId}/${type.typeName}`;
+        if (typeMap.has(qualifiedId)) {
+          throw new Error(`Duplicate custom type ID: "${qualifiedId}"`);
+        }
+        typeMap.set(qualifiedId, type);
+      }
+    }
+    if (ext.constraints !== void 0) {
+      for (const constraint of ext.constraints) {
+        const qualifiedId = `${ext.extensionId}/${constraint.constraintName}`;
+        if (constraintMap.has(qualifiedId)) {
+          throw new Error(`Duplicate custom constraint ID: "${qualifiedId}"`);
+        }
+        constraintMap.set(qualifiedId, constraint);
+      }
+    }
+    if (ext.annotations !== void 0) {
+      for (const annotation of ext.annotations) {
+        const qualifiedId = `${ext.extensionId}/${annotation.annotationName}`;
+        if (annotationMap.has(qualifiedId)) {
+          throw new Error(`Duplicate custom annotation ID: "${qualifiedId}"`);
+        }
+        annotationMap.set(qualifiedId, annotation);
+      }
+    }
+  }
+  return {
+    extensions,
+    findType: (typeId) => typeMap.get(typeId),
+    findConstraint: (constraintId) => constraintMap.get(constraintId),
+    findAnnotation: (annotationId) => annotationMap.get(annotationId)
+  };
+}
+
 // src/json-schema/schema.ts
 import { z as z3 } from "zod";
 var jsonSchemaTypeSchema = z3.enum([
@@ -850,12 +1013,9 @@ var jsonSchema7Schema = z3.lazy(
 );
 
 // src/validate/constraint-validator.ts
-function makeCode(ctx, category, number) {
-  return `${ctx.vendorPrefix}-${category}-${String(number).padStart(3, "0")}`;
-}
 function addContradiction(ctx, message, primary, related) {
   ctx.diagnostics.push({
-    code: makeCode(ctx, "CONTRADICTION", 1),
+    code: "CONTRADICTING_CONSTRAINTS",
     message,
     severity: "error",
     primaryLocation: primary,
@@ -864,7 +1024,7 @@ function addContradiction(ctx, message, primary, related) {
 }
 function addTypeMismatch(ctx, message, primary) {
   ctx.diagnostics.push({
-    code: makeCode(ctx, "TYPE_MISMATCH", 1),
+    code: "TYPE_MISMATCH",
     message,
     severity: "error",
     primaryLocation: primary,
@@ -873,28 +1033,153 @@ function addTypeMismatch(ctx, message, primary) {
 }
 function addUnknownExtension(ctx, message, primary) {
   ctx.diagnostics.push({
-    code: makeCode(ctx, "UNKNOWN_EXTENSION", 1),
+    code: "UNKNOWN_EXTENSION",
     message,
     severity: "warning",
     primaryLocation: primary,
     relatedLocations: []
   });
 }
+function addConstraintBroadening(ctx, message, primary, related) {
+  ctx.diagnostics.push({
+    code: "CONSTRAINT_BROADENING",
+    message,
+    severity: "error",
+    primaryLocation: primary,
+    relatedLocations: [related]
+  });
+}
 function findNumeric(constraints, constraintKind) {
-  return constraints.find(
-    (c) => c.constraintKind === constraintKind
-  );
+  return constraints.find((c) => c.constraintKind === constraintKind);
 }
 function findLength(constraints, constraintKind) {
-  return constraints.find(
-    (c) => c.constraintKind === constraintKind
-  );
+  return constraints.find((c) => c.constraintKind === constraintKind);
 }
 function findAllowedMembers(constraints) {
   return constraints.filter(
     (c) => c.constraintKind === "allowedMembers"
   );
 }
+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 checkNumericContradictions(ctx, fieldName, constraints) {
   const min = findNumeric(constraints, "minimum");
   const max = findNumeric(constraints, "maximum");
@@ -991,6 +1276,8 @@ function typeLabel(type) {
       return "array";
     case "object":
       return "object";
+    case "record":
+      return "record";
     case "union":
       return "union";
     case "reference":
@@ -1005,74 +1292,140 @@ function typeLabel(type) {
     }
   }
 }
-function checkTypeApplicability(ctx, fieldName, type, constraints) {
-  const isNumber = type.kind === "primitive" && type.primitiveKind === "number";
-  const isString = type.kind === "primitive" && type.primitiveKind === "string";
-  const isArray = type.kind === "array";
-  const isEnum = type.kind === "enum";
-  const label = typeLabel(type);
-  for (const constraint of constraints) {
-    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;
+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 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 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" && effectiveType.primitiveKind === "number";
+  const isString = effectiveType.kind === "primitive" && effectiveType.primitiveKind === "string";
+  const isArray = effectiveType.kind === "array";
+  const isEnum = effectiveType.kind === "enum";
+  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
+        );
       }
-      case "minLength":
-      case "maxLength":
-      case "pattern": {
-        if (!isString) {
-          addTypeMismatch(
-            ctx,
-            `Field "${fieldName}": constraint "${ck}" is only valid on string fields, but field type is "${label}"`,
-            constraint.provenance
-          );
-        }
-        break;
+      break;
+    }
+    case "minLength":
+    case "maxLength":
+    case "pattern": {
+      if (!isString) {
+        addTypeMismatch(
+          ctx,
+          `Field "${fieldName}": constraint "${ck}" is only valid on string fields, but field type is "${label}"`,
+          constraint.provenance
+        );
       }
-      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;
+      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
+        );
       }
-      case "allowedMembers": {
-        if (!isEnum) {
-          addTypeMismatch(
-            ctx,
-            `Field "${fieldName}": constraint "allowedMembers" is only valid on enum fields, but field type is "${label}"`,
-            constraint.provenance
-          );
-        }
-        break;
+      break;
+    }
+    case "allowedMembers": {
+      if (!isEnum) {
+        addTypeMismatch(
+          ctx,
+          `Field "${fieldName}": constraint "allowedMembers" is only valid on enum fields, but field type is "${label}"`,
+          constraint.provenance
+        );
       }
-      case "custom": {
-        checkCustomConstraint(ctx, fieldName, type, constraint);
-        break;
+      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") {
+        addTypeMismatch(
+          ctx,
+          `Field "${fieldName}": path-targeted constraint "${constraint.constraintKind}" references unknown path segment "${resolution.segment}"`,
+          constraint.provenance
+        );
+        continue;
       }
-      default: {
-        const _exhaustive = constraint;
-        throw new Error(
-          `Unhandled constraint kind: ${_exhaustive.constraintKind}`
+      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) {
@@ -1116,6 +1469,7 @@ function validateConstraints(ctx, name, type, constraints) {
   checkNumericContradictions(ctx, name, constraints);
   checkLengthContradictions(ctx, name, constraints);
   checkAllowedMembersContradiction(ctx, name, constraints);
+  checkConstraintBroadening(ctx, name, constraints);
   checkTypeApplicability(ctx, name, type, constraints);
 }
 function validateElement(ctx, element) {
@@ -1142,8 +1496,8 @@ function validateElement(ctx, element) {
 function validateIR(ir, options) {
   const ctx = {
     diagnostics: [],
-    vendorPrefix: options?.vendorPrefix ?? "FORMSPEC",
-    extensionRegistry: options?.extensionRegistry
+    extensionRegistry: options?.extensionRegistry,
+    typeRegistry: ir.typeRegistry
   };
   for (const element of ir.elements) {
     validateElement(ctx, element);
@@ -1155,9 +1509,9 @@ function validateIR(ir, options) {
 }
 
 // src/browser.ts
-function buildFormSchemas(form) {
+function buildFormSchemas(form, options) {
   return {
-    jsonSchema: generateJsonSchema(form),
+    jsonSchema: generateJsonSchema(form, options),
     uiSchema: generateUiSchema(form)
   };
 }
@@ -1167,7 +1521,9 @@ export {
   categorizationSchema,
   categorySchema,
   controlSchema,
+  createExtensionRegistry,
   generateJsonSchema,
+  generateJsonSchemaFromIR,
   generateUiSchema,
   getSchemaExtension,
   groupLayoutSchema,