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

package/dist/browser.js

@@ -1,48 +1,1151 @@
-/**
- * Browser-safe exports for `@formspec/build`.
- *
- * This entry point excludes Node.js-specific functions like `writeSchemas`
- * that use `node:fs` and `node:path`, making it suitable for browser environments.
- *
- * @example
- * ```typescript
- * // In browser code (e.g., playground)
- * import { buildFormSchemas, generateJsonSchema, generateUiSchema } from "@formspec/build/browser";
- *
- * const form = formspec(field.text("name"));
- * const { jsonSchema, uiSchema } = buildFormSchemas(form);
- * ```
- *
- * @packageDocumentation
- */
-import { generateJsonSchema } from "./json-schema/generator.js";
-import { generateUiSchema } from "./ui-schema/generator.js";
-export { setSchemaExtension, getSchemaExtension } from "./json-schema/types.js";
-// Re-export individual generators
-export { generateJsonSchema } from "./json-schema/generator.js";
-export { generateUiSchema } from "./ui-schema/generator.js";
-/**
- * Builds both JSON Schema and UI Schema from a FormSpec.
- *
- * This is a browser-safe version that does not include file system operations.
- *
- * @example
- * ```typescript
- * const form = formspec(
- *   field.text("name", { required: true }),
- *   field.number("age", { min: 0 }),
- * );
- *
- * const { jsonSchema, uiSchema } = buildFormSchemas(form);
- * ```
- *
- * @param form - The FormSpec to build schemas from
- * @returns Object containing both jsonSchema and uiSchema
- */
-export function buildFormSchemas(form) {
+// src/canonicalize/chain-dsl-canonicalizer.ts
+import { IR_VERSION } from "@formspec/core";
+var CHAIN_DSL_PROVENANCE = {
+  surface: "chain-dsl",
+  file: "",
+  line: 0,
+  column: 0
+};
+function isGroup(el) {
+  return el._type === "group";
+}
+function isConditional(el) {
+  return el._type === "conditional";
+}
+function isField(el) {
+  return el._type === "field";
+}
+function canonicalizeChainDSL(form) {
+  return {
+    kind: "form-ir",
+    irVersion: IR_VERSION,
+    elements: canonicalizeElements(form.elements),
+    typeRegistry: {},
+    provenance: CHAIN_DSL_PROVENANCE
+  };
+}
+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 canonicalizeTextField(field);
+    case "number":
+      return canonicalizeNumberField(field);
+    case "boolean":
+      return canonicalizeBooleanField(field);
+    case "enum":
+      return canonicalizeStaticEnumField(field);
+    case "dynamic_enum":
+      return canonicalizeDynamicEnumField(field);
+    case "dynamic_schema":
+      return canonicalizeDynamicSchemaField(field);
+    case "array":
+      return canonicalizeArrayField(field);
+    case "object":
+      return canonicalizeObjectField(field);
+    default: {
+      const _exhaustive = field;
+      throw new Error(`Unknown field type: ${JSON.stringify(_exhaustive)}`);
+    }
+  }
+}
+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
+import { IR_VERSION as IR_VERSION2 } from "@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.kind) {
+      case "field":
+        properties[element.name] = generateFieldSchema(element, ctx);
+        if (element.required) {
+          required.push(element.name);
+        }
+        break;
+      case "group":
+        collectFields(element.elements, properties, required, ctx);
+        break;
+      case "conditional":
+        collectFields(element.elements, properties, required, ctx);
+        break;
+      default: {
+        const _exhaustive = element;
+        void _exhaustive;
+      }
+    }
+  }
+}
+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 {
-        jsonSchema: generateJsonSchema(form),
-        uiSchema: generateUiSchema(form),
+      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 = [];
+  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",
+    additionalProperties: true,
+    "x-formspec-schemaSource": type.sourceKey
+  };
+}
+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
+import { z } from "zod";
+var jsonPointerSchema = z.string();
+var ruleEffectSchema = z.enum(["SHOW", "HIDE", "ENABLE", "DISABLE"]);
+var uiSchemaElementTypeSchema = z.enum([
+  "Control",
+  "VerticalLayout",
+  "HorizontalLayout",
+  "Group",
+  "Categorization",
+  "Category",
+  "Label"
+]);
+var ruleConditionSchema = z.lazy(
+  () => z.object({
+    const: z.unknown().optional(),
+    enum: z.array(z.unknown()).readonly().optional(),
+    type: z.string().optional(),
+    not: ruleConditionSchema.optional(),
+    minimum: z.number().optional(),
+    maximum: z.number().optional(),
+    exclusiveMinimum: z.number().optional(),
+    exclusiveMaximum: z.number().optional(),
+    minLength: z.number().optional(),
+    properties: z.record(z.string(), ruleConditionSchema).optional(),
+    required: z.array(z.string()).optional(),
+    allOf: z.array(ruleConditionSchema).optional()
+  }).strict()
+);
+var schemaBasedConditionSchema = z.object({
+  scope: jsonPointerSchema,
+  schema: ruleConditionSchema
+}).strict();
+var ruleSchema = z.object({
+  effect: ruleEffectSchema,
+  condition: schemaBasedConditionSchema
+}).strict();
+var uiSchemaElementSchema = z.lazy(
+  () => z.union([
+    controlSchema,
+    verticalLayoutSchema,
+    horizontalLayoutSchema,
+    groupLayoutSchema,
+    categorizationSchema,
+    categorySchema,
+    labelElementSchema
+  ])
+);
+var controlSchema = z.object({
+  type: z.literal("Control"),
+  scope: jsonPointerSchema,
+  label: z.union([z.string(), z.literal(false)]).optional(),
+  rule: ruleSchema.optional(),
+  options: z.record(z.string(), z.unknown()).optional()
+}).passthrough();
+var verticalLayoutSchema = z.lazy(
+  () => z.object({
+    type: z.literal("VerticalLayout"),
+    elements: z.array(uiSchemaElementSchema),
+    rule: ruleSchema.optional(),
+    options: z.record(z.string(), z.unknown()).optional()
+  }).passthrough()
+);
+var horizontalLayoutSchema = z.lazy(
+  () => z.object({
+    type: z.literal("HorizontalLayout"),
+    elements: z.array(uiSchemaElementSchema),
+    rule: ruleSchema.optional(),
+    options: z.record(z.string(), z.unknown()).optional()
+  }).passthrough()
+);
+var groupLayoutSchema = z.lazy(
+  () => z.object({
+    type: z.literal("Group"),
+    label: z.string(),
+    elements: z.array(uiSchemaElementSchema),
+    rule: ruleSchema.optional(),
+    options: z.record(z.string(), z.unknown()).optional()
+  }).passthrough()
+);
+var categorySchema = z.lazy(
+  () => z.object({
+    type: z.literal("Category"),
+    label: z.string(),
+    elements: z.array(uiSchemaElementSchema),
+    rule: ruleSchema.optional(),
+    options: z.record(z.string(), z.unknown()).optional()
+  }).passthrough()
+);
+var categorizationSchema = z.lazy(
+  () => z.object({
+    type: z.literal("Categorization"),
+    elements: z.array(categorySchema),
+    label: z.string().optional(),
+    rule: ruleSchema.optional(),
+    options: z.record(z.string(), z.unknown()).optional()
+  }).passthrough()
+);
+var labelElementSchema = z.object({
+  type: z.literal("Label"),
+  text: z.string(),
+  rule: ruleSchema.optional(),
+  options: z.record(z.string(), z.unknown()).optional()
+}).passthrough();
+var uiSchema = z.lazy(
+  () => z.union([verticalLayoutSchema, horizontalLayoutSchema, groupLayoutSchema, categorizationSchema])
+);
+
+// src/ui-schema/ir-generator.ts
+import { z as z2 } from "zod";
+function parseOrThrow(schema, value, label) {
+  try {
+    return schema.parse(value);
+  } catch (error) {
+    if (error instanceof z2.ZodError) {
+      throw new Error(
+        `Generated ${label} failed validation:
+${error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n")}`
+      );
+    }
+    throw error;
+  }
+}
+function fieldToScope(fieldName) {
+  return `#/properties/${fieldName}`;
+}
+function createShowRule(fieldName, value) {
+  return {
+    effect: "SHOW",
+    condition: {
+      scope: fieldToScope(fieldName),
+      schema: { const: value }
+    }
+  };
+}
+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
+            }
+          }
+        ]
+      }
+    }
+  };
+}
+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.kind) {
+      case "field": {
+        result.push(fieldNodeToControl(element, parentRule));
+        break;
+      }
+      case "group": {
+        result.push(groupNodeToLayout(element, parentRule));
+        break;
+      }
+      case "conditional": {
+        const newRule = createShowRule(element.fieldName, element.value);
+        const combinedRule = parentRule !== void 0 ? combineRules(parentRule, newRule) : newRule;
+        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 generateUiSchemaFromIR(ir) {
+  const result = {
+    type: "VerticalLayout",
+    elements: irElementsToUiSchema(ir.elements)
+  };
+  return parseOrThrow(uiSchema, result, "UI Schema");
+}
+
+// src/ui-schema/generator.ts
+function generateUiSchema(form) {
+  const ir = canonicalizeChainDSL(form);
+  return generateUiSchemaFromIR(ir);
+}
+
+// src/json-schema/types.ts
+function setSchemaExtension(schema, key, value) {
+  schema[key] = value;
+}
+function getSchemaExtension(schema, key) {
+  return schema[key];
+}
+
+// src/json-schema/schema.ts
+import { z as z3 } from "zod";
+var jsonSchemaTypeSchema = z3.enum([
+  "string",
+  "number",
+  "integer",
+  "boolean",
+  "object",
+  "array",
+  "null"
+]);
+var jsonSchema7Schema = z3.lazy(
+  () => z3.object({
+    $schema: z3.string().optional(),
+    $id: z3.string().optional(),
+    $ref: z3.string().optional(),
+    // Metadata
+    title: z3.string().optional(),
+    description: z3.string().optional(),
+    deprecated: z3.boolean().optional(),
+    // Type
+    type: z3.union([jsonSchemaTypeSchema, z3.array(jsonSchemaTypeSchema)]).optional(),
+    // String validation
+    minLength: z3.number().optional(),
+    maxLength: z3.number().optional(),
+    pattern: z3.string().optional(),
+    // Number validation
+    minimum: z3.number().optional(),
+    maximum: z3.number().optional(),
+    exclusiveMinimum: z3.number().optional(),
+    exclusiveMaximum: z3.number().optional(),
+    // Enum
+    enum: z3.array(z3.union([z3.string(), z3.number(), z3.boolean(), z3.null()])).readonly().optional(),
+    const: z3.union([z3.string(), z3.number(), z3.boolean(), z3.null()]).optional(),
+    // Object
+    properties: z3.record(z3.string(), jsonSchema7Schema).optional(),
+    required: z3.array(z3.string()).optional(),
+    additionalProperties: z3.union([z3.boolean(), jsonSchema7Schema]).optional(),
+    // Array
+    items: z3.union([jsonSchema7Schema, z3.array(jsonSchema7Schema)]).optional(),
+    minItems: z3.number().optional(),
+    maxItems: z3.number().optional(),
+    // Composition
+    allOf: z3.array(jsonSchema7Schema).optional(),
+    anyOf: z3.array(jsonSchema7Schema).optional(),
+    oneOf: z3.array(jsonSchema7Schema).optional(),
+    not: jsonSchema7Schema.optional(),
+    // Conditional
+    if: jsonSchema7Schema.optional(),
+    then: jsonSchema7Schema.optional(),
+    else: jsonSchema7Schema.optional(),
+    // Format
+    format: z3.string().optional(),
+    // Default
+    default: z3.unknown().optional(),
+    // FormSpec extensions
+    "x-formspec-source": z3.string().optional(),
+    "x-formspec-params": z3.array(z3.string()).readonly().optional(),
+    "x-formspec-schemaSource": z3.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 {
+    jsonSchema: generateJsonSchema(form),
+    uiSchema: generateUiSchema(form)
+  };
 }
+export {
+  buildFormSchemas,
+  canonicalizeChainDSL,
+  categorizationSchema,
+  categorySchema,
+  controlSchema,
+  generateJsonSchema,
+  generateUiSchema,
+  getSchemaExtension,
+  groupLayoutSchema,
+  horizontalLayoutSchema,
+  jsonSchema7Schema,
+  jsonSchemaTypeSchema,
+  labelElementSchema,
+  ruleConditionSchema,
+  ruleEffectSchema,
+  ruleSchema,
+  schemaBasedConditionSchema,
+  setSchemaExtension,
+  uiSchemaElementSchema,
+  uiSchemaElementTypeSchema,
+  uiSchema as uiSchemaSchema,
+  validateIR,
+  verticalLayoutSchema
+};
 //# sourceMappingURL=browser.js.map