@formspec/build 0.1.0-alpha.11 → 0.1.0-alpha.12

package/dist/browser.cjs

@@ -21,12 +21,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var browser_exports = {};
 __export(browser_exports, {
   buildFormSchemas: () => buildFormSchemas,
+  canonicalizeChainDSL: () => canonicalizeChainDSL,
   categorizationSchema: () => categorizationSchema,
   categorySchema: () => categorySchema,
   controlSchema: () => controlSchema,
   generateJsonSchema: () => generateJsonSchema,
   generateUiSchema: () => generateUiSchema,
-  generateUiSchemaFromFields: () => generateUiSchemaFromFields,
   getSchemaExtension: () => getSchemaExtension,
   groupLayoutSchema: () => groupLayoutSchema,
   horizontalLayoutSchema: () => horizontalLayoutSchema,
@@ -41,211 +41,540 @@ __export(browser_exports, {
   uiSchemaElementSchema: () => uiSchemaElementSchema,
   uiSchemaElementTypeSchema: () => uiSchemaElementTypeSchema,
   uiSchemaSchema: () => uiSchema,
+  validateIR: () => validateIR,
   verticalLayoutSchema: () => verticalLayoutSchema
 });
 module.exports = __toCommonJS(browser_exports);
 
-// src/json-schema/schema.ts
-var import_zod = require("zod");
-var jsonSchemaTypeSchema = import_zod.z.enum([
-  "string",
-  "number",
-  "integer",
-  "boolean",
-  "object",
-  "array",
-  "null"
-]);
-var jsonSchema7Schema = import_zod.z.lazy(
-  () => import_zod.z.object({
-    $schema: import_zod.z.string().optional(),
-    $id: import_zod.z.string().optional(),
-    $ref: import_zod.z.string().optional(),
-    // Metadata
-    title: import_zod.z.string().optional(),
-    description: import_zod.z.string().optional(),
-    deprecated: import_zod.z.boolean().optional(),
-    // Type
-    type: import_zod.z.union([jsonSchemaTypeSchema, import_zod.z.array(jsonSchemaTypeSchema)]).optional(),
-    // String validation
-    minLength: import_zod.z.number().optional(),
-    maxLength: import_zod.z.number().optional(),
-    pattern: import_zod.z.string().optional(),
-    // Number validation
-    minimum: import_zod.z.number().optional(),
-    maximum: import_zod.z.number().optional(),
-    exclusiveMinimum: import_zod.z.number().optional(),
-    exclusiveMaximum: import_zod.z.number().optional(),
-    // Enum
-    enum: import_zod.z.array(import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean(), import_zod.z.null()])).readonly().optional(),
-    const: import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean(), import_zod.z.null()]).optional(),
-    // Object
-    properties: import_zod.z.record(import_zod.z.string(), jsonSchema7Schema).optional(),
-    required: import_zod.z.array(import_zod.z.string()).optional(),
-    additionalProperties: import_zod.z.union([import_zod.z.boolean(), jsonSchema7Schema]).optional(),
-    // Array
-    items: import_zod.z.union([jsonSchema7Schema, import_zod.z.array(jsonSchema7Schema)]).optional(),
-    minItems: import_zod.z.number().optional(),
-    maxItems: import_zod.z.number().optional(),
-    // Composition
-    allOf: import_zod.z.array(jsonSchema7Schema).optional(),
-    anyOf: import_zod.z.array(jsonSchema7Schema).optional(),
-    oneOf: import_zod.z.array(jsonSchema7Schema).optional(),
-    not: jsonSchema7Schema.optional(),
-    // Conditional
-    if: jsonSchema7Schema.optional(),
-    then: jsonSchema7Schema.optional(),
-    else: jsonSchema7Schema.optional(),
-    // Format
-    format: import_zod.z.string().optional(),
-    // Default
-    default: import_zod.z.unknown().optional(),
-    // FormSpec extensions
-    "x-formspec-source": import_zod.z.string().optional(),
-    "x-formspec-params": import_zod.z.array(import_zod.z.string()).readonly().optional(),
-    "x-formspec-schemaSource": import_zod.z.string().optional()
-  }).passthrough()
-);
-
-// src/json-schema/generator.ts
-var import_zod2 = require("zod");
-function parseOrThrow(schema, value, label) {
-  try {
-    return schema.parse(value);
-  } catch (error) {
-    if (error instanceof import_zod2.z.ZodError) {
-      throw new Error(
-        `Generated ${label} failed validation:
-${error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n")}`
-      );
-    }
-    throw error;
-  }
+// src/canonicalize/chain-dsl-canonicalizer.ts
+var import_core = require("@formspec/core");
+var CHAIN_DSL_PROVENANCE = {
+  surface: "chain-dsl",
+  file: "",
+  line: 0,
+  column: 0
+};
+function isGroup(el) {
+  return el._type === "group";
 }
-function generateNestedSchema(elements) {
-  const properties = {};
-  const required = [];
-  collectFields(elements, properties, required);
-  const uniqueRequired = [...new Set(required)];
+function isConditional(el) {
+  return el._type === "conditional";
+}
+function isField(el) {
+  return el._type === "field";
+}
+function canonicalizeChainDSL(form) {
   return {
-    type: "object",
-    properties,
-    ...uniqueRequired.length > 0 && { required: uniqueRequired }
+    kind: "form-ir",
+    irVersion: import_core.IR_VERSION,
+    elements: canonicalizeElements(form.elements),
+    typeRegistry: {},
+    provenance: CHAIN_DSL_PROVENANCE
   };
 }
-function fieldToJsonSchema(field) {
-  const base = {};
-  if (field.label !== void 0) {
-    base.title = field.label;
+function canonicalizeElements(elements) {
+  return elements.map(canonicalizeElement);
+}
+function canonicalizeElement(element) {
+  if (isField(element)) {
+    return canonicalizeField(element);
+  }
+  if (isGroup(element)) {
+    return canonicalizeGroup(element);
   }
+  if (isConditional(element)) {
+    return canonicalizeConditional(element);
+  }
+  const _exhaustive = element;
+  throw new Error(`Unknown element type: ${JSON.stringify(_exhaustive)}`);
+}
+function canonicalizeField(field) {
   switch (field._field) {
     case "text":
-      return { ...base, type: "string" };
+      return canonicalizeTextField(field);
     case "number":
-      return {
-        ...base,
-        type: "number",
-        ...field.min !== void 0 && { minimum: field.min },
-        ...field.max !== void 0 && { maximum: field.max }
-      };
+      return canonicalizeNumberField(field);
     case "boolean":
-      return { ...base, type: "boolean" };
-    case "enum": {
-      const opts = field.options;
-      const isObjectOptions = opts.length > 0 && opts.every(
-        (opt) => typeof opt === "object" && "id" in opt && "label" in opt
-      );
-      if (isObjectOptions) {
-        return {
-          ...base,
-          type: "string",
-          oneOf: opts.map((o) => ({
-            const: o.id,
-            title: o.label
-          }))
-        };
-      }
-      return { ...base, type: "string", enum: opts };
-    }
+      return canonicalizeBooleanField(field);
+    case "enum":
+      return canonicalizeStaticEnumField(field);
     case "dynamic_enum":
-      return {
-        ...base,
-        type: "string",
-        "x-formspec-source": field.source,
-        ...field.params !== void 0 && field.params.length > 0 && { "x-formspec-params": field.params }
-      };
+      return canonicalizeDynamicEnumField(field);
     case "dynamic_schema":
-      return {
-        ...base,
-        type: "object",
-        additionalProperties: true,
-        "x-formspec-schemaSource": field.schemaSource
-      };
-    case "array": {
-      const arrayField = field;
-      return {
-        ...base,
-        type: "array",
-        items: generateNestedSchema(arrayField.items),
-        ...arrayField.minItems !== void 0 && { minItems: arrayField.minItems },
-        ...arrayField.maxItems !== void 0 && { maxItems: arrayField.maxItems }
-      };
-    }
-    case "object": {
-      const objectField = field;
-      const nestedSchema = generateNestedSchema(objectField.properties);
-      return {
-        ...base,
-        ...nestedSchema
-      };
-    }
+      return canonicalizeDynamicSchemaField(field);
+    case "array":
+      return canonicalizeArrayField(field);
+    case "object":
+      return canonicalizeObjectField(field);
     default: {
       const _exhaustive = field;
-      return _exhaustive;
+      throw new Error(`Unknown field type: ${JSON.stringify(_exhaustive)}`);
     }
   }
 }
-function collectFields(elements, properties, required) {
+function canonicalizeTextField(field) {
+  const type = { kind: "primitive", primitiveKind: "string" };
+  return buildFieldNode(
+    field.name,
+    type,
+    field.required,
+    buildAnnotations(field.label, field.placeholder)
+  );
+}
+function canonicalizeNumberField(field) {
+  const type = { kind: "primitive", primitiveKind: "number" };
+  const constraints = [];
+  if (field.min !== void 0) {
+    const c = {
+      kind: "constraint",
+      constraintKind: "minimum",
+      value: field.min,
+      provenance: CHAIN_DSL_PROVENANCE
+    };
+    constraints.push(c);
+  }
+  if (field.max !== void 0) {
+    const c = {
+      kind: "constraint",
+      constraintKind: "maximum",
+      value: field.max,
+      provenance: CHAIN_DSL_PROVENANCE
+    };
+    constraints.push(c);
+  }
+  return buildFieldNode(
+    field.name,
+    type,
+    field.required,
+    buildAnnotations(field.label),
+    constraints
+  );
+}
+function canonicalizeBooleanField(field) {
+  const type = { kind: "primitive", primitiveKind: "boolean" };
+  return buildFieldNode(field.name, type, field.required, buildAnnotations(field.label));
+}
+function canonicalizeStaticEnumField(field) {
+  const members = field.options.map((opt) => {
+    if (typeof opt === "string") {
+      return { value: opt };
+    }
+    return { value: opt.id, displayName: opt.label };
+  });
+  const type = { kind: "enum", members };
+  return buildFieldNode(field.name, type, field.required, buildAnnotations(field.label));
+}
+function canonicalizeDynamicEnumField(field) {
+  const type = {
+    kind: "dynamic",
+    dynamicKind: "enum",
+    sourceKey: field.source,
+    parameterFields: field.params ? [...field.params] : []
+  };
+  return buildFieldNode(field.name, type, field.required, buildAnnotations(field.label));
+}
+function canonicalizeDynamicSchemaField(field) {
+  const type = {
+    kind: "dynamic",
+    dynamicKind: "schema",
+    sourceKey: field.schemaSource,
+    parameterFields: []
+  };
+  return buildFieldNode(field.name, type, field.required, buildAnnotations(field.label));
+}
+function canonicalizeArrayField(field) {
+  const itemProperties = buildObjectProperties(field.items);
+  const itemsType = {
+    kind: "object",
+    properties: itemProperties,
+    additionalProperties: false
+  };
+  const type = { kind: "array", items: itemsType };
+  const constraints = [];
+  if (field.minItems !== void 0) {
+    const c = {
+      kind: "constraint",
+      constraintKind: "minItems",
+      value: field.minItems,
+      provenance: CHAIN_DSL_PROVENANCE
+    };
+    constraints.push(c);
+  }
+  if (field.maxItems !== void 0) {
+    const c = {
+      kind: "constraint",
+      constraintKind: "maxItems",
+      value: field.maxItems,
+      provenance: CHAIN_DSL_PROVENANCE
+    };
+    constraints.push(c);
+  }
+  return buildFieldNode(
+    field.name,
+    type,
+    field.required,
+    buildAnnotations(field.label),
+    constraints
+  );
+}
+function canonicalizeObjectField(field) {
+  const properties = buildObjectProperties(field.properties);
+  const type = {
+    kind: "object",
+    properties,
+    additionalProperties: false
+  };
+  return buildFieldNode(field.name, type, field.required, buildAnnotations(field.label));
+}
+function canonicalizeGroup(g) {
+  return {
+    kind: "group",
+    label: g.label,
+    elements: canonicalizeElements(g.elements),
+    provenance: CHAIN_DSL_PROVENANCE
+  };
+}
+function canonicalizeConditional(c) {
+  return {
+    kind: "conditional",
+    fieldName: c.field,
+    // Conditional values from the chain DSL are JSON-serializable primitives
+    // (strings, numbers, booleans) produced by the `is()` predicate helper.
+    value: assertJsonValue(c.value),
+    elements: canonicalizeElements(c.elements),
+    provenance: CHAIN_DSL_PROVENANCE
+  };
+}
+function assertJsonValue(v) {
+  if (v === null || typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+    return v;
+  }
+  if (Array.isArray(v)) {
+    return v.map(assertJsonValue);
+  }
+  if (typeof v === "object") {
+    const result = {};
+    for (const [key, val] of Object.entries(v)) {
+      result[key] = assertJsonValue(val);
+    }
+    return result;
+  }
+  throw new TypeError(`Conditional value is not a valid JsonValue: ${typeof v}`);
+}
+function buildFieldNode(name, type, required, annotations, constraints = []) {
+  return {
+    kind: "field",
+    name,
+    type,
+    required: required === true,
+    constraints,
+    annotations,
+    provenance: CHAIN_DSL_PROVENANCE
+  };
+}
+function buildAnnotations(label, placeholder) {
+  const annotations = [];
+  if (label !== void 0) {
+    const a = {
+      kind: "annotation",
+      annotationKind: "displayName",
+      value: label,
+      provenance: CHAIN_DSL_PROVENANCE
+    };
+    annotations.push(a);
+  }
+  if (placeholder !== void 0) {
+    const a = {
+      kind: "annotation",
+      annotationKind: "placeholder",
+      value: placeholder,
+      provenance: CHAIN_DSL_PROVENANCE
+    };
+    annotations.push(a);
+  }
+  return annotations;
+}
+function buildObjectProperties(elements, insideConditional = false) {
+  const properties = [];
+  for (const el of elements) {
+    if (isField(el)) {
+      const fieldNode = canonicalizeField(el);
+      properties.push({
+        name: fieldNode.name,
+        type: fieldNode.type,
+        // Fields inside a conditional branch are always optional in the
+        // data schema, regardless of their `required` flag — the condition
+        // may not be met, so the field may be absent.
+        optional: insideConditional || !fieldNode.required,
+        constraints: fieldNode.constraints,
+        annotations: fieldNode.annotations,
+        provenance: CHAIN_DSL_PROVENANCE
+      });
+    } else if (isGroup(el)) {
+      properties.push(...buildObjectProperties(el.elements, insideConditional));
+    } else if (isConditional(el)) {
+      properties.push(...buildObjectProperties(el.elements, true));
+    }
+  }
+  return properties;
+}
+
+// src/canonicalize/tsdoc-canonicalizer.ts
+var import_core2 = require("@formspec/core");
+
+// src/json-schema/ir-generator.ts
+function makeContext() {
+  return { defs: {} };
+}
+function generateJsonSchemaFromIR(ir) {
+  const ctx = makeContext();
+  for (const [name, typeDef] of Object.entries(ir.typeRegistry)) {
+    ctx.defs[name] = generateTypeNode(typeDef.type, ctx);
+  }
+  const properties = {};
+  const required = [];
+  collectFields(ir.elements, properties, required, ctx);
+  const uniqueRequired = [...new Set(required)];
+  const result = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    type: "object",
+    properties,
+    ...uniqueRequired.length > 0 && { required: uniqueRequired }
+  };
+  if (Object.keys(ctx.defs).length > 0) {
+    result.$defs = ctx.defs;
+  }
+  return result;
+}
+function collectFields(elements, properties, required, ctx) {
   for (const element of elements) {
-    switch (element._type) {
+    switch (element.kind) {
       case "field":
-        properties[element.name] = fieldToJsonSchema(element);
-        if (element.required === true) {
+        properties[element.name] = generateFieldSchema(element, ctx);
+        if (element.required) {
           required.push(element.name);
         }
         break;
       case "group":
-        collectFields(element.elements, properties, required);
+        collectFields(element.elements, properties, required, ctx);
         break;
       case "conditional":
-        collectFields(
-          element.elements,
-          properties,
-          required
-        );
+        collectFields(element.elements, properties, required, ctx);
         break;
+      default: {
+        const _exhaustive = element;
+        void _exhaustive;
+      }
     }
   }
 }
-function generateJsonSchema(form) {
+function generateFieldSchema(field, ctx) {
+  const schema = generateTypeNode(field.type, ctx);
+  applyConstraints(schema, field.constraints);
+  applyAnnotations(schema, field.annotations);
+  return schema;
+}
+function generateTypeNode(type, ctx) {
+  switch (type.kind) {
+    case "primitive":
+      return generatePrimitiveType(type);
+    case "enum":
+      return generateEnumType(type);
+    case "array":
+      return generateArrayType(type, ctx);
+    case "object":
+      return generateObjectType(type, ctx);
+    case "union":
+      return generateUnionType(type, ctx);
+    case "reference":
+      return generateReferenceType(type);
+    case "dynamic":
+      return generateDynamicType(type);
+    case "custom":
+      return generateCustomType(type);
+    default: {
+      const _exhaustive = type;
+      return _exhaustive;
+    }
+  }
+}
+function generatePrimitiveType(type) {
+  return { type: type.primitiveKind };
+}
+function generateEnumType(type) {
+  const hasDisplayNames = type.members.some((m) => m.displayName !== void 0);
+  if (hasDisplayNames) {
+    return {
+      oneOf: type.members.map((m) => {
+        const entry = { const: m.value };
+        if (m.displayName !== void 0) {
+          entry.title = m.displayName;
+        }
+        return entry;
+      })
+    };
+  }
+  return { enum: type.members.map((m) => m.value) };
+}
+function generateArrayType(type, ctx) {
+  return {
+    type: "array",
+    items: generateTypeNode(type.items, ctx)
+  };
+}
+function generateObjectType(type, ctx) {
   const properties = {};
   const required = [];
-  collectFields(form.elements, properties, required);
-  const uniqueRequired = [...new Set(required)];
-  const result = {
-    $schema: "https://json-schema.org/draft-07/schema#",
+  for (const prop of type.properties) {
+    properties[prop.name] = generatePropertySchema(prop, ctx);
+    if (!prop.optional) {
+      required.push(prop.name);
+    }
+  }
+  const schema = { type: "object", properties };
+  if (required.length > 0) {
+    schema.required = required;
+  }
+  if (!type.additionalProperties) {
+    schema.additionalProperties = false;
+  }
+  return schema;
+}
+function generatePropertySchema(prop, ctx) {
+  const schema = generateTypeNode(prop.type, ctx);
+  applyConstraints(schema, prop.constraints);
+  applyAnnotations(schema, prop.annotations);
+  return schema;
+}
+function generateUnionType(type, ctx) {
+  if (isBooleanUnion(type)) {
+    return { type: "boolean" };
+  }
+  return {
+    anyOf: type.members.map((m) => generateTypeNode(m, ctx))
+  };
+}
+function isBooleanUnion(type) {
+  if (type.members.length !== 2) return false;
+  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 generateReferenceType(type) {
+  return { $ref: `#/$defs/${type.name}` };
+}
+function generateDynamicType(type) {
+  if (type.dynamicKind === "enum") {
+    const schema = {
+      type: "string",
+      "x-formspec-source": type.sourceKey
+    };
+    if (type.parameterFields.length > 0) {
+      schema["x-formspec-params"] = [...type.parameterFields];
+    }
+    return schema;
+  }
+  return {
     type: "object",
-    properties,
-    ...uniqueRequired.length > 0 && { required: uniqueRequired }
+    additionalProperties: true,
+    "x-formspec-schemaSource": type.sourceKey
   };
-  return parseOrThrow(jsonSchema7Schema, result, "JSON Schema");
+}
+function generateCustomType(_type) {
+  return { type: "object" };
+}
+function applyConstraints(schema, constraints) {
+  for (const constraint of constraints) {
+    switch (constraint.constraintKind) {
+      case "minimum":
+        schema.minimum = constraint.value;
+        break;
+      case "maximum":
+        schema.maximum = constraint.value;
+        break;
+      case "exclusiveMinimum":
+        schema.exclusiveMinimum = constraint.value;
+        break;
+      case "exclusiveMaximum":
+        schema.exclusiveMaximum = constraint.value;
+        break;
+      case "multipleOf": {
+        const { value } = constraint;
+        if (value === 1 && schema.type === "number") {
+          schema.type = "integer";
+        } else {
+          schema.multipleOf = value;
+        }
+        break;
+      }
+      case "minLength":
+        schema.minLength = constraint.value;
+        break;
+      case "maxLength":
+        schema.maxLength = constraint.value;
+        break;
+      case "minItems":
+        schema.minItems = constraint.value;
+        break;
+      case "maxItems":
+        schema.maxItems = constraint.value;
+        break;
+      case "pattern":
+        schema.pattern = constraint.pattern;
+        break;
+      case "uniqueItems":
+        schema.uniqueItems = constraint.value;
+        break;
+      case "allowedMembers":
+        break;
+      case "custom":
+        break;
+      default: {
+        const _exhaustive = constraint;
+        void _exhaustive;
+      }
+    }
+  }
+}
+function applyAnnotations(schema, annotations) {
+  for (const annotation of annotations) {
+    switch (annotation.annotationKind) {
+      case "displayName":
+        schema.title = annotation.value;
+        break;
+      case "description":
+        schema.description = annotation.value;
+        break;
+      case "defaultValue":
+        schema.default = annotation.value;
+        break;
+      case "deprecated":
+        schema.deprecated = true;
+        break;
+      case "placeholder":
+        break;
+      case "formatHint":
+        break;
+      case "custom":
+        break;
+      default: {
+        const _exhaustive = annotation;
+        void _exhaustive;
+      }
+    }
+  }
+}
+
+// src/json-schema/generator.ts
+function generateJsonSchema(form) {
+  const ir = canonicalizeChainDSL(form);
+  return generateJsonSchemaFromIR(ir);
 }
 
 // src/ui-schema/schema.ts
-var import_zod3 = require("zod");
-var jsonPointerSchema = import_zod3.z.string();
-var ruleEffectSchema = import_zod3.z.enum(["SHOW", "HIDE", "ENABLE", "DISABLE"]);
-var uiSchemaElementTypeSchema = import_zod3.z.enum([
+var import_zod = require("zod");
+var jsonPointerSchema = import_zod.z.string();
+var ruleEffectSchema = import_zod.z.enum(["SHOW", "HIDE", "ENABLE", "DISABLE"]);
+var uiSchemaElementTypeSchema = import_zod.z.enum([
   "Control",
   "VerticalLayout",
   "HorizontalLayout",
@@ -254,32 +583,32 @@ var uiSchemaElementTypeSchema = import_zod3.z.enum([
   "Category",
   "Label"
 ]);
-var ruleConditionSchema = import_zod3.z.lazy(
-  () => import_zod3.z.object({
-    const: import_zod3.z.unknown().optional(),
-    enum: import_zod3.z.array(import_zod3.z.unknown()).readonly().optional(),
-    type: import_zod3.z.string().optional(),
+var ruleConditionSchema = import_zod.z.lazy(
+  () => import_zod.z.object({
+    const: import_zod.z.unknown().optional(),
+    enum: import_zod.z.array(import_zod.z.unknown()).readonly().optional(),
+    type: import_zod.z.string().optional(),
     not: ruleConditionSchema.optional(),
-    minimum: import_zod3.z.number().optional(),
-    maximum: import_zod3.z.number().optional(),
-    exclusiveMinimum: import_zod3.z.number().optional(),
-    exclusiveMaximum: import_zod3.z.number().optional(),
-    minLength: import_zod3.z.number().optional(),
-    properties: import_zod3.z.record(import_zod3.z.string(), ruleConditionSchema).optional(),
-    required: import_zod3.z.array(import_zod3.z.string()).optional(),
-    allOf: import_zod3.z.array(ruleConditionSchema).optional()
+    minimum: import_zod.z.number().optional(),
+    maximum: import_zod.z.number().optional(),
+    exclusiveMinimum: import_zod.z.number().optional(),
+    exclusiveMaximum: import_zod.z.number().optional(),
+    minLength: import_zod.z.number().optional(),
+    properties: import_zod.z.record(import_zod.z.string(), ruleConditionSchema).optional(),
+    required: import_zod.z.array(import_zod.z.string()).optional(),
+    allOf: import_zod.z.array(ruleConditionSchema).optional()
   }).strict()
 );
-var schemaBasedConditionSchema = import_zod3.z.object({
+var schemaBasedConditionSchema = import_zod.z.object({
   scope: jsonPointerSchema,
   schema: ruleConditionSchema
 }).strict();
-var ruleSchema = import_zod3.z.object({
+var ruleSchema = import_zod.z.object({
   effect: ruleEffectSchema,
   condition: schemaBasedConditionSchema
 }).strict();
-var uiSchemaElementSchema = import_zod3.z.lazy(
-  () => import_zod3.z.union([
+var uiSchemaElementSchema = import_zod.z.lazy(
+  () => import_zod.z.union([
     controlSchema,
     verticalLayoutSchema,
     horizontalLayoutSchema,
@@ -289,73 +618,73 @@ var uiSchemaElementSchema = import_zod3.z.lazy(
     labelElementSchema
   ])
 );
-var controlSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("Control"),
+var controlSchema = import_zod.z.object({
+  type: import_zod.z.literal("Control"),
   scope: jsonPointerSchema,
-  label: import_zod3.z.union([import_zod3.z.string(), import_zod3.z.literal(false)]).optional(),
+  label: import_zod.z.union([import_zod.z.string(), import_zod.z.literal(false)]).optional(),
   rule: ruleSchema.optional(),
-  options: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
+  options: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
 }).passthrough();
-var verticalLayoutSchema = import_zod3.z.lazy(
-  () => import_zod3.z.object({
-    type: import_zod3.z.literal("VerticalLayout"),
-    elements: import_zod3.z.array(uiSchemaElementSchema),
+var verticalLayoutSchema = import_zod.z.lazy(
+  () => import_zod.z.object({
+    type: import_zod.z.literal("VerticalLayout"),
+    elements: import_zod.z.array(uiSchemaElementSchema),
     rule: ruleSchema.optional(),
-    options: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
+    options: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
   }).passthrough()
 );
-var horizontalLayoutSchema = import_zod3.z.lazy(
-  () => import_zod3.z.object({
-    type: import_zod3.z.literal("HorizontalLayout"),
-    elements: import_zod3.z.array(uiSchemaElementSchema),
+var horizontalLayoutSchema = import_zod.z.lazy(
+  () => import_zod.z.object({
+    type: import_zod.z.literal("HorizontalLayout"),
+    elements: import_zod.z.array(uiSchemaElementSchema),
     rule: ruleSchema.optional(),
-    options: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
+    options: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
   }).passthrough()
 );
-var groupLayoutSchema = import_zod3.z.lazy(
-  () => import_zod3.z.object({
-    type: import_zod3.z.literal("Group"),
-    label: import_zod3.z.string(),
-    elements: import_zod3.z.array(uiSchemaElementSchema),
+var groupLayoutSchema = import_zod.z.lazy(
+  () => import_zod.z.object({
+    type: import_zod.z.literal("Group"),
+    label: import_zod.z.string(),
+    elements: import_zod.z.array(uiSchemaElementSchema),
     rule: ruleSchema.optional(),
-    options: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
+    options: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
   }).passthrough()
 );
-var categorySchema = import_zod3.z.lazy(
-  () => import_zod3.z.object({
-    type: import_zod3.z.literal("Category"),
-    label: import_zod3.z.string(),
-    elements: import_zod3.z.array(uiSchemaElementSchema),
+var categorySchema = import_zod.z.lazy(
+  () => import_zod.z.object({
+    type: import_zod.z.literal("Category"),
+    label: import_zod.z.string(),
+    elements: import_zod.z.array(uiSchemaElementSchema),
     rule: ruleSchema.optional(),
-    options: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
+    options: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
   }).passthrough()
 );
-var categorizationSchema = import_zod3.z.lazy(
-  () => import_zod3.z.object({
-    type: import_zod3.z.literal("Categorization"),
-    elements: import_zod3.z.array(categorySchema),
-    label: import_zod3.z.string().optional(),
+var categorizationSchema = import_zod.z.lazy(
+  () => import_zod.z.object({
+    type: import_zod.z.literal("Categorization"),
+    elements: import_zod.z.array(categorySchema),
+    label: import_zod.z.string().optional(),
     rule: ruleSchema.optional(),
-    options: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
+    options: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
   }).passthrough()
 );
-var labelElementSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("Label"),
-  text: import_zod3.z.string(),
+var labelElementSchema = import_zod.z.object({
+  type: import_zod.z.literal("Label"),
+  text: import_zod.z.string(),
   rule: ruleSchema.optional(),
-  options: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
+  options: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
 }).passthrough();
-var uiSchema = import_zod3.z.lazy(
-  () => import_zod3.z.union([verticalLayoutSchema, horizontalLayoutSchema, groupLayoutSchema, categorizationSchema])
+var uiSchema = import_zod.z.lazy(
+  () => import_zod.z.union([verticalLayoutSchema, horizontalLayoutSchema, groupLayoutSchema, categorizationSchema])
 );
 
-// src/ui-schema/generator.ts
-var import_zod4 = require("zod");
-function parseOrThrow2(schema, value, label) {
+// src/ui-schema/ir-generator.ts
+var import_zod2 = require("zod");
+function parseOrThrow(schema, value, label) {
   try {
     return schema.parse(value);
   } catch (error) {
-    if (error instanceof import_zod4.z.ZodError) {
+    if (error instanceof import_zod2.z.ZodError) {
       throw new Error(
         `Generated ${label} failed validation:
 ${error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n")}`
@@ -400,110 +729,64 @@ function combineRules(parentRule, childRule) {
     }
   };
 }
-function elementsToUiSchema(elements, parentRule) {
+function fieldNodeToControl(field, parentRule) {
+  const displayNameAnnotation = field.annotations.find((a) => a.annotationKind === "displayName");
+  const control = {
+    type: "Control",
+    scope: fieldToScope(field.name),
+    ...displayNameAnnotation !== void 0 && { label: displayNameAnnotation.value },
+    ...parentRule !== void 0 && { rule: parentRule }
+  };
+  return control;
+}
+function groupNodeToLayout(group, parentRule) {
+  return {
+    type: "Group",
+    label: group.label,
+    elements: irElementsToUiSchema(group.elements, parentRule),
+    ...parentRule !== void 0 && { rule: parentRule }
+  };
+}
+function irElementsToUiSchema(elements, parentRule) {
   const result = [];
   for (const element of elements) {
-    switch (element._type) {
+    switch (element.kind) {
       case "field": {
-        const control = {
-          type: "Control",
-          scope: fieldToScope(element.name),
-          ...element.label !== void 0 && { label: element.label },
-          ...parentRule !== void 0 && { rule: parentRule }
-        };
-        result.push(control);
+        result.push(fieldNodeToControl(element, parentRule));
         break;
       }
       case "group": {
-        const groupElement = element;
-        const group = {
-          type: "Group",
-          label: groupElement.label,
-          elements: elementsToUiSchema(groupElement.elements, parentRule),
-          ...parentRule !== void 0 && { rule: parentRule }
-        };
-        result.push(group);
+        result.push(groupNodeToLayout(element, parentRule));
         break;
       }
       case "conditional": {
-        const conditionalElement = element;
-        const newRule = createShowRule(conditionalElement.field, conditionalElement.value);
+        const newRule = createShowRule(element.fieldName, element.value);
         const combinedRule = parentRule !== void 0 ? combineRules(parentRule, newRule) : newRule;
-        const childElements = elementsToUiSchema(conditionalElement.elements, combinedRule);
+        const childElements = irElementsToUiSchema(element.elements, combinedRule);
         result.push(...childElements);
         break;
       }
+      default: {
+        const _exhaustive = element;
+        void _exhaustive;
+        throw new Error("Unhandled IR element kind");
+      }
     }
   }
   return result;
 }
-function formSpecFieldToElement(field, scopePrefix = "#/properties") {
-  const control = {
-    type: "Control",
-    scope: `${scopePrefix}/${field.id}`
-  };
-  if (field.label !== void 0) {
-    control.label = field.label;
-  }
-  if (field.showWhen !== void 0 && typeof field.showWhen === "object" && "field" in field.showWhen && "value" in field.showWhen) {
-    const sw = field.showWhen;
-    control.rule = {
-      effect: "SHOW",
-      condition: {
-        scope: `#/properties/${sw.field}`,
-        schema: { const: sw.value }
-      }
-    };
-  }
-  return control;
-}
-function generateUiSchemaFromFields(fields) {
-  const groupMap = /* @__PURE__ */ new Map();
-  const orderedKeys = [];
-  const ungrouped = [];
-  for (const field of fields) {
-    const element = formSpecFieldToElement(field);
-    if (field.group !== void 0) {
-      if (!groupMap.has(field.group)) {
-        groupMap.set(field.group, []);
-        orderedKeys.push(field.group);
-      }
-      groupMap.get(field.group).push(element);
-    } else {
-      orderedKeys.push(null);
-      ungrouped.push(element);
-    }
-  }
-  const elements = [];
-  let ungroupedIndex = 0;
-  for (const key of orderedKeys) {
-    if (key === null) {
-      const el = ungrouped[ungroupedIndex++];
-      if (el !== void 0) {
-        elements.push(el);
-      }
-    } else {
-      const groupElements = groupMap.get(key) ?? [];
-      const groupLayout = {
-        type: "Group",
-        label: key,
-        elements: groupElements
-      };
-      elements.push(groupLayout);
-    }
-  }
+function generateUiSchemaFromIR(ir) {
   const result = {
     type: "VerticalLayout",
-    elements
+    elements: irElementsToUiSchema(ir.elements)
   };
-  return parseOrThrow2(uiSchema, result, "UI Schema");
+  return parseOrThrow(uiSchema, result, "UI Schema");
 }
+
+// src/ui-schema/generator.ts
 function generateUiSchema(form) {
-  const result = {
-    type: "VerticalLayout",
-    elements: elementsToUiSchema(form.elements)
-  };
-  return parseOrThrow2(uiSchema, result, "UI Schema");
+  const ir = canonicalizeChainDSL(form);
+  return generateUiSchemaFromIR(ir);
 }
 
 // src/json-schema/types.ts
@@ -514,6 +797,373 @@ function getSchemaExtension(schema, key) {
   return schema[key];
 }
 
+// src/json-schema/schema.ts
+var import_zod3 = require("zod");
+var jsonSchemaTypeSchema = import_zod3.z.enum([
+  "string",
+  "number",
+  "integer",
+  "boolean",
+  "object",
+  "array",
+  "null"
+]);
+var jsonSchema7Schema = import_zod3.z.lazy(
+  () => import_zod3.z.object({
+    $schema: import_zod3.z.string().optional(),
+    $id: import_zod3.z.string().optional(),
+    $ref: import_zod3.z.string().optional(),
+    // Metadata
+    title: import_zod3.z.string().optional(),
+    description: import_zod3.z.string().optional(),
+    deprecated: import_zod3.z.boolean().optional(),
+    // Type
+    type: import_zod3.z.union([jsonSchemaTypeSchema, import_zod3.z.array(jsonSchemaTypeSchema)]).optional(),
+    // String validation
+    minLength: import_zod3.z.number().optional(),
+    maxLength: import_zod3.z.number().optional(),
+    pattern: import_zod3.z.string().optional(),
+    // Number validation
+    minimum: import_zod3.z.number().optional(),
+    maximum: import_zod3.z.number().optional(),
+    exclusiveMinimum: import_zod3.z.number().optional(),
+    exclusiveMaximum: import_zod3.z.number().optional(),
+    // Enum
+    enum: import_zod3.z.array(import_zod3.z.union([import_zod3.z.string(), import_zod3.z.number(), import_zod3.z.boolean(), import_zod3.z.null()])).readonly().optional(),
+    const: import_zod3.z.union([import_zod3.z.string(), import_zod3.z.number(), import_zod3.z.boolean(), import_zod3.z.null()]).optional(),
+    // Object
+    properties: import_zod3.z.record(import_zod3.z.string(), jsonSchema7Schema).optional(),
+    required: import_zod3.z.array(import_zod3.z.string()).optional(),
+    additionalProperties: import_zod3.z.union([import_zod3.z.boolean(), jsonSchema7Schema]).optional(),
+    // Array
+    items: import_zod3.z.union([jsonSchema7Schema, import_zod3.z.array(jsonSchema7Schema)]).optional(),
+    minItems: import_zod3.z.number().optional(),
+    maxItems: import_zod3.z.number().optional(),
+    // Composition
+    allOf: import_zod3.z.array(jsonSchema7Schema).optional(),
+    anyOf: import_zod3.z.array(jsonSchema7Schema).optional(),
+    oneOf: import_zod3.z.array(jsonSchema7Schema).optional(),
+    not: jsonSchema7Schema.optional(),
+    // Conditional
+    if: jsonSchema7Schema.optional(),
+    then: jsonSchema7Schema.optional(),
+    else: jsonSchema7Schema.optional(),
+    // Format
+    format: import_zod3.z.string().optional(),
+    // Default
+    default: import_zod3.z.unknown().optional(),
+    // FormSpec extensions
+    "x-formspec-source": import_zod3.z.string().optional(),
+    "x-formspec-params": import_zod3.z.array(import_zod3.z.string()).readonly().optional(),
+    "x-formspec-schemaSource": import_zod3.z.string().optional()
+  }).passthrough()
+);
+
+// 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),
+    message,
+    severity: "error",
+    primaryLocation: primary,
+    relatedLocations: [related]
+  });
+}
+function addTypeMismatch(ctx, message, primary) {
+  ctx.diagnostics.push({
+    code: makeCode(ctx, "TYPE_MISMATCH", 1),
+    message,
+    severity: "error",
+    primaryLocation: primary,
+    relatedLocations: []
+  });
+}
+function addUnknownExtension(ctx, message, primary) {
+  ctx.diagnostics.push({
+    code: makeCode(ctx, "UNKNOWN_EXTENSION", 1),
+    message,
+    severity: "warning",
+    primaryLocation: primary,
+    relatedLocations: []
+  });
+}
+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 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 typeLabel(type) {
+  switch (type.kind) {
+    case "primitive":
+      return type.primitiveKind;
+    case "enum":
+      return "enum";
+    case "array":
+      return "array";
+    case "object":
+      return "object";
+    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 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;
+      }
+      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;
+      }
+      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 "custom": {
+        checkCustomConstraint(ctx, fieldName, type, constraint);
+        break;
+      }
+      default: {
+        const _exhaustive = constraint;
+        throw new Error(
+          `Unhandled constraint kind: ${_exhaustive.constraintKind}`
+        );
+      }
+    }
+  }
+}
+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;
+  }
+  if (registration.applicableTypes === null) return;
+  if (!registration.applicableTypes.includes(type.kind)) {
+    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, field.constraints);
+  if (field.type.kind === "object") {
+    for (const prop of field.type.properties) {
+      validateObjectProperty(ctx, field.name, prop);
+    }
+  }
+}
+function validateObjectProperty(ctx, parentName, prop) {
+  const qualifiedName = `${parentName}.${prop.name}`;
+  validateConstraints(ctx, qualifiedName, prop.type, prop.constraints);
+  if (prop.type.kind === "object") {
+    for (const nestedProp of prop.type.properties) {
+      validateObjectProperty(ctx, qualifiedName, nestedProp);
+    }
+  }
+}
+function validateConstraints(ctx, name, type, constraints) {
+  checkNumericContradictions(ctx, name, constraints);
+  checkLengthContradictions(ctx, name, constraints);
+  checkAllowedMembersContradiction(ctx, name, constraints);
+  checkTypeApplicability(ctx, name, type, constraints);
+}
+function validateElement(ctx, element) {
+  switch (element.kind) {
+    case "field":
+      validateFieldNode(ctx, element);
+      break;
+    case "group":
+      for (const child of element.elements) {
+        validateElement(ctx, child);
+      }
+      break;
+    case "conditional":
+      for (const child of element.elements) {
+        validateElement(ctx, child);
+      }
+      break;
+    default: {
+      const _exhaustive = element;
+      throw new Error(`Unhandled element kind: ${_exhaustive.kind}`);
+    }
+  }
+}
+function validateIR(ir, options) {
+  const ctx = {
+    diagnostics: [],
+    vendorPrefix: options?.vendorPrefix ?? "FORMSPEC",
+    extensionRegistry: options?.extensionRegistry
+  };
+  for (const element of ir.elements) {
+    validateElement(ctx, element);
+  }
+  return {
+    diagnostics: ctx.diagnostics,
+    valid: ctx.diagnostics.every((d) => d.severity !== "error")
+  };
+}
+
 // src/browser.ts
 function buildFormSchemas(form) {
   return {
@@ -524,12 +1174,12 @@ function buildFormSchemas(form) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   buildFormSchemas,
+  canonicalizeChainDSL,
   categorizationSchema,
   categorySchema,
   controlSchema,
   generateJsonSchema,
   generateUiSchema,
-  generateUiSchemaFromFields,
   getSchemaExtension,
   groupLayoutSchema,
   horizontalLayoutSchema,
@@ -544,6 +1194,7 @@ function buildFormSchemas(form) {
   uiSchemaElementSchema,
   uiSchemaElementTypeSchema,
   uiSchemaSchema,
+  validateIR,
   verticalLayoutSchema
 });
 //# sourceMappingURL=browser.cjs.map