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

package/dist/index.cjs

@@ -34,13 +34,10 @@ __export(index_exports, {
   categorizationSchema: () => categorizationSchema,
   categorySchema: () => categorySchema,
   controlSchema: () => controlSchema,
-  findDecoratedClasses: () => findDecoratedClasses,
-  generateCodegenOutput: () => generateCodegenOutput,
   generateJsonSchema: () => generateJsonSchema,
   generateSchemas: () => generateSchemas,
   generateSchemasFromClass: () => generateSchemasFromClass,
   generateUiSchema: () => generateUiSchema,
-  generateUiSchemaFromFields: () => generateUiSchemaFromFields,
   getSchemaExtension: () => getSchemaExtension,
   groupLayoutSchema: () => groupLayoutSchema,
   horizontalLayoutSchema: () => horizontalLayoutSchema,
@@ -50,7 +47,6 @@ __export(index_exports, {
   ruleConditionSchema: () => ruleConditionSchema,
   ruleEffectSchema: () => ruleEffectSchema,
   ruleSchema: () => ruleSchema,
-  runCodegen: () => runCodegen,
   schemaBasedConditionSchema: () => schemaBasedConditionSchema,
   setSchemaExtension: () => setSchemaExtension,
   uiSchemaElementSchema: () => uiSchemaElementSchema,
@@ -61,207 +57,606 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/json-schema/schema.ts
-var import_zod = require("zod");
-var jsonSchemaTypeSchema = import_zod.z.enum([
-  "string",
-  "number",
-  "integer",
-  "boolean",
-  "object",
-  "array",
-  "null"
-]);
-var jsonSchema7Schema = import_zod.z.lazy(
-  () => import_zod.z.object({
-    $schema: import_zod.z.string().optional(),
-    $id: import_zod.z.string().optional(),
-    $ref: import_zod.z.string().optional(),
-    // Metadata
-    title: import_zod.z.string().optional(),
-    description: import_zod.z.string().optional(),
-    deprecated: import_zod.z.boolean().optional(),
-    // Type
-    type: import_zod.z.union([jsonSchemaTypeSchema, import_zod.z.array(jsonSchemaTypeSchema)]).optional(),
-    // String validation
-    minLength: import_zod.z.number().optional(),
-    maxLength: import_zod.z.number().optional(),
-    pattern: import_zod.z.string().optional(),
-    // Number validation
-    minimum: import_zod.z.number().optional(),
-    maximum: import_zod.z.number().optional(),
-    exclusiveMinimum: import_zod.z.number().optional(),
-    exclusiveMaximum: import_zod.z.number().optional(),
-    // Enum
-    enum: import_zod.z.array(import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean(), import_zod.z.null()])).readonly().optional(),
-    const: import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean(), import_zod.z.null()]).optional(),
-    // Object
-    properties: import_zod.z.record(import_zod.z.string(), jsonSchema7Schema).optional(),
-    required: import_zod.z.array(import_zod.z.string()).optional(),
-    additionalProperties: import_zod.z.union([import_zod.z.boolean(), jsonSchema7Schema]).optional(),
-    // Array
-    items: import_zod.z.union([jsonSchema7Schema, import_zod.z.array(jsonSchema7Schema)]).optional(),
-    minItems: import_zod.z.number().optional(),
-    maxItems: import_zod.z.number().optional(),
-    // Composition
-    allOf: import_zod.z.array(jsonSchema7Schema).optional(),
-    anyOf: import_zod.z.array(jsonSchema7Schema).optional(),
-    oneOf: import_zod.z.array(jsonSchema7Schema).optional(),
-    not: jsonSchema7Schema.optional(),
-    // Conditional
-    if: jsonSchema7Schema.optional(),
-    then: jsonSchema7Schema.optional(),
-    else: jsonSchema7Schema.optional(),
-    // Format
-    format: import_zod.z.string().optional(),
-    // Default
-    default: import_zod.z.unknown().optional(),
-    // FormSpec extensions
-    "x-formspec-source": import_zod.z.string().optional(),
-    "x-formspec-params": import_zod.z.array(import_zod.z.string()).readonly().optional(),
-    "x-formspec-schemaSource": import_zod.z.string().optional()
-  }).passthrough()
-);
-
-// src/json-schema/generator.ts
-var import_zod2 = require("zod");
-function parseOrThrow(schema, value, label) {
-  try {
-    return schema.parse(value);
-  } catch (error) {
-    if (error instanceof import_zod2.z.ZodError) {
-      throw new Error(
-        `Generated ${label} failed validation:
-${error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n")}`
-      );
-    }
-    throw error;
-  }
+// src/canonicalize/chain-dsl-canonicalizer.ts
+var import_core = require("@formspec/core");
+var CHAIN_DSL_PROVENANCE = {
+  surface: "chain-dsl",
+  file: "",
+  line: 0,
+  column: 0
+};
+function isGroup(el) {
+  return el._type === "group";
 }
-function generateNestedSchema(elements) {
-  const properties = {};
-  const required = [];
-  collectFields(elements, properties, required);
-  const uniqueRequired = [...new Set(required)];
+function isConditional(el) {
+  return el._type === "conditional";
+}
+function isField(el) {
+  return el._type === "field";
+}
+function canonicalizeChainDSL(form) {
   return {
-    type: "object",
-    properties,
-    ...uniqueRequired.length > 0 && { required: uniqueRequired }
+    kind: "form-ir",
+    irVersion: import_core.IR_VERSION,
+    elements: canonicalizeElements(form.elements),
+    typeRegistry: {},
+    provenance: CHAIN_DSL_PROVENANCE
   };
 }
-function fieldToJsonSchema(field) {
-  const base = {};
-  if (field.label !== void 0) {
-    base.title = field.label;
+function canonicalizeElements(elements) {
+  return elements.map(canonicalizeElement);
+}
+function canonicalizeElement(element) {
+  if (isField(element)) {
+    return canonicalizeField(element);
+  }
+  if (isGroup(element)) {
+    return canonicalizeGroup(element);
   }
+  if (isConditional(element)) {
+    return canonicalizeConditional(element);
+  }
+  const _exhaustive = element;
+  throw new Error(`Unknown element type: ${JSON.stringify(_exhaustive)}`);
+}
+function canonicalizeField(field) {
   switch (field._field) {
     case "text":
-      return { ...base, type: "string" };
+      return canonicalizeTextField(field);
     case "number":
-      return {
-        ...base,
-        type: "number",
-        ...field.min !== void 0 && { minimum: field.min },
-        ...field.max !== void 0 && { maximum: field.max }
-      };
+      return canonicalizeNumberField(field);
     case "boolean":
-      return { ...base, type: "boolean" };
-    case "enum": {
-      const opts = field.options;
-      const isObjectOptions = opts.length > 0 && opts.every(
-        (opt) => typeof opt === "object" && "id" in opt && "label" in opt
-      );
-      if (isObjectOptions) {
-        return {
-          ...base,
-          type: "string",
-          oneOf: opts.map((o) => ({
-            const: o.id,
-            title: o.label
-          }))
-        };
-      }
-      return { ...base, type: "string", enum: opts };
-    }
+      return canonicalizeBooleanField(field);
+    case "enum":
+      return canonicalizeStaticEnumField(field);
     case "dynamic_enum":
-      return {
-        ...base,
-        type: "string",
-        "x-formspec-source": field.source,
-        ...field.params !== void 0 && field.params.length > 0 && { "x-formspec-params": field.params }
-      };
+      return canonicalizeDynamicEnumField(field);
     case "dynamic_schema":
-      return {
-        ...base,
-        type: "object",
-        additionalProperties: true,
-        "x-formspec-schemaSource": field.schemaSource
-      };
-    case "array": {
-      const arrayField = field;
-      return {
-        ...base,
-        type: "array",
-        items: generateNestedSchema(arrayField.items),
-        ...arrayField.minItems !== void 0 && { minItems: arrayField.minItems },
-        ...arrayField.maxItems !== void 0 && { maxItems: arrayField.maxItems }
-      };
-    }
-    case "object": {
-      const objectField = field;
-      const nestedSchema = generateNestedSchema(objectField.properties);
-      return {
-        ...base,
-        ...nestedSchema
-      };
-    }
+      return canonicalizeDynamicSchemaField(field);
+    case "array":
+      return canonicalizeArrayField(field);
+    case "object":
+      return canonicalizeObjectField(field);
     default: {
       const _exhaustive = field;
-      return _exhaustive;
+      throw new Error(`Unknown field type: ${JSON.stringify(_exhaustive)}`);
     }
   }
 }
-function collectFields(elements, properties, required) {
+function canonicalizeTextField(field) {
+  const type = { kind: "primitive", primitiveKind: "string" };
+  return buildFieldNode(
+    field.name,
+    type,
+    field.required,
+    buildAnnotations(field.label, field.placeholder)
+  );
+}
+function canonicalizeNumberField(field) {
+  const type = { kind: "primitive", primitiveKind: "number" };
+  const constraints = [];
+  if (field.min !== void 0) {
+    const c = {
+      kind: "constraint",
+      constraintKind: "minimum",
+      value: field.min,
+      provenance: CHAIN_DSL_PROVENANCE
+    };
+    constraints.push(c);
+  }
+  if (field.max !== void 0) {
+    const c = {
+      kind: "constraint",
+      constraintKind: "maximum",
+      value: field.max,
+      provenance: CHAIN_DSL_PROVENANCE
+    };
+    constraints.push(c);
+  }
+  return buildFieldNode(
+    field.name,
+    type,
+    field.required,
+    buildAnnotations(field.label),
+    constraints
+  );
+}
+function canonicalizeBooleanField(field) {
+  const type = { kind: "primitive", primitiveKind: "boolean" };
+  return buildFieldNode(field.name, type, field.required, buildAnnotations(field.label));
+}
+function canonicalizeStaticEnumField(field) {
+  const members = field.options.map((opt) => {
+    if (typeof opt === "string") {
+      return { value: opt };
+    }
+    return { value: opt.id, displayName: opt.label };
+  });
+  const type = { kind: "enum", members };
+  return buildFieldNode(field.name, type, field.required, buildAnnotations(field.label));
+}
+function canonicalizeDynamicEnumField(field) {
+  const type = {
+    kind: "dynamic",
+    dynamicKind: "enum",
+    sourceKey: field.source,
+    parameterFields: field.params ? [...field.params] : []
+  };
+  return buildFieldNode(field.name, type, field.required, buildAnnotations(field.label));
+}
+function canonicalizeDynamicSchemaField(field) {
+  const type = {
+    kind: "dynamic",
+    dynamicKind: "schema",
+    sourceKey: field.schemaSource,
+    parameterFields: []
+  };
+  return buildFieldNode(field.name, type, field.required, buildAnnotations(field.label));
+}
+function canonicalizeArrayField(field) {
+  const itemProperties = buildObjectProperties(field.items);
+  const itemsType = {
+    kind: "object",
+    properties: itemProperties,
+    additionalProperties: false
+  };
+  const type = { kind: "array", items: itemsType };
+  const constraints = [];
+  if (field.minItems !== void 0) {
+    const c = {
+      kind: "constraint",
+      constraintKind: "minItems",
+      value: field.minItems,
+      provenance: CHAIN_DSL_PROVENANCE
+    };
+    constraints.push(c);
+  }
+  if (field.maxItems !== void 0) {
+    const c = {
+      kind: "constraint",
+      constraintKind: "maxItems",
+      value: field.maxItems,
+      provenance: CHAIN_DSL_PROVENANCE
+    };
+    constraints.push(c);
+  }
+  return buildFieldNode(
+    field.name,
+    type,
+    field.required,
+    buildAnnotations(field.label),
+    constraints
+  );
+}
+function canonicalizeObjectField(field) {
+  const properties = buildObjectProperties(field.properties);
+  const type = {
+    kind: "object",
+    properties,
+    additionalProperties: false
+  };
+  return buildFieldNode(field.name, type, field.required, buildAnnotations(field.label));
+}
+function canonicalizeGroup(g) {
+  return {
+    kind: "group",
+    label: g.label,
+    elements: canonicalizeElements(g.elements),
+    provenance: CHAIN_DSL_PROVENANCE
+  };
+}
+function canonicalizeConditional(c) {
+  return {
+    kind: "conditional",
+    fieldName: c.field,
+    // Conditional values from the chain DSL are JSON-serializable primitives
+    // (strings, numbers, booleans) produced by the `is()` predicate helper.
+    value: assertJsonValue(c.value),
+    elements: canonicalizeElements(c.elements),
+    provenance: CHAIN_DSL_PROVENANCE
+  };
+}
+function assertJsonValue(v) {
+  if (v === null || typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+    return v;
+  }
+  if (Array.isArray(v)) {
+    return v.map(assertJsonValue);
+  }
+  if (typeof v === "object") {
+    const result = {};
+    for (const [key, val] of Object.entries(v)) {
+      result[key] = assertJsonValue(val);
+    }
+    return result;
+  }
+  throw new TypeError(`Conditional value is not a valid JsonValue: ${typeof v}`);
+}
+function buildFieldNode(name, type, required, annotations, constraints = []) {
+  return {
+    kind: "field",
+    name,
+    type,
+    required: required === true,
+    constraints,
+    annotations,
+    provenance: CHAIN_DSL_PROVENANCE
+  };
+}
+function buildAnnotations(label, placeholder) {
+  const annotations = [];
+  if (label !== void 0) {
+    const a = {
+      kind: "annotation",
+      annotationKind: "displayName",
+      value: label,
+      provenance: CHAIN_DSL_PROVENANCE
+    };
+    annotations.push(a);
+  }
+  if (placeholder !== void 0) {
+    const a = {
+      kind: "annotation",
+      annotationKind: "placeholder",
+      value: placeholder,
+      provenance: CHAIN_DSL_PROVENANCE
+    };
+    annotations.push(a);
+  }
+  return annotations;
+}
+function buildObjectProperties(elements, insideConditional = false) {
+  const properties = [];
+  for (const el of elements) {
+    if (isField(el)) {
+      const fieldNode = canonicalizeField(el);
+      properties.push({
+        name: fieldNode.name,
+        type: fieldNode.type,
+        // Fields inside a conditional branch are always optional in the
+        // data schema, regardless of their `required` flag — the condition
+        // may not be met, so the field may be absent.
+        optional: insideConditional || !fieldNode.required,
+        constraints: fieldNode.constraints,
+        annotations: fieldNode.annotations,
+        provenance: CHAIN_DSL_PROVENANCE
+      });
+    } else if (isGroup(el)) {
+      properties.push(...buildObjectProperties(el.elements, insideConditional));
+    } else if (isConditional(el)) {
+      properties.push(...buildObjectProperties(el.elements, true));
+    }
+  }
+  return properties;
+}
+
+// src/canonicalize/tsdoc-canonicalizer.ts
+var import_core2 = require("@formspec/core");
+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: import_core2.IR_VERSION,
+    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;
+}
+
+// src/json-schema/ir-generator.ts
+function makeContext() {
+  return { defs: {} };
+}
+function generateJsonSchemaFromIR(ir) {
+  const ctx = makeContext();
+  for (const [name, typeDef] of Object.entries(ir.typeRegistry)) {
+    ctx.defs[name] = generateTypeNode(typeDef.type, ctx);
+  }
+  const properties = {};
+  const required = [];
+  collectFields(ir.elements, properties, required, ctx);
+  const uniqueRequired = [...new Set(required)];
+  const result = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    type: "object",
+    properties,
+    ...uniqueRequired.length > 0 && { required: uniqueRequired }
+  };
+  if (Object.keys(ctx.defs).length > 0) {
+    result.$defs = ctx.defs;
+  }
+  return result;
+}
+function collectFields(elements, properties, required, ctx) {
   for (const element of elements) {
-    switch (element._type) {
+    switch (element.kind) {
       case "field":
-        properties[element.name] = fieldToJsonSchema(element);
-        if (element.required === true) {
+        properties[element.name] = generateFieldSchema(element, ctx);
+        if (element.required) {
           required.push(element.name);
         }
         break;
       case "group":
-        collectFields(element.elements, properties, required);
+        collectFields(element.elements, properties, required, ctx);
         break;
       case "conditional":
-        collectFields(
-          element.elements,
-          properties,
-          required
-        );
+        collectFields(element.elements, properties, required, ctx);
         break;
+      default: {
+        const _exhaustive = element;
+        void _exhaustive;
+      }
     }
   }
 }
-function generateJsonSchema(form) {
+function generateFieldSchema(field, ctx) {
+  const schema = generateTypeNode(field.type, ctx);
+  applyConstraints(schema, field.constraints);
+  applyAnnotations(schema, field.annotations);
+  return schema;
+}
+function generateTypeNode(type, ctx) {
+  switch (type.kind) {
+    case "primitive":
+      return generatePrimitiveType(type);
+    case "enum":
+      return generateEnumType(type);
+    case "array":
+      return generateArrayType(type, ctx);
+    case "object":
+      return generateObjectType(type, ctx);
+    case "union":
+      return generateUnionType(type, ctx);
+    case "reference":
+      return generateReferenceType(type);
+    case "dynamic":
+      return generateDynamicType(type);
+    case "custom":
+      return generateCustomType(type);
+    default: {
+      const _exhaustive = type;
+      return _exhaustive;
+    }
+  }
+}
+function generatePrimitiveType(type) {
+  return { type: type.primitiveKind };
+}
+function generateEnumType(type) {
+  const hasDisplayNames = type.members.some((m) => m.displayName !== void 0);
+  if (hasDisplayNames) {
+    return {
+      oneOf: type.members.map((m) => {
+        const entry = { const: m.value };
+        if (m.displayName !== void 0) {
+          entry.title = m.displayName;
+        }
+        return entry;
+      })
+    };
+  }
+  return { enum: type.members.map((m) => m.value) };
+}
+function generateArrayType(type, ctx) {
+  return {
+    type: "array",
+    items: generateTypeNode(type.items, ctx)
+  };
+}
+function generateObjectType(type, ctx) {
   const properties = {};
   const required = [];
-  collectFields(form.elements, properties, required);
-  const uniqueRequired = [...new Set(required)];
-  const result = {
-    $schema: "https://json-schema.org/draft-07/schema#",
+  for (const prop of type.properties) {
+    properties[prop.name] = generatePropertySchema(prop, ctx);
+    if (!prop.optional) {
+      required.push(prop.name);
+    }
+  }
+  const schema = { type: "object", properties };
+  if (required.length > 0) {
+    schema.required = required;
+  }
+  if (!type.additionalProperties) {
+    schema.additionalProperties = false;
+  }
+  return schema;
+}
+function generatePropertySchema(prop, ctx) {
+  const schema = generateTypeNode(prop.type, ctx);
+  applyConstraints(schema, prop.constraints);
+  applyAnnotations(schema, prop.annotations);
+  return schema;
+}
+function generateUnionType(type, ctx) {
+  if (isBooleanUnion(type)) {
+    return { type: "boolean" };
+  }
+  return {
+    anyOf: type.members.map((m) => generateTypeNode(m, ctx))
+  };
+}
+function isBooleanUnion(type) {
+  if (type.members.length !== 2) return false;
+  const kinds = type.members.map((m) => m.kind);
+  return kinds.every((k) => k === "primitive") && type.members.every((m) => m.kind === "primitive" && m.primitiveKind === "boolean");
+}
+function generateReferenceType(type) {
+  return { $ref: `#/$defs/${type.name}` };
+}
+function generateDynamicType(type) {
+  if (type.dynamicKind === "enum") {
+    const schema = {
+      type: "string",
+      "x-formspec-source": type.sourceKey
+    };
+    if (type.parameterFields.length > 0) {
+      schema["x-formspec-params"] = [...type.parameterFields];
+    }
+    return schema;
+  }
+  return {
     type: "object",
-    properties,
-    ...uniqueRequired.length > 0 && { required: uniqueRequired }
+    additionalProperties: true,
+    "x-formspec-schemaSource": type.sourceKey
   };
-  return parseOrThrow(jsonSchema7Schema, result, "JSON Schema");
+}
+function generateCustomType(_type) {
+  return { type: "object" };
+}
+function applyConstraints(schema, constraints) {
+  for (const constraint of constraints) {
+    switch (constraint.constraintKind) {
+      case "minimum":
+        schema.minimum = constraint.value;
+        break;
+      case "maximum":
+        schema.maximum = constraint.value;
+        break;
+      case "exclusiveMinimum":
+        schema.exclusiveMinimum = constraint.value;
+        break;
+      case "exclusiveMaximum":
+        schema.exclusiveMaximum = constraint.value;
+        break;
+      case "multipleOf": {
+        const { value } = constraint;
+        if (value === 1 && schema.type === "number") {
+          schema.type = "integer";
+        } else {
+          schema.multipleOf = value;
+        }
+        break;
+      }
+      case "minLength":
+        schema.minLength = constraint.value;
+        break;
+      case "maxLength":
+        schema.maxLength = constraint.value;
+        break;
+      case "minItems":
+        schema.minItems = constraint.value;
+        break;
+      case "maxItems":
+        schema.maxItems = constraint.value;
+        break;
+      case "pattern":
+        schema.pattern = constraint.pattern;
+        break;
+      case "uniqueItems":
+        schema.uniqueItems = constraint.value;
+        break;
+      case "allowedMembers":
+        break;
+      case "custom":
+        break;
+      default: {
+        const _exhaustive = constraint;
+        void _exhaustive;
+      }
+    }
+  }
+}
+function applyAnnotations(schema, annotations) {
+  for (const annotation of annotations) {
+    switch (annotation.annotationKind) {
+      case "displayName":
+        schema.title = annotation.value;
+        break;
+      case "description":
+        schema.description = annotation.value;
+        break;
+      case "defaultValue":
+        schema.default = annotation.value;
+        break;
+      case "deprecated":
+        schema.deprecated = true;
+        break;
+      case "placeholder":
+        break;
+      case "formatHint":
+        break;
+      case "custom":
+        break;
+      default: {
+        const _exhaustive = annotation;
+        void _exhaustive;
+      }
+    }
+  }
+}
+
+// src/json-schema/generator.ts
+function generateJsonSchema(form) {
+  const ir = canonicalizeChainDSL(form);
+  return generateJsonSchemaFromIR(ir);
 }
 
 // src/ui-schema/schema.ts
-var import_zod3 = require("zod");
-var jsonPointerSchema = import_zod3.z.string();
-var ruleEffectSchema = import_zod3.z.enum(["SHOW", "HIDE", "ENABLE", "DISABLE"]);
-var uiSchemaElementTypeSchema = import_zod3.z.enum([
+var import_zod = require("zod");
+var jsonPointerSchema = import_zod.z.string();
+var ruleEffectSchema = import_zod.z.enum(["SHOW", "HIDE", "ENABLE", "DISABLE"]);
+var uiSchemaElementTypeSchema = import_zod.z.enum([
   "Control",
   "VerticalLayout",
   "HorizontalLayout",
@@ -270,32 +665,32 @@ var uiSchemaElementTypeSchema = import_zod3.z.enum([
   "Category",
   "Label"
 ]);
-var ruleConditionSchema = import_zod3.z.lazy(
-  () => import_zod3.z.object({
-    const: import_zod3.z.unknown().optional(),
-    enum: import_zod3.z.array(import_zod3.z.unknown()).readonly().optional(),
-    type: import_zod3.z.string().optional(),
+var ruleConditionSchema = import_zod.z.lazy(
+  () => import_zod.z.object({
+    const: import_zod.z.unknown().optional(),
+    enum: import_zod.z.array(import_zod.z.unknown()).readonly().optional(),
+    type: import_zod.z.string().optional(),
     not: ruleConditionSchema.optional(),
-    minimum: import_zod3.z.number().optional(),
-    maximum: import_zod3.z.number().optional(),
-    exclusiveMinimum: import_zod3.z.number().optional(),
-    exclusiveMaximum: import_zod3.z.number().optional(),
-    minLength: import_zod3.z.number().optional(),
-    properties: import_zod3.z.record(import_zod3.z.string(), ruleConditionSchema).optional(),
-    required: import_zod3.z.array(import_zod3.z.string()).optional(),
-    allOf: import_zod3.z.array(ruleConditionSchema).optional()
+    minimum: import_zod.z.number().optional(),
+    maximum: import_zod.z.number().optional(),
+    exclusiveMinimum: import_zod.z.number().optional(),
+    exclusiveMaximum: import_zod.z.number().optional(),
+    minLength: import_zod.z.number().optional(),
+    properties: import_zod.z.record(import_zod.z.string(), ruleConditionSchema).optional(),
+    required: import_zod.z.array(import_zod.z.string()).optional(),
+    allOf: import_zod.z.array(ruleConditionSchema).optional()
   }).strict()
 );
-var schemaBasedConditionSchema = import_zod3.z.object({
+var schemaBasedConditionSchema = import_zod.z.object({
   scope: jsonPointerSchema,
   schema: ruleConditionSchema
 }).strict();
-var ruleSchema = import_zod3.z.object({
+var ruleSchema = import_zod.z.object({
   effect: ruleEffectSchema,
   condition: schemaBasedConditionSchema
 }).strict();
-var uiSchemaElementSchema = import_zod3.z.lazy(
-  () => import_zod3.z.union([
+var uiSchemaElementSchema = import_zod.z.lazy(
+  () => import_zod.z.union([
     controlSchema,
     verticalLayoutSchema,
     horizontalLayoutSchema,
@@ -305,73 +700,73 @@ var uiSchemaElementSchema = import_zod3.z.lazy(
     labelElementSchema
   ])
 );
-var controlSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("Control"),
+var controlSchema = import_zod.z.object({
+  type: import_zod.z.literal("Control"),
   scope: jsonPointerSchema,
-  label: import_zod3.z.union([import_zod3.z.string(), import_zod3.z.literal(false)]).optional(),
+  label: import_zod.z.union([import_zod.z.string(), import_zod.z.literal(false)]).optional(),
   rule: ruleSchema.optional(),
-  options: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
+  options: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
 }).passthrough();
-var verticalLayoutSchema = import_zod3.z.lazy(
-  () => import_zod3.z.object({
-    type: import_zod3.z.literal("VerticalLayout"),
-    elements: import_zod3.z.array(uiSchemaElementSchema),
+var verticalLayoutSchema = import_zod.z.lazy(
+  () => import_zod.z.object({
+    type: import_zod.z.literal("VerticalLayout"),
+    elements: import_zod.z.array(uiSchemaElementSchema),
     rule: ruleSchema.optional(),
-    options: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
+    options: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
   }).passthrough()
 );
-var horizontalLayoutSchema = import_zod3.z.lazy(
-  () => import_zod3.z.object({
-    type: import_zod3.z.literal("HorizontalLayout"),
-    elements: import_zod3.z.array(uiSchemaElementSchema),
+var horizontalLayoutSchema = import_zod.z.lazy(
+  () => import_zod.z.object({
+    type: import_zod.z.literal("HorizontalLayout"),
+    elements: import_zod.z.array(uiSchemaElementSchema),
     rule: ruleSchema.optional(),
-    options: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
+    options: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
   }).passthrough()
 );
-var groupLayoutSchema = import_zod3.z.lazy(
-  () => import_zod3.z.object({
-    type: import_zod3.z.literal("Group"),
-    label: import_zod3.z.string(),
-    elements: import_zod3.z.array(uiSchemaElementSchema),
+var groupLayoutSchema = import_zod.z.lazy(
+  () => import_zod.z.object({
+    type: import_zod.z.literal("Group"),
+    label: import_zod.z.string(),
+    elements: import_zod.z.array(uiSchemaElementSchema),
     rule: ruleSchema.optional(),
-    options: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
+    options: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
   }).passthrough()
 );
-var categorySchema = import_zod3.z.lazy(
-  () => import_zod3.z.object({
-    type: import_zod3.z.literal("Category"),
-    label: import_zod3.z.string(),
-    elements: import_zod3.z.array(uiSchemaElementSchema),
+var categorySchema = import_zod.z.lazy(
+  () => import_zod.z.object({
+    type: import_zod.z.literal("Category"),
+    label: import_zod.z.string(),
+    elements: import_zod.z.array(uiSchemaElementSchema),
     rule: ruleSchema.optional(),
-    options: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
+    options: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
   }).passthrough()
 );
-var categorizationSchema = import_zod3.z.lazy(
-  () => import_zod3.z.object({
-    type: import_zod3.z.literal("Categorization"),
-    elements: import_zod3.z.array(categorySchema),
-    label: import_zod3.z.string().optional(),
+var categorizationSchema = import_zod.z.lazy(
+  () => import_zod.z.object({
+    type: import_zod.z.literal("Categorization"),
+    elements: import_zod.z.array(categorySchema),
+    label: import_zod.z.string().optional(),
     rule: ruleSchema.optional(),
-    options: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
+    options: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
   }).passthrough()
 );
-var labelElementSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("Label"),
-  text: import_zod3.z.string(),
+var labelElementSchema = import_zod.z.object({
+  type: import_zod.z.literal("Label"),
+  text: import_zod.z.string(),
   rule: ruleSchema.optional(),
-  options: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
+  options: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
 }).passthrough();
-var uiSchema = import_zod3.z.lazy(
-  () => import_zod3.z.union([verticalLayoutSchema, horizontalLayoutSchema, groupLayoutSchema, categorizationSchema])
+var uiSchema = import_zod.z.lazy(
+  () => import_zod.z.union([verticalLayoutSchema, horizontalLayoutSchema, groupLayoutSchema, categorizationSchema])
 );
 
-// src/ui-schema/generator.ts
-var import_zod4 = require("zod");
-function parseOrThrow2(schema, value, label) {
+// src/ui-schema/ir-generator.ts
+var import_zod2 = require("zod");
+function parseOrThrow(schema, value, label) {
   try {
     return schema.parse(value);
   } catch (error) {
-    if (error instanceof import_zod4.z.ZodError) {
+    if (error instanceof import_zod2.z.ZodError) {
       throw new Error(
         `Generated ${label} failed validation:
 ${error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n")}`
@@ -416,115 +811,69 @@ function combineRules(parentRule, childRule) {
     }
   };
 }
-function elementsToUiSchema(elements, parentRule) {
+function fieldNodeToControl(field, parentRule) {
+  const displayNameAnnotation = field.annotations.find((a) => a.annotationKind === "displayName");
+  const control = {
+    type: "Control",
+    scope: fieldToScope(field.name),
+    ...displayNameAnnotation !== void 0 && { label: displayNameAnnotation.value },
+    ...parentRule !== void 0 && { rule: parentRule }
+  };
+  return control;
+}
+function groupNodeToLayout(group, parentRule) {
+  return {
+    type: "Group",
+    label: group.label,
+    elements: irElementsToUiSchema(group.elements, parentRule),
+    ...parentRule !== void 0 && { rule: parentRule }
+  };
+}
+function irElementsToUiSchema(elements, parentRule) {
   const result = [];
   for (const element of elements) {
-    switch (element._type) {
+    switch (element.kind) {
       case "field": {
-        const control = {
-          type: "Control",
-          scope: fieldToScope(element.name),
-          ...element.label !== void 0 && { label: element.label },
-          ...parentRule !== void 0 && { rule: parentRule }
-        };
-        result.push(control);
+        result.push(fieldNodeToControl(element, parentRule));
         break;
       }
       case "group": {
-        const groupElement = element;
-        const group = {
-          type: "Group",
-          label: groupElement.label,
-          elements: elementsToUiSchema(groupElement.elements, parentRule),
-          ...parentRule !== void 0 && { rule: parentRule }
-        };
-        result.push(group);
+        result.push(groupNodeToLayout(element, parentRule));
         break;
       }
       case "conditional": {
-        const conditionalElement = element;
-        const newRule = createShowRule(conditionalElement.field, conditionalElement.value);
+        const newRule = createShowRule(element.fieldName, element.value);
         const combinedRule = parentRule !== void 0 ? combineRules(parentRule, newRule) : newRule;
-        const childElements = elementsToUiSchema(conditionalElement.elements, combinedRule);
+        const childElements = irElementsToUiSchema(element.elements, combinedRule);
         result.push(...childElements);
         break;
       }
+      default: {
+        const _exhaustive = element;
+        void _exhaustive;
+        throw new Error("Unhandled IR element kind");
+      }
     }
   }
   return result;
 }
-function formSpecFieldToElement(field, scopePrefix = "#/properties") {
-  const control = {
-    type: "Control",
-    scope: `${scopePrefix}/${field.id}`
-  };
-  if (field.label !== void 0) {
-    control.label = field.label;
-  }
-  if (field.showWhen !== void 0 && typeof field.showWhen === "object" && "field" in field.showWhen && "value" in field.showWhen) {
-    const sw = field.showWhen;
-    control.rule = {
-      effect: "SHOW",
-      condition: {
-        scope: `#/properties/${sw.field}`,
-        schema: { const: sw.value }
-      }
-    };
-  }
-  return control;
-}
-function generateUiSchemaFromFields(fields) {
-  const groupMap = /* @__PURE__ */ new Map();
-  const orderedKeys = [];
-  const ungrouped = [];
-  for (const field of fields) {
-    const element = formSpecFieldToElement(field);
-    if (field.group !== void 0) {
-      if (!groupMap.has(field.group)) {
-        groupMap.set(field.group, []);
-        orderedKeys.push(field.group);
-      }
-      groupMap.get(field.group).push(element);
-    } else {
-      orderedKeys.push(null);
-      ungrouped.push(element);
-    }
-  }
-  const elements = [];
-  let ungroupedIndex = 0;
-  for (const key of orderedKeys) {
-    if (key === null) {
-      const el = ungrouped[ungroupedIndex++];
-      if (el !== void 0) {
-        elements.push(el);
-      }
-    } else {
-      const groupElements = groupMap.get(key) ?? [];
-      const groupLayout = {
-        type: "Group",
-        label: key,
-        elements: groupElements
-      };
-      elements.push(groupLayout);
-    }
-  }
+function generateUiSchemaFromIR(ir) {
   const result = {
     type: "VerticalLayout",
-    elements
+    elements: irElementsToUiSchema(ir.elements)
   };
-  return parseOrThrow2(uiSchema, result, "UI Schema");
+  return parseOrThrow(uiSchema, result, "UI Schema");
 }
+
+// src/ui-schema/generator.ts
 function generateUiSchema(form) {
-  const result = {
-    type: "VerticalLayout",
-    elements: elementsToUiSchema(form.elements)
-  };
-  return parseOrThrow2(uiSchema, result, "UI Schema");
+  const ir = canonicalizeChainDSL(form);
+  return generateUiSchemaFromIR(ir);
 }
 
 // src/index.ts
-var fs2 = __toESM(require("fs"), 1);
-var path3 = __toESM(require("path"), 1);
+var fs = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
 
 // src/json-schema/types.ts
 function setSchemaExtension(schema, key, value) {
@@ -534,296 +883,241 @@ function getSchemaExtension(schema, key) {
   return schema[key];
 }
 
-// src/analyzer/type-converter.ts
-var ts4 = __toESM(require("typescript"), 1);
-
-// src/analyzer/class-analyzer.ts
-var ts3 = __toESM(require("typescript"), 1);
+// src/json-schema/schema.ts
+var import_zod3 = require("zod");
+var jsonSchemaTypeSchema = import_zod3.z.enum([
+  "string",
+  "number",
+  "integer",
+  "boolean",
+  "object",
+  "array",
+  "null"
+]);
+var jsonSchema7Schema = import_zod3.z.lazy(
+  () => import_zod3.z.object({
+    $schema: import_zod3.z.string().optional(),
+    $id: import_zod3.z.string().optional(),
+    $ref: import_zod3.z.string().optional(),
+    // Metadata
+    title: import_zod3.z.string().optional(),
+    description: import_zod3.z.string().optional(),
+    deprecated: import_zod3.z.boolean().optional(),
+    // Type
+    type: import_zod3.z.union([jsonSchemaTypeSchema, import_zod3.z.array(jsonSchemaTypeSchema)]).optional(),
+    // String validation
+    minLength: import_zod3.z.number().optional(),
+    maxLength: import_zod3.z.number().optional(),
+    pattern: import_zod3.z.string().optional(),
+    // Number validation
+    minimum: import_zod3.z.number().optional(),
+    maximum: import_zod3.z.number().optional(),
+    exclusiveMinimum: import_zod3.z.number().optional(),
+    exclusiveMaximum: import_zod3.z.number().optional(),
+    // Enum
+    enum: import_zod3.z.array(import_zod3.z.union([import_zod3.z.string(), import_zod3.z.number(), import_zod3.z.boolean(), import_zod3.z.null()])).readonly().optional(),
+    const: import_zod3.z.union([import_zod3.z.string(), import_zod3.z.number(), import_zod3.z.boolean(), import_zod3.z.null()]).optional(),
+    // Object
+    properties: import_zod3.z.record(import_zod3.z.string(), jsonSchema7Schema).optional(),
+    required: import_zod3.z.array(import_zod3.z.string()).optional(),
+    additionalProperties: import_zod3.z.union([import_zod3.z.boolean(), jsonSchema7Schema]).optional(),
+    // Array
+    items: import_zod3.z.union([jsonSchema7Schema, import_zod3.z.array(jsonSchema7Schema)]).optional(),
+    minItems: import_zod3.z.number().optional(),
+    maxItems: import_zod3.z.number().optional(),
+    // Composition
+    allOf: import_zod3.z.array(jsonSchema7Schema).optional(),
+    anyOf: import_zod3.z.array(jsonSchema7Schema).optional(),
+    oneOf: import_zod3.z.array(jsonSchema7Schema).optional(),
+    not: jsonSchema7Schema.optional(),
+    // Conditional
+    if: jsonSchema7Schema.optional(),
+    then: jsonSchema7Schema.optional(),
+    else: jsonSchema7Schema.optional(),
+    // Format
+    format: import_zod3.z.string().optional(),
+    // Default
+    default: import_zod3.z.unknown().optional(),
+    // FormSpec extensions
+    "x-formspec-source": import_zod3.z.string().optional(),
+    "x-formspec-params": import_zod3.z.array(import_zod3.z.string()).readonly().optional(),
+    "x-formspec-schemaSource": import_zod3.z.string().optional()
+  }).passthrough()
+);
 
-// src/analyzer/decorator-extractor.ts
+// src/analyzer/program.ts
 var ts = __toESM(require("typescript"), 1);
-var import_core = require("@formspec/core");
-function extractDecorators(member) {
-  const decorators = [];
-  const modifiers = ts.canHaveDecorators(member) ? ts.getDecorators(member) : void 0;
-  if (!modifiers) return decorators;
-  for (const decorator of modifiers) {
-    const info = parseDecorator(decorator);
-    if (info) {
-      decorators.push(info);
-    }
-  }
-  return decorators;
-}
-function parseDecorator(decorator) {
-  const expr = decorator.expression;
-  if (ts.isIdentifier(expr)) {
-    return {
-      name: expr.text,
-      args: [],
-      node: decorator
-    };
-  }
-  if (ts.isCallExpression(expr)) {
-    const callee = expr.expression;
-    let name = null;
-    if (ts.isIdentifier(callee)) {
-      name = callee.text;
-    } else if (ts.isPropertyAccessExpression(callee)) {
-      name = callee.name.text;
-    }
-    if (!name) return null;
-    const args = expr.arguments.map(extractArgValue);
-    return {
-      name,
-      args,
-      node: decorator
-    };
-  }
-  return null;
-}
-function extractArgValue(node) {
-  if (ts.isStringLiteral(node)) {
-    return node.text;
-  }
-  if (ts.isNumericLiteral(node)) {
-    return Number(node.text);
-  }
-  if (node.kind === ts.SyntaxKind.TrueKeyword) {
-    return true;
-  }
-  if (node.kind === ts.SyntaxKind.FalseKeyword) {
-    return false;
-  }
-  if (node.kind === ts.SyntaxKind.NullKeyword) {
-    return null;
-  }
-  if (ts.isPrefixUnaryExpression(node)) {
-    if (node.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(node.operand)) {
-      return -Number(node.operand.text);
-    }
-    if (node.operator === ts.SyntaxKind.PlusToken && ts.isNumericLiteral(node.operand)) {
-      return Number(node.operand.text);
-    }
-  }
-  if (ts.isArrayLiteralExpression(node)) {
-    return node.elements.map((el) => {
-      if (ts.isSpreadElement(el)) {
-        return null;
-      }
-      return extractArgValue(el);
-    });
-  }
-  if (ts.isObjectLiteralExpression(node)) {
-    const obj = {};
-    for (const prop of node.properties) {
-      if (ts.isPropertyAssignment(prop)) {
-        const key = getPropertyName(prop.name);
-        if (key) {
-          obj[key] = extractArgValue(prop.initializer);
-        }
-      } else if (ts.isShorthandPropertyAssignment(prop)) {
-        const key = prop.name.text;
-        obj[key] = null;
-      }
-    }
-    return obj;
-  }
-  if (ts.isNoSubstitutionTemplateLiteral(node)) {
-    return node.text;
-  }
-  if (ts.isRegularExpressionLiteral(node)) {
-    const regexText = node.text;
-    const lastSlash = regexText.lastIndexOf("/");
-    if (lastSlash > 0) {
-      return regexText.substring(1, lastSlash);
-    }
-    return regexText;
-  }
-  if (ts.isNewExpression(node)) {
-    if (ts.isIdentifier(node.expression) && node.expression.text === "RegExp" && node.arguments && node.arguments.length > 0) {
-      const firstArg = node.arguments[0];
-      if (firstArg && ts.isStringLiteral(firstArg)) {
-        return firstArg.text;
-      }
-    }
-  }
-  if (ts.isIdentifier(node)) {
-    return null;
-  }
-  return null;
-}
-function getPropertyName(name) {
-  if (ts.isIdentifier(name)) {
-    return name.text;
-  }
-  if (ts.isStringLiteral(name)) {
-    return name.text;
-  }
-  if (ts.isNumericLiteral(name)) {
-    return name.text;
-  }
-  return null;
-}
-var FORMSPEC_DECORATORS = {
-  // Display metadata
-  Field: { argTypes: ["object"] },
-  // Grouping
-  Group: { argTypes: ["string"] },
-  // Conditional display
-  ShowWhen: { argTypes: ["object"] },
-  // Enum options
-  EnumOptions: { argTypes: ["array"] },
-  // Numeric constraints
-  Minimum: { argTypes: ["number"] },
-  Maximum: { argTypes: ["number"] },
-  ExclusiveMinimum: { argTypes: ["number"] },
-  ExclusiveMaximum: { argTypes: ["number"] },
-  // String constraints
-  MinLength: { argTypes: ["number"] },
-  MaxLength: { argTypes: ["number"] },
-  Pattern: { argTypes: ["string"] }
-};
-function isFormSpecDecoratorsPath(fileName) {
-  const normalized = fileName.replace(/\\/g, "/");
-  return normalized.includes("node_modules/@formspec/decorators") || normalized.includes("/packages/decorators/");
-}
-function resolveDecorator(decorator, checker) {
-  const expr = decorator.expression;
-  let targetNode;
-  let name;
-  if (ts.isIdentifier(expr)) {
-    targetNode = expr;
-    name = expr.text;
-  } else if (ts.isCallExpression(expr)) {
-    if (ts.isIdentifier(expr.expression)) {
-      targetNode = expr.expression;
-      name = expr.expression.text;
-    } else {
-      return null;
-    }
-  } else {
-    return null;
-  }
-  if (name in FORMSPEC_DECORATORS) {
-    const symbol = checker.getSymbolAtLocation(targetNode);
-    if (symbol) {
-      const declarations = symbol.declarations;
-      if (declarations && declarations.length > 0) {
-        const decl = declarations[0];
-        if (decl) {
-          const sourceFile = decl.getSourceFile();
-          const fileName = sourceFile.fileName;
-          if (isFormSpecDecoratorsPath(fileName)) {
-            return {
-              name,
-              isFormSpec: true,
-              isMarker: !ts.isCallExpression(expr)
-            };
-          }
-        }
-      }
-    }
-  }
-  const resolvedSymbol = checker.getSymbolAtLocation(targetNode);
-  if (!resolvedSymbol) return null;
-  const type = checker.getTypeOfSymbol(resolvedSymbol);
-  const props = type.getProperties();
-  let extendsBuiltin;
-  let extensionName;
-  let isMarker = false;
-  for (const prop of props) {
-    const escapedName = prop.getEscapedName();
-    if (escapedName.startsWith("__@") && (escapedName.includes("formspec.extends") || escapedName.includes("FORMSPEC_EXTENDS"))) {
-      const propType = checker.getTypeOfSymbol(prop);
-      if (propType.isStringLiteral()) {
-        extendsBuiltin = propType.value;
-      }
-    }
-    if (escapedName.startsWith("__@") && (escapedName.includes("formspec.extension") || escapedName.includes("FORMSPEC_EXTENSION"))) {
-      const propType = checker.getTypeOfSymbol(prop);
-      if (propType.isStringLiteral()) {
-        extensionName = propType.value;
-      }
+var path = __toESM(require("path"), 1);
+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")}`
+      );
     }
-    if (escapedName.startsWith("__@") && (escapedName.includes("formspec.marker") || escapedName.includes("FORMSPEC_MARKER"))) {
-      isMarker = true;
+    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}`);
     }
-  }
-  if (extendsBuiltin) {
-    return {
-      name,
-      extendsBuiltin,
-      isFormSpec: true,
-      isMarker: false
+    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];
   }
-  if (extensionName) {
-    return {
-      name,
-      extensionName,
-      isFormSpec: true,
-      isMarker
-    };
+  const program = ts.createProgram(fileNames, compilerOptions);
+  const sourceFile = program.getSourceFile(absolutePath);
+  if (!sourceFile) {
+    throw new Error(`Could not find source file: ${absolutePath}`);
   }
-  if (isMarker) {
-    return {
-      name,
-      isFormSpec: true,
-      isMarker: true
-    };
+  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);
   }
-  return null;
+  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);
 }
 
+// src/analyzer/class-analyzer.ts
+var ts4 = __toESM(require("typescript"), 1);
+
 // src/analyzer/jsdoc-constraints.ts
+var ts3 = __toESM(require("typescript"), 1);
+var import_core4 = require("@formspec/core");
+
+// src/analyzer/tsdoc-parser.ts
 var ts2 = __toESM(require("typescript"), 1);
-var import_core2 = require("@formspec/core");
-function extractJSDocConstraints(node) {
-  const results = [];
-  const jsDocTags = ts2.getJSDocTags(node);
-  for (const tag of jsDocTags) {
-    const tagName = tag.tagName.text;
-    if (!(tagName in import_core2.CONSTRAINT_TAG_DEFINITIONS)) {
-      continue;
-    }
-    const constraintName = tagName;
-    const expectedType = import_core2.CONSTRAINT_TAG_DEFINITIONS[constraintName];
-    const commentText = getTagCommentText(tag);
-    if (commentText === void 0 || commentText === "") {
-      continue;
-    }
-    const trimmed = commentText.trim();
-    if (trimmed === "") {
-      continue;
-    }
-    if (expectedType === "number") {
-      const value = Number(trimmed);
-      if (Number.isNaN(value)) {
+var import_tsdoc = require("@microsoft/tsdoc");
+var import_core3 = require("@formspec/core");
+var NUMERIC_CONSTRAINT_MAP = {
+  Minimum: "minimum",
+  Maximum: "maximum",
+  ExclusiveMinimum: "exclusiveMinimum",
+  ExclusiveMaximum: "exclusiveMaximum"
+};
+var LENGTH_CONSTRAINT_MAP = {
+  MinLength: "minLength",
+  MaxLength: "maxLength"
+};
+var TAGS_REQUIRING_RAW_TEXT = /* @__PURE__ */ new Set(["Pattern", "EnumOptions"]);
+function isBuiltinConstraintName(tagName) {
+  return tagName in import_core3.BUILTIN_CONSTRAINT_DEFINITIONS;
+}
+function createFormSpecTSDocConfig() {
+  const config = new import_tsdoc.TSDocConfiguration();
+  for (const tagName of Object.keys(import_core3.BUILTIN_CONSTRAINT_DEFINITIONS)) {
+    config.addTagDefinition(
+      new import_tsdoc.TSDocTagDefinition({
+        tagName: "@" + tagName,
+        syntaxKind: import_tsdoc.TSDocTagSyntaxKind.BlockTag,
+        allowMultiple: true
+      })
+    );
+  }
+  return config;
+}
+var sharedParser;
+function getParser() {
+  sharedParser ??= new import_tsdoc.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;
       }
-      results.push(createSyntheticDecorator(constraintName, value));
-    } else if (expectedType === "json") {
-      try {
-        const parsed = JSON.parse(trimmed);
-        if (!Array.isArray(parsed)) {
-          continue;
-        }
-        results.push(createSyntheticDecorator(constraintName, parsed));
-      } catch {
+      const commentText = sourceText.substring(range.pos, range.end);
+      if (!commentText.startsWith("/**")) {
         continue;
       }
-    } else {
-      results.push(createSyntheticDecorator(constraintName, trimmed));
+      const parser = getParser();
+      const parserContext = parser.parseRange(
+        import_tsdoc.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);
     }
   }
-  return results;
-}
-function extractJSDocFieldMetadata(node) {
-  const jsDocTags = ts2.getJSDocTags(node);
   let displayName;
   let description;
-  for (const tag of jsDocTags) {
+  let displayNameTag;
+  let descriptionTag;
+  for (const tag of jsDocTagsAll) {
     const tagName = tag.tagName.text;
     const commentText = getTagCommentText(tag);
     if (commentText === void 0 || commentText.trim() === "") {
@@ -832,18 +1126,132 @@ function extractJSDocFieldMetadata(node) {
     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 import_tsdoc.DocPlainText) {
+    return node.text;
+  }
+  if (node instanceof import_tsdoc.DocSoftBreak) {
+    return " ";
+  }
+  if (typeof node.getChildNodes === "function") {
+    for (const child of node.getChildNodes()) {
+      result += extractPlainText(child);
     }
   }
-  if (displayName === void 0 && description === void 0) {
+  return result;
+}
+function parseConstraintValue(tagName, text, provenance) {
+  if (!isBuiltinConstraintName(tagName)) {
+    return null;
+  }
+  const expectedType = import_core3.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;
   }
-  const fieldOpts = {
-    ...displayName !== void 0 ? { displayName } : {},
-    ...description !== void 0 ? { description } : {}
+  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
   };
-  return createSyntheticDecorator("Field", fieldOpts);
 }
 function getTagCommentText(tag) {
   if (tag.comment === void 0) {
@@ -854,30 +1262,76 @@ function getTagCommentText(tag) {
   }
   return ts2.getTextOfJSDocComment(tag.comment);
 }
-function createSyntheticDecorator(name, value) {
+
+// src/analyzer/jsdoc-constraints.ts
+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 {
-    name,
-    args: [value],
-    node: void 0
+    kind: "annotation",
+    annotationKind: "defaultValue",
+    value,
+    provenance: {
+      surface: "tsdoc",
+      file,
+      line: line + 1,
+      column: character
+    }
   };
 }
 
 // src/analyzer/class-analyzer.ts
-function analyzeClass(classDecl, checker) {
+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 (ts3.isPropertyDeclaration(member)) {
-      const fieldInfo = analyzeField(member, checker);
-      if (fieldInfo) {
-        fields.push(fieldInfo);
+    if (ts4.isPropertyDeclaration(member)) {
+      const fieldNode = analyzeFieldToIR(member, checker, file, typeRegistry, visiting);
+      if (fieldNode) {
+        fields.push(fieldNode);
+        fieldLayouts.push({});
       }
-    } else if (ts3.isMethodDeclaration(member)) {
+    } else if (ts4.isMethodDeclaration(member)) {
       const methodInfo = analyzeMethod(member, checker);
       if (methodInfo) {
-        const isStatic = member.modifiers?.some((m) => m.kind === ts3.SyntaxKind.StaticKeyword);
+        const isStatic = member.modifiers?.some((m) => m.kind === ts4.SyntaxKind.StaticKeyword);
         if (isStatic) {
           staticMethods.push(methodInfo);
         } else {
@@ -886,159 +1340,29 @@ function analyzeClass(classDecl, checker) {
       }
     }
   }
-  return {
-    name,
-    fields,
-    instanceMethods,
-    staticMethods
-  };
-}
-function analyzeField(prop, checker) {
-  if (!ts3.isIdentifier(prop.name)) {
-    return null;
-  }
-  const name = prop.name.text;
-  const typeNode = prop.type;
-  const type = checker.getTypeAtLocation(prop);
-  const optional = prop.questionToken !== void 0;
-  const decorators = extractDecorators(prop);
-  for (const dec of decorators) {
-    if (dec.node) {
-      const resolved = resolveDecorator(dec.node, checker);
-      if (resolved) {
-        dec.resolved = resolved;
-      }
-    }
-  }
-  if (prop.type) {
-    const aliasConstraints = extractTypeAliasConstraints(prop.type, checker);
-    decorators.push(...aliasConstraints);
-  }
-  const jsdocConstraints = extractJSDocConstraints(prop);
-  decorators.push(...jsdocConstraints);
-  const deprecated = hasDeprecatedTag(prop);
-  const defaultValue = extractDefaultValue(prop.initializer);
-  return {
-    name,
-    typeNode,
-    type,
-    optional,
-    decorators,
-    deprecated,
-    defaultValue
-  };
-}
-function extractTypeAliasConstraints(typeNode, checker) {
-  if (!ts3.isTypeReferenceNode(typeNode)) return [];
-  const symbol = checker.getSymbolAtLocation(typeNode.typeName);
-  if (!symbol?.declarations) return [];
-  const aliasDecl = symbol.declarations.find(ts3.isTypeAliasDeclaration);
-  if (!aliasDecl) return [];
-  if (ts3.isTypeLiteralNode(aliasDecl.type)) return [];
-  return extractJSDocConstraints(aliasDecl);
-}
-function hasDeprecatedTag(node) {
-  const jsDocTags = ts3.getJSDocTags(node);
-  return jsDocTags.some((tag) => tag.tagName.text === "deprecated");
-}
-function extractDefaultValue(initializer) {
-  if (!initializer) return void 0;
-  if (ts3.isStringLiteral(initializer)) {
-    return initializer.text;
-  }
-  if (ts3.isNumericLiteral(initializer)) {
-    return Number(initializer.text);
-  }
-  if (initializer.kind === ts3.SyntaxKind.TrueKeyword) {
-    return true;
-  }
-  if (initializer.kind === ts3.SyntaxKind.FalseKeyword) {
-    return false;
-  }
-  if (initializer.kind === ts3.SyntaxKind.NullKeyword) {
-    return null;
-  }
-  if (ts3.isPrefixUnaryExpression(initializer)) {
-    if (initializer.operator === ts3.SyntaxKind.MinusToken && ts3.isNumericLiteral(initializer.operand)) {
-      return -Number(initializer.operand.text);
-    }
-  }
-  return void 0;
-}
-function analyzeMethod(method, checker) {
-  if (!ts3.isIdentifier(method.name)) {
-    return null;
-  }
-  const name = method.name.text;
-  const parameters = [];
-  for (const param of method.parameters) {
-    if (ts3.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 = ts3.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 (!ts3.isTypeReferenceNode(typeNode)) return null;
-  const typeName = ts3.isIdentifier(typeNode.typeName) ? typeNode.typeName.text : ts3.isQualifiedName(typeNode.typeName) ? typeNode.typeName.right.text : null;
-  if (typeName !== "InferSchema" && typeName !== "InferFormSchema") return null;
-  const typeArg = typeNode.typeArguments?.[0];
-  if (!typeArg || !ts3.isTypeQueryNode(typeArg)) return null;
-  if (ts3.isIdentifier(typeArg.exprName)) {
-    return typeArg.exprName.text;
-  }
-  if (ts3.isQualifiedName(typeArg.exprName)) {
-    return typeArg.exprName.right.text;
-  }
-  return null;
+  return { name, fields, fieldLayouts, typeRegistry, instanceMethods, staticMethods };
 }
-function analyzeInterface(interfaceDecl, checker) {
+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 (ts3.isPropertySignature(member)) {
-      const fieldInfo = analyzeInterfaceProperty(member, checker);
-      if (fieldInfo) {
-        fields.push(fieldInfo);
+    if (ts4.isPropertySignature(member)) {
+      const fieldNode = analyzeInterfacePropertyToIR(member, checker, file, typeRegistry, visiting);
+      if (fieldNode) {
+        fields.push(fieldNode);
       }
     }
   }
-  return {
-    name,
-    fields,
-    instanceMethods: [],
-    staticMethods: []
-  };
+  const fieldLayouts = fields.map(() => ({}));
+  return { name, fields, fieldLayouts, typeRegistry, instanceMethods: [], staticMethods: [] };
 }
-function analyzeTypeAlias(typeAlias, checker) {
-  if (!ts3.isTypeLiteralNode(typeAlias.type)) {
+function analyzeTypeAliasToIR(typeAlias, checker, file = "") {
+  if (!ts4.isTypeLiteralNode(typeAlias.type)) {
     const sourceFile = typeAlias.getSourceFile();
     const { line } = sourceFile.getLineAndCharacterOfPosition(typeAlias.getStart());
-    const kindDesc = ts3.SyntaxKind[typeAlias.type.kind] ?? "unknown";
+    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})`
@@ -1046,11 +1370,13 @@ function analyzeTypeAlias(typeAlias, checker) {
   }
   const name = typeAlias.name.text;
   const fields = [];
+  const typeRegistry = {};
+  const visiting = /* @__PURE__ */ new Set();
   for (const member of typeAlias.type.members) {
-    if (ts3.isPropertySignature(member)) {
-      const fieldInfo = analyzeInterfaceProperty(member, checker);
-      if (fieldInfo) {
-        fields.push(fieldInfo);
+    if (ts4.isPropertySignature(member)) {
+      const fieldNode = analyzeInterfacePropertyToIR(member, checker, file, typeRegistry, visiting);
+      if (fieldNode) {
+        fields.push(fieldNode);
       }
     }
   }
@@ -1059,505 +1385,368 @@ function analyzeTypeAlias(typeAlias, checker) {
     analysis: {
       name,
       fields,
+      fieldLayouts: fields.map(() => ({})),
+      typeRegistry,
       instanceMethods: [],
       staticMethods: []
     }
   };
 }
-function analyzeInterfaceProperty(prop, checker) {
-  if (!ts3.isIdentifier(prop.name)) {
+function analyzeFieldToIR(prop, checker, file, typeRegistry, visiting) {
+  if (!ts4.isIdentifier(prop.name)) {
     return null;
   }
   const name = prop.name.text;
-  const typeNode = prop.type;
-  const type = checker.getTypeAtLocation(prop);
+  const tsType = checker.getTypeAtLocation(prop);
   const optional = prop.questionToken !== void 0;
-  const decorators = [];
-  if (typeNode) {
-    const aliasConstraints = extractTypeAliasConstraints(typeNode, checker);
-    decorators.push(...aliasConstraints);
-  }
-  const fieldMetadata = extractJSDocFieldMetadata(prop);
-  if (fieldMetadata) {
-    decorators.push(fieldMetadata);
-  }
-  const jsdocConstraints = extractJSDocConstraints(prop);
-  decorators.push(...jsdocConstraints);
-  const deprecated = hasDeprecatedTag(prop);
+  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,
-    typeNode,
     type,
-    optional,
-    decorators,
-    deprecated,
-    defaultValue: void 0
+    required: !optional,
+    constraints,
+    annotations,
+    provenance
   };
 }
-
-// src/analyzer/type-converter.ts
-function getNamedTypeFieldInfoMap(type, checker) {
-  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 fieldInfo = analyzeField(member, checker);
-          if (fieldInfo) map.set(fieldInfo.name, fieldInfo);
-        }
-      }
-      return map;
-    }
-    const interfaceDecl = declarations.find(ts4.isInterfaceDeclaration);
-    if (interfaceDecl) {
-      return buildFieldInfoMapFromSignatures(interfaceDecl.members, checker);
-    }
-    const typeAliasDecl = declarations.find(ts4.isTypeAliasDeclaration);
-    if (typeAliasDecl && ts4.isTypeLiteralNode(typeAliasDecl.type)) {
-      return buildFieldInfoMapFromSignatures(typeAliasDecl.type.members, checker);
-    }
-  }
-  return null;
-}
-function buildFieldInfoMapFromSignatures(members, checker) {
-  const map = /* @__PURE__ */ new Map();
-  for (const member of members) {
-    if (ts4.isPropertySignature(member)) {
-      const fieldInfo = analyzeInterfaceProperty(member, checker);
-      if (fieldInfo) {
-        map.set(fieldInfo.name, fieldInfo);
-      }
-    }
+function analyzeInterfacePropertyToIR(prop, checker, file, typeRegistry, visiting) {
+  if (!ts4.isIdentifier(prop.name)) {
+    return null;
   }
-  return map;
-}
-function getObjectPropertyInfos(type, checker) {
-  const fieldInfoMap = getNamedTypeFieldInfoMap(type, checker);
-  const result = [];
-  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 fieldInfo = fieldInfoMap?.get(prop.name) ?? void 0;
-    result.push({ name: prop.name, type: propType, optional, fieldInfo });
+  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));
   }
-  return result;
-}
-function convertType(type, checker) {
-  return convertTypeInternal(type, checker, /* @__PURE__ */ new Set());
+  constraints.push(...extractJSDocConstraintNodes(prop, file));
+  const annotations = [];
+  annotations.push(...extractJSDocAnnotationNodes(prop, file));
+  return {
+    kind: "field",
+    name,
+    type,
+    required: !optional,
+    constraints,
+    annotations,
+    provenance
+  };
 }
-function convertTypeInternal(type, checker, visiting) {
+function resolveTypeNode(type, checker, file, typeRegistry, visiting) {
   if (type.flags & ts4.TypeFlags.String) {
-    return { jsonSchema: { type: "string" }, formSpecFieldType: "text" };
+    return { kind: "primitive", primitiveKind: "string" };
   }
   if (type.flags & ts4.TypeFlags.Number) {
-    return { jsonSchema: { type: "number" }, formSpecFieldType: "number" };
+    return { kind: "primitive", primitiveKind: "number" };
   }
   if (type.flags & ts4.TypeFlags.Boolean) {
-    return { jsonSchema: { type: "boolean" }, formSpecFieldType: "boolean" };
+    return { kind: "primitive", primitiveKind: "boolean" };
   }
   if (type.flags & ts4.TypeFlags.Null) {
-    return { jsonSchema: { type: "null" }, formSpecFieldType: "null" };
+    return { kind: "primitive", primitiveKind: "null" };
   }
   if (type.flags & ts4.TypeFlags.Undefined) {
-    return { jsonSchema: {}, formSpecFieldType: "undefined" };
+    return { kind: "primitive", primitiveKind: "null" };
   }
   if (type.isStringLiteral()) {
     return {
-      jsonSchema: { const: type.value },
-      formSpecFieldType: "enum"
+      kind: "enum",
+      members: [{ value: type.value }]
     };
   }
   if (type.isNumberLiteral()) {
     return {
-      jsonSchema: { const: type.value },
-      formSpecFieldType: "number"
+      kind: "enum",
+      members: [{ value: type.value }]
     };
   }
   if (type.isUnion()) {
-    return convertUnionType(type, checker, visiting);
+    return resolveUnionType(type, checker, file, typeRegistry, visiting);
   }
   if (checker.isArrayType(type)) {
-    return convertArrayType(type, checker, visiting);
+    return resolveArrayType(type, checker, file, typeRegistry, visiting);
   }
-  if (type.flags & ts4.TypeFlags.Object) {
-    return convertObjectType(type, checker, visiting);
+  if (isObjectType(type)) {
+    return resolveObjectType(type, checker, file, typeRegistry, visiting);
   }
-  return { jsonSchema: {}, formSpecFieldType: "unknown" };
+  return { kind: "primitive", primitiveKind: "string" };
 }
-function convertUnionType(type, checker, visiting) {
-  const types = type.types;
-  const nonNullTypes = types.filter(
+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 = types.some((t) => t.flags & ts4.TypeFlags.Null);
-  const isBooleanUnion = nonNullTypes.length === 2 && nonNullTypes.every((t) => t.flags & ts4.TypeFlags.BooleanLiteral);
-  if (isBooleanUnion) {
-    const result = {
-      jsonSchema: { type: "boolean" },
-      formSpecFieldType: "boolean"
-    };
+  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) {
-      result.jsonSchema = { oneOf: [{ type: "boolean" }, { type: "null" }] };
+      return {
+        kind: "union",
+        members: [boolNode, { kind: "primitive", primitiveKind: "null" }]
+      };
     }
-    return result;
+    return boolNode;
   }
   const allStringLiterals = nonNullTypes.every((t) => t.isStringLiteral());
   if (allStringLiterals && nonNullTypes.length > 0) {
-    const enumValues = nonNullTypes.map((t) => t.value);
-    const result = {
-      jsonSchema: { enum: enumValues },
-      formSpecFieldType: "enum"
+    const stringTypes = nonNullTypes.filter((t) => t.isStringLiteral());
+    const enumNode = {
+      kind: "enum",
+      members: stringTypes.map((t) => ({ value: t.value }))
     };
     if (hasNull) {
-      result.jsonSchema = { oneOf: [{ enum: enumValues }, { type: "null" }] };
+      return {
+        kind: "union",
+        members: [enumNode, { kind: "primitive", primitiveKind: "null" }]
+      };
     }
-    return result;
+    return enumNode;
   }
   const allNumberLiterals = nonNullTypes.every((t) => t.isNumberLiteral());
   if (allNumberLiterals && nonNullTypes.length > 0) {
-    const enumValues = nonNullTypes.map((t) => t.value);
-    const result = {
-      jsonSchema: { enum: enumValues },
-      formSpecFieldType: "enum"
+    const numberTypes = nonNullTypes.filter((t) => t.isNumberLiteral());
+    const enumNode = {
+      kind: "enum",
+      members: numberTypes.map((t) => ({ value: t.value }))
     };
     if (hasNull) {
-      result.jsonSchema = { oneOf: [{ enum: enumValues }, { type: "null" }] };
+      return {
+        kind: "union",
+        members: [enumNode, { kind: "primitive", primitiveKind: "null" }]
+      };
     }
-    return result;
+    return enumNode;
   }
   if (nonNullTypes.length === 1 && nonNullTypes[0]) {
-    const result = convertTypeInternal(nonNullTypes[0], checker, visiting);
+    const inner = resolveTypeNode(nonNullTypes[0], checker, file, typeRegistry, visiting);
     if (hasNull) {
-      result.jsonSchema = { oneOf: [result.jsonSchema, { type: "null" }] };
+      return {
+        kind: "union",
+        members: [inner, { kind: "primitive", primitiveKind: "null" }]
+      };
     }
-    return result;
+    return inner;
   }
-  const schemas = nonNullTypes.map((t) => convertTypeInternal(t, checker, visiting).jsonSchema);
+  const members = nonNullTypes.map(
+    (t) => resolveTypeNode(t, checker, file, typeRegistry, visiting)
+  );
   if (hasNull) {
-    schemas.push({ type: "null" });
+    members.push({ kind: "primitive", primitiveKind: "null" });
   }
-  return {
-    jsonSchema: { oneOf: schemas },
-    formSpecFieldType: "union"
-  };
+  return { kind: "union", members };
 }
-function convertArrayType(type, checker, visiting) {
-  const typeArgs = type.typeArguments;
+function resolveArrayType(type, checker, file, typeRegistry, visiting) {
+  const typeArgs = isTypeReference(type) ? type.typeArguments : void 0;
   const elementType = typeArgs?.[0];
-  const itemSchema = elementType ? convertTypeInternal(elementType, checker, visiting).jsonSchema : {};
-  return {
-    jsonSchema: {
-      type: "array",
-      items: itemSchema
-    },
-    formSpecFieldType: "array"
-  };
+  const items = elementType ? resolveTypeNode(elementType, checker, file, typeRegistry, visiting) : { kind: "primitive", primitiveKind: "string" };
+  return { kind: "array", items };
 }
-function convertObjectType(type, checker, visiting) {
+function resolveObjectType(type, checker, file, typeRegistry, visiting) {
   if (visiting.has(type)) {
-    return { jsonSchema: { type: "object" }, formSpecFieldType: "object" };
+    return { kind: "object", properties: [], additionalProperties: false };
   }
   visiting.add(type);
-  const properties = {};
-  const required = [];
-  for (const propInfo of getObjectPropertyInfos(type, checker)) {
-    const propSchema = convertTypeInternal(propInfo.type, checker, visiting).jsonSchema;
-    properties[propInfo.name] = propInfo.fieldInfo ? applyDecoratorsToSchema(propSchema, propInfo.fieldInfo.decorators, propInfo.fieldInfo) : propSchema;
-    if (!propInfo.optional) {
-      required.push(propInfo.name);
-    }
+  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);
-  return {
-    jsonSchema: {
-      type: "object",
-      properties,
-      ...required.length > 0 ? { required } : {}
-    },
-    formSpecFieldType: "object"
-  };
-}
-function createFormSpecField(fieldName, type, decorators, optional, checker, visitedTypes = /* @__PURE__ */ new Set()) {
-  const { formSpecFieldType } = convertType(type, checker);
-  const field = {
-    _field: formSpecFieldType,
-    id: fieldName
+  const objectNode = {
+    kind: "object",
+    properties,
+    additionalProperties: false
   };
-  if (!optional) {
-    field.required = true;
-  }
-  if (formSpecFieldType === "object" && type.flags & ts4.TypeFlags.Object) {
-    if (!visitedTypes.has(type)) {
-      visitedTypes.add(type);
-      const nestedFields = [];
-      for (const propInfo of getObjectPropertyInfos(type, checker)) {
-        nestedFields.push(
-          createFormSpecField(
-            propInfo.name,
-            propInfo.type,
-            propInfo.fieldInfo?.decorators ?? [],
-            propInfo.optional,
-            checker,
-            visitedTypes
-          )
-        );
-      }
-      visitedTypes.delete(type);
-      if (nestedFields.length > 0) {
-        field.fields = nestedFields;
-      }
-    }
+  if (typeName) {
+    typeRegistry[typeName] = {
+      name: typeName,
+      type: objectNode,
+      provenance: provenanceForFile(file)
+    };
+    return { kind: "reference", name: typeName, typeArguments: [] };
   }
-  for (const dec of decorators) {
-    applyDecoratorToField(field, dec);
-  }
-  return field;
-}
-function applyDecoratorToField(field, decorator) {
-  const { args } = decorator;
-  const resolved = decorator.resolved;
-  const effectiveName = resolved?.extendsBuiltin ?? decorator.name;
-  switch (effectiveName) {
-    case "Field": {
-      const opts = args[0];
-      if (typeof opts === "object" && opts !== null && !Array.isArray(opts)) {
-        if (typeof opts["displayName"] === "string") {
-          field.label = opts["displayName"];
-        }
-        if (typeof opts["description"] === "string") {
-          field.description = opts["description"];
-        }
-        if (typeof opts["placeholder"] === "string") {
-          field.placeholder = opts["placeholder"];
-        }
-      }
-      break;
-    }
-    case "Minimum":
-      if (typeof args[0] === "number") {
-        field.min = args[0];
-      }
-      break;
-    case "Maximum":
-      if (typeof args[0] === "number") {
-        field.max = args[0];
-      }
-      break;
-    case "MinLength":
-      if (typeof args[0] === "number") {
-        field.minLength = args[0];
-      }
-      break;
-    case "MaxLength":
-      if (typeof args[0] === "number") {
-        field.maxLength = args[0];
-      }
-      break;
-    case "Pattern":
-      if (typeof args[0] === "string") {
-        field.pattern = args[0];
-      }
-      break;
-    case "EnumOptions":
-      if (Array.isArray(args[0])) {
-        field.options = args[0];
-      }
-      break;
-    case "ShowWhen":
-      if (typeof args[0] === "object" && args[0] !== null) {
-        field.showWhen = args[0];
-      }
-      break;
-    case "Group":
-      if (typeof args[0] === "string") {
-        field.group = args[0];
-      }
-      break;
-  }
-}
-function applyDecoratorsToSchema(schema, decorators, fieldInfo) {
-  const result = { ...schema };
-  for (const dec of decorators) {
-    const { args } = dec;
-    const resolved = dec.resolved;
-    const effectiveName = resolved?.extendsBuiltin ?? dec.name;
-    switch (effectiveName) {
-      case "Field": {
-        const opts = args[0];
-        if (typeof opts === "object" && opts !== null && !Array.isArray(opts)) {
-          if (typeof opts["displayName"] === "string") {
-            result.title = opts["displayName"];
-          }
-          if (typeof opts["description"] === "string") {
-            result.description = opts["description"];
+  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
+            });
           }
         }
-        break;
-      }
-      case "Minimum":
-        if (typeof args[0] === "number") {
-          result.minimum = args[0];
-        }
-        break;
-      case "Maximum":
-        if (typeof args[0] === "number") {
-          result.maximum = args[0];
-        }
-        break;
-      case "ExclusiveMinimum":
-        if (typeof args[0] === "number") {
-          result.exclusiveMinimum = args[0];
-        }
-        break;
-      case "ExclusiveMaximum":
-        if (typeof args[0] === "number") {
-          result.exclusiveMaximum = args[0];
-        }
-        break;
-      case "MinLength":
-        if (typeof args[0] === "number") {
-          result.minLength = args[0];
-        }
-        break;
-      case "MaxLength":
-        if (typeof args[0] === "number") {
-          result.maxLength = args[0];
-        }
-        break;
-      case "Pattern":
-        if (typeof args[0] === "string") {
-          result.pattern = args[0];
-        }
-        break;
-    }
-    if (resolved?.extensionName && /^[a-z][a-z0-9-]*$/.test(resolved.extensionName)) {
-      const key = `x-formspec-${resolved.extensionName}`;
-      if (resolved.isMarker) {
-        setSchemaExtension(result, key, true);
-      } else {
-        setSchemaExtension(result, key, args[0] ?? true);
       }
+      return map;
     }
-  }
-  if (fieldInfo) {
-    if (fieldInfo.deprecated) {
-      result.deprecated = true;
+    const interfaceDecl = declarations.find(ts4.isInterfaceDeclaration);
+    if (interfaceDecl) {
+      return buildFieldNodeInfoMap(interfaceDecl.members, checker, file, typeRegistry, visiting);
     }
-    if (fieldInfo.defaultValue !== void 0) {
-      result.default = fieldInfo.defaultValue;
+    const typeAliasDecl = declarations.find(ts4.isTypeAliasDeclaration);
+    if (typeAliasDecl && ts4.isTypeLiteralNode(typeAliasDecl.type)) {
+      return buildFieldNodeInfoMap(
+        typeAliasDecl.type.members,
+        checker,
+        file,
+        typeRegistry,
+        visiting
+      );
     }
   }
-  return result;
+  return null;
 }
-
-// src/analyzer/program.ts
-var ts5 = __toESM(require("typescript"), 1);
-var path = __toESM(require("path"), 1);
-function createProgramContext(filePath) {
-  const absolutePath = path.resolve(filePath);
-  const fileDir = path.dirname(absolutePath);
-  const configPath = ts5.findConfigFile(fileDir, ts5.sys.fileExists.bind(ts5.sys), "tsconfig.json");
-  let compilerOptions;
-  let fileNames;
-  if (configPath) {
-    const configFile = ts5.readConfigFile(configPath, ts5.sys.readFile.bind(ts5.sys));
-    if (configFile.error) {
-      throw new Error(
-        `Error reading tsconfig.json: ${ts5.flattenDiagnosticMessageText(configFile.error.messageText, "\n")}`
-      );
-    }
-    const parsed = ts5.parseJsonConfigFileContent(
-      configFile.config,
-      ts5.sys,
-      path.dirname(configPath)
-    );
-    if (parsed.errors.length > 0) {
-      const errorMessages = parsed.errors.map((e) => ts5.flattenDiagnosticMessageText(e.messageText, "\n")).join("\n");
-      throw new Error(`Error parsing tsconfig.json: ${errorMessages}`);
+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
+        });
+      }
     }
-    compilerOptions = parsed.options;
-    fileNames = parsed.fileNames.includes(absolutePath) ? parsed.fileNames : [...parsed.fileNames, absolutePath];
-  } else {
-    compilerOptions = {
-      target: ts5.ScriptTarget.ES2022,
-      module: ts5.ModuleKind.NodeNext,
-      moduleResolution: ts5.ModuleResolutionKind.NodeNext,
-      strict: true,
-      skipLibCheck: true,
-      declaration: true
-    };
-    fileNames = [absolutePath];
-  }
-  const program = ts5.createProgram(fileNames, compilerOptions);
-  const sourceFile = program.getSourceFile(absolutePath);
-  if (!sourceFile) {
-    throw new Error(`Could not find source file: ${absolutePath}`);
   }
+  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 {
-    program,
-    checker: program.getTypeChecker(),
-    sourceFile
+    surface: "tsdoc",
+    file,
+    line: line + 1,
+    column: character
   };
 }
-function findNodeByName(sourceFile, name, predicate, getName) {
-  let result = null;
-  function visit(node) {
-    if (result) return;
-    if (predicate(node) && getName(node) === name) {
-      result = node;
-      return;
+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;
     }
-    ts5.forEachChild(node, visit);
   }
-  visit(sourceFile);
-  return result;
+  const aliasSymbol = type.aliasSymbol;
+  if (aliasSymbol?.declarations) {
+    const aliasDecl = aliasSymbol.declarations.find(ts4.isTypeAliasDeclaration);
+    if (aliasDecl) {
+      return aliasDecl.name.text;
+    }
+  }
+  return null;
 }
-function findClassByName(sourceFile, className) {
-  return findNodeByName(sourceFile, className, ts5.isClassDeclaration, (n) => n.name?.text);
+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 findInterfaceByName(sourceFile, interfaceName) {
-  return findNodeByName(sourceFile, interfaceName, ts5.isInterfaceDeclaration, (n) => n.name.text);
+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 findTypeAliasByName(sourceFile, aliasName) {
-  return findNodeByName(sourceFile, aliasName, ts5.isTypeAliasDeclaration, (n) => n.name.text);
+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;
 }
 
 // src/generators/class-schema.ts
-function generateClassSchemas(analysis, checker) {
-  const properties = {};
-  const required = [];
-  const uiElements = [];
-  for (const field of analysis.fields) {
-    const { jsonSchema: baseSchema } = convertType(field.type, checker);
-    const fieldSchema = applyDecoratorsToSchema(baseSchema, field.decorators, field);
-    properties[field.name] = fieldSchema;
-    if (!field.optional) {
-      required.push(field.name);
-    }
-    const formSpecField = createFormSpecField(
-      field.name,
-      field.type,
-      field.decorators,
-      field.optional,
-      checker
-    );
-    uiElements.push(formSpecField);
-  }
-  const jsonSchema = {
-    type: "object",
-    properties,
-    ...required.length > 0 ? { required } : {}
+function generateClassSchemas(analysis, source) {
+  const ir = canonicalizeTSDoc(analysis, source);
+  return {
+    jsonSchema: generateJsonSchemaFromIR(ir),
+    uiSchema: generateUiSchemaFromIR(ir)
   };
-  const uiSchema2 = generateUiSchemaFromFields(uiElements);
-  return { jsonSchema, uiSchema: uiSchema2 };
 }
 function generateSchemasFromClass(options) {
   const ctx = createProgramContext(options.filePath);
@@ -1565,26 +1754,27 @@ function generateSchemasFromClass(options) {
   if (!classDecl) {
     throw new Error(`Class "${options.className}" not found in ${options.filePath}`);
   }
-  const analysis = analyzeClass(classDecl, ctx.checker);
-  return generateClassSchemas(analysis, ctx.checker);
+  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 = analyzeClass(classDecl, ctx.checker);
-    return generateClassSchemas(analysis, ctx.checker);
+    const analysis = analyzeClassToIR(classDecl, ctx.checker, options.filePath);
+    return generateClassSchemas(analysis, source);
   }
   const interfaceDecl = findInterfaceByName(ctx.sourceFile, options.typeName);
   if (interfaceDecl) {
-    const analysis = analyzeInterface(interfaceDecl, ctx.checker);
-    return generateClassSchemas(analysis, ctx.checker);
+    const analysis = analyzeInterfaceToIR(interfaceDecl, ctx.checker, options.filePath);
+    return generateClassSchemas(analysis, source);
   }
   const typeAlias = findTypeAliasByName(ctx.sourceFile, options.typeName);
   if (typeAlias) {
-    const result = analyzeTypeAlias(typeAlias, ctx.checker);
+    const result = analyzeTypeAliasToIR(typeAlias, ctx.checker, options.filePath);
     if (result.ok) {
-      return generateClassSchemas(result.analysis, ctx.checker);
+      return generateClassSchemas(result.analysis, source);
     }
     throw new Error(result.error);
   }
@@ -1593,453 +1783,6 @@ function generateSchemas(options) {
   );
 }
 
-// src/codegen/index.ts
-var ts6 = __toESM(require("typescript"), 1);
-var path2 = __toESM(require("path"), 1);
-var fs = __toESM(require("fs"), 1);
-function findDecoratedClasses(files, baseDir) {
-  const program = ts6.createProgram(files, {
-    target: ts6.ScriptTarget.ESNext,
-    module: ts6.ModuleKind.ESNext,
-    moduleResolution: ts6.ModuleResolutionKind.NodeNext,
-    // TC39 Stage 3 decorators — do not use experimentalDecorators
-    strict: true
-  });
-  const checker = program.getTypeChecker();
-  const results = [];
-  for (const sourceFile of program.getSourceFiles()) {
-    if (sourceFile.isDeclarationFile) continue;
-    if (!files.some((f) => path2.resolve(f) === sourceFile.fileName)) continue;
-    ts6.forEachChild(sourceFile, (node) => {
-      if (ts6.isClassDeclaration(node) && hasDecoratedProperties(node)) {
-        const className = node.name?.text;
-        if (!className) return;
-        const typeMetadata = extractTypeMetadata(node, checker);
-        const relativePath = path2.relative(baseDir, sourceFile.fileName);
-        const exported = isClassExported(node, sourceFile);
-        results.push({
-          name: className,
-          sourcePath: relativePath.replace(/\.tsx?$/, ""),
-          typeMetadata,
-          isExported: exported
-        });
-      }
-    });
-  }
-  return results;
-}
-function hasDecoratedProperties(node) {
-  return node.members.some((member) => {
-    if (!ts6.isPropertyDeclaration(member)) return false;
-    const decorators = ts6.getDecorators(member);
-    return decorators !== void 0 && decorators.length > 0;
-  });
-}
-function isClassExported(classNode, sourceFile) {
-  const className = classNode.name?.text;
-  if (!className) return false;
-  const modifiers = ts6.getModifiers(classNode);
-  if (modifiers) {
-    const hasExport = modifiers.some((mod) => mod.kind === ts6.SyntaxKind.ExportKeyword);
-    if (hasExport) return true;
-  }
-  for (const statement of sourceFile.statements) {
-    if (ts6.isExportDeclaration(statement) && statement.exportClause) {
-      if (ts6.isNamedExports(statement.exportClause)) {
-        for (const element of statement.exportClause.elements) {
-          const localName = element.propertyName?.text ?? element.name.text;
-          if (localName === className) {
-            return true;
-          }
-        }
-      }
-    }
-  }
-  return false;
-}
-function extractTypeMetadata(classNode, checker) {
-  const metadata = {};
-  for (const member of classNode.members) {
-    if (!ts6.isPropertyDeclaration(member)) continue;
-    if (!member.name || !ts6.isIdentifier(member.name)) continue;
-    const symbol = checker.getSymbolAtLocation(member.name);
-    if (!symbol) continue;
-    const type = checker.getTypeOfSymbolAtLocation(symbol, member);
-    const fieldName = member.name.text;
-    const isOptional = !!(symbol.flags & ts6.SymbolFlags.Optional);
-    const typeInfo = convertTypeToMetadata(type, checker);
-    if (isOptional) {
-      typeInfo.optional = true;
-    }
-    metadata[fieldName] = typeInfo;
-  }
-  return metadata;
-}
-function convertTypeToMetadata(type, checker, visited = /* @__PURE__ */ new Set()) {
-  const isObjectType = (type.flags & ts6.TypeFlags.Object) !== 0;
-  if (isObjectType) {
-    if (visited.has(type)) {
-      return { type: "unknown" };
-    }
-    visited.add(type);
-  }
-  if (type.isUnion()) {
-    const types = type.types;
-    const nonNullTypes = types.filter(
-      (t) => !(t.flags & (ts6.TypeFlags.Null | ts6.TypeFlags.Undefined))
-    );
-    const hasNull = types.some((t) => t.flags & ts6.TypeFlags.Null);
-    const isBooleanUnion = nonNullTypes.length === 2 && nonNullTypes.every((t) => t.flags & ts6.TypeFlags.BooleanLiteral);
-    if (isBooleanUnion) {
-      const result = { type: "boolean" };
-      if (hasNull) result.nullable = true;
-      return result;
-    }
-    const allStringLiterals = nonNullTypes.every((t) => t.isStringLiteral());
-    if (allStringLiterals && nonNullTypes.length > 0) {
-      const result = {
-        type: "enum",
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion -- TypeScript doesn't narrow array types from `every` predicate
-        values: nonNullTypes.map((t) => t.value)
-      };
-      if (hasNull) result.nullable = true;
-      return result;
-    }
-    const allNumberLiterals = nonNullTypes.every((t) => t.isNumberLiteral());
-    if (allNumberLiterals && nonNullTypes.length > 0) {
-      const result = {
-        type: "enum",
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion -- TypeScript doesn't narrow array types from `every` predicate
-        values: nonNullTypes.map((t) => t.value)
-      };
-      if (hasNull) result.nullable = true;
-      return result;
-    }
-    if (nonNullTypes.length === 1) {
-      const singleType = nonNullTypes[0];
-      if (!singleType) return { type: "unknown" };
-      const result = convertTypeToMetadata(singleType, checker, visited);
-      if (hasNull) result.nullable = true;
-      return result;
-    }
-    return { type: "unknown" };
-  }
-  if (type.flags & ts6.TypeFlags.String) return { type: "string" };
-  if (type.flags & ts6.TypeFlags.Number) return { type: "number" };
-  if (type.flags & ts6.TypeFlags.Boolean) return { type: "boolean" };
-  if (type.isStringLiteral()) {
-    return { type: "enum", values: [type.value] };
-  }
-  if (type.isNumberLiteral()) {
-    return { type: "enum", values: [type.value] };
-  }
-  if (checker.isArrayType(type)) {
-    const typeArgs = type.typeArguments;
-    return {
-      type: "array",
-      itemType: typeArgs?.[0] ? convertTypeToMetadata(typeArgs[0], checker, visited) : { type: "unknown" }
-    };
-  }
-  if (type.flags & ts6.TypeFlags.Object) {
-    const properties = {};
-    for (const prop of type.getProperties()) {
-      const declaration = prop.valueDeclaration ?? prop.declarations?.[0];
-      if (!declaration) continue;
-      const propType = checker.getTypeOfSymbolAtLocation(prop, declaration);
-      const propOptional = !!(prop.flags & ts6.SymbolFlags.Optional);
-      const propMeta = convertTypeToMetadata(propType, checker, visited);
-      if (propOptional) propMeta.optional = true;
-      properties[prop.name] = propMeta;
-    }
-    if (Object.keys(properties).length > 0) {
-      return { type: "object", properties };
-    }
-    return { type: "object" };
-  }
-  return { type: "unknown" };
-}
-function generateCodegenOutput(classes, outputPath, baseDir) {
-  const outputDir = path2.dirname(path2.resolve(outputPath));
-  const lines = [
-    "/**",
-    " * Auto-generated by FormSpec CLI.",
-    " * DO NOT EDIT - changes will be overwritten.",
-    " *",
-    " * This file provides:",
-    " * - Type metadata patches for runtime schema generation",
-    " * - Inferred schema types (e.g., UserFormSchema)",
-    " * - Type-safe FormSpec accessors (e.g., getUserFormFormSpec())",
-    " *",
-    " * Usage:",
-    " *   import { UserFormSchema, getUserFormFormSpec } from './__formspec_types__';",
-    " *",
-    " *   const data: UserFormSchema = { name: 'Alice', country: 'us' };",
-    " *   const spec = getUserFormFormSpec();",
-    " */",
-    "",
-    "/* eslint-disable @typescript-eslint/no-explicit-any */",
-    ""
-  ];
-  for (const cls of classes) {
-    const absoluteSourcePath = path2.resolve(baseDir, cls.sourcePath);
-    const importPath = getRelativeImportPath(outputDir, absoluteSourcePath);
-    lines.push(`import { ${cls.name} } from "${importPath}";`);
-  }
-  lines.push("");
-  lines.push("// =============================================================================");
-  lines.push("// Type Metadata Patches");
-  lines.push("// =============================================================================");
-  lines.push("");
-  for (const cls of classes) {
-    const metadataJson = JSON.stringify(cls.typeMetadata, null, 2).split("\n").map((line, i) => i === 0 ? line : "  " + line).join("\n");
-    lines.push(`(${cls.name} as any).__formspec_types__ = ${metadataJson};`);
-    lines.push("");
-  }
-  lines.push("// =============================================================================");
-  lines.push("// Inferred Schema Types");
-  lines.push("// =============================================================================");
-  lines.push("");
-  for (const cls of classes) {
-    lines.push(generateSchemaType(cls));
-    lines.push("");
-  }
-  lines.push("// =============================================================================");
-  lines.push("// Type-Safe FormSpec Accessors");
-  lines.push("// =============================================================================");
-  lines.push("");
-  for (const cls of classes) {
-    lines.push(generateTypedAccessor(cls));
-    lines.push("");
-  }
-  return lines.join("\n");
-}
-function metadataToTypeString(metadata) {
-  const baseType = metadataToBaseTypeString(metadata);
-  if (metadata.nullable && metadata.optional) {
-    return `${baseType} | null | undefined`;
-  }
-  if (metadata.nullable) {
-    return `${baseType} | null`;
-  }
-  if (metadata.optional) {
-    return `${baseType} | undefined`;
-  }
-  return baseType;
-}
-var VALID_IDENTIFIER = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
-var RESERVED_WORDS = /* @__PURE__ */ new Set([
-  // Keywords
-  "break",
-  "case",
-  "catch",
-  "continue",
-  "debugger",
-  "default",
-  "delete",
-  "do",
-  "else",
-  "finally",
-  "for",
-  "function",
-  "if",
-  "in",
-  "instanceof",
-  "new",
-  "return",
-  "switch",
-  "this",
-  "throw",
-  "try",
-  "typeof",
-  "var",
-  "void",
-  "while",
-  "with",
-  "class",
-  "const",
-  "enum",
-  "export",
-  "extends",
-  "import",
-  "super",
-  "implements",
-  "interface",
-  "let",
-  "package",
-  "private",
-  "protected",
-  "public",
-  "static",
-  "yield",
-  // ES6+ keywords
-  "async",
-  "await",
-  // Literal values (not technically keywords but best to quote)
-  "null",
-  "true",
-  "false",
-  // Accessor keywords
-  "get",
-  "set",
-  // Strict mode reserved
-  "arguments",
-  "eval"
-]);
-function needsPropertyQuoting(key) {
-  if (!VALID_IDENTIFIER.test(key)) {
-    return true;
-  }
-  return RESERVED_WORDS.has(key);
-}
-function escapePropertyKey(key) {
-  if (needsPropertyQuoting(key)) {
-    return JSON.stringify(key);
-  }
-  return key;
-}
-function metadataToBaseTypeString(metadata) {
-  switch (metadata.type) {
-    case "string":
-      return "string";
-    case "number":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "enum":
-      if (metadata.values && metadata.values.length > 0) {
-        return metadata.values.map((v) => typeof v === "string" ? JSON.stringify(v) : String(v)).join(" | ");
-      }
-      return "string";
-    case "array":
-      if (metadata.itemType) {
-        const itemType = metadataToTypeString(metadata.itemType);
-        if (itemType.includes("|")) {
-          return `(${itemType})[]`;
-        }
-        return `${itemType}[]`;
-      }
-      return "unknown[]";
-    case "object":
-      if (metadata.properties && Object.keys(metadata.properties).length > 0) {
-        const props = Object.entries(metadata.properties).map(([key, propMeta]) => {
-          const optional = propMeta.optional ? "?" : "";
-          return `${escapePropertyKey(key)}${optional}: ${metadataToTypeString(propMeta)}`;
-        }).join("; ");
-        return `{ ${props} }`;
-      }
-      return "Record<string, unknown>";
-    default:
-      return "unknown";
-  }
-}
-function generateSchemaType(cls) {
-  const props = Object.entries(cls.typeMetadata).map(([fieldName, metadata]) => {
-    const optional = metadata.optional ? "?" : "";
-    const typeStr = metadataToTypeString(metadata);
-    return `  ${escapePropertyKey(fieldName)}${optional}: ${typeStr};`;
-  }).join("\n");
-  return `export type ${cls.name}Schema = {
-${props}
-};`;
-}
-function metadataTypeToFieldType(type) {
-  switch (type) {
-    case "string":
-      return "text";
-    case "number":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "enum":
-      return "enum";
-    case "array":
-      return "array";
-    case "object":
-      return "object";
-    default:
-      return "text";
-  }
-}
-function generateTypedAccessor(cls) {
-  const lines = [];
-  const elementTypes = Object.entries(cls.typeMetadata).map(([fieldName, metadata]) => {
-    const fieldType = metadataTypeToFieldType(metadata.type);
-    const required = !metadata.optional;
-    let elementType = `{ readonly _field: "${fieldType}"; readonly id: "${fieldName}"; readonly required: ${String(required)}`;
-    if (metadata.type === "enum" && metadata.values) {
-      const optionValues = metadata.values.map((v) => typeof v === "string" ? JSON.stringify(v) : String(v)).join(", ");
-      elementType += `; readonly options: readonly [${optionValues}]`;
-    }
-    elementType += " }";
-    return elementType;
-  });
-  lines.push(`export type ${cls.name}Elements = readonly [
-  ${elementTypes.join(",\n  ")}
-];`);
-  lines.push("");
-  lines.push(`export type ${cls.name}FormSpec = { readonly elements: ${cls.name}Elements };`);
-  lines.push("");
-  lines.push(`/**`);
-  lines.push(` * Type-safe FormSpec accessor for ${cls.name}.`);
-  lines.push(` * Reads the patched type metadata from the class.`);
-  lines.push(` */`);
-  lines.push(`export function get${cls.name}FormSpec(): ${cls.name}FormSpec {`);
-  lines.push(
-    `  const types = (${cls.name} as any).__formspec_types__ as Record<string, unknown>[];`
-  );
-  lines.push(`  return { elements: types } as unknown as ${cls.name}FormSpec;`);
-  lines.push(`}`);
-  return lines.join("\n");
-}
-function getRelativeImportPath(outputDir, sourcePath) {
-  let relativePath = path2.relative(outputDir, sourcePath);
-  if (!relativePath.startsWith(".")) {
-    relativePath = "./" + relativePath;
-  }
-  relativePath = relativePath.replace(/\\/g, "/");
-  return relativePath + ".js";
-}
-function runCodegen(options) {
-  const baseDir = options.baseDir ?? path2.dirname(options.output);
-  const absoluteFiles = options.files.map((f) => path2.resolve(f));
-  console.log(`Scanning ${String(absoluteFiles.length)} file(s) for decorated classes...`);
-  const classes = findDecoratedClasses(absoluteFiles, baseDir);
-  if (classes.length === 0) {
-    console.log("No decorated classes found.");
-    return;
-  }
-  console.log(`Found ${String(classes.length)} decorated class(es):`);
-  for (const cls of classes) {
-    const fieldCount = Object.keys(cls.typeMetadata).length;
-    console.log(`  - ${cls.name} (${String(fieldCount)} field(s))`);
-  }
-  const unexported = classes.filter((cls) => !cls.isExported);
-  if (unexported.length > 0) {
-    console.warn(
-      `
-\u26A0\uFE0F  Warning: The following decorated classes are not exported from their source files:`
-    );
-    for (const cls of unexported) {
-      console.warn(`   - ${cls.name} (${cls.sourcePath})`);
-    }
-    console.warn(
-      `
-   The generated code will fail to compile because it cannot import these classes.`
-    );
-    console.warn(`   To fix this, add 'export' to the class declaration, for example:`);
-    console.warn(`     export class YourClassName { ... }
-`);
-  }
-  const output = generateCodegenOutput(classes, options.output, baseDir);
-  const outputDir = path2.dirname(options.output);
-  if (!fs.existsSync(outputDir)) {
-    fs.mkdirSync(outputDir, { recursive: true });
-  }
-  fs.writeFileSync(options.output, output);
-  console.log(`
-Generated: ${options.output}`);
-}
-
 // src/index.ts
 function buildFormSchemas(form) {
   return {
@@ -2050,13 +1793,13 @@ function buildFormSchemas(form) {
 function writeSchemas(form, options) {
   const { outDir, name = "schema", indent = 2 } = options;
   const { jsonSchema, uiSchema: uiSchema2 } = buildFormSchemas(form);
-  if (!fs2.existsSync(outDir)) {
-    fs2.mkdirSync(outDir, { recursive: true });
+  if (!fs.existsSync(outDir)) {
+    fs.mkdirSync(outDir, { recursive: true });
   }
-  const jsonSchemaPath = path3.join(outDir, `${name}-schema.json`);
-  const uiSchemaPath = path3.join(outDir, `${name}-uischema.json`);
-  fs2.writeFileSync(jsonSchemaPath, JSON.stringify(jsonSchema, null, indent));
-  fs2.writeFileSync(uiSchemaPath, JSON.stringify(uiSchema2, null, indent));
+  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 };
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -2065,13 +1808,10 @@ function writeSchemas(form, options) {
   categorizationSchema,
   categorySchema,
   controlSchema,
-  findDecoratedClasses,
-  generateCodegenOutput,
   generateJsonSchema,
   generateSchemas,
   generateSchemasFromClass,
   generateUiSchema,
-  generateUiSchemaFromFields,
   getSchemaExtension,
   groupLayoutSchema,
   horizontalLayoutSchema,
@@ -2081,7 +1821,6 @@ function writeSchemas(form, options) {
   ruleConditionSchema,
   ruleEffectSchema,
   ruleSchema,
-  runCodegen,
   schemaBasedConditionSchema,
   setSchemaExtension,
   uiSchemaElementSchema,