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

package/dist/cli.js

@@ -1,22 +1,1905 @@
 #!/usr/bin/env node
-/**
- * FormSpec CLI - Generate JSON Schema and UI Schema from form definitions
- *
- * Usage:
- *   formspec-build <input-file> [options]
- *
- * Options:
- *   -o, --out-dir <dir>   Output directory (default: ./generated)
- *   -n, --name <name>     Base name for output files (default: derived from input)
- *   -h, --help            Show help
- *
- * Example:
- *   formspec-build src/forms/product.ts -o ./schemas -n product
- */
-import * as path from "node:path";
-import { pathToFileURL } from "node:url";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/canonicalize/chain-dsl-canonicalizer.ts
+import { IR_VERSION } from "@formspec/core";
+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;
+}
+var CHAIN_DSL_PROVENANCE;
+var init_chain_dsl_canonicalizer = __esm({
+  "src/canonicalize/chain-dsl-canonicalizer.ts"() {
+    "use strict";
+    CHAIN_DSL_PROVENANCE = {
+      surface: "chain-dsl",
+      file: "",
+      line: 0,
+      column: 0
+    };
+  }
+});
+
+// src/canonicalize/tsdoc-canonicalizer.ts
+import { IR_VERSION as IR_VERSION2 } from "@formspec/core";
+function canonicalizeTSDoc(analysis, source) {
+  const file = source?.file ?? "";
+  const provenance = {
+    surface: "tsdoc",
+    file,
+    line: 1,
+    column: 0
+  };
+  const elements = assembleElements(analysis.fields, analysis.fieldLayouts, provenance);
+  return {
+    kind: "form-ir",
+    irVersion: IR_VERSION2,
+    elements,
+    typeRegistry: analysis.typeRegistry,
+    provenance
+  };
+}
+function assembleElements(fields, layouts, provenance) {
+  const elements = [];
+  const groupMap = /* @__PURE__ */ new Map();
+  const topLevelOrder = [];
+  for (let i = 0; i < fields.length; i++) {
+    const field = fields[i];
+    const layout = layouts[i];
+    if (!field || !layout) continue;
+    const element = wrapInConditional(field, layout, provenance);
+    if (layout.groupLabel !== void 0) {
+      const label = layout.groupLabel;
+      let groupElements = groupMap.get(label);
+      if (!groupElements) {
+        groupElements = [];
+        groupMap.set(label, groupElements);
+        topLevelOrder.push({ type: "group", label });
+      }
+      groupElements.push(element);
+    } else {
+      topLevelOrder.push({ type: "element", element });
+    }
+  }
+  for (const entry of topLevelOrder) {
+    if (entry.type === "group") {
+      const groupElements = groupMap.get(entry.label);
+      if (groupElements) {
+        const groupNode = {
+          kind: "group",
+          label: entry.label,
+          elements: groupElements,
+          provenance
+        };
+        elements.push(groupNode);
+        groupMap.delete(entry.label);
+      }
+    } else {
+      elements.push(entry.element);
+    }
+  }
+  return elements;
+}
+function wrapInConditional(field, layout, provenance) {
+  if (layout.showWhen === void 0) {
+    return field;
+  }
+  const conditional = {
+    kind: "conditional",
+    fieldName: layout.showWhen.field,
+    value: layout.showWhen.value,
+    elements: [field],
+    provenance
+  };
+  return conditional;
+}
+var init_tsdoc_canonicalizer = __esm({
+  "src/canonicalize/tsdoc-canonicalizer.ts"() {
+    "use strict";
+  }
+});
+
+// src/canonicalize/index.ts
+var init_canonicalize = __esm({
+  "src/canonicalize/index.ts"() {
+    "use strict";
+    init_chain_dsl_canonicalizer();
+    init_tsdoc_canonicalizer();
+  }
+});
+
+// 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 {
+      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;
+      }
+    }
+  }
+}
+var init_ir_generator = __esm({
+  "src/json-schema/ir-generator.ts"() {
+    "use strict";
+  }
+});
+
+// src/json-schema/generator.ts
+function generateJsonSchema(form) {
+  const ir = canonicalizeChainDSL(form);
+  return generateJsonSchemaFromIR(ir);
+}
+var init_generator = __esm({
+  "src/json-schema/generator.ts"() {
+    "use strict";
+    init_canonicalize();
+    init_ir_generator();
+  }
+});
+
+// src/ui-schema/schema.ts
+import { z } from "zod";
+var jsonPointerSchema, ruleEffectSchema, uiSchemaElementTypeSchema, ruleConditionSchema, schemaBasedConditionSchema, ruleSchema, uiSchemaElementSchema, controlSchema, verticalLayoutSchema, horizontalLayoutSchema, groupLayoutSchema, categorySchema, categorizationSchema, labelElementSchema, uiSchema;
+var init_schema = __esm({
+  "src/ui-schema/schema.ts"() {
+    "use strict";
+    jsonPointerSchema = z.string();
+    ruleEffectSchema = z.enum(["SHOW", "HIDE", "ENABLE", "DISABLE"]);
+    uiSchemaElementTypeSchema = z.enum([
+      "Control",
+      "VerticalLayout",
+      "HorizontalLayout",
+      "Group",
+      "Categorization",
+      "Category",
+      "Label"
+    ]);
+    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()
+    );
+    schemaBasedConditionSchema = z.object({
+      scope: jsonPointerSchema,
+      schema: ruleConditionSchema
+    }).strict();
+    ruleSchema = z.object({
+      effect: ruleEffectSchema,
+      condition: schemaBasedConditionSchema
+    }).strict();
+    uiSchemaElementSchema = z.lazy(
+      () => z.union([
+        controlSchema,
+        verticalLayoutSchema,
+        horizontalLayoutSchema,
+        groupLayoutSchema,
+        categorizationSchema,
+        categorySchema,
+        labelElementSchema
+      ])
+    );
+    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();
+    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()
+    );
+    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()
+    );
+    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()
+    );
+    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()
+    );
+    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()
+    );
+    labelElementSchema = z.object({
+      type: z.literal("Label"),
+      text: z.string(),
+      rule: ruleSchema.optional(),
+      options: z.record(z.string(), z.unknown()).optional()
+    }).passthrough();
+    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");
+}
+var init_ir_generator2 = __esm({
+  "src/ui-schema/ir-generator.ts"() {
+    "use strict";
+    init_schema();
+  }
+});
+
+// src/ui-schema/generator.ts
+function generateUiSchema(form) {
+  const ir = canonicalizeChainDSL(form);
+  return generateUiSchemaFromIR(ir);
+}
+var init_generator2 = __esm({
+  "src/ui-schema/generator.ts"() {
+    "use strict";
+    init_canonicalize();
+    init_ir_generator2();
+  }
+});
+
+// src/json-schema/types.ts
+function setSchemaExtension(schema, key, value) {
+  schema[key] = value;
+}
+function getSchemaExtension(schema, key) {
+  return schema[key];
+}
+var init_types = __esm({
+  "src/json-schema/types.ts"() {
+    "use strict";
+  }
+});
+
+// src/json-schema/schema.ts
+import { z as z3 } from "zod";
+var jsonSchemaTypeSchema, jsonSchema7Schema;
+var init_schema2 = __esm({
+  "src/json-schema/schema.ts"() {
+    "use strict";
+    jsonSchemaTypeSchema = z3.enum([
+      "string",
+      "number",
+      "integer",
+      "boolean",
+      "object",
+      "array",
+      "null"
+    ]);
+    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/analyzer/program.ts
+import * as ts from "typescript";
+import * as path from "path";
+function createProgramContext(filePath) {
+  const absolutePath = path.resolve(filePath);
+  const fileDir = path.dirname(absolutePath);
+  const configPath = ts.findConfigFile(fileDir, ts.sys.fileExists.bind(ts.sys), "tsconfig.json");
+  let compilerOptions;
+  let fileNames;
+  if (configPath) {
+    const configFile = ts.readConfigFile(configPath, ts.sys.readFile.bind(ts.sys));
+    if (configFile.error) {
+      throw new Error(
+        `Error reading tsconfig.json: ${ts.flattenDiagnosticMessageText(configFile.error.messageText, "\n")}`
+      );
+    }
+    const parsed = ts.parseJsonConfigFileContent(
+      configFile.config,
+      ts.sys,
+      path.dirname(configPath)
+    );
+    if (parsed.errors.length > 0) {
+      const errorMessages = parsed.errors.map((e) => ts.flattenDiagnosticMessageText(e.messageText, "\n")).join("\n");
+      throw new Error(`Error parsing tsconfig.json: ${errorMessages}`);
+    }
+    compilerOptions = parsed.options;
+    fileNames = parsed.fileNames.includes(absolutePath) ? parsed.fileNames : [...parsed.fileNames, absolutePath];
+  } else {
+    compilerOptions = {
+      target: ts.ScriptTarget.ES2022,
+      module: ts.ModuleKind.NodeNext,
+      moduleResolution: ts.ModuleResolutionKind.NodeNext,
+      strict: true,
+      skipLibCheck: true,
+      declaration: true
+    };
+    fileNames = [absolutePath];
+  }
+  const program = ts.createProgram(fileNames, compilerOptions);
+  const sourceFile = program.getSourceFile(absolutePath);
+  if (!sourceFile) {
+    throw new Error(`Could not find source file: ${absolutePath}`);
+  }
+  return {
+    program,
+    checker: program.getTypeChecker(),
+    sourceFile
+  };
+}
+function findNodeByName(sourceFile, name, predicate, getName) {
+  let result = null;
+  function visit(node) {
+    if (result) return;
+    if (predicate(node) && getName(node) === name) {
+      result = node;
+      return;
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return result;
+}
+function findClassByName(sourceFile, className) {
+  return findNodeByName(sourceFile, className, ts.isClassDeclaration, (n) => n.name?.text);
+}
+function findInterfaceByName(sourceFile, interfaceName) {
+  return findNodeByName(sourceFile, interfaceName, ts.isInterfaceDeclaration, (n) => n.name.text);
+}
+function findTypeAliasByName(sourceFile, aliasName) {
+  return findNodeByName(sourceFile, aliasName, ts.isTypeAliasDeclaration, (n) => n.name.text);
+}
+var init_program = __esm({
+  "src/analyzer/program.ts"() {
+    "use strict";
+  }
+});
+
+// src/analyzer/tsdoc-parser.ts
+import * as ts2 from "typescript";
+import {
+  TSDocParser,
+  TSDocConfiguration,
+  TSDocTagDefinition,
+  TSDocTagSyntaxKind,
+  DocPlainText,
+  DocSoftBreak,
+  TextRange
+} from "@microsoft/tsdoc";
+import {
+  BUILTIN_CONSTRAINT_DEFINITIONS
+} from "@formspec/core";
+function isBuiltinConstraintName(tagName) {
+  return tagName in BUILTIN_CONSTRAINT_DEFINITIONS;
+}
+function createFormSpecTSDocConfig() {
+  const config = new TSDocConfiguration();
+  for (const tagName of Object.keys(BUILTIN_CONSTRAINT_DEFINITIONS)) {
+    config.addTagDefinition(
+      new TSDocTagDefinition({
+        tagName: "@" + tagName,
+        syntaxKind: TSDocTagSyntaxKind.BlockTag,
+        allowMultiple: true
+      })
+    );
+  }
+  return config;
+}
+function getParser() {
+  sharedParser ??= new TSDocParser(createFormSpecTSDocConfig());
+  return sharedParser;
+}
+function parseTSDocTags(node, file = "") {
+  const constraints = [];
+  const annotations = [];
+  const sourceFile = node.getSourceFile();
+  const sourceText = sourceFile.getFullText();
+  const commentRanges = ts2.getLeadingCommentRanges(sourceText, node.getFullStart());
+  if (commentRanges) {
+    for (const range of commentRanges) {
+      if (range.kind !== ts2.SyntaxKind.MultiLineCommentTrivia) {
+        continue;
+      }
+      const commentText = sourceText.substring(range.pos, range.end);
+      if (!commentText.startsWith("/**")) {
+        continue;
+      }
+      const parser = getParser();
+      const parserContext = parser.parseRange(
+        TextRange.fromStringRange(sourceText, range.pos, range.end)
+      );
+      const docComment = parserContext.docComment;
+      for (const block of docComment.customBlocks) {
+        const tagName = block.blockTag.tagName.substring(1);
+        if (TAGS_REQUIRING_RAW_TEXT.has(tagName)) continue;
+        const text = extractBlockText(block).trim();
+        if (text === "") continue;
+        const provenance = provenanceForComment(range, sourceFile, file, tagName);
+        const constraintNode = parseConstraintValue(tagName, text, provenance);
+        if (constraintNode) {
+          constraints.push(constraintNode);
+        }
+      }
+      if (docComment.deprecatedBlock !== void 0) {
+        annotations.push({
+          kind: "annotation",
+          annotationKind: "deprecated",
+          provenance: provenanceForComment(range, sourceFile, file, "deprecated")
+        });
+      }
+    }
+  }
+  const jsDocTagsAll = ts2.getJSDocTags(node);
+  for (const tag of jsDocTagsAll) {
+    const tagName = tag.tagName.text;
+    if (!TAGS_REQUIRING_RAW_TEXT.has(tagName)) continue;
+    const commentText = getTagCommentText(tag);
+    if (commentText === void 0 || commentText.trim() === "") continue;
+    const text = commentText.trim();
+    const provenance = provenanceForJSDocTag(tag, file);
+    const constraintNode = parseConstraintValue(tagName, text, provenance);
+    if (constraintNode) {
+      constraints.push(constraintNode);
+    }
+  }
+  let displayName;
+  let description;
+  let displayNameTag;
+  let descriptionTag;
+  for (const tag of jsDocTagsAll) {
+    const tagName = tag.tagName.text;
+    const commentText = getTagCommentText(tag);
+    if (commentText === void 0 || commentText.trim() === "") {
+      continue;
+    }
+    const trimmed = commentText.trim();
+    if (tagName === "Field_displayName") {
+      displayName = trimmed;
+      displayNameTag = tag;
+    } else if (tagName === "Field_description") {
+      description = trimmed;
+      descriptionTag = tag;
+    }
+  }
+  if (displayName !== void 0 && displayNameTag) {
+    annotations.push({
+      kind: "annotation",
+      annotationKind: "displayName",
+      value: displayName,
+      provenance: provenanceForJSDocTag(displayNameTag, file)
+    });
+  }
+  if (description !== void 0 && descriptionTag) {
+    annotations.push({
+      kind: "annotation",
+      annotationKind: "description",
+      value: description,
+      provenance: provenanceForJSDocTag(descriptionTag, file)
+    });
+  }
+  return { constraints, annotations };
+}
+function extractBlockText(block) {
+  return extractPlainText(block.content);
+}
+function extractPlainText(node) {
+  let result = "";
+  if (node instanceof DocPlainText) {
+    return node.text;
+  }
+  if (node instanceof DocSoftBreak) {
+    return " ";
+  }
+  if (typeof node.getChildNodes === "function") {
+    for (const child of node.getChildNodes()) {
+      result += extractPlainText(child);
+    }
+  }
+  return result;
+}
+function parseConstraintValue(tagName, text, provenance) {
+  if (!isBuiltinConstraintName(tagName)) {
+    return null;
+  }
+  const expectedType = BUILTIN_CONSTRAINT_DEFINITIONS[tagName];
+  if (expectedType === "number") {
+    const value = Number(text);
+    if (Number.isNaN(value)) {
+      return null;
+    }
+    const numericKind = NUMERIC_CONSTRAINT_MAP[tagName];
+    if (numericKind) {
+      return {
+        kind: "constraint",
+        constraintKind: numericKind,
+        value,
+        provenance
+      };
+    }
+    const lengthKind = LENGTH_CONSTRAINT_MAP[tagName];
+    if (lengthKind) {
+      return {
+        kind: "constraint",
+        constraintKind: lengthKind,
+        value,
+        provenance
+      };
+    }
+    return null;
+  }
+  if (expectedType === "json") {
+    try {
+      const parsed = JSON.parse(text);
+      if (!Array.isArray(parsed)) {
+        return null;
+      }
+      const members = [];
+      for (const item of parsed) {
+        if (typeof item === "string" || typeof item === "number") {
+          members.push(item);
+        } else if (typeof item === "object" && item !== null && "id" in item) {
+          const id = item["id"];
+          if (typeof id === "string" || typeof id === "number") {
+            members.push(id);
+          }
+        }
+      }
+      return {
+        kind: "constraint",
+        constraintKind: "allowedMembers",
+        members,
+        provenance
+      };
+    } catch {
+      return null;
+    }
+  }
+  return {
+    kind: "constraint",
+    constraintKind: "pattern",
+    pattern: text,
+    provenance
+  };
+}
+function provenanceForComment(range, sourceFile, file, tagName) {
+  const { line, character } = sourceFile.getLineAndCharacterOfPosition(range.pos);
+  return {
+    surface: "tsdoc",
+    file,
+    line: line + 1,
+    column: character,
+    tagName: "@" + tagName
+  };
+}
+function provenanceForJSDocTag(tag, file) {
+  const sourceFile = tag.getSourceFile();
+  const { line, character } = sourceFile.getLineAndCharacterOfPosition(tag.getStart());
+  return {
+    surface: "tsdoc",
+    file,
+    line: line + 1,
+    column: character,
+    tagName: "@" + tag.tagName.text
+  };
+}
+function getTagCommentText(tag) {
+  if (tag.comment === void 0) {
+    return void 0;
+  }
+  if (typeof tag.comment === "string") {
+    return tag.comment;
+  }
+  return ts2.getTextOfJSDocComment(tag.comment);
+}
+var NUMERIC_CONSTRAINT_MAP, LENGTH_CONSTRAINT_MAP, TAGS_REQUIRING_RAW_TEXT, sharedParser;
+var init_tsdoc_parser = __esm({
+  "src/analyzer/tsdoc-parser.ts"() {
+    "use strict";
+    NUMERIC_CONSTRAINT_MAP = {
+      Minimum: "minimum",
+      Maximum: "maximum",
+      ExclusiveMinimum: "exclusiveMinimum",
+      ExclusiveMaximum: "exclusiveMaximum"
+    };
+    LENGTH_CONSTRAINT_MAP = {
+      MinLength: "minLength",
+      MaxLength: "maxLength"
+    };
+    TAGS_REQUIRING_RAW_TEXT = /* @__PURE__ */ new Set(["Pattern", "EnumOptions"]);
+  }
+});
+
+// src/analyzer/jsdoc-constraints.ts
+import * as ts3 from "typescript";
+import {
+  BUILTIN_CONSTRAINT_DEFINITIONS as BUILTIN_CONSTRAINT_DEFINITIONS2
+} from "@formspec/core";
+function extractJSDocConstraintNodes(node, file = "") {
+  const result = parseTSDocTags(node, file);
+  return [...result.constraints];
+}
+function extractJSDocAnnotationNodes(node, file = "") {
+  const result = parseTSDocTags(node, file);
+  return [...result.annotations];
+}
+function extractDefaultValueAnnotation(initializer, file = "") {
+  if (!initializer) return null;
+  let value;
+  if (ts3.isStringLiteral(initializer)) {
+    value = initializer.text;
+  } else if (ts3.isNumericLiteral(initializer)) {
+    value = Number(initializer.text);
+  } else if (initializer.kind === ts3.SyntaxKind.TrueKeyword) {
+    value = true;
+  } else if (initializer.kind === ts3.SyntaxKind.FalseKeyword) {
+    value = false;
+  } else if (initializer.kind === ts3.SyntaxKind.NullKeyword) {
+    value = null;
+  } else if (ts3.isPrefixUnaryExpression(initializer)) {
+    if (initializer.operator === ts3.SyntaxKind.MinusToken && ts3.isNumericLiteral(initializer.operand)) {
+      value = -Number(initializer.operand.text);
+    }
+  }
+  if (value === void 0) return null;
+  const sourceFile = initializer.getSourceFile();
+  const { line, character } = sourceFile.getLineAndCharacterOfPosition(initializer.getStart());
+  return {
+    kind: "annotation",
+    annotationKind: "defaultValue",
+    value,
+    provenance: {
+      surface: "tsdoc",
+      file,
+      line: line + 1,
+      column: character
+    }
+  };
+}
+var init_jsdoc_constraints = __esm({
+  "src/analyzer/jsdoc-constraints.ts"() {
+    "use strict";
+    init_tsdoc_parser();
+  }
+});
+
+// src/analyzer/class-analyzer.ts
+import * as ts4 from "typescript";
+function isObjectType(type) {
+  return !!(type.flags & ts4.TypeFlags.Object);
+}
+function isTypeReference(type) {
+  return !!(type.flags & ts4.TypeFlags.Object) && !!(type.objectFlags & ts4.ObjectFlags.Reference);
+}
+function analyzeClassToIR(classDecl, checker, file = "") {
+  const name = classDecl.name?.text ?? "AnonymousClass";
+  const fields = [];
+  const fieldLayouts = [];
+  const typeRegistry = {};
+  const visiting = /* @__PURE__ */ new Set();
+  const instanceMethods = [];
+  const staticMethods = [];
+  for (const member of classDecl.members) {
+    if (ts4.isPropertyDeclaration(member)) {
+      const fieldNode = analyzeFieldToIR(member, checker, file, typeRegistry, visiting);
+      if (fieldNode) {
+        fields.push(fieldNode);
+        fieldLayouts.push({});
+      }
+    } else if (ts4.isMethodDeclaration(member)) {
+      const methodInfo = analyzeMethod(member, checker);
+      if (methodInfo) {
+        const isStatic = member.modifiers?.some((m) => m.kind === ts4.SyntaxKind.StaticKeyword);
+        if (isStatic) {
+          staticMethods.push(methodInfo);
+        } else {
+          instanceMethods.push(methodInfo);
+        }
+      }
+    }
+  }
+  return { name, fields, fieldLayouts, typeRegistry, instanceMethods, staticMethods };
+}
+function analyzeInterfaceToIR(interfaceDecl, checker, file = "") {
+  const name = interfaceDecl.name.text;
+  const fields = [];
+  const typeRegistry = {};
+  const visiting = /* @__PURE__ */ new Set();
+  for (const member of interfaceDecl.members) {
+    if (ts4.isPropertySignature(member)) {
+      const fieldNode = analyzeInterfacePropertyToIR(member, checker, file, typeRegistry, visiting);
+      if (fieldNode) {
+        fields.push(fieldNode);
+      }
+    }
+  }
+  const fieldLayouts = fields.map(() => ({}));
+  return { name, fields, fieldLayouts, typeRegistry, instanceMethods: [], staticMethods: [] };
+}
+function analyzeTypeAliasToIR(typeAlias, checker, file = "") {
+  if (!ts4.isTypeLiteralNode(typeAlias.type)) {
+    const sourceFile = typeAlias.getSourceFile();
+    const { line } = sourceFile.getLineAndCharacterOfPosition(typeAlias.getStart());
+    const kindDesc = ts4.SyntaxKind[typeAlias.type.kind] ?? "unknown";
+    return {
+      ok: false,
+      error: `Type alias "${typeAlias.name.text}" at line ${String(line + 1)} is not an object type literal (found ${kindDesc})`
+    };
+  }
+  const name = typeAlias.name.text;
+  const fields = [];
+  const typeRegistry = {};
+  const visiting = /* @__PURE__ */ new Set();
+  for (const member of typeAlias.type.members) {
+    if (ts4.isPropertySignature(member)) {
+      const fieldNode = analyzeInterfacePropertyToIR(member, checker, file, typeRegistry, visiting);
+      if (fieldNode) {
+        fields.push(fieldNode);
+      }
+    }
+  }
+  return {
+    ok: true,
+    analysis: {
+      name,
+      fields,
+      fieldLayouts: fields.map(() => ({})),
+      typeRegistry,
+      instanceMethods: [],
+      staticMethods: []
+    }
+  };
+}
+function analyzeFieldToIR(prop, checker, file, typeRegistry, visiting) {
+  if (!ts4.isIdentifier(prop.name)) {
+    return null;
+  }
+  const name = prop.name.text;
+  const tsType = checker.getTypeAtLocation(prop);
+  const optional = prop.questionToken !== void 0;
+  const provenance = provenanceForNode(prop, file);
+  const type = resolveTypeNode(tsType, checker, file, typeRegistry, visiting);
+  const constraints = [];
+  if (prop.type) {
+    constraints.push(...extractTypeAliasConstraintNodes(prop.type, checker, file));
+  }
+  constraints.push(...extractJSDocConstraintNodes(prop, file));
+  const annotations = [];
+  annotations.push(...extractJSDocAnnotationNodes(prop, file));
+  const defaultAnnotation = extractDefaultValueAnnotation(prop.initializer, file);
+  if (defaultAnnotation) {
+    annotations.push(defaultAnnotation);
+  }
+  return {
+    kind: "field",
+    name,
+    type,
+    required: !optional,
+    constraints,
+    annotations,
+    provenance
+  };
+}
+function analyzeInterfacePropertyToIR(prop, checker, file, typeRegistry, visiting) {
+  if (!ts4.isIdentifier(prop.name)) {
+    return null;
+  }
+  const name = prop.name.text;
+  const tsType = checker.getTypeAtLocation(prop);
+  const optional = prop.questionToken !== void 0;
+  const provenance = provenanceForNode(prop, file);
+  const type = resolveTypeNode(tsType, checker, file, typeRegistry, visiting);
+  const constraints = [];
+  if (prop.type) {
+    constraints.push(...extractTypeAliasConstraintNodes(prop.type, checker, file));
+  }
+  constraints.push(...extractJSDocConstraintNodes(prop, file));
+  const annotations = [];
+  annotations.push(...extractJSDocAnnotationNodes(prop, file));
+  return {
+    kind: "field",
+    name,
+    type,
+    required: !optional,
+    constraints,
+    annotations,
+    provenance
+  };
+}
+function resolveTypeNode(type, checker, file, typeRegistry, visiting) {
+  if (type.flags & ts4.TypeFlags.String) {
+    return { kind: "primitive", primitiveKind: "string" };
+  }
+  if (type.flags & ts4.TypeFlags.Number) {
+    return { kind: "primitive", primitiveKind: "number" };
+  }
+  if (type.flags & ts4.TypeFlags.Boolean) {
+    return { kind: "primitive", primitiveKind: "boolean" };
+  }
+  if (type.flags & ts4.TypeFlags.Null) {
+    return { kind: "primitive", primitiveKind: "null" };
+  }
+  if (type.flags & ts4.TypeFlags.Undefined) {
+    return { kind: "primitive", primitiveKind: "null" };
+  }
+  if (type.isStringLiteral()) {
+    return {
+      kind: "enum",
+      members: [{ value: type.value }]
+    };
+  }
+  if (type.isNumberLiteral()) {
+    return {
+      kind: "enum",
+      members: [{ value: type.value }]
+    };
+  }
+  if (type.isUnion()) {
+    return resolveUnionType(type, checker, file, typeRegistry, visiting);
+  }
+  if (checker.isArrayType(type)) {
+    return resolveArrayType(type, checker, file, typeRegistry, visiting);
+  }
+  if (isObjectType(type)) {
+    return resolveObjectType(type, checker, file, typeRegistry, visiting);
+  }
+  return { kind: "primitive", primitiveKind: "string" };
+}
+function resolveUnionType(type, checker, file, typeRegistry, visiting) {
+  const allTypes = type.types;
+  const nonNullTypes = allTypes.filter(
+    (t) => !(t.flags & (ts4.TypeFlags.Null | ts4.TypeFlags.Undefined))
+  );
+  const hasNull = allTypes.some((t) => t.flags & ts4.TypeFlags.Null);
+  const isBooleanUnion2 = nonNullTypes.length === 2 && nonNullTypes.every((t) => t.flags & ts4.TypeFlags.BooleanLiteral);
+  if (isBooleanUnion2) {
+    const boolNode = { kind: "primitive", primitiveKind: "boolean" };
+    if (hasNull) {
+      return {
+        kind: "union",
+        members: [boolNode, { kind: "primitive", primitiveKind: "null" }]
+      };
+    }
+    return boolNode;
+  }
+  const allStringLiterals = nonNullTypes.every((t) => t.isStringLiteral());
+  if (allStringLiterals && nonNullTypes.length > 0) {
+    const stringTypes = nonNullTypes.filter((t) => t.isStringLiteral());
+    const enumNode = {
+      kind: "enum",
+      members: stringTypes.map((t) => ({ value: t.value }))
+    };
+    if (hasNull) {
+      return {
+        kind: "union",
+        members: [enumNode, { kind: "primitive", primitiveKind: "null" }]
+      };
+    }
+    return enumNode;
+  }
+  const allNumberLiterals = nonNullTypes.every((t) => t.isNumberLiteral());
+  if (allNumberLiterals && nonNullTypes.length > 0) {
+    const numberTypes = nonNullTypes.filter((t) => t.isNumberLiteral());
+    const enumNode = {
+      kind: "enum",
+      members: numberTypes.map((t) => ({ value: t.value }))
+    };
+    if (hasNull) {
+      return {
+        kind: "union",
+        members: [enumNode, { kind: "primitive", primitiveKind: "null" }]
+      };
+    }
+    return enumNode;
+  }
+  if (nonNullTypes.length === 1 && nonNullTypes[0]) {
+    const inner = resolveTypeNode(nonNullTypes[0], checker, file, typeRegistry, visiting);
+    if (hasNull) {
+      return {
+        kind: "union",
+        members: [inner, { kind: "primitive", primitiveKind: "null" }]
+      };
+    }
+    return inner;
+  }
+  const members = nonNullTypes.map(
+    (t) => resolveTypeNode(t, checker, file, typeRegistry, visiting)
+  );
+  if (hasNull) {
+    members.push({ kind: "primitive", primitiveKind: "null" });
+  }
+  return { kind: "union", members };
+}
+function resolveArrayType(type, checker, file, typeRegistry, visiting) {
+  const typeArgs = isTypeReference(type) ? type.typeArguments : void 0;
+  const elementType = typeArgs?.[0];
+  const items = elementType ? resolveTypeNode(elementType, checker, file, typeRegistry, visiting) : { kind: "primitive", primitiveKind: "string" };
+  return { kind: "array", items };
+}
+function resolveObjectType(type, checker, file, typeRegistry, visiting) {
+  if (visiting.has(type)) {
+    return { kind: "object", properties: [], additionalProperties: false };
+  }
+  visiting.add(type);
+  const typeName = getNamedTypeName(type);
+  if (typeName && typeName in typeRegistry) {
+    visiting.delete(type);
+    return { kind: "reference", name: typeName, typeArguments: [] };
+  }
+  const properties = [];
+  const fieldInfoMap = getNamedTypeFieldNodeInfoMap(type, checker, file, typeRegistry, visiting);
+  for (const prop of type.getProperties()) {
+    const declaration = prop.valueDeclaration ?? prop.declarations?.[0];
+    if (!declaration) continue;
+    const propType = checker.getTypeOfSymbolAtLocation(prop, declaration);
+    const optional = !!(prop.flags & ts4.SymbolFlags.Optional);
+    const propTypeNode = resolveTypeNode(propType, checker, file, typeRegistry, visiting);
+    const fieldNodeInfo = fieldInfoMap?.get(prop.name);
+    properties.push({
+      name: prop.name,
+      type: propTypeNode,
+      optional,
+      constraints: fieldNodeInfo?.constraints ?? [],
+      annotations: fieldNodeInfo?.annotations ?? [],
+      provenance: fieldNodeInfo?.provenance ?? provenanceForFile(file)
+    });
+  }
+  visiting.delete(type);
+  const objectNode = {
+    kind: "object",
+    properties,
+    additionalProperties: false
+  };
+  if (typeName) {
+    typeRegistry[typeName] = {
+      name: typeName,
+      type: objectNode,
+      provenance: provenanceForFile(file)
+    };
+    return { kind: "reference", name: typeName, typeArguments: [] };
+  }
+  return objectNode;
+}
+function getNamedTypeFieldNodeInfoMap(type, checker, file, typeRegistry, visiting) {
+  const symbols = [type.getSymbol(), type.aliasSymbol].filter(
+    (s) => s?.declarations != null && s.declarations.length > 0
+  );
+  for (const symbol of symbols) {
+    const declarations = symbol.declarations;
+    if (!declarations) continue;
+    const classDecl = declarations.find(ts4.isClassDeclaration);
+    if (classDecl) {
+      const map = /* @__PURE__ */ new Map();
+      for (const member of classDecl.members) {
+        if (ts4.isPropertyDeclaration(member) && ts4.isIdentifier(member.name)) {
+          const fieldNode = analyzeFieldToIR(member, checker, file, typeRegistry, visiting);
+          if (fieldNode) {
+            map.set(fieldNode.name, {
+              constraints: [...fieldNode.constraints],
+              annotations: [...fieldNode.annotations],
+              provenance: fieldNode.provenance
+            });
+          }
+        }
+      }
+      return map;
+    }
+    const interfaceDecl = declarations.find(ts4.isInterfaceDeclaration);
+    if (interfaceDecl) {
+      return buildFieldNodeInfoMap(interfaceDecl.members, checker, file, typeRegistry, visiting);
+    }
+    const typeAliasDecl = declarations.find(ts4.isTypeAliasDeclaration);
+    if (typeAliasDecl && ts4.isTypeLiteralNode(typeAliasDecl.type)) {
+      return buildFieldNodeInfoMap(
+        typeAliasDecl.type.members,
+        checker,
+        file,
+        typeRegistry,
+        visiting
+      );
+    }
+  }
+  return null;
+}
+function buildFieldNodeInfoMap(members, checker, file, typeRegistry, visiting) {
+  const map = /* @__PURE__ */ new Map();
+  for (const member of members) {
+    if (ts4.isPropertySignature(member)) {
+      const fieldNode = analyzeInterfacePropertyToIR(member, checker, file, typeRegistry, visiting);
+      if (fieldNode) {
+        map.set(fieldNode.name, {
+          constraints: [...fieldNode.constraints],
+          annotations: [...fieldNode.annotations],
+          provenance: fieldNode.provenance
+        });
+      }
+    }
+  }
+  return map;
+}
+function extractTypeAliasConstraintNodes(typeNode, checker, file) {
+  if (!ts4.isTypeReferenceNode(typeNode)) return [];
+  const symbol = checker.getSymbolAtLocation(typeNode.typeName);
+  if (!symbol?.declarations) return [];
+  const aliasDecl = symbol.declarations.find(ts4.isTypeAliasDeclaration);
+  if (!aliasDecl) return [];
+  if (ts4.isTypeLiteralNode(aliasDecl.type)) return [];
+  return extractJSDocConstraintNodes(aliasDecl, file);
+}
+function provenanceForNode(node, file) {
+  const sourceFile = node.getSourceFile();
+  const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+  return {
+    surface: "tsdoc",
+    file,
+    line: line + 1,
+    column: character
+  };
+}
+function provenanceForFile(file) {
+  return { surface: "tsdoc", file, line: 0, column: 0 };
+}
+function getNamedTypeName(type) {
+  const symbol = type.getSymbol();
+  if (symbol?.declarations) {
+    const decl = symbol.declarations[0];
+    if (decl && (ts4.isClassDeclaration(decl) || ts4.isInterfaceDeclaration(decl) || ts4.isTypeAliasDeclaration(decl))) {
+      const name = ts4.isClassDeclaration(decl) ? decl.name?.text : decl.name.text;
+      if (name) return name;
+    }
+  }
+  const aliasSymbol = type.aliasSymbol;
+  if (aliasSymbol?.declarations) {
+    const aliasDecl = aliasSymbol.declarations.find(ts4.isTypeAliasDeclaration);
+    if (aliasDecl) {
+      return aliasDecl.name.text;
+    }
+  }
+  return null;
+}
+function analyzeMethod(method, checker) {
+  if (!ts4.isIdentifier(method.name)) {
+    return null;
+  }
+  const name = method.name.text;
+  const parameters = [];
+  for (const param of method.parameters) {
+    if (ts4.isIdentifier(param.name)) {
+      const paramInfo = analyzeParameter(param, checker);
+      parameters.push(paramInfo);
+    }
+  }
+  const returnTypeNode = method.type;
+  const signature = checker.getSignatureFromDeclaration(method);
+  const returnType = signature ? checker.getReturnTypeOfSignature(signature) : checker.getTypeAtLocation(method);
+  return { name, parameters, returnTypeNode, returnType };
+}
+function analyzeParameter(param, checker) {
+  const name = ts4.isIdentifier(param.name) ? param.name.text : "param";
+  const typeNode = param.type;
+  const type = checker.getTypeAtLocation(param);
+  const formSpecExportName = detectFormSpecReference(typeNode);
+  const optional = param.questionToken !== void 0 || param.initializer !== void 0;
+  return { name, typeNode, type, formSpecExportName, optional };
+}
+function detectFormSpecReference(typeNode) {
+  if (!typeNode) return null;
+  if (!ts4.isTypeReferenceNode(typeNode)) return null;
+  const typeName = ts4.isIdentifier(typeNode.typeName) ? typeNode.typeName.text : ts4.isQualifiedName(typeNode.typeName) ? typeNode.typeName.right.text : null;
+  if (typeName !== "InferSchema" && typeName !== "InferFormSchema") return null;
+  const typeArg = typeNode.typeArguments?.[0];
+  if (!typeArg || !ts4.isTypeQueryNode(typeArg)) return null;
+  if (ts4.isIdentifier(typeArg.exprName)) {
+    return typeArg.exprName.text;
+  }
+  if (ts4.isQualifiedName(typeArg.exprName)) {
+    return typeArg.exprName.right.text;
+  }
+  return null;
+}
+var init_class_analyzer = __esm({
+  "src/analyzer/class-analyzer.ts"() {
+    "use strict";
+    init_jsdoc_constraints();
+  }
+});
+
+// src/generators/class-schema.ts
+function generateClassSchemas(analysis, source) {
+  const ir = canonicalizeTSDoc(analysis, source);
+  return {
+    jsonSchema: generateJsonSchemaFromIR(ir),
+    uiSchema: generateUiSchemaFromIR(ir)
+  };
+}
+function generateSchemasFromClass(options) {
+  const ctx = createProgramContext(options.filePath);
+  const classDecl = findClassByName(ctx.sourceFile, options.className);
+  if (!classDecl) {
+    throw new Error(`Class "${options.className}" not found in ${options.filePath}`);
+  }
+  const analysis = analyzeClassToIR(classDecl, ctx.checker, options.filePath);
+  return generateClassSchemas(analysis, { file: options.filePath });
+}
+function generateSchemas(options) {
+  const ctx = createProgramContext(options.filePath);
+  const source = { file: options.filePath };
+  const classDecl = findClassByName(ctx.sourceFile, options.typeName);
+  if (classDecl) {
+    const analysis = analyzeClassToIR(classDecl, ctx.checker, options.filePath);
+    return generateClassSchemas(analysis, source);
+  }
+  const interfaceDecl = findInterfaceByName(ctx.sourceFile, options.typeName);
+  if (interfaceDecl) {
+    const analysis = analyzeInterfaceToIR(interfaceDecl, ctx.checker, options.filePath);
+    return generateClassSchemas(analysis, source);
+  }
+  const typeAlias = findTypeAliasByName(ctx.sourceFile, options.typeName);
+  if (typeAlias) {
+    const result = analyzeTypeAliasToIR(typeAlias, ctx.checker, options.filePath);
+    if (result.ok) {
+      return generateClassSchemas(result.analysis, source);
+    }
+    throw new Error(result.error);
+  }
+  throw new Error(
+    `Type "${options.typeName}" not found as a class, interface, or type alias in ${options.filePath}`
+  );
+}
+var init_class_schema = __esm({
+  "src/generators/class-schema.ts"() {
+    "use strict";
+    init_program();
+    init_class_analyzer();
+    init_canonicalize();
+    init_ir_generator();
+    init_ir_generator2();
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  buildFormSchemas: () => buildFormSchemas,
+  categorizationSchema: () => categorizationSchema,
+  categorySchema: () => categorySchema,
+  controlSchema: () => controlSchema,
+  generateJsonSchema: () => generateJsonSchema,
+  generateSchemas: () => generateSchemas,
+  generateSchemasFromClass: () => generateSchemasFromClass,
+  generateUiSchema: () => generateUiSchema,
+  getSchemaExtension: () => getSchemaExtension,
+  groupLayoutSchema: () => groupLayoutSchema,
+  horizontalLayoutSchema: () => horizontalLayoutSchema,
+  jsonSchema7Schema: () => jsonSchema7Schema,
+  jsonSchemaTypeSchema: () => jsonSchemaTypeSchema,
+  labelElementSchema: () => labelElementSchema,
+  ruleConditionSchema: () => ruleConditionSchema,
+  ruleEffectSchema: () => ruleEffectSchema,
+  ruleSchema: () => ruleSchema,
+  schemaBasedConditionSchema: () => schemaBasedConditionSchema,
+  setSchemaExtension: () => setSchemaExtension,
+  uiSchemaElementSchema: () => uiSchemaElementSchema,
+  uiSchemaElementTypeSchema: () => uiSchemaElementTypeSchema,
+  uiSchemaSchema: () => uiSchema,
+  verticalLayoutSchema: () => verticalLayoutSchema,
+  writeSchemas: () => writeSchemas
+});
+import * as fs from "fs";
+import * as path2 from "path";
+function buildFormSchemas(form) {
+  return {
+    jsonSchema: generateJsonSchema(form),
+    uiSchema: generateUiSchema(form)
+  };
+}
+function writeSchemas(form, options) {
+  const { outDir, name = "schema", indent = 2 } = options;
+  const { jsonSchema, uiSchema: uiSchema2 } = buildFormSchemas(form);
+  if (!fs.existsSync(outDir)) {
+    fs.mkdirSync(outDir, { recursive: true });
+  }
+  const jsonSchemaPath = path2.join(outDir, `${name}-schema.json`);
+  const uiSchemaPath = path2.join(outDir, `${name}-uischema.json`);
+  fs.writeFileSync(jsonSchemaPath, JSON.stringify(jsonSchema, null, indent));
+  fs.writeFileSync(uiSchemaPath, JSON.stringify(uiSchema2, null, indent));
+  return { jsonSchemaPath, uiSchemaPath };
+}
+var init_index = __esm({
+  "src/index.ts"() {
+    "use strict";
+    init_generator();
+    init_generator2();
+    init_types();
+    init_schema();
+    init_schema2();
+    init_generator();
+    init_generator2();
+    init_class_schema();
+  }
+});
+
+// src/cli.ts
+import * as path3 from "path";
+import { pathToFileURL } from "url";
 function printHelp() {
-    console.log(`
+  console.log(`
 FormSpec Build CLI - Generate JSON Schema and UI Schema
 
 Usage:
@@ -38,99 +1921,93 @@ The input file should export a FormSpec as its default export or as 'form':
 `);
 }
 function parseArgs(args) {
-    const positional = [];
-    let outDir = "./generated";
-    let name = "";
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (arg === undefined)
-            continue;
-        if (arg === "-h" || arg === "--help") {
-            printHelp();
-            process.exit(0);
-        }
-        if (arg === "-o" || arg === "--out-dir") {
-            const nextArg = args[i + 1];
-            if (!nextArg) {
-                console.error("Error: --out-dir requires a value");
-                return null;
-            }
-            outDir = nextArg;
-            i++;
-            continue;
-        }
-        if (arg === "-n" || arg === "--name") {
-            const nextArg = args[i + 1];
-            if (!nextArg) {
-                console.error("Error: --name requires a value");
-                return null;
-            }
-            name = nextArg;
-            i++;
-            continue;
-        }
-        if (arg.startsWith("-")) {
-            console.error(`Error: Unknown option: ${arg}`);
-            return null;
-        }
-        positional.push(arg);
+  const positional = [];
+  let outDir = "./generated";
+  let name = "";
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === void 0) continue;
+    if (arg === "-h" || arg === "--help") {
+      printHelp();
+      process.exit(0);
     }
-    if (positional.length === 0) {
-        console.error("Error: No input file specified");
-        printHelp();
+    if (arg === "-o" || arg === "--out-dir") {
+      const nextArg = args[i + 1];
+      if (!nextArg) {
+        console.error("Error: --out-dir requires a value");
         return null;
+      }
+      outDir = nextArg;
+      i++;
+      continue;
     }
-    const inputFile = positional[0];
-    if (!inputFile) {
-        console.error("Error: No input file specified");
+    if (arg === "-n" || arg === "--name") {
+      const nextArg = args[i + 1];
+      if (!nextArg) {
+        console.error("Error: --name requires a value");
         return null;
+      }
+      name = nextArg;
+      i++;
+      continue;
     }
-    // Default name from input file
-    if (!name) {
-        name = path.basename(inputFile, path.extname(inputFile));
+    if (arg.startsWith("-")) {
+      console.error(`Error: Unknown option: ${arg}`);
+      return null;
     }
-    return { inputFile, outDir, name };
+    positional.push(arg);
+  }
+  if (positional.length === 0) {
+    console.error("Error: No input file specified");
+    printHelp();
+    return null;
+  }
+  const inputFile = positional[0];
+  if (!inputFile) {
+    console.error("Error: No input file specified");
+    return null;
+  }
+  if (!name) {
+    name = path3.basename(inputFile, path3.extname(inputFile));
+  }
+  return { inputFile, outDir, name };
 }
 async function main() {
-    const args = process.argv.slice(2);
-    const options = parseArgs(args);
-    if (!options) {
-        process.exit(1);
-    }
-    const { inputFile, outDir, name } = options;
-    // Resolve input file path
-    const absoluteInput = path.resolve(process.cwd(), inputFile);
-    try {
-        // Dynamically import the input file
-        // Use file URL for cross-platform compatibility (Windows paths need file:// URLs)
-        const fileUrl = pathToFileURL(absoluteInput).href;
-        const module = (await import(fileUrl));
-        // Look for the form export
-        const form = module["default"] ?? module["form"];
-        if (!form || typeof form !== "object" || !("elements" in form)) {
-            console.error("Error: Input file must export a FormSpec as default export or as 'form'");
-            console.error("Example:");
-            console.error('  export default formspec(field.text("name"));');
-            console.error("  // or");
-            console.error('  export const form = formspec(field.text("name"));');
-            process.exit(1);
-        }
-        // Import writeSchemas dynamically to avoid circular deps
-        const { writeSchemas } = await import("./index.js");
-        const { jsonSchemaPath, uiSchemaPath } = writeSchemas(form, { outDir, name });
-        console.log("Generated:");
-        console.log(`  ${jsonSchemaPath}`);
-        console.log(`  ${uiSchemaPath}`);
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            console.error(`Error: ${error.message}`);
-        }
-        else {
-            console.error("Error:", error);
-        }
-        process.exit(1);
+  const args = process.argv.slice(2);
+  const options = parseArgs(args);
+  if (!options) {
+    process.exit(1);
+  }
+  const { inputFile, outDir, name } = options;
+  const absoluteInput = path3.resolve(process.cwd(), inputFile);
+  try {
+    const fileUrl = pathToFileURL(absoluteInput).href;
+    const module = await import(fileUrl);
+    const form = module["default"] ?? module["form"];
+    if (!form || typeof form !== "object" || !("elements" in form)) {
+      console.error("Error: Input file must export a FormSpec as default export or as 'form'");
+      console.error("Example:");
+      console.error('  export default formspec(field.text("name"));');
+      console.error("  // or");
+      console.error('  export const form = formspec(field.text("name"));');
+      process.exit(1);
+    }
+    const { writeSchemas: writeSchemas2 } = await Promise.resolve().then(() => (init_index(), index_exports));
+    const { jsonSchemaPath, uiSchemaPath } = writeSchemas2(
+      form,
+      { outDir, name }
+    );
+    console.log("Generated:");
+    console.log(`  ${jsonSchemaPath}`);
+    console.log(`  ${uiSchemaPath}`);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`Error: ${error.message}`);
+    } else {
+      console.error("Error:", error);
     }
+    process.exit(1);
+  }
 }
 void main();
 //# sourceMappingURL=cli.js.map