@formspec/build 0.1.0-alpha.4 → 0.1.0-alpha.41

package/dist/browser.js

@@ -0,0 +1,2070 @@
+// src/canonicalize/chain-dsl-canonicalizer.ts
+import { IR_VERSION, _getFormSpecMetadataPolicy } from "@formspec/core/internals";
+
+// src/metadata/policy.ts
+var NOOP_INFLECT = () => "";
+function normalizePluralization(input) {
+  if (input?.mode === "infer-if-missing") {
+    return {
+      mode: "infer-if-missing",
+      infer: () => "",
+      inflect: input.inflect
+    };
+  }
+  if (input?.mode === "require-explicit") {
+    return {
+      mode: "require-explicit",
+      infer: () => "",
+      inflect: NOOP_INFLECT
+    };
+  }
+  return {
+    mode: "disabled",
+    infer: () => "",
+    inflect: NOOP_INFLECT
+  };
+}
+function normalizeScalarPolicy(input) {
+  if (input?.mode === "infer-if-missing") {
+    return {
+      mode: "infer-if-missing",
+      infer: input.infer,
+      pluralization: normalizePluralization(input.pluralization)
+    };
+  }
+  if (input?.mode === "require-explicit") {
+    return {
+      mode: "require-explicit",
+      infer: () => "",
+      pluralization: normalizePluralization(input.pluralization)
+    };
+  }
+  return {
+    mode: "disabled",
+    infer: () => "",
+    pluralization: normalizePluralization(input?.pluralization)
+  };
+}
+function normalizeDeclarationPolicy(input) {
+  return {
+    apiName: normalizeScalarPolicy(input?.apiName),
+    displayName: normalizeScalarPolicy(input?.displayName)
+  };
+}
+function normalizeEnumMemberDisplayNamePolicy(input) {
+  if (input?.mode === "infer-if-missing") {
+    return {
+      mode: "infer-if-missing",
+      infer: input.infer
+    };
+  }
+  if (input?.mode === "require-explicit") {
+    return {
+      mode: "require-explicit",
+      infer: () => ""
+    };
+  }
+  return {
+    mode: "disabled",
+    infer: () => ""
+  };
+}
+function normalizeEnumMemberPolicy(input) {
+  return {
+    displayName: normalizeEnumMemberDisplayNamePolicy(input?.displayName)
+  };
+}
+function normalizeMetadataPolicy(input) {
+  return {
+    type: normalizeDeclarationPolicy(input?.type),
+    field: normalizeDeclarationPolicy(input?.field),
+    method: normalizeDeclarationPolicy(input?.method),
+    enumMember: normalizeEnumMemberPolicy(input?.enumMember)
+  };
+}
+function getDeclarationMetadataPolicy(policy, declarationKind) {
+  return policy[declarationKind];
+}
+function makeMetadataContext(surface, declarationKind, logicalName, buildContext) {
+  return {
+    surface,
+    declarationKind,
+    logicalName,
+    ...buildContext !== void 0 && { buildContext }
+  };
+}
+
+// src/metadata/resolve.ts
+function toExplicitScalar(value) {
+  return value !== void 0 && value.trim() !== "" ? { value, source: "explicit" } : void 0;
+}
+function toExplicitResolvedMetadata(explicit) {
+  if (explicit === void 0) {
+    return void 0;
+  }
+  const apiName = toExplicitScalar(explicit.apiName);
+  const displayName = toExplicitScalar(explicit.displayName);
+  const apiNamePlural = toExplicitScalar(explicit.apiNamePlural);
+  const displayNamePlural = toExplicitScalar(explicit.displayNamePlural);
+  const metadata = {
+    ...apiName !== void 0 && { apiName },
+    ...displayName !== void 0 && { displayName },
+    ...apiNamePlural !== void 0 && { apiNamePlural },
+    ...displayNamePlural !== void 0 && { displayNamePlural }
+  };
+  return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
+function resolveScalar(current, policy, context, metadataLabel) {
+  if (current !== void 0) {
+    return current;
+  }
+  if (policy.mode === "require-explicit") {
+    throw new Error(
+      `Metadata policy requires explicit ${metadataLabel} for ${context.declarationKind} "${context.logicalName}" on the ${context.surface} surface.`
+    );
+  }
+  if (policy.mode !== "infer-if-missing") {
+    return void 0;
+  }
+  const inferredValue = policy.infer(context);
+  return inferredValue.trim() !== "" ? { value: inferredValue, source: "inferred" } : void 0;
+}
+function resolvePlural(current, singular, policy, context, metadataLabel) {
+  if (current !== void 0) {
+    return current;
+  }
+  if (policy.mode === "require-explicit") {
+    throw new Error(
+      `Metadata policy requires explicit ${metadataLabel} for ${context.declarationKind} "${context.logicalName}" on the ${context.surface} surface.`
+    );
+  }
+  if (singular === void 0 || policy.mode !== "infer-if-missing") {
+    return void 0;
+  }
+  const pluralValue = policy.inflect({ ...context, singular: singular.value });
+  return pluralValue.trim() !== "" ? { value: pluralValue, source: "inferred" } : void 0;
+}
+function resolveResolvedMetadata(current, policy, context) {
+  const apiName = resolveScalar(current?.apiName, policy.apiName, context, "apiName");
+  const displayName = resolveScalar(
+    current?.displayName,
+    policy.displayName,
+    context,
+    "displayName"
+  );
+  const apiNamePlural = resolvePlural(
+    current?.apiNamePlural,
+    apiName,
+    policy.apiName.pluralization,
+    context,
+    "apiNamePlural"
+  );
+  const displayNamePlural = resolvePlural(
+    current?.displayNamePlural,
+    displayName,
+    policy.displayName.pluralization,
+    context,
+    "displayNamePlural"
+  );
+  if (apiName === void 0 && displayName === void 0 && apiNamePlural === void 0 && displayNamePlural === void 0) {
+    return void 0;
+  }
+  return {
+    ...apiName !== void 0 && { apiName },
+    ...displayName !== void 0 && { displayName },
+    ...apiNamePlural !== void 0 && { apiNamePlural },
+    ...displayNamePlural !== void 0 && { displayNamePlural }
+  };
+}
+function resolveEnumMemberDisplayName(current, policy, context) {
+  if (current !== void 0) {
+    return current;
+  }
+  if (policy.mode === "require-explicit") {
+    throw new Error(
+      `Metadata policy requires explicit displayName for enum member "${context.logicalName}" on the ${context.surface} surface.`
+    );
+  }
+  if (policy.mode !== "infer-if-missing") {
+    return void 0;
+  }
+  const inferredValue = policy.infer(context).trim();
+  return inferredValue !== "" ? inferredValue : void 0;
+}
+function resolveEnumTypeMetadata(type, options) {
+  const members = type.members.map((member) => {
+    const displayName = resolveEnumMemberDisplayName(
+      member.displayName,
+      options.policy.enumMember.displayName,
+      {
+        surface: options.surface,
+        logicalName: String(member.value),
+        memberValue: member.value,
+        ...options.buildContext !== void 0 && { buildContext: options.buildContext }
+      }
+    );
+    if (displayName === member.displayName) {
+      return member;
+    }
+    return displayName === void 0 ? { value: member.value } : { value: member.value, displayName };
+  });
+  return members.some((member, index) => member !== type.members[index]) ? { ...type, members } : type;
+}
+function resolveTypeNodeMetadata(type, options) {
+  switch (type.kind) {
+    case "array":
+      return {
+        ...type,
+        items: resolveTypeNodeMetadata(type.items, options)
+      };
+    case "object":
+      return {
+        ...type,
+        properties: type.properties.map((property) => resolveObjectPropertyMetadata(property, options))
+      };
+    case "record":
+      return {
+        ...type,
+        valueType: resolveTypeNodeMetadata(type.valueType, options)
+      };
+    case "union":
+      return {
+        ...type,
+        members: type.members.map((member) => resolveTypeNodeMetadata(member, options))
+      };
+    case "enum":
+      return resolveEnumTypeMetadata(type, options);
+    case "reference":
+    case "primitive":
+    case "dynamic":
+    case "custom":
+      return type;
+    default: {
+      const _exhaustive = type;
+      return _exhaustive;
+    }
+  }
+}
+function resolveObjectPropertyMetadata(property, options) {
+  const metadata = resolveResolvedMetadata(property.metadata, options.policy.field, {
+    surface: options.surface,
+    declarationKind: "field",
+    logicalName: property.name,
+    ...options.buildContext !== void 0 && { buildContext: options.buildContext }
+  });
+  return {
+    ...property,
+    ...metadata !== void 0 && { metadata },
+    type: resolveTypeNodeMetadata(property.type, options)
+  };
+}
+function resolveFieldMetadataNode(field, options) {
+  const metadata = resolveResolvedMetadata(field.metadata, options.policy.field, {
+    surface: options.surface,
+    declarationKind: "field",
+    logicalName: field.name,
+    ...options.buildContext !== void 0 && { buildContext: options.buildContext }
+  });
+  return {
+    ...field,
+    ...metadata !== void 0 && { metadata },
+    type: resolveTypeNodeMetadata(field.type, options)
+  };
+}
+function resolveFormElementMetadata(element, options) {
+  switch (element.kind) {
+    case "field":
+      return resolveFieldMetadataNode(element, options);
+    case "group":
+      return {
+        ...element,
+        elements: element.elements.map((child) => resolveFormElementMetadata(child, options))
+      };
+    case "conditional":
+      return {
+        ...element,
+        elements: element.elements.map((child) => resolveFormElementMetadata(child, options))
+      };
+    default: {
+      const _exhaustive = element;
+      return _exhaustive;
+    }
+  }
+}
+function resolveTypeDefinitionMetadata(typeDefinition, options) {
+  const metadata = resolveResolvedMetadata(typeDefinition.metadata, options.policy.type, {
+    surface: options.surface,
+    declarationKind: "type",
+    logicalName: typeDefinition.name,
+    ...options.buildContext !== void 0 && { buildContext: options.buildContext }
+  });
+  return {
+    ...typeDefinition,
+    ...metadata !== void 0 && { metadata },
+    type: resolveTypeNodeMetadata(typeDefinition.type, options)
+  };
+}
+function resolveMetadata(explicit, policy, context) {
+  return resolveResolvedMetadata(toExplicitResolvedMetadata(explicit), policy, context);
+}
+function getSerializedName(logicalName, metadata) {
+  return metadata?.apiName?.value ?? logicalName;
+}
+function getDisplayName(metadata) {
+  return metadata?.displayName?.value;
+}
+function resolveFormIRMetadata(ir, options) {
+  const metadata = options.resolveRootTypeMetadata === false ? ir.metadata : resolveResolvedMetadata(ir.metadata, options.policy.type, {
+    surface: options.surface,
+    declarationKind: "type",
+    logicalName: options.rootLogicalName ?? ir.name ?? "FormSpec",
+    ...options.buildContext !== void 0 && { buildContext: options.buildContext }
+  });
+  return {
+    ...ir,
+    ...metadata !== void 0 && { metadata },
+    elements: ir.elements.map((element) => resolveFormElementMetadata(element, options)),
+    typeRegistry: Object.fromEntries(
+      Object.entries(ir.typeRegistry).map(([name, definition]) => [
+        name,
+        resolveTypeDefinitionMetadata(definition, options)
+      ])
+    )
+  };
+}
+
+// src/canonicalize/chain-dsl-canonicalizer.ts
+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, options) {
+  const metadataPolicy = normalizeMetadataPolicy(
+    options?.metadata ?? _getFormSpecMetadataPolicy(form)
+  );
+  const ir = {
+    kind: "form-ir",
+    irVersion: IR_VERSION,
+    elements: canonicalizeElements(form.elements, metadataPolicy),
+    rootAnnotations: [],
+    typeRegistry: {},
+    provenance: CHAIN_DSL_PROVENANCE
+  };
+  return resolveFormIRMetadata(ir, {
+    policy: metadataPolicy,
+    surface: "chain-dsl",
+    // Chain DSL has no root/type-metadata authoring surface, so only resolve
+    // field/type-registry metadata and enum-member labels here.
+    resolveRootTypeMetadata: false
+  });
+}
+function canonicalizeElements(elements, metadataPolicy) {
+  return elements.map((element) => canonicalizeElement(element, metadataPolicy));
+}
+function canonicalizeElement(element, metadataPolicy) {
+  if (isField(element)) {
+    return canonicalizeField(element, metadataPolicy);
+  }
+  if (isGroup(element)) {
+    return canonicalizeGroup(element, metadataPolicy);
+  }
+  if (isConditional(element)) {
+    return canonicalizeConditional(element, metadataPolicy);
+  }
+  const _exhaustive = element;
+  throw new Error(`Unknown element type: ${JSON.stringify(_exhaustive)}`);
+}
+function canonicalizeField(field, metadataPolicy) {
+  switch (field._field) {
+    case "text":
+      return canonicalizeTextField(field, metadataPolicy);
+    case "number":
+      return canonicalizeNumberField(field, metadataPolicy);
+    case "boolean":
+      return canonicalizeBooleanField(field, metadataPolicy);
+    case "enum":
+      return canonicalizeStaticEnumField(field, metadataPolicy);
+    case "dynamic_enum":
+      return canonicalizeDynamicEnumField(field, metadataPolicy);
+    case "dynamic_schema":
+      return canonicalizeDynamicSchemaField(field, metadataPolicy);
+    case "array":
+      return canonicalizeArrayField(field, metadataPolicy);
+    case "object":
+      return canonicalizeObjectField(field, metadataPolicy);
+    default: {
+      const _exhaustive = field;
+      throw new Error(`Unknown field type: ${JSON.stringify(_exhaustive)}`);
+    }
+  }
+}
+function canonicalizeTextField(field, metadataPolicy) {
+  const type = { kind: "primitive", primitiveKind: "string" };
+  const constraints = [];
+  if (field.minLength !== void 0) {
+    const c = {
+      kind: "constraint",
+      constraintKind: "minLength",
+      value: field.minLength,
+      provenance: CHAIN_DSL_PROVENANCE
+    };
+    constraints.push(c);
+  }
+  if (field.maxLength !== void 0) {
+    const c = {
+      kind: "constraint",
+      constraintKind: "maxLength",
+      value: field.maxLength,
+      provenance: CHAIN_DSL_PROVENANCE
+    };
+    constraints.push(c);
+  }
+  if (field.pattern !== void 0) {
+    const c = {
+      kind: "constraint",
+      constraintKind: "pattern",
+      pattern: field.pattern,
+      provenance: CHAIN_DSL_PROVENANCE
+    };
+    constraints.push(c);
+  }
+  return buildFieldNode(
+    field.name,
+    resolveFieldMetadata(field.name, field, metadataPolicy),
+    type,
+    field.required,
+    buildAnnotations(getExplicitDisplayName(field), field.placeholder),
+    constraints
+  );
+}
+function canonicalizeNumberField(field, metadataPolicy) {
+  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);
+  }
+  if (field.multipleOf !== void 0) {
+    const c = {
+      kind: "constraint",
+      constraintKind: "multipleOf",
+      value: field.multipleOf,
+      provenance: CHAIN_DSL_PROVENANCE
+    };
+    constraints.push(c);
+  }
+  return buildFieldNode(
+    field.name,
+    resolveFieldMetadata(field.name, field, metadataPolicy),
+    type,
+    field.required,
+    buildAnnotations(getExplicitDisplayName(field)),
+    constraints
+  );
+}
+function canonicalizeBooleanField(field, metadataPolicy) {
+  const type = { kind: "primitive", primitiveKind: "boolean" };
+  return buildFieldNode(
+    field.name,
+    resolveFieldMetadata(field.name, field, metadataPolicy),
+    type,
+    field.required,
+    buildAnnotations(getExplicitDisplayName(field))
+  );
+}
+function canonicalizeStaticEnumField(field, metadataPolicy) {
+  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,
+    resolveFieldMetadata(field.name, field, metadataPolicy),
+    type,
+    field.required,
+    buildAnnotations(getExplicitDisplayName(field))
+  );
+}
+function canonicalizeDynamicEnumField(field, metadataPolicy) {
+  const type = {
+    kind: "dynamic",
+    dynamicKind: "enum",
+    sourceKey: field.source,
+    parameterFields: field.params ? [...field.params] : []
+  };
+  return buildFieldNode(
+    field.name,
+    resolveFieldMetadata(field.name, field, metadataPolicy),
+    type,
+    field.required,
+    buildAnnotations(getExplicitDisplayName(field))
+  );
+}
+function canonicalizeDynamicSchemaField(field, metadataPolicy) {
+  const type = {
+    kind: "dynamic",
+    dynamicKind: "schema",
+    sourceKey: field.schemaSource,
+    parameterFields: []
+  };
+  return buildFieldNode(
+    field.name,
+    resolveFieldMetadata(field.name, field, metadataPolicy),
+    type,
+    field.required,
+    buildAnnotations(getExplicitDisplayName(field))
+  );
+}
+function canonicalizeArrayField(field, metadataPolicy) {
+  const itemProperties = buildObjectProperties(field.items, metadataPolicy);
+  const itemsType = {
+    kind: "object",
+    properties: itemProperties,
+    additionalProperties: true
+  };
+  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,
+    resolveFieldMetadata(field.name, field, metadataPolicy),
+    type,
+    field.required,
+    buildAnnotations(getExplicitDisplayName(field)),
+    constraints
+  );
+}
+function canonicalizeObjectField(field, metadataPolicy) {
+  const properties = buildObjectProperties(field.properties, metadataPolicy);
+  const type = {
+    kind: "object",
+    properties,
+    additionalProperties: true
+  };
+  return buildFieldNode(
+    field.name,
+    resolveFieldMetadata(field.name, field, metadataPolicy),
+    type,
+    field.required,
+    buildAnnotations(getExplicitDisplayName(field))
+  );
+}
+function canonicalizeGroup(g, metadataPolicy) {
+  return {
+    kind: "group",
+    label: g.label,
+    elements: canonicalizeElements(g.elements, metadataPolicy),
+    provenance: CHAIN_DSL_PROVENANCE
+  };
+}
+function canonicalizeConditional(c, metadataPolicy) {
+  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, metadataPolicy),
+    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, metadata, type, required, annotations, constraints = []) {
+  return {
+    kind: "field",
+    name,
+    ...metadata !== void 0 && { metadata },
+    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, metadataPolicy, insideConditional = false) {
+  const properties = [];
+  for (const el of elements) {
+    if (isField(el)) {
+      const fieldNode = canonicalizeField(el, metadataPolicy);
+      properties.push({
+        name: fieldNode.name,
+        ...fieldNode.metadata !== void 0 && { metadata: fieldNode.metadata },
+        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, metadataPolicy, insideConditional));
+    } else if (isConditional(el)) {
+      properties.push(...buildObjectProperties(el.elements, metadataPolicy, true));
+    }
+  }
+  return properties;
+}
+function getExplicitDisplayName(field) {
+  if (field.label !== void 0 && field.displayName !== void 0) {
+    throw new Error('Chain DSL fields cannot specify both "label" and "displayName".');
+  }
+  return field.displayName ?? field.label;
+}
+function resolveFieldMetadata(logicalName, field, metadataPolicy) {
+  const displayName = getExplicitDisplayName(field);
+  return resolveMetadata(
+    {
+      ...field.apiName !== void 0 && { apiName: field.apiName },
+      ...displayName !== void 0 && { displayName }
+    },
+    getDeclarationMetadataPolicy(metadataPolicy, "field"),
+    makeMetadataContext("chain-dsl", "field", logicalName)
+  );
+}
+
+// src/canonicalize/tsdoc-canonicalizer.ts
+import { IR_VERSION as IR_VERSION2 } from "@formspec/core/internals";
+
+// src/metadata/collision-guards.ts
+function assertUniqueSerializedNames(entries, scope) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const previous = seen.get(entry.serializedName);
+    if (previous !== void 0) {
+      if (previous.logicalName === entry.logicalName && previous.category === entry.category) {
+        continue;
+      }
+      throw new Error(
+        `Serialized name collision in ${scope}: ${previous.category} "${previous.logicalName}" and ${entry.category} "${entry.logicalName}" both resolve to "${entry.serializedName}".`
+      );
+    }
+    seen.set(entry.serializedName, entry);
+  }
+}
+function collectFlattenedFields(elements) {
+  const fields = [];
+  for (const element of elements) {
+    switch (element.kind) {
+      case "field":
+        fields.push(element);
+        break;
+      case "group":
+      case "conditional":
+        fields.push(...collectFlattenedFields(element.elements));
+        break;
+      default: {
+        const exhaustive = element;
+        void exhaustive;
+      }
+    }
+  }
+  return fields;
+}
+function validateObjectProperties(properties, scope) {
+  assertUniqueSerializedNames(
+    properties.map((property) => ({
+      logicalName: property.name,
+      serializedName: getSerializedName(property.name, property.metadata),
+      category: "object property"
+    })),
+    scope
+  );
+  for (const property of properties) {
+    validateTypeNode(
+      property.type,
+      `${scope}.${getSerializedName(property.name, property.metadata)}`
+    );
+  }
+}
+function validateTypeNode(type, scope) {
+  switch (type.kind) {
+    case "array":
+      validateTypeNode(type.items, `${scope}[]`);
+      break;
+    case "object":
+      validateObjectProperties(type.properties, scope);
+      break;
+    case "record":
+      validateTypeNode(type.valueType, `${scope}.*`);
+      break;
+    case "union":
+      type.members.forEach((member, index) => {
+        validateTypeNode(member, `${scope}|${String(index)}`);
+      });
+      break;
+    case "reference":
+    case "primitive":
+    case "enum":
+    case "dynamic":
+    case "custom":
+      break;
+    default: {
+      const exhaustive = type;
+      void exhaustive;
+    }
+  }
+}
+function validateTypeDefinitions(typeRegistry) {
+  const definitions = Object.values(typeRegistry);
+  assertUniqueSerializedNames(
+    definitions.map((definition) => ({
+      logicalName: definition.name,
+      serializedName: getSerializedName(definition.name, definition.metadata),
+      category: "type definition"
+    })),
+    "$defs"
+  );
+  for (const definition of definitions) {
+    validateTypeDefinition(definition);
+  }
+}
+function validateTypeDefinition(definition) {
+  validateTypeNode(
+    definition.type,
+    `type "${getSerializedName(definition.name, definition.metadata)}"`
+  );
+}
+function assertNoSerializedNameCollisions(ir) {
+  assertUniqueSerializedNames(
+    collectFlattenedFields(ir.elements).map((field) => ({
+      logicalName: field.name,
+      serializedName: getSerializedName(field.name, field.metadata),
+      category: "field"
+    })),
+    "form root"
+  );
+  for (const field of collectFlattenedFields(ir.elements)) {
+    validateTypeNode(field.type, `field "${getSerializedName(field.name, field.metadata)}"`);
+  }
+  validateTypeDefinitions(ir.typeRegistry);
+}
+
+// src/json-schema/ir-generator.ts
+function makeContext(options) {
+  const vendorPrefix = options?.vendorPrefix ?? "x-formspec";
+  const rawEnumSerialization = options?.enumSerialization;
+  if (!vendorPrefix.startsWith("x-")) {
+    throw new Error(
+      `Invalid vendorPrefix "${vendorPrefix}". Extension JSON Schema keywords must start with "x-".`
+    );
+  }
+  if (rawEnumSerialization !== void 0 && rawEnumSerialization !== "enum" && rawEnumSerialization !== "oneOf") {
+    throw new Error(
+      `Invalid enumSerialization "${rawEnumSerialization}". Expected "enum" or "oneOf".`
+    );
+  }
+  const enumSerialization = rawEnumSerialization ?? "enum";
+  return {
+    defs: {},
+    typeNameMap: {},
+    typeRegistry: {},
+    extensionRegistry: options?.extensionRegistry,
+    vendorPrefix,
+    enumSerialization
+  };
+}
+function generateJsonSchemaFromIR(ir, options) {
+  assertNoSerializedNameCollisions(ir);
+  const ctx = {
+    ...makeContext(options),
+    typeRegistry: ir.typeRegistry,
+    typeNameMap: Object.fromEntries(
+      Object.entries(ir.typeRegistry).map(([name, typeDef]) => [
+        name,
+        getSerializedName(name, typeDef.metadata)
+      ])
+    )
+  };
+  for (const [name, typeDef] of Object.entries(ir.typeRegistry)) {
+    const schemaName = ctx.typeNameMap[name] ?? name;
+    ctx.defs[schemaName] = generateTypeNode(typeDef.type, ctx);
+    applyResolvedMetadata(ctx.defs[schemaName], typeDef.metadata);
+    if (typeDef.constraints && typeDef.constraints.length > 0) {
+      applyConstraints(ctx.defs[schemaName], typeDef.constraints, ctx);
+    }
+    if (typeDef.annotations && typeDef.annotations.length > 0) {
+      applyAnnotations(ctx.defs[schemaName], typeDef.annotations, 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 }
+  };
+  applyResolvedMetadata(result, ir.metadata);
+  if (ir.annotations && ir.annotations.length > 0) {
+    applyAnnotations(result, ir.annotations, ctx);
+  }
+  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[getSerializedFieldName(element)] = generateFieldSchema(element, ctx);
+        if (element.required) {
+          required.push(getSerializedFieldName(element));
+        }
+        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);
+  const itemStringSchema = schema.type === "array" && schema.items?.type === "string" ? schema.items : void 0;
+  const directConstraints = [];
+  const itemConstraints = [];
+  const pathConstraints = [];
+  for (const c of field.constraints) {
+    if (c.path) {
+      pathConstraints.push(c);
+    } else if (itemStringSchema !== void 0 && isStringItemConstraint(c)) {
+      itemConstraints.push(c);
+    } else {
+      directConstraints.push(c);
+    }
+  }
+  applyConstraints(schema, directConstraints, ctx);
+  if (itemStringSchema !== void 0) {
+    applyConstraints(itemStringSchema, itemConstraints, ctx);
+  }
+  const rootAnnotations = [];
+  const itemAnnotations = [];
+  for (const annotation of field.annotations) {
+    if (itemStringSchema !== void 0 && annotation.annotationKind === "format") {
+      itemAnnotations.push(annotation);
+    } else {
+      rootAnnotations.push(annotation);
+    }
+  }
+  applyResolvedMetadata(schema, field.metadata);
+  applyAnnotations(schema, rootAnnotations, ctx);
+  if (itemStringSchema !== void 0) {
+    applyAnnotations(itemStringSchema, itemAnnotations, ctx);
+  }
+  if (pathConstraints.length === 0) {
+    return schema;
+  }
+  return applyPathTargetedConstraints(schema, pathConstraints, ctx, field.type);
+}
+function isStringItemConstraint(constraint) {
+  switch (constraint.constraintKind) {
+    case "minLength":
+    case "maxLength":
+    case "pattern":
+      return true;
+    default:
+      return false;
+  }
+}
+function applyPathTargetedConstraints(schema, pathConstraints, ctx, typeNode) {
+  if (schema.type === "array" && schema.items) {
+    const referencedType = typeNode?.kind === "reference" ? resolveReferencedType(typeNode, ctx) : void 0;
+    const nestedType = typeNode?.kind === "array" ? typeNode.items : referencedType?.kind === "array" ? referencedType.items : void 0;
+    schema.items = applyPathTargetedConstraints(schema.items, pathConstraints, ctx, nestedType);
+    return schema;
+  }
+  const propertyOverrides = buildPropertyOverrides(pathConstraints, typeNode, ctx);
+  const nullableValueBranch = getNullableUnionValueSchema(schema);
+  if (nullableValueBranch !== void 0) {
+    const updatedNullableValueBranch = applyPathTargetedConstraints(
+      nullableValueBranch,
+      pathConstraints,
+      ctx,
+      resolveTraversableTypeNode(typeNode, ctx)
+    );
+    if (schema.oneOf !== void 0) {
+      schema.oneOf = schema.oneOf.map(
+        (branch) => branch === nullableValueBranch ? updatedNullableValueBranch : branch
+      );
+    }
+    return schema;
+  }
+  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]) {
+        mergeSchemaOverride(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) {
+  switch (type.kind) {
+    case "primitive":
+      return generatePrimitiveType(type);
+    case "enum":
+      return generateEnumType(type, ctx);
+    case "array":
+      return generateArrayType(type, ctx);
+    case "object":
+      return generateObjectType(type, ctx);
+    case "record":
+      return generateRecordType(type, ctx);
+    case "union":
+      return generateUnionType(type, ctx);
+    case "reference":
+      return generateReferenceType(type, ctx);
+    case "dynamic":
+      return generateDynamicType(type);
+    case "custom":
+      return generateCustomType(type, ctx);
+    default: {
+      const _exhaustive = type;
+      return _exhaustive;
+    }
+  }
+}
+function generatePrimitiveType(type) {
+  return {
+    type: type.primitiveKind === "integer" || type.primitiveKind === "bigint" ? "integer" : type.primitiveKind
+  };
+}
+function generateEnumType(type, ctx) {
+  if (ctx.enumSerialization === "oneOf") {
+    return {
+      oneOf: type.members.map((m) => ({
+        const: m.value,
+        title: m.displayName ?? String(m.value)
+      }))
+    };
+  }
+  const schema = { enum: type.members.map((m) => m.value) };
+  const displayNames = buildEnumDisplayNameExtension(type);
+  if (displayNames !== void 0) {
+    schema[`${ctx.vendorPrefix}-display-names`] = displayNames;
+  }
+  return schema;
+}
+function buildEnumDisplayNameExtension(type) {
+  if (!type.members.some((member) => member.displayName !== void 0)) {
+    return void 0;
+  }
+  const displayNames = /* @__PURE__ */ Object.create(null);
+  for (const member of type.members) {
+    const key = String(member.value);
+    if (Object.hasOwn(displayNames, key)) {
+      throw new Error(
+        `Enum display-name key "${key}" is ambiguous after stringification. Use oneOf serialization for mixed string/number enum values that collide.`
+      );
+    }
+    displayNames[key] = member.displayName ?? key;
+  }
+  return displayNames;
+}
+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) {
+    const propertyName = getSerializedObjectPropertyName(prop);
+    properties[propertyName] = generatePropertySchema(prop, ctx);
+    if (!prop.optional) {
+      required.push(propertyName);
+    }
+  }
+  const schema = { type: "object", properties };
+  if (required.length > 0) {
+    schema.required = required;
+  }
+  if (!type.additionalProperties) {
+    schema.additionalProperties = false;
+  }
+  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, ctx);
+  applyResolvedMetadata(schema, prop.metadata);
+  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))
+  };
+}
+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 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, ctx) {
+  return { $ref: `#/$defs/${getSerializedTypeName(type.name, ctx)}` };
+}
+function getSerializedFieldName(field) {
+  return getSerializedName(field.name, field.metadata);
+}
+function getSerializedObjectPropertyName(property) {
+  return getSerializedName(property.name, property.metadata);
+}
+function getSerializedTypeName(logicalName, ctx) {
+  return ctx.typeNameMap[logicalName] ?? logicalName;
+}
+function applyResolvedMetadata(schema, metadata) {
+  const displayName = getDisplayName(metadata);
+  if (displayName !== void 0) {
+    schema.title = displayName;
+  }
+}
+function resolveReferencedType(type, ctx) {
+  return ctx.typeRegistry[type.name]?.type;
+}
+function dereferenceTypeNode(typeNode, ctx) {
+  if (typeNode?.kind !== "reference") {
+    return typeNode;
+  }
+  return resolveReferencedType(typeNode, ctx);
+}
+function unwrapNullableTypeNode(typeNode) {
+  if (typeNode?.kind !== "union" || !isNullableUnion(typeNode)) {
+    return typeNode;
+  }
+  return typeNode.members.find(
+    (member) => !(member.kind === "primitive" && member.primitiveKind === "null")
+  );
+}
+function resolveTraversableTypeNode(typeNode, ctx) {
+  const dereferenced = dereferenceTypeNode(typeNode, ctx);
+  const unwrapped = unwrapNullableTypeNode(dereferenced);
+  if (unwrapped !== dereferenced) {
+    return resolveTraversableTypeNode(unwrapped, ctx);
+  }
+  return dereferenced;
+}
+function resolveSerializedPropertyName(logicalName, typeNode, ctx) {
+  const effectiveType = resolveTraversableTypeNode(typeNode, ctx);
+  if (effectiveType?.kind === "array") {
+    return resolveSerializedPropertyName(logicalName, effectiveType.items, ctx);
+  }
+  if (effectiveType?.kind === "object") {
+    const property = effectiveType.properties.find((candidate) => candidate.name === logicalName);
+    return property === void 0 ? logicalName : getSerializedObjectPropertyName(property);
+  }
+  return logicalName;
+}
+function resolveTargetTypeNode(logicalName, typeNode, ctx) {
+  const effectiveType = resolveTraversableTypeNode(typeNode, ctx);
+  if (effectiveType?.kind === "array") {
+    return resolveTargetTypeNode(logicalName, effectiveType.items, ctx);
+  }
+  if (effectiveType?.kind !== "object") {
+    return void 0;
+  }
+  return effectiveType.properties.find((candidate) => candidate.name === logicalName)?.type;
+}
+function buildPropertyOverrides(pathConstraints, typeNode, ctx) {
+  const byTarget = /* @__PURE__ */ new Map();
+  for (const constraint of pathConstraints) {
+    const target = constraint.path?.segments[0];
+    if (!target) {
+      continue;
+    }
+    const grouped = byTarget.get(target) ?? [];
+    grouped.push(constraint);
+    byTarget.set(target, grouped);
+  }
+  const overrides = {};
+  for (const [target, constraints] of byTarget) {
+    overrides[resolveSerializedPropertyName(target, typeNode, ctx)] = buildPathOverrideSchema(
+      constraints.map(stripLeadingPathSegment),
+      resolveTargetTypeNode(target, typeNode, ctx),
+      ctx
+    );
+  }
+  return overrides;
+}
+function buildPathOverrideSchema(constraints, typeNode, ctx) {
+  const schema = {};
+  const directConstraints = [];
+  const nestedConstraints = [];
+  for (const constraint of constraints) {
+    if (constraint.path === void 0 || constraint.path.segments.length === 0) {
+      directConstraints.push(constraint);
+    } else {
+      nestedConstraints.push(constraint);
+    }
+  }
+  applyConstraints(schema, directConstraints, ctx);
+  if (nestedConstraints.length === 0) {
+    return schema;
+  }
+  const effectiveType = resolveTraversableTypeNode(typeNode, ctx);
+  if (effectiveType?.kind === "array") {
+    schema.items = buildPathOverrideSchema(nestedConstraints, effectiveType.items, ctx);
+    return schema;
+  }
+  schema.properties = buildPropertyOverrides(nestedConstraints, effectiveType, ctx);
+  return schema;
+}
+function mergeSchemaOverride(target, override) {
+  const nullableValueBranch = getNullableUnionValueSchema(target);
+  if (nullableValueBranch !== void 0) {
+    mergeSchemaOverride(nullableValueBranch, override);
+    return;
+  }
+  if (override.properties !== void 0) {
+    const mergedProperties = target.properties ?? {};
+    for (const [name, propertyOverride] of Object.entries(override.properties)) {
+      const existing = mergedProperties[name];
+      if (existing === void 0) {
+        mergedProperties[name] = propertyOverride;
+      } else {
+        mergeSchemaOverride(existing, propertyOverride);
+      }
+    }
+    target.properties = mergedProperties;
+  }
+  if (override.items !== void 0) {
+    if (target.items === void 0) {
+      target.items = override.items;
+    } else {
+      mergeSchemaOverride(target.items, override.items);
+    }
+  }
+  for (const [key, value] of Object.entries(override)) {
+    if (key === "properties" || key === "items") {
+      continue;
+    }
+    target[key] = value;
+  }
+}
+function stripLeadingPathSegment(constraint) {
+  const segments = constraint.path?.segments;
+  if (segments === void 0 || segments.length === 0) {
+    return constraint;
+  }
+  const [, ...rest] = segments;
+  if (rest.length === 0) {
+    const { path: _path, ...stripped } = constraint;
+    return stripped;
+  }
+  return {
+    ...constraint,
+    path: { segments: rest }
+  };
+}
+function getNullableUnionValueSchema(schema) {
+  if (schema.oneOf?.length !== 2) {
+    return void 0;
+  }
+  const valueSchema = schema.oneOf.find((branch) => branch.type !== "null");
+  const nullSchema = schema.oneOf.find((branch) => branch.type === "null");
+  return valueSchema !== void 0 && nullSchema !== void 0 ? valueSchema : void 0;
+}
+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 applyConstraints(schema, constraints, ctx) {
+  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 "const":
+        schema.const = constraint.value;
+        break;
+      case "allowedMembers":
+        break;
+      case "custom":
+        applyCustomConstraint(schema, constraint, ctx);
+        break;
+      default: {
+        const _exhaustive = constraint;
+        void _exhaustive;
+      }
+    }
+  }
+}
+function applyAnnotations(schema, annotations, ctx) {
+  for (const annotation of annotations) {
+    switch (annotation.annotationKind) {
+      case "displayName":
+        schema.title ??= annotation.value;
+        break;
+      case "description":
+        schema.description = annotation.value;
+        break;
+      case "remarks":
+        schema[`${ctx.vendorPrefix}-remarks`] = annotation.value;
+        break;
+      case "defaultValue":
+        schema.default = annotation.value;
+        break;
+      case "format":
+        schema.format = annotation.value;
+        break;
+      case "deprecated":
+        schema.deprecated = true;
+        if (annotation.message !== void 0 && annotation.message !== "") {
+          schema[`${ctx.vendorPrefix}-deprecation-description`] = annotation.message;
+        }
+        break;
+      case "placeholder":
+        break;
+      case "formatHint":
+        break;
+      case "custom":
+        applyCustomAnnotation(schema, annotation, ctx);
+        break;
+      default: {
+        const _exhaustive = annotation;
+        void _exhaustive;
+      }
+    }
+  }
+}
+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`
+    );
+  }
+  assignVendorPrefixedExtensionKeywords(
+    schema,
+    registration.toJsonSchema(constraint.payload, ctx.vendorPrefix),
+    ctx.vendorPrefix,
+    `custom constraint "${constraint.constraintId}"`
+  );
+}
+function applyCustomAnnotation(schema, annotation, ctx) {
+  const registration = ctx.extensionRegistry?.findAnnotation(annotation.annotationId);
+  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;
+  }
+  assignVendorPrefixedExtensionKeywords(
+    schema,
+    registration.toJsonSchema(annotation.value, ctx.vendorPrefix),
+    ctx.vendorPrefix,
+    `custom annotation "${annotation.annotationId}"`
+  );
+}
+function assignVendorPrefixedExtensionKeywords(schema, extensionSchema, vendorPrefix, source) {
+  for (const [key, value] of Object.entries(extensionSchema)) {
+    if (!key.startsWith(`${vendorPrefix}-`)) {
+      throw new Error(
+        `Cannot apply ${source}: extension hooks may only emit "${vendorPrefix}-*" JSON Schema keywords`
+      );
+    }
+    schema[key] = value;
+  }
+}
+
+// src/json-schema/generator.ts
+function generateJsonSchema(form, options) {
+  const metadata = options?.metadata;
+  const vendorPrefix = options?.vendorPrefix;
+  const enumSerialization = options?.enumSerialization;
+  const ir = canonicalizeChainDSL(
+    form,
+    metadata !== void 0 ? { metadata } : void 0
+  );
+  const internalOptions = vendorPrefix === void 0 && enumSerialization === void 0 ? void 0 : {
+    ...vendorPrefix !== void 0 && { vendorPrefix },
+    ...enumSerialization !== void 0 && { enumSerialization }
+  };
+  return generateJsonSchemaFromIR(ir, internalOptions);
+}
+
+// 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 flattenConditionSchema(scope, schema) {
+  if (schema.allOf === void 0) {
+    if (scope === "#") {
+      return [schema];
+    }
+    const fieldName = scope.replace("#/properties/", "");
+    return [
+      {
+        properties: {
+          [fieldName]: schema
+        }
+      }
+    ];
+  }
+  return schema.allOf.flatMap((member) => flattenConditionSchema(scope, member));
+}
+function combineRules(parentRule, childRule) {
+  return {
+    effect: "SHOW",
+    condition: {
+      scope: "#",
+      schema: {
+        allOf: [
+          ...flattenConditionSchema(parentRule.condition.scope, parentRule.condition.schema),
+          ...flattenConditionSchema(childRule.condition.scope, childRule.condition.schema)
+        ]
+      }
+    }
+  };
+}
+function getFieldDisplayName(field) {
+  const resolvedDisplayName = getDisplayName(field.metadata);
+  if (resolvedDisplayName !== void 0) {
+    return resolvedDisplayName;
+  }
+  return field.annotations.find((annotation) => annotation.annotationKind === "displayName")?.value;
+}
+function fieldNodeToControl(field, fieldNameMap, parentRule) {
+  const placeholderAnnotation = field.annotations.find((a) => a.annotationKind === "placeholder");
+  const serializedName = fieldNameMap.get(field.name) ?? getSerializedName(field.name, field.metadata);
+  const displayName = getFieldDisplayName(field);
+  const control = {
+    type: "Control",
+    scope: fieldToScope(serializedName),
+    ...displayName !== void 0 && { label: displayName },
+    ...placeholderAnnotation !== void 0 && {
+      options: { placeholder: placeholderAnnotation.value }
+    },
+    ...parentRule !== void 0 && { rule: parentRule }
+  };
+  return control;
+}
+function groupNodeToLayout(group, fieldNameMap, parentRule) {
+  return {
+    type: "Group",
+    label: group.label,
+    elements: irElementsToUiSchema(group.elements, fieldNameMap, parentRule),
+    ...parentRule !== void 0 && { rule: parentRule }
+  };
+}
+function irElementsToUiSchema(elements, fieldNameMap, parentRule) {
+  const result = [];
+  for (const element of elements) {
+    switch (element.kind) {
+      case "field": {
+        result.push(fieldNodeToControl(element, fieldNameMap, parentRule));
+        break;
+      }
+      case "group": {
+        result.push(groupNodeToLayout(element, fieldNameMap, parentRule));
+        break;
+      }
+      case "conditional": {
+        const newRule = createShowRule(fieldNameMap.get(element.fieldName) ?? element.fieldName, element.value);
+        const combinedRule = parentRule !== void 0 ? combineRules(parentRule, newRule) : newRule;
+        const childElements = irElementsToUiSchema(element.elements, fieldNameMap, combinedRule);
+        result.push(...childElements);
+        break;
+      }
+      default: {
+        const _exhaustive = element;
+        void _exhaustive;
+        throw new Error("Unhandled IR element kind");
+      }
+    }
+  }
+  return result;
+}
+function generateUiSchemaFromIR(ir) {
+  assertNoSerializedNameCollisions(ir);
+  const fieldNameMap = collectFieldNameMap(ir.elements);
+  const result = {
+    type: "VerticalLayout",
+    elements: irElementsToUiSchema(ir.elements, fieldNameMap)
+  };
+  return parseOrThrow(uiSchema, result, "UI Schema");
+}
+function collectFieldNameMap(elements) {
+  const map = /* @__PURE__ */ new Map();
+  for (const element of elements) {
+    switch (element.kind) {
+      case "field":
+        map.set(element.name, getSerializedName(element.name, element.metadata));
+        break;
+      case "group":
+      case "conditional":
+        for (const [key, value] of collectFieldNameMap(element.elements)) {
+          map.set(key, value);
+        }
+        break;
+      default: {
+        const _exhaustive = element;
+        void _exhaustive;
+      }
+    }
+  }
+  return map;
+}
+
+// src/ui-schema/generator.ts
+function generateUiSchema(form, options) {
+  const ir = canonicalizeChainDSL(
+    form,
+    options?.metadata !== void 0 ? { metadata: options.metadata } : void 0
+  );
+  return generateUiSchemaFromIR(ir);
+}
+
+// src/json-schema/types.ts
+function setSchemaExtension(schema, key, value) {
+  schema[key] = value;
+}
+function getSchemaExtension(schema, key) {
+  return schema[key];
+}
+
+// src/extensions/registry.ts
+import {
+  BUILTIN_CONSTRAINT_DEFINITIONS,
+  normalizeConstraintTagName
+} from "@formspec/core/internals";
+import {
+  getTagDefinition,
+  normalizeFormSpecTagName
+} from "@formspec/analysis/internal";
+var BUILTIN_METADATA_TAGS = /* @__PURE__ */ new Set(["apiName", "displayName"]);
+function buildConstraintTagSources(extensions) {
+  return extensions.map((extension) => ({
+    extensionId: extension.extensionId,
+    ...extension.constraintTags !== void 0 ? {
+      constraintTags: extension.constraintTags.map((tag) => ({
+        tagName: normalizeFormSpecTagName(tag.tagName)
+      }))
+    } : {}
+  }));
+}
+function createExtensionRegistry(extensions) {
+  const reservedTagSources = buildConstraintTagSources(extensions);
+  const typeMap = /* @__PURE__ */ new Map();
+  const typeNameMap = /* @__PURE__ */ new Map();
+  const constraintMap = /* @__PURE__ */ new Map();
+  const constraintTagMap = /* @__PURE__ */ new Map();
+  const builtinBroadeningMap = /* @__PURE__ */ new Map();
+  const annotationMap = /* @__PURE__ */ new Map();
+  const metadataSlotMap = /* @__PURE__ */ new Map();
+  const metadataTagMap = /* @__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);
+        for (const sourceTypeName of type.tsTypeNames ?? [type.typeName]) {
+          if (typeNameMap.has(sourceTypeName)) {
+            throw new Error(`Duplicate custom type source name: "${sourceTypeName}"`);
+          }
+          typeNameMap.set(sourceTypeName, {
+            extensionId: ext.extensionId,
+            registration: type
+          });
+        }
+        if (type.builtinConstraintBroadenings !== void 0) {
+          for (const broadening of type.builtinConstraintBroadenings) {
+            const key = `${qualifiedId}:${broadening.tagName}`;
+            if (builtinBroadeningMap.has(key)) {
+              throw new Error(`Duplicate built-in constraint broadening: "${key}"`);
+            }
+            builtinBroadeningMap.set(key, {
+              extensionId: ext.extensionId,
+              registration: broadening
+            });
+          }
+        }
+      }
+    }
+    if (ext.constraints !== void 0) {
+      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.constraintTags !== void 0) {
+      for (const tag of ext.constraintTags) {
+        const canonicalTagName = normalizeFormSpecTagName(tag.tagName);
+        if (constraintTagMap.has(canonicalTagName)) {
+          throw new Error(`Duplicate custom constraint tag: "@${canonicalTagName}"`);
+        }
+        constraintTagMap.set(canonicalTagName, {
+          extensionId: ext.extensionId,
+          registration: tag
+        });
+      }
+    }
+    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);
+      }
+    }
+    if (ext.metadataSlots !== void 0) {
+      for (const slot of ext.metadataSlots) {
+        if (metadataSlotMap.has(slot.slotId)) {
+          throw new Error(`Duplicate metadata slot ID: "${slot.slotId}"`);
+        }
+        metadataSlotMap.set(slot.slotId, true);
+        const canonicalTagName = normalizeFormSpecTagName(slot.tagName);
+        if (slot.allowBare === false && (slot.qualifiers?.length ?? 0) === 0) {
+          throw new Error(
+            `Metadata tag "@${canonicalTagName}" must allow bare usage or declare at least one qualifier.`
+          );
+        }
+        if (metadataTagMap.has(canonicalTagName)) {
+          throw new Error(`Duplicate metadata tag: "@${canonicalTagName}"`);
+        }
+        if (BUILTIN_METADATA_TAGS.has(canonicalTagName)) {
+          throw new Error(
+            `Metadata tag "@${canonicalTagName}" conflicts with built-in metadata tags.`
+          );
+        }
+        if (constraintTagMap.has(canonicalTagName)) {
+          throw new Error(
+            `Metadata tag "@${canonicalTagName}" conflicts with existing FormSpec tag "@${canonicalTagName}".`
+          );
+        }
+        if (Object.hasOwn(BUILTIN_CONSTRAINT_DEFINITIONS, normalizeConstraintTagName(canonicalTagName))) {
+          throw new Error(
+            `Metadata tag "@${canonicalTagName}" conflicts with existing FormSpec tag "@${normalizeConstraintTagName(canonicalTagName)}".`
+          );
+        }
+        const existingTag = getTagDefinition(canonicalTagName, reservedTagSources);
+        if (existingTag !== null) {
+          throw BUILTIN_METADATA_TAGS.has(existingTag.canonicalName) ? new Error(
+            `Metadata tag "@${canonicalTagName}" conflicts with built-in metadata tags.`
+          ) : new Error(
+            `Metadata tag "@${canonicalTagName}" conflicts with existing FormSpec tag "@${existingTag.canonicalName}".`
+          );
+        }
+        metadataTagMap.set(canonicalTagName, true);
+      }
+    }
+  }
+  return {
+    extensions,
+    findType: (typeId) => typeMap.get(typeId),
+    findTypeByName: (typeName) => typeNameMap.get(typeName),
+    findConstraint: (constraintId) => constraintMap.get(constraintId),
+    findConstraintTag: (tagName) => constraintTagMap.get(normalizeFormSpecTagName(tagName)),
+    findBuiltinConstraintBroadening: (typeId, tagName) => builtinBroadeningMap.get(`${typeId}:${tagName}`),
+    findAnnotation: (annotationId) => annotationMap.get(annotationId)
+  };
+}
+
+// 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
+import {
+  analyzeConstraintTargets
+} from "@formspec/analysis/internal";
+function validateFieldNode(ctx, field) {
+  const analysis = analyzeConstraintTargets(
+    field.name,
+    field.type,
+    field.constraints,
+    ctx.typeRegistry,
+    ctx.extensionRegistry === void 0 ? void 0 : {
+      extensionRegistry: ctx.extensionRegistry
+    }
+  );
+  ctx.diagnostics.push(...analysis.diagnostics);
+  if (field.type.kind === "object") {
+    for (const property of field.type.properties) {
+      validateObjectProperty(ctx, field.name, property);
+    }
+  }
+}
+function validateObjectProperty(ctx, parentName, property) {
+  const qualifiedName = `${parentName}.${property.name}`;
+  const analysis = analyzeConstraintTargets(
+    qualifiedName,
+    property.type,
+    property.constraints,
+    ctx.typeRegistry,
+    ctx.extensionRegistry === void 0 ? void 0 : {
+      extensionRegistry: ctx.extensionRegistry
+    }
+  );
+  ctx.diagnostics.push(...analysis.diagnostics);
+  if (property.type.kind === "object") {
+    for (const nestedProperty of property.type.properties) {
+      validateObjectProperty(ctx, qualifiedName, nestedProperty);
+    }
+  }
+}
+function 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: ${String(exhaustive)}`);
+    }
+  }
+}
+function validateIR(ir, options) {
+  const ctx = {
+    diagnostics: [],
+    extensionRegistry: options?.extensionRegistry,
+    typeRegistry: ir.typeRegistry
+  };
+  for (const element of ir.elements) {
+    validateElement(ctx, element);
+  }
+  return {
+    diagnostics: ctx.diagnostics,
+    valid: ctx.diagnostics.every((diagnostic) => diagnostic.severity !== "error")
+  };
+}
+
+// src/browser.ts
+function buildFormSchemas(form, options) {
+  return {
+    jsonSchema: generateJsonSchema(form, options),
+    uiSchema: generateUiSchema(form, options)
+  };
+}
+export {
+  buildFormSchemas,
+  canonicalizeChainDSL,
+  categorizationSchema,
+  categorySchema,
+  controlSchema,
+  createExtensionRegistry,
+  generateJsonSchema,
+  generateJsonSchemaFromIR,
+  generateUiSchema,
+  getSchemaExtension,
+  groupLayoutSchema,
+  horizontalLayoutSchema,
+  jsonSchema7Schema,
+  jsonSchemaTypeSchema,
+  labelElementSchema,
+  ruleConditionSchema,
+  ruleEffectSchema,
+  ruleSchema,
+  schemaBasedConditionSchema,
+  setSchemaExtension,
+  uiSchemaElementSchema,
+  uiSchemaElementTypeSchema,
+  uiSchema as uiSchemaSchema,
+  validateIR,
+  verticalLayoutSchema
+};
+//# sourceMappingURL=browser.js.map