@formspec/build 0.1.0-alpha.2 → 0.1.0-alpha.21

package/dist/cli.cjs

@@ -0,0 +1,3859 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/canonicalize/chain-dsl-canonicalizer.ts
+function isGroup(el) {
+  return el._type === "group";
+}
+function isConditional(el) {
+  return el._type === "conditional";
+}
+function isField(el) {
+  return el._type === "field";
+}
+function canonicalizeChainDSL(form) {
+  return {
+    kind: "form-ir",
+    irVersion: import_core.IR_VERSION,
+    elements: canonicalizeElements(form.elements),
+    rootAnnotations: [],
+    typeRegistry: {},
+    provenance: CHAIN_DSL_PROVENANCE
+  };
+}
+function canonicalizeElements(elements) {
+  return elements.map(canonicalizeElement);
+}
+function canonicalizeElement(element) {
+  if (isField(element)) {
+    return canonicalizeField(element);
+  }
+  if (isGroup(element)) {
+    return canonicalizeGroup(element);
+  }
+  if (isConditional(element)) {
+    return canonicalizeConditional(element);
+  }
+  const _exhaustive = element;
+  throw new Error(`Unknown element type: ${JSON.stringify(_exhaustive)}`);
+}
+function canonicalizeField(field) {
+  switch (field._field) {
+    case "text":
+      return canonicalizeTextField(field);
+    case "number":
+      return canonicalizeNumberField(field);
+    case "boolean":
+      return canonicalizeBooleanField(field);
+    case "enum":
+      return canonicalizeStaticEnumField(field);
+    case "dynamic_enum":
+      return canonicalizeDynamicEnumField(field);
+    case "dynamic_schema":
+      return canonicalizeDynamicSchemaField(field);
+    case "array":
+      return canonicalizeArrayField(field);
+    case "object":
+      return canonicalizeObjectField(field);
+    default: {
+      const _exhaustive = field;
+      throw new Error(`Unknown field type: ${JSON.stringify(_exhaustive)}`);
+    }
+  }
+}
+function canonicalizeTextField(field) {
+  const type = { kind: "primitive", primitiveKind: "string" };
+  const constraints = [];
+  if (field.minLength !== void 0) {
+    const c = {
+      kind: "constraint",
+      constraintKind: "minLength",
+      value: field.minLength,
+      provenance: CHAIN_DSL_PROVENANCE
+    };
+    constraints.push(c);
+  }
+  if (field.maxLength !== void 0) {
+    const c = {
+      kind: "constraint",
+      constraintKind: "maxLength",
+      value: field.maxLength,
+      provenance: CHAIN_DSL_PROVENANCE
+    };
+    constraints.push(c);
+  }
+  if (field.pattern !== void 0) {
+    const c = {
+      kind: "constraint",
+      constraintKind: "pattern",
+      pattern: field.pattern,
+      provenance: CHAIN_DSL_PROVENANCE
+    };
+    constraints.push(c);
+  }
+  return buildFieldNode(
+    field.name,
+    type,
+    field.required,
+    buildAnnotations(field.label, field.placeholder),
+    constraints
+  );
+}
+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);
+  }
+  if (field.multipleOf !== void 0) {
+    const c = {
+      kind: "constraint",
+      constraintKind: "multipleOf",
+      value: field.multipleOf,
+      provenance: CHAIN_DSL_PROVENANCE
+    };
+    constraints.push(c);
+  }
+  return buildFieldNode(
+    field.name,
+    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: true
+  };
+  const type = { kind: "array", items: itemsType };
+  const constraints = [];
+  if (field.minItems !== void 0) {
+    const c = {
+      kind: "constraint",
+      constraintKind: "minItems",
+      value: field.minItems,
+      provenance: CHAIN_DSL_PROVENANCE
+    };
+    constraints.push(c);
+  }
+  if (field.maxItems !== void 0) {
+    const c = {
+      kind: "constraint",
+      constraintKind: "maxItems",
+      value: field.maxItems,
+      provenance: CHAIN_DSL_PROVENANCE
+    };
+    constraints.push(c);
+  }
+  return buildFieldNode(
+    field.name,
+    type,
+    field.required,
+    buildAnnotations(field.label),
+    constraints
+  );
+}
+function canonicalizeObjectField(field) {
+  const properties = buildObjectProperties(field.properties);
+  const type = {
+    kind: "object",
+    properties,
+    additionalProperties: true
+  };
+  return buildFieldNode(field.name, type, field.required, buildAnnotations(field.label));
+}
+function canonicalizeGroup(g) {
+  return {
+    kind: "group",
+    label: g.label,
+    elements: canonicalizeElements(g.elements),
+    provenance: CHAIN_DSL_PROVENANCE
+  };
+}
+function canonicalizeConditional(c) {
+  return {
+    kind: "conditional",
+    fieldName: c.field,
+    // Conditional values from the chain DSL are JSON-serializable primitives
+    // (strings, numbers, booleans) produced by the `is()` predicate helper.
+    value: assertJsonValue(c.value),
+    elements: canonicalizeElements(c.elements),
+    provenance: CHAIN_DSL_PROVENANCE
+  };
+}
+function assertJsonValue(v) {
+  if (v === null || typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+    return v;
+  }
+  if (Array.isArray(v)) {
+    return v.map(assertJsonValue);
+  }
+  if (typeof v === "object") {
+    const result = {};
+    for (const [key, val] of Object.entries(v)) {
+      result[key] = assertJsonValue(val);
+    }
+    return result;
+  }
+  throw new TypeError(`Conditional value is not a valid JsonValue: ${typeof v}`);
+}
+function buildFieldNode(name, type, required, annotations, constraints = []) {
+  return {
+    kind: "field",
+    name,
+    type,
+    required: required === true,
+    constraints,
+    annotations,
+    provenance: CHAIN_DSL_PROVENANCE
+  };
+}
+function buildAnnotations(label, placeholder) {
+  const annotations = [];
+  if (label !== void 0) {
+    const a = {
+      kind: "annotation",
+      annotationKind: "displayName",
+      value: label,
+      provenance: CHAIN_DSL_PROVENANCE
+    };
+    annotations.push(a);
+  }
+  if (placeholder !== void 0) {
+    const a = {
+      kind: "annotation",
+      annotationKind: "placeholder",
+      value: placeholder,
+      provenance: CHAIN_DSL_PROVENANCE
+    };
+    annotations.push(a);
+  }
+  return annotations;
+}
+function buildObjectProperties(elements, insideConditional = false) {
+  const properties = [];
+  for (const el of elements) {
+    if (isField(el)) {
+      const fieldNode = canonicalizeField(el);
+      properties.push({
+        name: fieldNode.name,
+        type: fieldNode.type,
+        // Fields inside a conditional branch are always optional in the
+        // data schema, regardless of their `required` flag — the condition
+        // may not be met, so the field may be absent.
+        optional: insideConditional || !fieldNode.required,
+        constraints: fieldNode.constraints,
+        annotations: fieldNode.annotations,
+        provenance: CHAIN_DSL_PROVENANCE
+      });
+    } else if (isGroup(el)) {
+      properties.push(...buildObjectProperties(el.elements, insideConditional));
+    } else if (isConditional(el)) {
+      properties.push(...buildObjectProperties(el.elements, true));
+    }
+  }
+  return properties;
+}
+var import_core, CHAIN_DSL_PROVENANCE;
+var init_chain_dsl_canonicalizer = __esm({
+  "src/canonicalize/chain-dsl-canonicalizer.ts"() {
+    "use strict";
+    import_core = require("@formspec/core");
+    CHAIN_DSL_PROVENANCE = {
+      surface: "chain-dsl",
+      file: "",
+      line: 0,
+      column: 0
+    };
+  }
+});
+
+// src/canonicalize/tsdoc-canonicalizer.ts
+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,
+    ...analysis.annotations !== void 0 && analysis.annotations.length > 0 && { rootAnnotations: analysis.annotations },
+    ...analysis.annotations !== void 0 && analysis.annotations.length > 0 && { annotations: analysis.annotations },
+    provenance
+  };
+}
+function assembleElements(fields, layouts, provenance) {
+  const elements = [];
+  const groupMap = /* @__PURE__ */ new Map();
+  const topLevelOrder = [];
+  for (let i = 0; i < fields.length; i++) {
+    const field = fields[i];
+    const layout = layouts[i];
+    if (!field || !layout) continue;
+    const element = wrapInConditional(field, layout, provenance);
+    if (layout.groupLabel !== void 0) {
+      const label = layout.groupLabel;
+      let groupElements = groupMap.get(label);
+      if (!groupElements) {
+        groupElements = [];
+        groupMap.set(label, groupElements);
+        topLevelOrder.push({ type: "group", label });
+      }
+      groupElements.push(element);
+    } else {
+      topLevelOrder.push({ type: "element", element });
+    }
+  }
+  for (const entry of topLevelOrder) {
+    if (entry.type === "group") {
+      const groupElements = groupMap.get(entry.label);
+      if (groupElements) {
+        const groupNode = {
+          kind: "group",
+          label: entry.label,
+          elements: groupElements,
+          provenance
+        };
+        elements.push(groupNode);
+        groupMap.delete(entry.label);
+      }
+    } else {
+      elements.push(entry.element);
+    }
+  }
+  return elements;
+}
+function wrapInConditional(field, layout, provenance) {
+  if (layout.showWhen === void 0) {
+    return field;
+  }
+  const conditional = {
+    kind: "conditional",
+    fieldName: layout.showWhen.field,
+    value: layout.showWhen.value,
+    elements: [field],
+    provenance
+  };
+  return conditional;
+}
+var import_core2;
+var init_tsdoc_canonicalizer = __esm({
+  "src/canonicalize/tsdoc-canonicalizer.ts"() {
+    "use strict";
+    import_core2 = require("@formspec/core");
+  }
+});
+
+// src/canonicalize/index.ts
+var init_canonicalize = __esm({
+  "src/canonicalize/index.ts"() {
+    "use strict";
+    init_chain_dsl_canonicalizer();
+    init_tsdoc_canonicalizer();
+  }
+});
+
+// src/json-schema/ir-generator.ts
+function makeContext(options) {
+  const vendorPrefix = options?.vendorPrefix ?? "x-formspec";
+  if (!vendorPrefix.startsWith("x-")) {
+    throw new Error(
+      `Invalid vendorPrefix "${vendorPrefix}". Extension JSON Schema keywords must start with "x-".`
+    );
+  }
+  return {
+    defs: {},
+    extensionRegistry: options?.extensionRegistry,
+    vendorPrefix
+  };
+}
+function generateJsonSchemaFromIR(ir, options) {
+  const ctx = makeContext(options);
+  for (const [name, typeDef] of Object.entries(ir.typeRegistry)) {
+    ctx.defs[name] = generateTypeNode(typeDef.type, ctx);
+    if (typeDef.constraints && typeDef.constraints.length > 0) {
+      applyConstraints(ctx.defs[name], typeDef.constraints, ctx);
+    }
+    if (typeDef.annotations && typeDef.annotations.length > 0) {
+      applyAnnotations(ctx.defs[name], typeDef.annotations, ctx);
+    }
+  }
+  const properties = {};
+  const required = [];
+  collectFields(ir.elements, properties, required, ctx);
+  const uniqueRequired = [...new Set(required)];
+  const result = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    type: "object",
+    properties,
+    ...uniqueRequired.length > 0 && { required: uniqueRequired }
+  };
+  if (ir.annotations && ir.annotations.length > 0) {
+    applyAnnotations(result, ir.annotations, ctx);
+  }
+  if (Object.keys(ctx.defs).length > 0) {
+    result.$defs = ctx.defs;
+  }
+  return result;
+}
+function collectFields(elements, properties, required, ctx) {
+  for (const element of elements) {
+    switch (element.kind) {
+      case "field":
+        properties[element.name] = generateFieldSchema(element, ctx);
+        if (element.required) {
+          required.push(element.name);
+        }
+        break;
+      case "group":
+        collectFields(element.elements, properties, required, ctx);
+        break;
+      case "conditional":
+        collectFields(element.elements, properties, required, ctx);
+        break;
+      default: {
+        const _exhaustive = element;
+        void _exhaustive;
+      }
+    }
+  }
+}
+function generateFieldSchema(field, ctx) {
+  const schema = generateTypeNode(field.type, ctx);
+  const itemStringSchema = schema.type === "array" && schema.items?.type === "string" ? schema.items : void 0;
+  const directConstraints = [];
+  const itemConstraints = [];
+  const pathConstraints = [];
+  for (const c of field.constraints) {
+    if (c.path) {
+      pathConstraints.push(c);
+    } else if (itemStringSchema !== void 0 && isStringItemConstraint(c)) {
+      itemConstraints.push(c);
+    } else {
+      directConstraints.push(c);
+    }
+  }
+  applyConstraints(schema, directConstraints, ctx);
+  if (itemStringSchema !== void 0) {
+    applyConstraints(itemStringSchema, itemConstraints, ctx);
+  }
+  const rootAnnotations = [];
+  const itemAnnotations = [];
+  for (const annotation of field.annotations) {
+    if (itemStringSchema !== void 0 && annotation.annotationKind === "format") {
+      itemAnnotations.push(annotation);
+    } else {
+      rootAnnotations.push(annotation);
+    }
+  }
+  applyAnnotations(schema, rootAnnotations, ctx);
+  if (itemStringSchema !== void 0) {
+    applyAnnotations(itemStringSchema, itemAnnotations, ctx);
+  }
+  if (pathConstraints.length === 0) {
+    return schema;
+  }
+  return applyPathTargetedConstraints(schema, pathConstraints, ctx);
+}
+function isStringItemConstraint(constraint) {
+  switch (constraint.constraintKind) {
+    case "minLength":
+    case "maxLength":
+    case "pattern":
+      return true;
+    default:
+      return false;
+  }
+}
+function applyPathTargetedConstraints(schema, pathConstraints, ctx) {
+  if (schema.type === "array" && schema.items) {
+    schema.items = applyPathTargetedConstraints(schema.items, pathConstraints, ctx);
+    return schema;
+  }
+  const byTarget = /* @__PURE__ */ new Map();
+  for (const c of pathConstraints) {
+    const target = c.path?.segments[0];
+    if (!target) continue;
+    const group = byTarget.get(target) ?? [];
+    group.push(c);
+    byTarget.set(target, group);
+  }
+  const propertyOverrides = {};
+  for (const [target, constraints] of byTarget) {
+    const subSchema = {};
+    applyConstraints(subSchema, constraints, ctx);
+    propertyOverrides[target] = subSchema;
+  }
+  if (schema.$ref) {
+    const { $ref, ...rest } = schema;
+    const refPart = { $ref };
+    const overridePart = {
+      properties: propertyOverrides,
+      ...rest
+    };
+    return { allOf: [refPart, overridePart] };
+  }
+  if (schema.type === "object" && schema.properties) {
+    const missingOverrides = {};
+    for (const [target, overrideSchema] of Object.entries(propertyOverrides)) {
+      if (schema.properties[target]) {
+        Object.assign(schema.properties[target], overrideSchema);
+      } else {
+        missingOverrides[target] = overrideSchema;
+      }
+    }
+    if (Object.keys(missingOverrides).length === 0) {
+      return schema;
+    }
+    return {
+      allOf: [schema, { properties: missingOverrides }]
+    };
+  }
+  if (schema.allOf) {
+    schema.allOf = [...schema.allOf, { properties: propertyOverrides }];
+    return schema;
+  }
+  return schema;
+}
+function generateTypeNode(type, ctx) {
+  switch (type.kind) {
+    case "primitive":
+      return generatePrimitiveType(type);
+    case "enum":
+      return generateEnumType(type);
+    case "array":
+      return generateArrayType(type, ctx);
+    case "object":
+      return generateObjectType(type, ctx);
+    case "record":
+      return generateRecordType(type, ctx);
+    case "union":
+      return generateUnionType(type, ctx);
+    case "reference":
+      return generateReferenceType(type);
+    case "dynamic":
+      return generateDynamicType(type);
+    case "custom":
+      return generateCustomType(type, ctx);
+    default: {
+      const _exhaustive = type;
+      return _exhaustive;
+    }
+  }
+}
+function generatePrimitiveType(type) {
+  return {
+    type: type.primitiveKind === "integer" || type.primitiveKind === "bigint" ? "integer" : type.primitiveKind
+  };
+}
+function generateEnumType(type) {
+  const hasDisplayNames = type.members.some((m) => m.displayName !== void 0);
+  if (hasDisplayNames) {
+    return {
+      oneOf: type.members.map((m) => {
+        const entry = { const: m.value };
+        if (m.displayName !== void 0) {
+          entry.title = m.displayName;
+        }
+        return entry;
+      })
+    };
+  }
+  return { enum: type.members.map((m) => m.value) };
+}
+function generateArrayType(type, ctx) {
+  return {
+    type: "array",
+    items: generateTypeNode(type.items, ctx)
+  };
+}
+function generateObjectType(type, ctx) {
+  const properties = {};
+  const required = [];
+  for (const prop of type.properties) {
+    properties[prop.name] = generatePropertySchema(prop, ctx);
+    if (!prop.optional) {
+      required.push(prop.name);
+    }
+  }
+  const schema = { type: "object", properties };
+  if (required.length > 0) {
+    schema.required = required;
+  }
+  if (!type.additionalProperties) {
+    schema.additionalProperties = false;
+  }
+  return schema;
+}
+function generateRecordType(type, ctx) {
+  return {
+    type: "object",
+    additionalProperties: generateTypeNode(type.valueType, ctx)
+  };
+}
+function generatePropertySchema(prop, ctx) {
+  const schema = generateTypeNode(prop.type, ctx);
+  applyConstraints(schema, prop.constraints, ctx);
+  applyAnnotations(schema, prop.annotations, ctx);
+  return schema;
+}
+function generateUnionType(type, ctx) {
+  if (isBooleanUnion(type)) {
+    return { type: "boolean" };
+  }
+  if (isNullableUnion(type)) {
+    return {
+      oneOf: type.members.map((m) => generateTypeNode(m, ctx))
+    };
+  }
+  return {
+    anyOf: type.members.map((m) => generateTypeNode(m, ctx))
+  };
+}
+function isBooleanUnion(type) {
+  if (type.members.length !== 2) return false;
+  const kinds = type.members.map((m) => m.kind);
+  return kinds.every((k) => k === "primitive") && type.members.every((m) => m.kind === "primitive" && m.primitiveKind === "boolean");
+}
+function isNullableUnion(type) {
+  if (type.members.length !== 2) return false;
+  const nullCount = type.members.filter(
+    (m) => m.kind === "primitive" && m.primitiveKind === "null"
+  ).length;
+  return nullCount === 1;
+}
+function generateReferenceType(type) {
+  return { $ref: `#/$defs/${type.name}` };
+}
+function generateDynamicType(type) {
+  if (type.dynamicKind === "enum") {
+    const schema = {
+      type: "string",
+      "x-formspec-source": type.sourceKey
+    };
+    if (type.parameterFields.length > 0) {
+      schema["x-formspec-params"] = [...type.parameterFields];
+    }
+    return schema;
+  }
+  return {
+    type: "object",
+    additionalProperties: true,
+    "x-formspec-schemaSource": type.sourceKey
+  };
+}
+function applyConstraints(schema, constraints, ctx) {
+  for (const constraint of constraints) {
+    switch (constraint.constraintKind) {
+      case "minimum":
+        schema.minimum = constraint.value;
+        break;
+      case "maximum":
+        schema.maximum = constraint.value;
+        break;
+      case "exclusiveMinimum":
+        schema.exclusiveMinimum = constraint.value;
+        break;
+      case "exclusiveMaximum":
+        schema.exclusiveMaximum = constraint.value;
+        break;
+      case "multipleOf": {
+        const { value } = constraint;
+        if (value === 1 && schema.type === "number") {
+          schema.type = "integer";
+        } else {
+          schema.multipleOf = value;
+        }
+        break;
+      }
+      case "minLength":
+        schema.minLength = constraint.value;
+        break;
+      case "maxLength":
+        schema.maxLength = constraint.value;
+        break;
+      case "minItems":
+        schema.minItems = constraint.value;
+        break;
+      case "maxItems":
+        schema.maxItems = constraint.value;
+        break;
+      case "pattern":
+        schema.pattern = constraint.pattern;
+        break;
+      case "uniqueItems":
+        schema.uniqueItems = constraint.value;
+        break;
+      case "const":
+        schema.const = constraint.value;
+        break;
+      case "allowedMembers":
+        break;
+      case "custom":
+        applyCustomConstraint(schema, constraint, ctx);
+        break;
+      default: {
+        const _exhaustive = constraint;
+        void _exhaustive;
+      }
+    }
+  }
+}
+function applyAnnotations(schema, annotations, ctx) {
+  for (const annotation of annotations) {
+    switch (annotation.annotationKind) {
+      case "displayName":
+        schema.title = annotation.value;
+        break;
+      case "description":
+        schema.description = annotation.value;
+        break;
+      case "remarks":
+        schema[`${ctx.vendorPrefix}-remarks`] = annotation.value;
+        break;
+      case "defaultValue":
+        schema.default = annotation.value;
+        break;
+      case "format":
+        schema.format = annotation.value;
+        break;
+      case "deprecated":
+        schema.deprecated = true;
+        if (annotation.message !== void 0 && annotation.message !== "") {
+          schema[`${ctx.vendorPrefix}-deprecation-description`] = annotation.message;
+        }
+        break;
+      case "placeholder":
+        break;
+      case "formatHint":
+        break;
+      case "custom":
+        applyCustomAnnotation(schema, annotation, ctx);
+        break;
+      default: {
+        const _exhaustive = annotation;
+        void _exhaustive;
+      }
+    }
+  }
+}
+function generateCustomType(type, ctx) {
+  const registration = ctx.extensionRegistry?.findType(type.typeId);
+  if (registration === void 0) {
+    throw new Error(
+      `Cannot generate JSON Schema for custom type "${type.typeId}" without a matching extension registration`
+    );
+  }
+  return registration.toJsonSchema(type.payload, ctx.vendorPrefix);
+}
+function applyCustomConstraint(schema, constraint, ctx) {
+  const registration = ctx.extensionRegistry?.findConstraint(constraint.constraintId);
+  if (registration === void 0) {
+    throw new Error(
+      `Cannot generate JSON Schema for custom constraint "${constraint.constraintId}" without a matching extension registration`
+    );
+  }
+  assignVendorPrefixedExtensionKeywords(
+    schema,
+    registration.toJsonSchema(constraint.payload, ctx.vendorPrefix),
+    ctx.vendorPrefix,
+    `custom constraint "${constraint.constraintId}"`
+  );
+}
+function applyCustomAnnotation(schema, annotation, ctx) {
+  const registration = ctx.extensionRegistry?.findAnnotation(annotation.annotationId);
+  if (registration === void 0) {
+    throw new Error(
+      `Cannot generate JSON Schema for custom annotation "${annotation.annotationId}" without a matching extension registration`
+    );
+  }
+  if (registration.toJsonSchema === void 0) {
+    return;
+  }
+  assignVendorPrefixedExtensionKeywords(
+    schema,
+    registration.toJsonSchema(annotation.value, ctx.vendorPrefix),
+    ctx.vendorPrefix,
+    `custom annotation "${annotation.annotationId}"`
+  );
+}
+function assignVendorPrefixedExtensionKeywords(schema, extensionSchema, vendorPrefix, source) {
+  for (const [key, value] of Object.entries(extensionSchema)) {
+    if (!key.startsWith(`${vendorPrefix}-`)) {
+      throw new Error(
+        `Cannot apply ${source}: extension hooks may only emit "${vendorPrefix}-*" JSON Schema keywords`
+      );
+    }
+    schema[key] = value;
+  }
+}
+var init_ir_generator = __esm({
+  "src/json-schema/ir-generator.ts"() {
+    "use strict";
+  }
+});
+
+// src/json-schema/generator.ts
+function generateJsonSchema(form, options) {
+  const ir = canonicalizeChainDSL(form);
+  return generateJsonSchemaFromIR(ir, options);
+}
+var init_generator = __esm({
+  "src/json-schema/generator.ts"() {
+    "use strict";
+    init_canonicalize();
+    init_ir_generator();
+  }
+});
+
+// src/ui-schema/schema.ts
+var import_zod, jsonPointerSchema, ruleEffectSchema, uiSchemaElementTypeSchema, ruleConditionSchema, schemaBasedConditionSchema, ruleSchema, uiSchemaElementSchema, controlSchema, verticalLayoutSchema, horizontalLayoutSchema, groupLayoutSchema, categorySchema, categorizationSchema, labelElementSchema, uiSchema;
+var init_schema = __esm({
+  "src/ui-schema/schema.ts"() {
+    "use strict";
+    import_zod = require("zod");
+    jsonPointerSchema = import_zod.z.string();
+    ruleEffectSchema = import_zod.z.enum(["SHOW", "HIDE", "ENABLE", "DISABLE"]);
+    uiSchemaElementTypeSchema = import_zod.z.enum([
+      "Control",
+      "VerticalLayout",
+      "HorizontalLayout",
+      "Group",
+      "Categorization",
+      "Category",
+      "Label"
+    ]);
+    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_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()
+    );
+    schemaBasedConditionSchema = import_zod.z.object({
+      scope: jsonPointerSchema,
+      schema: ruleConditionSchema
+    }).strict();
+    ruleSchema = import_zod.z.object({
+      effect: ruleEffectSchema,
+      condition: schemaBasedConditionSchema
+    }).strict();
+    uiSchemaElementSchema = import_zod.z.lazy(
+      () => import_zod.z.union([
+        controlSchema,
+        verticalLayoutSchema,
+        horizontalLayoutSchema,
+        groupLayoutSchema,
+        categorizationSchema,
+        categorySchema,
+        labelElementSchema
+      ])
+    );
+    controlSchema = import_zod.z.object({
+      type: import_zod.z.literal("Control"),
+      scope: jsonPointerSchema,
+      label: import_zod.z.union([import_zod.z.string(), import_zod.z.literal(false)]).optional(),
+      rule: ruleSchema.optional(),
+      options: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+    }).passthrough();
+    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_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+      }).passthrough()
+    );
+    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_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+      }).passthrough()
+    );
+    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_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+      }).passthrough()
+    );
+    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_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+      }).passthrough()
+    );
+    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_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+      }).passthrough()
+    );
+    labelElementSchema = import_zod.z.object({
+      type: import_zod.z.literal("Label"),
+      text: import_zod.z.string(),
+      rule: ruleSchema.optional(),
+      options: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+    }).passthrough();
+    uiSchema = import_zod.z.lazy(
+      () => import_zod.z.union([verticalLayoutSchema, horizontalLayoutSchema, groupLayoutSchema, categorizationSchema])
+    );
+  }
+});
+
+// src/ui-schema/ir-generator.ts
+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;
+  }
+}
+function fieldToScope(fieldName) {
+  return `#/properties/${fieldName}`;
+}
+function createShowRule(fieldName, value) {
+  return {
+    effect: "SHOW",
+    condition: {
+      scope: fieldToScope(fieldName),
+      schema: { const: value }
+    }
+  };
+}
+function flattenConditionSchema(scope, schema) {
+  if (schema.allOf === void 0) {
+    if (scope === "#") {
+      return [schema];
+    }
+    const fieldName = scope.replace("#/properties/", "");
+    return [
+      {
+        properties: {
+          [fieldName]: schema
+        }
+      }
+    ];
+  }
+  return schema.allOf.flatMap((member) => flattenConditionSchema(scope, member));
+}
+function combineRules(parentRule, childRule) {
+  return {
+    effect: "SHOW",
+    condition: {
+      scope: "#",
+      schema: {
+        allOf: [
+          ...flattenConditionSchema(parentRule.condition.scope, parentRule.condition.schema),
+          ...flattenConditionSchema(childRule.condition.scope, childRule.condition.schema)
+        ]
+      }
+    }
+  };
+}
+function fieldNodeToControl(field, parentRule) {
+  const displayNameAnnotation = field.annotations.find((a) => a.annotationKind === "displayName");
+  const placeholderAnnotation = field.annotations.find((a) => a.annotationKind === "placeholder");
+  const control = {
+    type: "Control",
+    scope: fieldToScope(field.name),
+    ...displayNameAnnotation !== void 0 && { label: displayNameAnnotation.value },
+    ...placeholderAnnotation !== void 0 && {
+      options: { placeholder: placeholderAnnotation.value }
+    },
+    ...parentRule !== void 0 && { rule: parentRule }
+  };
+  return control;
+}
+function groupNodeToLayout(group, parentRule) {
+  return {
+    type: "Group",
+    label: group.label,
+    elements: irElementsToUiSchema(group.elements, parentRule),
+    ...parentRule !== void 0 && { rule: parentRule }
+  };
+}
+function irElementsToUiSchema(elements, parentRule) {
+  const result = [];
+  for (const element of elements) {
+    switch (element.kind) {
+      case "field": {
+        result.push(fieldNodeToControl(element, parentRule));
+        break;
+      }
+      case "group": {
+        result.push(groupNodeToLayout(element, parentRule));
+        break;
+      }
+      case "conditional": {
+        const newRule = createShowRule(element.fieldName, element.value);
+        const combinedRule = parentRule !== void 0 ? combineRules(parentRule, newRule) : newRule;
+        const childElements = irElementsToUiSchema(element.elements, combinedRule);
+        result.push(...childElements);
+        break;
+      }
+      default: {
+        const _exhaustive = element;
+        void _exhaustive;
+        throw new Error("Unhandled IR element kind");
+      }
+    }
+  }
+  return result;
+}
+function generateUiSchemaFromIR(ir) {
+  const result = {
+    type: "VerticalLayout",
+    elements: irElementsToUiSchema(ir.elements)
+  };
+  return parseOrThrow(uiSchema, result, "UI Schema");
+}
+var import_zod2;
+var init_ir_generator2 = __esm({
+  "src/ui-schema/ir-generator.ts"() {
+    "use strict";
+    init_schema();
+    import_zod2 = require("zod");
+  }
+});
+
+// src/ui-schema/generator.ts
+function generateUiSchema(form) {
+  const ir = canonicalizeChainDSL(form);
+  return generateUiSchemaFromIR(ir);
+}
+var init_generator2 = __esm({
+  "src/ui-schema/generator.ts"() {
+    "use strict";
+    init_canonicalize();
+    init_ir_generator2();
+  }
+});
+
+// src/json-schema/types.ts
+function setSchemaExtension(schema, key, value) {
+  schema[key] = value;
+}
+function getSchemaExtension(schema, key) {
+  return schema[key];
+}
+var init_types = __esm({
+  "src/json-schema/types.ts"() {
+    "use strict";
+  }
+});
+
+// src/extensions/registry.ts
+function createExtensionRegistry(extensions) {
+  const typeMap = /* @__PURE__ */ new Map();
+  const typeNameMap = /* @__PURE__ */ new Map();
+  const constraintMap = /* @__PURE__ */ new Map();
+  const constraintTagMap = /* @__PURE__ */ new Map();
+  const builtinBroadeningMap = /* @__PURE__ */ new Map();
+  const annotationMap = /* @__PURE__ */ new Map();
+  for (const ext of extensions) {
+    if (ext.types !== void 0) {
+      for (const type of ext.types) {
+        const qualifiedId = `${ext.extensionId}/${type.typeName}`;
+        if (typeMap.has(qualifiedId)) {
+          throw new Error(`Duplicate custom type ID: "${qualifiedId}"`);
+        }
+        typeMap.set(qualifiedId, type);
+        for (const sourceTypeName of type.tsTypeNames ?? [type.typeName]) {
+          if (typeNameMap.has(sourceTypeName)) {
+            throw new Error(`Duplicate custom type source name: "${sourceTypeName}"`);
+          }
+          typeNameMap.set(sourceTypeName, {
+            extensionId: ext.extensionId,
+            registration: type
+          });
+        }
+        if (type.builtinConstraintBroadenings !== void 0) {
+          for (const broadening of type.builtinConstraintBroadenings) {
+            const key = `${qualifiedId}:${broadening.tagName}`;
+            if (builtinBroadeningMap.has(key)) {
+              throw new Error(`Duplicate built-in constraint broadening: "${key}"`);
+            }
+            builtinBroadeningMap.set(key, {
+              extensionId: ext.extensionId,
+              registration: broadening
+            });
+          }
+        }
+      }
+    }
+    if (ext.constraints !== void 0) {
+      for (const constraint of ext.constraints) {
+        const qualifiedId = `${ext.extensionId}/${constraint.constraintName}`;
+        if (constraintMap.has(qualifiedId)) {
+          throw new Error(`Duplicate custom constraint ID: "${qualifiedId}"`);
+        }
+        constraintMap.set(qualifiedId, constraint);
+      }
+    }
+    if (ext.constraintTags !== void 0) {
+      for (const tag of ext.constraintTags) {
+        if (constraintTagMap.has(tag.tagName)) {
+          throw new Error(`Duplicate custom constraint tag: "@${tag.tagName}"`);
+        }
+        constraintTagMap.set(tag.tagName, {
+          extensionId: ext.extensionId,
+          registration: tag
+        });
+      }
+    }
+    if (ext.annotations !== void 0) {
+      for (const annotation of ext.annotations) {
+        const qualifiedId = `${ext.extensionId}/${annotation.annotationName}`;
+        if (annotationMap.has(qualifiedId)) {
+          throw new Error(`Duplicate custom annotation ID: "${qualifiedId}"`);
+        }
+        annotationMap.set(qualifiedId, annotation);
+      }
+    }
+  }
+  return {
+    extensions,
+    findType: (typeId) => typeMap.get(typeId),
+    findTypeByName: (typeName) => typeNameMap.get(typeName),
+    findConstraint: (constraintId) => constraintMap.get(constraintId),
+    findConstraintTag: (tagName) => constraintTagMap.get(tagName),
+    findBuiltinConstraintBroadening: (typeId, tagName) => builtinBroadeningMap.get(`${typeId}:${tagName}`),
+    findAnnotation: (annotationId) => annotationMap.get(annotationId)
+  };
+}
+var init_registry = __esm({
+  "src/extensions/registry.ts"() {
+    "use strict";
+  }
+});
+
+// src/extensions/index.ts
+var init_extensions = __esm({
+  "src/extensions/index.ts"() {
+    "use strict";
+    init_registry();
+  }
+});
+
+// src/json-schema/schema.ts
+var import_zod3, jsonSchemaTypeSchema, jsonSchema7Schema;
+var init_schema2 = __esm({
+  "src/json-schema/schema.ts"() {
+    "use strict";
+    import_zod3 = require("zod");
+    jsonSchemaTypeSchema = import_zod3.z.enum([
+      "string",
+      "number",
+      "integer",
+      "boolean",
+      "object",
+      "array",
+      "null"
+    ]);
+    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/tsdoc-parser.ts
+function createFormSpecTSDocConfig(extensionTagNames = []) {
+  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
+      })
+    );
+  }
+  for (const tagName of ["displayName", "format", "placeholder"]) {
+    config.addTagDefinition(
+      new import_tsdoc.TSDocTagDefinition({
+        tagName: "@" + tagName,
+        syntaxKind: import_tsdoc.TSDocTagSyntaxKind.BlockTag,
+        allowMultiple: true
+      })
+    );
+  }
+  for (const tagName of extensionTagNames) {
+    config.addTagDefinition(
+      new import_tsdoc.TSDocTagDefinition({
+        tagName: "@" + tagName,
+        syntaxKind: import_tsdoc.TSDocTagSyntaxKind.BlockTag,
+        allowMultiple: true
+      })
+    );
+  }
+  return config;
+}
+function sharedCommentSyntaxOptions(options, offset) {
+  const extensions = options?.extensionRegistry?.extensions;
+  return {
+    ...offset !== void 0 ? { offset } : {},
+    ...extensions !== void 0 ? { extensions } : {}
+  };
+}
+function sharedTagValueOptions(options) {
+  return {
+    ...options?.extensionRegistry !== void 0 ? { registry: options.extensionRegistry } : {},
+    ...options?.fieldType !== void 0 ? { fieldType: options.fieldType } : {}
+  };
+}
+function buildSupportingDeclarations(sourceFile) {
+  return sourceFile.statements.filter(
+    (statement) => !ts.isImportDeclaration(statement) && !ts.isImportEqualsDeclaration(statement) && !(ts.isExportDeclaration(statement) && statement.moduleSpecifier !== void 0)
+  ).map((statement) => statement.getText(sourceFile));
+}
+function renderSyntheticArgumentExpression(valueKind, argumentText) {
+  const trimmed = argumentText.trim();
+  if (trimmed === "") {
+    return null;
+  }
+  switch (valueKind) {
+    case "number":
+    case "integer":
+    case "signedInteger":
+      return Number.isFinite(Number(trimmed)) ? trimmed : JSON.stringify(trimmed);
+    case "string":
+      return JSON.stringify(argumentText);
+    case "json":
+      try {
+        JSON.parse(trimmed);
+        return `(${trimmed})`;
+      } catch {
+        return JSON.stringify(trimmed);
+      }
+    case "boolean":
+      return trimmed === "true" || trimmed === "false" ? trimmed : JSON.stringify(trimmed);
+    case "condition":
+      return "undefined as unknown as FormSpecCondition";
+    case null:
+      return null;
+    default: {
+      return String(valueKind);
+    }
+  }
+}
+function getArrayElementType(type, checker) {
+  if (!checker.isArrayType(type)) {
+    return null;
+  }
+  return checker.getTypeArguments(type)[0] ?? null;
+}
+function supportsConstraintCapability(type, checker, capability) {
+  if (capability === void 0) {
+    return true;
+  }
+  if ((0, import_internal.hasTypeSemanticCapability)(type, checker, capability)) {
+    return true;
+  }
+  if (capability === "string-like") {
+    const itemType = getArrayElementType(type, checker);
+    return itemType !== null && (0, import_internal.hasTypeSemanticCapability)(itemType, checker, capability);
+  }
+  return false;
+}
+function makeDiagnostic(code, message, provenance) {
+  return {
+    code,
+    message,
+    severity: "error",
+    primaryLocation: provenance,
+    relatedLocations: []
+  };
+}
+function placementLabel(placement) {
+  switch (placement) {
+    case "class":
+      return "class declarations";
+    case "class-field":
+      return "class fields";
+    case "class-method":
+      return "class methods";
+    case "interface":
+      return "interface declarations";
+    case "interface-field":
+      return "interface fields";
+    case "type-alias":
+      return "type aliases";
+    case "type-alias-field":
+      return "type-alias properties";
+    case "variable":
+      return "variables";
+    case "function":
+      return "functions";
+    case "function-parameter":
+      return "function parameters";
+    case "method-parameter":
+      return "method parameters";
+    default: {
+      const exhaustive = placement;
+      return String(exhaustive);
+    }
+  }
+}
+function capabilityLabel(capability) {
+  switch (capability) {
+    case "numeric-comparable":
+      return "number";
+    case "string-like":
+      return "string";
+    case "array-like":
+      return "array";
+    case "enum-member-addressable":
+      return "enum";
+    case "json-like":
+      return "JSON-compatible";
+    case "object-like":
+      return "object";
+    case "condition-like":
+      return "conditional";
+    case void 0:
+      return "compatible";
+    default:
+      return capability;
+  }
+}
+function getBroadenedCustomTypeId(fieldType) {
+  if (fieldType?.kind === "custom") {
+    return fieldType.typeId;
+  }
+  if (fieldType?.kind !== "union") {
+    return void 0;
+  }
+  const customMembers = fieldType.members.filter(
+    (member) => member.kind === "custom"
+  );
+  if (customMembers.length !== 1) {
+    return void 0;
+  }
+  const nonCustomMembers = fieldType.members.filter((member) => member.kind !== "custom");
+  const allOtherMembersAreNull = nonCustomMembers.every(
+    (member) => member.kind === "primitive" && member.primitiveKind === "null"
+  );
+  const customMember = customMembers[0];
+  return allOtherMembersAreNull && customMember !== void 0 ? customMember.typeId : void 0;
+}
+function hasBuiltinConstraintBroadening(tagName, options) {
+  const broadenedTypeId = getBroadenedCustomTypeId(options?.fieldType);
+  return broadenedTypeId !== void 0 && options?.extensionRegistry?.findBuiltinConstraintBroadening(broadenedTypeId, tagName) !== void 0;
+}
+function buildCompilerBackedConstraintDiagnostics(node, sourceFile, tagName, parsedTag, provenance, supportingDeclarations, options) {
+  if (!(0, import_core3.isBuiltinConstraintName)(tagName)) {
+    return [];
+  }
+  const checker = options?.checker;
+  const subjectType = options?.subjectType;
+  if (checker === void 0 || subjectType === void 0) {
+    return [];
+  }
+  const placement = (0, import_internal.resolveDeclarationPlacement)(node);
+  if (placement === null) {
+    return [];
+  }
+  const definition = (0, import_internal.getTagDefinition)(tagName, options?.extensionRegistry?.extensions);
+  if (definition === null) {
+    return [];
+  }
+  if (!definition.placements.includes(placement)) {
+    return [
+      makeDiagnostic(
+        "INVALID_TAG_PLACEMENT",
+        `Tag "@${tagName}" is not allowed on ${placementLabel(placement)}.`,
+        provenance
+      )
+    ];
+  }
+  const target = parsedTag?.target ?? null;
+  const hasBroadening = target === null && hasBuiltinConstraintBroadening(tagName, options);
+  if (target !== null) {
+    if (target.kind !== "path") {
+      return [
+        makeDiagnostic(
+          "UNSUPPORTED_TARGETING_SYNTAX",
+          `Tag "@${tagName}" does not support ${target.kind} targeting syntax.`,
+          provenance
+        )
+      ];
+    }
+    if (!target.valid || target.path === null) {
+      return [
+        makeDiagnostic(
+          "UNSUPPORTED_TARGETING_SYNTAX",
+          `Tag "@${tagName}" has invalid path targeting syntax.`,
+          provenance
+        )
+      ];
+    }
+    const resolution = (0, import_internal.resolvePathTargetType)(subjectType, checker, target.path.segments);
+    if (resolution.kind === "missing-property") {
+      return [
+        makeDiagnostic(
+          "UNKNOWN_PATH_TARGET",
+          `Target "${target.rawText}": path-targeted constraint "${tagName}" references unknown path segment "${resolution.segment}"`,
+          provenance
+        )
+      ];
+    }
+    if (resolution.kind === "unresolvable") {
+      const actualType = checker.typeToString(resolution.type, node, SYNTHETIC_TYPE_FORMAT_FLAGS);
+      return [
+        makeDiagnostic(
+          "TYPE_MISMATCH",
+          `Target "${target.rawText}": path-targeted constraint "${tagName}" is invalid because type "${actualType}" cannot be traversed`,
+          provenance
+        )
+      ];
+    }
+    const requiredCapability = definition.capabilities[0];
+    if (requiredCapability !== void 0 && !supportsConstraintCapability(resolution.type, checker, requiredCapability)) {
+      const actualType = checker.typeToString(resolution.type, node, SYNTHETIC_TYPE_FORMAT_FLAGS);
+      return [
+        makeDiagnostic(
+          "TYPE_MISMATCH",
+          `Target "${target.rawText}": constraint "${tagName}" is only valid on ${capabilityLabel(requiredCapability)} targets, but field type is "${actualType}"`,
+          provenance
+        )
+      ];
+    }
+  } else if (!hasBroadening) {
+    const requiredCapability = definition.capabilities[0];
+    if (requiredCapability !== void 0 && !supportsConstraintCapability(subjectType, checker, requiredCapability)) {
+      const actualType = checker.typeToString(subjectType, node, SYNTHETIC_TYPE_FORMAT_FLAGS);
+      return [
+        makeDiagnostic(
+          "TYPE_MISMATCH",
+          `Target "${node.getText(sourceFile)}": constraint "${tagName}" is only valid on ${capabilityLabel(requiredCapability)} targets, but field type is "${actualType}"`,
+          provenance
+        )
+      ];
+    }
+  }
+  const argumentExpression = renderSyntheticArgumentExpression(
+    definition.valueKind,
+    parsedTag?.argumentText ?? ""
+  );
+  if (definition.requiresArgument && argumentExpression === null) {
+    return [];
+  }
+  if (hasBroadening) {
+    return [];
+  }
+  const subjectTypeText = checker.typeToString(subjectType, node, SYNTHETIC_TYPE_FORMAT_FLAGS);
+  const hostType = options?.hostType ?? subjectType;
+  const hostTypeText = checker.typeToString(hostType, node, SYNTHETIC_TYPE_FORMAT_FLAGS);
+  const result = (0, import_internal.checkSyntheticTagApplication)({
+    tagName,
+    placement,
+    hostType: hostTypeText,
+    subjectType: subjectTypeText,
+    ...target?.kind === "path" ? { target: { kind: "path", text: target.rawText } } : {},
+    ...argumentExpression !== null ? { argumentExpression } : {},
+    supportingDeclarations,
+    ...options?.extensionRegistry !== void 0 ? {
+      extensions: options.extensionRegistry.extensions.map((extension) => ({
+        extensionId: extension.extensionId,
+        ...extension.constraintTags !== void 0 ? {
+          constraintTags: extension.constraintTags.map((tag) => ({ tagName: tag.tagName }))
+        } : {}
+      }))
+    } : {}
+  });
+  if (result.diagnostics.length === 0) {
+    return [];
+  }
+  const expectedLabel = definition.valueKind === null ? "compatible argument" : capabilityLabel(definition.valueKind);
+  return [
+    makeDiagnostic(
+      "TYPE_MISMATCH",
+      `Tag "@${tagName}" received an invalid argument for ${expectedLabel}.`,
+      provenance
+    )
+  ];
+}
+function getParser(options) {
+  const extensionTagNames = [
+    ...options?.extensionRegistry?.extensions.flatMap(
+      (extension) => (extension.constraintTags ?? []).map((tag) => tag.tagName)
+    ) ?? []
+  ].sort();
+  const cacheKey = extensionTagNames.join("|");
+  const existing = parserCache.get(cacheKey);
+  if (existing) {
+    return existing;
+  }
+  const parser = new import_tsdoc.TSDocParser(createFormSpecTSDocConfig(extensionTagNames));
+  parserCache.set(cacheKey, parser);
+  return parser;
+}
+function getExtensionRegistryCacheKey(registry) {
+  if (registry === void 0) {
+    return "";
+  }
+  return registry.extensions.map(
+    (extension) => JSON.stringify({
+      extensionId: extension.extensionId,
+      typeNames: extension.types?.map((type) => type.typeName) ?? [],
+      constraintTags: extension.constraintTags?.map((tag) => tag.tagName) ?? []
+    })
+  ).join("|");
+}
+function getParseCacheKey(node, file, options) {
+  const sourceFile = node.getSourceFile();
+  const checker = options?.checker;
+  return JSON.stringify({
+    file,
+    sourceFile: sourceFile.fileName,
+    sourceText: sourceFile.text,
+    start: node.getFullStart(),
+    end: node.getEnd(),
+    fieldType: options?.fieldType ?? null,
+    subjectType: checker !== void 0 && options?.subjectType !== void 0 ? checker.typeToString(options.subjectType, node, SYNTHETIC_TYPE_FORMAT_FLAGS) : null,
+    hostType: checker !== void 0 && options?.hostType !== void 0 ? checker.typeToString(options.hostType, node, SYNTHETIC_TYPE_FORMAT_FLAGS) : null,
+    extensions: getExtensionRegistryCacheKey(options?.extensionRegistry)
+  });
+}
+function parseTSDocTags(node, file = "", options) {
+  const cacheKey = getParseCacheKey(node, file, options);
+  const cached = parseResultCache.get(cacheKey);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const constraints = [];
+  const annotations = [];
+  const diagnostics = [];
+  let displayName;
+  let placeholder;
+  let displayNameProvenance;
+  let placeholderProvenance;
+  const rawTextTags = [];
+  const sourceFile = node.getSourceFile();
+  const sourceText = sourceFile.getFullText();
+  const supportingDeclarations = buildSupportingDeclarations(sourceFile);
+  const commentRanges = ts.getLeadingCommentRanges(sourceText, node.getFullStart());
+  const rawTextFallbacks = collectRawTextFallbacks(node, file);
+  if (commentRanges) {
+    for (const range of commentRanges) {
+      if (range.kind !== ts.SyntaxKind.MultiLineCommentTrivia) {
+        continue;
+      }
+      const commentText = sourceText.substring(range.pos, range.end);
+      if (!commentText.startsWith("/**")) {
+        continue;
+      }
+      const parser = getParser(options);
+      const parserContext = parser.parseRange(
+        import_tsdoc.TextRange.fromStringRange(sourceText, range.pos, range.end)
+      );
+      const docComment = parserContext.docComment;
+      const parsedComment = (0, import_internal.parseCommentBlock)(
+        commentText,
+        sharedCommentSyntaxOptions(options, range.pos)
+      );
+      let parsedTagCursor = 0;
+      const nextParsedTag = (normalizedTagName) => {
+        while (parsedTagCursor < parsedComment.tags.length) {
+          const candidate = parsedComment.tags[parsedTagCursor];
+          parsedTagCursor += 1;
+          if (candidate?.normalizedTagName === normalizedTagName) {
+            return candidate;
+          }
+        }
+        return null;
+      };
+      for (const parsedTag of parsedComment.tags) {
+        if (TAGS_REQUIRING_RAW_TEXT.has(parsedTag.normalizedTagName)) {
+          rawTextTags.push({ tag: parsedTag, commentText, commentOffset: range.pos });
+        }
+      }
+      for (const block of docComment.customBlocks) {
+        const tagName = (0, import_core3.normalizeConstraintTagName)(block.blockTag.tagName.substring(1));
+        const parsedTag = nextParsedTag(tagName);
+        if (tagName === "displayName" || tagName === "format" || tagName === "placeholder") {
+          const text2 = getBestBlockPayloadText(parsedTag, commentText, range.pos, block);
+          if (text2 === "") continue;
+          const provenance2 = parsedTag !== null ? provenanceForParsedTag(parsedTag, sourceFile, file) : provenanceForComment(range, sourceFile, file, tagName);
+          switch (tagName) {
+            case "displayName":
+              if (!isMemberTargetDisplayName(text2) && displayName === void 0) {
+                displayName = text2;
+                displayNameProvenance = provenance2;
+              }
+              break;
+            case "format":
+              annotations.push({
+                kind: "annotation",
+                annotationKind: "format",
+                value: text2,
+                provenance: provenance2
+              });
+              break;
+            case "placeholder":
+              if (placeholder === void 0) {
+                placeholder = text2;
+                placeholderProvenance = provenance2;
+              }
+              break;
+          }
+          continue;
+        }
+        if (TAGS_REQUIRING_RAW_TEXT.has(tagName)) continue;
+        const text = getBestBlockPayloadText(parsedTag, commentText, range.pos, block);
+        const expectedType = (0, import_core3.isBuiltinConstraintName)(tagName) ? import_core3.BUILTIN_CONSTRAINT_DEFINITIONS[tagName] : void 0;
+        if (text === "" && expectedType !== "boolean") continue;
+        const provenance = parsedTag !== null ? provenanceForParsedTag(parsedTag, sourceFile, file) : provenanceForComment(range, sourceFile, file, tagName);
+        const compilerDiagnostics = buildCompilerBackedConstraintDiagnostics(
+          node,
+          sourceFile,
+          tagName,
+          parsedTag,
+          provenance,
+          supportingDeclarations,
+          options
+        );
+        if (compilerDiagnostics.length > 0) {
+          diagnostics.push(...compilerDiagnostics);
+          continue;
+        }
+        const constraintNode = (0, import_internal.parseConstraintTagValue)(
+          tagName,
+          text,
+          provenance,
+          sharedTagValueOptions(options)
+        );
+        if (constraintNode) {
+          constraints.push(constraintNode);
+        }
+      }
+      if (docComment.deprecatedBlock !== void 0) {
+        const message = extractBlockText(docComment.deprecatedBlock).trim();
+        annotations.push({
+          kind: "annotation",
+          annotationKind: "deprecated",
+          ...message !== "" && { message },
+          provenance: provenanceForComment(range, sourceFile, file, "deprecated")
+        });
+      }
+      {
+        const summary = extractPlainText(docComment.summarySection).trim();
+        if (summary !== "") {
+          annotations.push({
+            kind: "annotation",
+            annotationKind: "description",
+            value: summary,
+            provenance: provenanceForComment(range, sourceFile, file, "summary")
+          });
+        }
+      }
+      if (docComment.remarksBlock !== void 0) {
+        const remarksText = extractBlockText(docComment.remarksBlock).trim();
+        if (remarksText !== "") {
+          annotations.push({
+            kind: "annotation",
+            annotationKind: "remarks",
+            value: remarksText,
+            provenance: provenanceForComment(range, sourceFile, file, "remarks")
+          });
+        }
+      }
+    }
+  }
+  if (displayName !== void 0 && displayNameProvenance !== void 0) {
+    annotations.push({
+      kind: "annotation",
+      annotationKind: "displayName",
+      value: displayName,
+      provenance: displayNameProvenance
+    });
+  }
+  if (placeholder !== void 0 && placeholderProvenance !== void 0) {
+    annotations.push({
+      kind: "annotation",
+      annotationKind: "placeholder",
+      value: placeholder,
+      provenance: placeholderProvenance
+    });
+  }
+  if (rawTextTags.length > 0) {
+    for (const rawTextTag of rawTextTags) {
+      const fallbackQueue = rawTextFallbacks.get(rawTextTag.tag.normalizedTagName);
+      const fallback = fallbackQueue?.shift();
+      const text = choosePreferredPayloadText(
+        getSharedPayloadText(rawTextTag.tag, rawTextTag.commentText, rawTextTag.commentOffset),
+        fallback?.text ?? ""
+      );
+      if (text === "") continue;
+      const provenance = provenanceForParsedTag(rawTextTag.tag, sourceFile, file);
+      if (rawTextTag.tag.normalizedTagName === "defaultValue") {
+        const defaultValueNode = (0, import_internal.parseDefaultValueTagValue)(text, provenance);
+        annotations.push(defaultValueNode);
+        continue;
+      }
+      const compilerDiagnostics = buildCompilerBackedConstraintDiagnostics(
+        node,
+        sourceFile,
+        rawTextTag.tag.normalizedTagName,
+        rawTextTag.tag,
+        provenance,
+        supportingDeclarations,
+        options
+      );
+      if (compilerDiagnostics.length > 0) {
+        diagnostics.push(...compilerDiagnostics);
+        continue;
+      }
+      const constraintNode = (0, import_internal.parseConstraintTagValue)(
+        rawTextTag.tag.normalizedTagName,
+        text,
+        provenance,
+        sharedTagValueOptions(options)
+      );
+      if (constraintNode) {
+        constraints.push(constraintNode);
+      }
+    }
+  }
+  for (const [tagName, fallbacks] of rawTextFallbacks) {
+    for (const fallback of fallbacks) {
+      const text = fallback.text.trim();
+      if (text === "") continue;
+      const provenance = fallback.provenance;
+      if (tagName === "defaultValue") {
+        const defaultValueNode = (0, import_internal.parseDefaultValueTagValue)(text, provenance);
+        annotations.push(defaultValueNode);
+        continue;
+      }
+      const compilerDiagnostics = buildCompilerBackedConstraintDiagnostics(
+        node,
+        sourceFile,
+        tagName,
+        null,
+        provenance,
+        supportingDeclarations,
+        options
+      );
+      if (compilerDiagnostics.length > 0) {
+        diagnostics.push(...compilerDiagnostics);
+        continue;
+      }
+      const constraintNode = (0, import_internal.parseConstraintTagValue)(
+        tagName,
+        text,
+        provenance,
+        sharedTagValueOptions(options)
+      );
+      if (constraintNode) {
+        constraints.push(constraintNode);
+      }
+    }
+  }
+  const result = { constraints, annotations, diagnostics };
+  parseResultCache.set(cacheKey, result);
+  return result;
+}
+function extractDisplayNameMetadata(node) {
+  let displayName;
+  const memberDisplayNames = /* @__PURE__ */ new Map();
+  const sourceFile = node.getSourceFile();
+  const sourceText = sourceFile.getFullText();
+  const commentRanges = ts.getLeadingCommentRanges(sourceText, node.getFullStart());
+  if (commentRanges) {
+    for (const range of commentRanges) {
+      if (range.kind !== ts.SyntaxKind.MultiLineCommentTrivia) continue;
+      const commentText = sourceText.substring(range.pos, range.end);
+      if (!commentText.startsWith("/**")) continue;
+      const parsed = (0, import_internal.parseCommentBlock)(commentText);
+      for (const tag of parsed.tags) {
+        if (tag.normalizedTagName !== "displayName") {
+          continue;
+        }
+        if (tag.target !== null && tag.argumentText !== "") {
+          memberDisplayNames.set(tag.target.rawText, tag.argumentText);
+          continue;
+        }
+        if (tag.argumentText !== "") {
+          displayName ??= tag.argumentText;
+        }
+      }
+    }
+  }
+  return {
+    ...displayName !== void 0 && { displayName },
+    memberDisplayNames
+  };
+}
+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);
+    }
+  }
+  return result;
+}
+function choosePreferredPayloadText(primary, fallback) {
+  const preferred = primary.trim();
+  const alternate = fallback.trim();
+  if (preferred === "") return alternate;
+  if (alternate === "") return preferred;
+  if (alternate.includes("\n")) return alternate;
+  if (alternate.length > preferred.length && alternate.startsWith(preferred)) {
+    return alternate;
+  }
+  return preferred;
+}
+function getSharedPayloadText(tag, commentText, commentOffset) {
+  if (tag.payloadSpan === null) {
+    return "";
+  }
+  return (0, import_internal.sliceCommentSpan)(commentText, tag.payloadSpan, {
+    offset: commentOffset
+  }).trim();
+}
+function getBestBlockPayloadText(tag, commentText, commentOffset, block) {
+  const sharedText = tag === null ? "" : getSharedPayloadText(tag, commentText, commentOffset);
+  const blockText = extractBlockText(block).replace(/\s+/g, " ").trim();
+  return choosePreferredPayloadText(sharedText, blockText);
+}
+function collectRawTextFallbacks(node, file) {
+  const fallbacks = /* @__PURE__ */ new Map();
+  for (const tag of ts.getJSDocTags(node)) {
+    const tagName = (0, import_core3.normalizeConstraintTagName)(tag.tagName.text);
+    if (!TAGS_REQUIRING_RAW_TEXT.has(tagName)) continue;
+    const commentText = getTagCommentText(tag)?.trim() ?? "";
+    if (commentText === "") continue;
+    const entries = fallbacks.get(tagName) ?? [];
+    entries.push({
+      text: commentText,
+      provenance: provenanceForJSDocTag(tag, file)
+    });
+    fallbacks.set(tagName, entries);
+  }
+  return fallbacks;
+}
+function isMemberTargetDisplayName(text) {
+  return (0, import_internal.parseTagSyntax)("displayName", text).target !== null;
+}
+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 provenanceForParsedTag(tag, sourceFile, file) {
+  const { line, character } = sourceFile.getLineAndCharacterOfPosition(tag.tagNameSpan.start);
+  return {
+    surface: "tsdoc",
+    file,
+    line: line + 1,
+    column: character,
+    tagName: "@" + tag.normalizedTagName
+  };
+}
+function provenanceForJSDocTag(tag, file) {
+  const sourceFile = tag.getSourceFile();
+  const { line, character } = sourceFile.getLineAndCharacterOfPosition(tag.getStart());
+  return {
+    surface: "tsdoc",
+    file,
+    line: line + 1,
+    column: character,
+    tagName: "@" + tag.tagName.text
+  };
+}
+function getTagCommentText(tag) {
+  if (tag.comment === void 0) {
+    return void 0;
+  }
+  if (typeof tag.comment === "string") {
+    return tag.comment;
+  }
+  return ts.getTextOfJSDocComment(tag.comment);
+}
+var ts, import_internal, import_tsdoc, import_core3, TAGS_REQUIRING_RAW_TEXT, SYNTHETIC_TYPE_FORMAT_FLAGS, parserCache, parseResultCache;
+var init_tsdoc_parser = __esm({
+  "src/analyzer/tsdoc-parser.ts"() {
+    "use strict";
+    ts = __toESM(require("typescript"), 1);
+    import_internal = require("@formspec/analysis/internal");
+    import_tsdoc = require("@microsoft/tsdoc");
+    import_core3 = require("@formspec/core");
+    TAGS_REQUIRING_RAW_TEXT = /* @__PURE__ */ new Set(["pattern", "enumOptions", "defaultValue"]);
+    SYNTHETIC_TYPE_FORMAT_FLAGS = ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope;
+    parserCache = /* @__PURE__ */ new Map();
+    parseResultCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/analyzer/jsdoc-constraints.ts
+function extractJSDocParseResult(node, file = "", options) {
+  return parseTSDocTags(node, file, options);
+}
+function extractJSDocConstraintNodes(node, file = "", options) {
+  const result = extractJSDocParseResult(node, file, options);
+  return [...result.constraints];
+}
+function extractJSDocAnnotationNodes(node, file = "", options) {
+  const result = extractJSDocParseResult(node, file, options);
+  return [...result.annotations];
+}
+function extractDefaultValueAnnotation(initializer, file = "") {
+  if (!initializer) return null;
+  let value;
+  if (ts2.isStringLiteral(initializer)) {
+    value = initializer.text;
+  } else if (ts2.isNumericLiteral(initializer)) {
+    value = Number(initializer.text);
+  } else if (initializer.kind === ts2.SyntaxKind.TrueKeyword) {
+    value = true;
+  } else if (initializer.kind === ts2.SyntaxKind.FalseKeyword) {
+    value = false;
+  } else if (initializer.kind === ts2.SyntaxKind.NullKeyword) {
+    value = null;
+  } else if (ts2.isPrefixUnaryExpression(initializer)) {
+    if (initializer.operator === ts2.SyntaxKind.MinusToken && ts2.isNumericLiteral(initializer.operand)) {
+      value = -Number(initializer.operand.text);
+    }
+  }
+  if (value === void 0) return null;
+  const sourceFile = initializer.getSourceFile();
+  const { line, character } = sourceFile.getLineAndCharacterOfPosition(initializer.getStart());
+  return {
+    kind: "annotation",
+    annotationKind: "defaultValue",
+    value,
+    provenance: {
+      surface: "tsdoc",
+      file,
+      line: line + 1,
+      column: character
+    }
+  };
+}
+var ts2;
+var init_jsdoc_constraints = __esm({
+  "src/analyzer/jsdoc-constraints.ts"() {
+    "use strict";
+    ts2 = __toESM(require("typescript"), 1);
+    init_tsdoc_parser();
+  }
+});
+
+// src/analyzer/class-analyzer.ts
+function isObjectType(type) {
+  return !!(type.flags & ts3.TypeFlags.Object);
+}
+function isTypeReference(type) {
+  return !!(type.flags & ts3.TypeFlags.Object) && !!(type.objectFlags & ts3.ObjectFlags.Reference);
+}
+function makeParseOptions(extensionRegistry, fieldType, checker, subjectType, hostType) {
+  if (extensionRegistry === void 0 && fieldType === void 0 && checker === void 0 && subjectType === void 0 && hostType === void 0) {
+    return void 0;
+  }
+  return {
+    ...extensionRegistry !== void 0 && { extensionRegistry },
+    ...fieldType !== void 0 && { fieldType },
+    ...checker !== void 0 && { checker },
+    ...subjectType !== void 0 && { subjectType },
+    ...hostType !== void 0 && { hostType }
+  };
+}
+function analyzeClassToIR(classDecl, checker, file = "", extensionRegistry) {
+  const name = classDecl.name?.text ?? "AnonymousClass";
+  const fields = [];
+  const fieldLayouts = [];
+  const typeRegistry = {};
+  const diagnostics = [];
+  const classType = checker.getTypeAtLocation(classDecl);
+  const classDoc = extractJSDocParseResult(
+    classDecl,
+    file,
+    makeParseOptions(extensionRegistry, void 0, checker, classType, classType)
+  );
+  const annotations = [...classDoc.annotations];
+  diagnostics.push(...classDoc.diagnostics);
+  const visiting = /* @__PURE__ */ new Set();
+  const instanceMethods = [];
+  const staticMethods = [];
+  for (const member of classDecl.members) {
+    if (ts3.isPropertyDeclaration(member)) {
+      const fieldNode = analyzeFieldToIR(
+        member,
+        checker,
+        file,
+        typeRegistry,
+        visiting,
+        diagnostics,
+        classType,
+        extensionRegistry
+      );
+      if (fieldNode) {
+        fields.push(fieldNode);
+        fieldLayouts.push({});
+      }
+    } else if (ts3.isMethodDeclaration(member)) {
+      const methodInfo = analyzeMethod(member, checker);
+      if (methodInfo) {
+        const isStatic = member.modifiers?.some((m) => m.kind === ts3.SyntaxKind.StaticKeyword);
+        if (isStatic) {
+          staticMethods.push(methodInfo);
+        } else {
+          instanceMethods.push(methodInfo);
+        }
+      }
+    }
+  }
+  return {
+    name,
+    fields,
+    fieldLayouts,
+    typeRegistry,
+    ...annotations.length > 0 && { annotations },
+    ...diagnostics.length > 0 && { diagnostics },
+    instanceMethods,
+    staticMethods
+  };
+}
+function analyzeInterfaceToIR(interfaceDecl, checker, file = "", extensionRegistry) {
+  const name = interfaceDecl.name.text;
+  const fields = [];
+  const typeRegistry = {};
+  const diagnostics = [];
+  const interfaceType = checker.getTypeAtLocation(interfaceDecl);
+  const interfaceDoc = extractJSDocParseResult(
+    interfaceDecl,
+    file,
+    makeParseOptions(extensionRegistry, void 0, checker, interfaceType, interfaceType)
+  );
+  const annotations = [...interfaceDoc.annotations];
+  diagnostics.push(...interfaceDoc.diagnostics);
+  const visiting = /* @__PURE__ */ new Set();
+  for (const member of interfaceDecl.members) {
+    if (ts3.isPropertySignature(member)) {
+      const fieldNode = analyzeInterfacePropertyToIR(
+        member,
+        checker,
+        file,
+        typeRegistry,
+        visiting,
+        diagnostics,
+        interfaceType,
+        extensionRegistry
+      );
+      if (fieldNode) {
+        fields.push(fieldNode);
+      }
+    }
+  }
+  const fieldLayouts = fields.map(() => ({}));
+  return {
+    name,
+    fields,
+    fieldLayouts,
+    typeRegistry,
+    ...annotations.length > 0 && { annotations },
+    ...diagnostics.length > 0 && { diagnostics },
+    instanceMethods: [],
+    staticMethods: []
+  };
+}
+function analyzeTypeAliasToIR(typeAlias, checker, file = "", extensionRegistry) {
+  if (!ts3.isTypeLiteralNode(typeAlias.type)) {
+    const sourceFile = typeAlias.getSourceFile();
+    const { line } = sourceFile.getLineAndCharacterOfPosition(typeAlias.getStart());
+    const kindDesc = ts3.SyntaxKind[typeAlias.type.kind] ?? "unknown";
+    return {
+      ok: false,
+      error: `Type alias "${typeAlias.name.text}" at line ${String(line + 1)} is not an object type literal (found ${kindDesc})`
+    };
+  }
+  const name = typeAlias.name.text;
+  const fields = [];
+  const typeRegistry = {};
+  const diagnostics = [];
+  const aliasType = checker.getTypeAtLocation(typeAlias);
+  const typeAliasDoc = extractJSDocParseResult(
+    typeAlias,
+    file,
+    makeParseOptions(extensionRegistry, void 0, checker, aliasType, aliasType)
+  );
+  const annotations = [...typeAliasDoc.annotations];
+  diagnostics.push(...typeAliasDoc.diagnostics);
+  const visiting = /* @__PURE__ */ new Set();
+  for (const member of typeAlias.type.members) {
+    if (ts3.isPropertySignature(member)) {
+      const fieldNode = analyzeInterfacePropertyToIR(
+        member,
+        checker,
+        file,
+        typeRegistry,
+        visiting,
+        diagnostics,
+        aliasType,
+        extensionRegistry
+      );
+      if (fieldNode) {
+        fields.push(fieldNode);
+      }
+    }
+  }
+  return {
+    ok: true,
+    analysis: {
+      name,
+      fields,
+      fieldLayouts: fields.map(() => ({})),
+      typeRegistry,
+      ...annotations.length > 0 && { annotations },
+      ...diagnostics.length > 0 && { diagnostics },
+      instanceMethods: [],
+      staticMethods: []
+    }
+  };
+}
+function analyzeFieldToIR(prop, checker, file, typeRegistry, visiting, diagnostics, hostType, extensionRegistry) {
+  if (!ts3.isIdentifier(prop.name)) {
+    return null;
+  }
+  const name = prop.name.text;
+  const tsType = checker.getTypeAtLocation(prop);
+  const optional = prop.questionToken !== void 0;
+  const provenance = provenanceForNode(prop, file);
+  let type = resolveTypeNode(
+    tsType,
+    checker,
+    file,
+    typeRegistry,
+    visiting,
+    prop,
+    extensionRegistry,
+    diagnostics
+  );
+  const constraints = [];
+  if (prop.type && !shouldEmitPrimitiveAliasDefinition(prop.type, checker)) {
+    constraints.push(
+      ...extractTypeAliasConstraintNodes(prop.type, checker, file, extensionRegistry)
+    );
+  }
+  const docResult = extractJSDocParseResult(
+    prop,
+    file,
+    makeParseOptions(extensionRegistry, type, checker, tsType, hostType)
+  );
+  constraints.push(...docResult.constraints);
+  diagnostics.push(...docResult.diagnostics);
+  let annotations = [];
+  annotations.push(...docResult.annotations);
+  const defaultAnnotation = extractDefaultValueAnnotation(prop.initializer, file);
+  if (defaultAnnotation && !annotations.some((a) => a.annotationKind === "defaultValue")) {
+    annotations.push(defaultAnnotation);
+  }
+  ({ type, annotations } = applyEnumMemberDisplayNames(type, annotations));
+  return {
+    kind: "field",
+    name,
+    type,
+    required: !optional,
+    constraints,
+    annotations,
+    provenance
+  };
+}
+function analyzeInterfacePropertyToIR(prop, checker, file, typeRegistry, visiting, diagnostics, hostType, extensionRegistry) {
+  if (!ts3.isIdentifier(prop.name)) {
+    return null;
+  }
+  const name = prop.name.text;
+  const tsType = checker.getTypeAtLocation(prop);
+  const optional = prop.questionToken !== void 0;
+  const provenance = provenanceForNode(prop, file);
+  let type = resolveTypeNode(
+    tsType,
+    checker,
+    file,
+    typeRegistry,
+    visiting,
+    prop,
+    extensionRegistry,
+    diagnostics
+  );
+  const constraints = [];
+  if (prop.type && !shouldEmitPrimitiveAliasDefinition(prop.type, checker)) {
+    constraints.push(
+      ...extractTypeAliasConstraintNodes(prop.type, checker, file, extensionRegistry)
+    );
+  }
+  const docResult = extractJSDocParseResult(
+    prop,
+    file,
+    makeParseOptions(extensionRegistry, type, checker, tsType, hostType)
+  );
+  constraints.push(...docResult.constraints);
+  diagnostics.push(...docResult.diagnostics);
+  let annotations = [];
+  annotations.push(...docResult.annotations);
+  ({ type, annotations } = applyEnumMemberDisplayNames(type, annotations));
+  return {
+    kind: "field",
+    name,
+    type,
+    required: !optional,
+    constraints,
+    annotations,
+    provenance
+  };
+}
+function applyEnumMemberDisplayNames(type, annotations) {
+  if (!annotations.some(
+    (annotation) => annotation.annotationKind === "displayName" && annotation.value.trim().startsWith(":")
+  )) {
+    return { type, annotations: [...annotations] };
+  }
+  const consumed = /* @__PURE__ */ new Set();
+  const nextType = rewriteEnumDisplayNames(type, annotations, consumed);
+  if (consumed.size === 0) {
+    return { type, annotations: [...annotations] };
+  }
+  return {
+    type: nextType,
+    annotations: annotations.filter((annotation) => !consumed.has(annotation))
+  };
+}
+function rewriteEnumDisplayNames(type, annotations, consumed) {
+  switch (type.kind) {
+    case "enum":
+      return applyEnumMemberDisplayNamesToEnum(type, annotations, consumed);
+    case "union": {
+      return {
+        ...type,
+        members: type.members.map(
+          (member) => rewriteEnumDisplayNames(member, annotations, consumed)
+        )
+      };
+    }
+    default:
+      return type;
+  }
+}
+function applyEnumMemberDisplayNamesToEnum(type, annotations, consumed) {
+  const displayNames = /* @__PURE__ */ new Map();
+  for (const annotation of annotations) {
+    if (annotation.annotationKind !== "displayName") continue;
+    const parsed = parseEnumMemberDisplayName(annotation.value);
+    if (!parsed) continue;
+    consumed.add(annotation);
+    const member = type.members.find((m) => String(m.value) === parsed.value);
+    if (!member) continue;
+    displayNames.set(String(member.value), parsed.label);
+  }
+  if (displayNames.size === 0) {
+    return type;
+  }
+  return {
+    ...type,
+    members: type.members.map((member) => {
+      const displayName = displayNames.get(String(member.value));
+      return displayName !== void 0 ? { ...member, displayName } : member;
+    })
+  };
+}
+function parseEnumMemberDisplayName(value) {
+  const trimmed = value.trim();
+  const match = /^:([^\s]+)\s+([\s\S]+)$/.exec(trimmed);
+  if (!match?.[1] || !match[2]) return null;
+  const label = match[2].trim();
+  if (label === "") return null;
+  return { value: match[1], label };
+}
+function resolveRegisteredCustomType(sourceNode, extensionRegistry, checker) {
+  if (sourceNode === void 0 || extensionRegistry === void 0) {
+    return null;
+  }
+  const typeNode = extractTypeNodeFromSource(sourceNode);
+  if (typeNode === void 0) {
+    return null;
+  }
+  return resolveRegisteredCustomTypeFromTypeNode(typeNode, extensionRegistry, checker);
+}
+function resolveRegisteredCustomTypeFromTypeNode(typeNode, extensionRegistry, checker) {
+  if (ts3.isParenthesizedTypeNode(typeNode)) {
+    return resolveRegisteredCustomTypeFromTypeNode(typeNode.type, extensionRegistry, checker);
+  }
+  const typeName = getTypeNodeRegistrationName(typeNode);
+  if (typeName === null) {
+    return null;
+  }
+  const registration = extensionRegistry.findTypeByName(typeName);
+  if (registration !== void 0) {
+    return {
+      kind: "custom",
+      typeId: `${registration.extensionId}/${registration.registration.typeName}`,
+      payload: null
+    };
+  }
+  if (ts3.isTypeReferenceNode(typeNode) && ts3.isIdentifier(typeNode.typeName)) {
+    const aliasDecl = checker.getSymbolAtLocation(typeNode.typeName)?.declarations?.find(ts3.isTypeAliasDeclaration);
+    if (aliasDecl !== void 0) {
+      return resolveRegisteredCustomTypeFromTypeNode(aliasDecl.type, extensionRegistry, checker);
+    }
+  }
+  return null;
+}
+function extractTypeNodeFromSource(sourceNode) {
+  if (ts3.isPropertyDeclaration(sourceNode) || ts3.isPropertySignature(sourceNode) || ts3.isParameter(sourceNode) || ts3.isTypeAliasDeclaration(sourceNode)) {
+    return sourceNode.type;
+  }
+  if (ts3.isTypeNode(sourceNode)) {
+    return sourceNode;
+  }
+  return void 0;
+}
+function getTypeNodeRegistrationName(typeNode) {
+  if (ts3.isTypeReferenceNode(typeNode)) {
+    return ts3.isIdentifier(typeNode.typeName) ? typeNode.typeName.text : typeNode.typeName.right.text;
+  }
+  if (ts3.isParenthesizedTypeNode(typeNode)) {
+    return getTypeNodeRegistrationName(typeNode.type);
+  }
+  if (typeNode.kind === ts3.SyntaxKind.BigIntKeyword || typeNode.kind === ts3.SyntaxKind.StringKeyword || typeNode.kind === ts3.SyntaxKind.NumberKeyword || typeNode.kind === ts3.SyntaxKind.BooleanKeyword) {
+    return typeNode.getText();
+  }
+  return null;
+}
+function resolveTypeNode(type, checker, file, typeRegistry, visiting, sourceNode, extensionRegistry, diagnostics) {
+  const customType = resolveRegisteredCustomType(sourceNode, extensionRegistry, checker);
+  if (customType) {
+    return customType;
+  }
+  const primitiveAlias = tryResolveNamedPrimitiveAlias(
+    type,
+    checker,
+    file,
+    typeRegistry,
+    visiting,
+    sourceNode,
+    extensionRegistry,
+    diagnostics
+  );
+  if (primitiveAlias) {
+    return primitiveAlias;
+  }
+  if (type.flags & ts3.TypeFlags.String) {
+    return { kind: "primitive", primitiveKind: "string" };
+  }
+  if (type.flags & ts3.TypeFlags.Number) {
+    return { kind: "primitive", primitiveKind: "number" };
+  }
+  if (type.flags & (ts3.TypeFlags.BigInt | ts3.TypeFlags.BigIntLiteral)) {
+    return { kind: "primitive", primitiveKind: "bigint" };
+  }
+  if (type.flags & ts3.TypeFlags.Boolean) {
+    return { kind: "primitive", primitiveKind: "boolean" };
+  }
+  if (type.flags & ts3.TypeFlags.Null) {
+    return { kind: "primitive", primitiveKind: "null" };
+  }
+  if (type.flags & ts3.TypeFlags.Undefined) {
+    return { kind: "primitive", primitiveKind: "null" };
+  }
+  if (type.isStringLiteral()) {
+    return {
+      kind: "enum",
+      members: [{ value: type.value }]
+    };
+  }
+  if (type.isNumberLiteral()) {
+    return {
+      kind: "enum",
+      members: [{ value: type.value }]
+    };
+  }
+  if (type.isUnion()) {
+    return resolveUnionType(
+      type,
+      checker,
+      file,
+      typeRegistry,
+      visiting,
+      sourceNode,
+      extensionRegistry,
+      diagnostics
+    );
+  }
+  if (checker.isArrayType(type)) {
+    return resolveArrayType(
+      type,
+      checker,
+      file,
+      typeRegistry,
+      visiting,
+      sourceNode,
+      extensionRegistry,
+      diagnostics
+    );
+  }
+  if (isObjectType(type)) {
+    return resolveObjectType(
+      type,
+      checker,
+      file,
+      typeRegistry,
+      visiting,
+      extensionRegistry,
+      diagnostics
+    );
+  }
+  return { kind: "primitive", primitiveKind: "string" };
+}
+function tryResolveNamedPrimitiveAlias(type, checker, file, typeRegistry, visiting, sourceNode, extensionRegistry, diagnostics) {
+  if (!(type.flags & (ts3.TypeFlags.String | ts3.TypeFlags.Number | ts3.TypeFlags.BigInt | ts3.TypeFlags.BigIntLiteral | ts3.TypeFlags.Boolean | ts3.TypeFlags.Null))) {
+    return null;
+  }
+  const aliasDecl = type.aliasSymbol?.declarations?.find(ts3.isTypeAliasDeclaration) ?? getReferencedTypeAliasDeclaration(sourceNode, checker);
+  if (!aliasDecl) {
+    return null;
+  }
+  const aliasName = aliasDecl.name.text;
+  if (!typeRegistry[aliasName]) {
+    const aliasType = checker.getTypeFromTypeNode(aliasDecl.type);
+    const constraints = [
+      ...extractJSDocConstraintNodes(aliasDecl, file, makeParseOptions(extensionRegistry)),
+      ...extractTypeAliasConstraintNodes(aliasDecl.type, checker, file, extensionRegistry)
+    ];
+    const annotations = extractJSDocAnnotationNodes(
+      aliasDecl,
+      file,
+      makeParseOptions(extensionRegistry)
+    );
+    typeRegistry[aliasName] = {
+      name: aliasName,
+      type: resolveAliasedPrimitiveTarget(
+        aliasType,
+        checker,
+        file,
+        typeRegistry,
+        visiting,
+        extensionRegistry,
+        diagnostics
+      ),
+      ...constraints.length > 0 && { constraints },
+      ...annotations.length > 0 && { annotations },
+      provenance: provenanceForDeclaration(aliasDecl, file)
+    };
+  }
+  return { kind: "reference", name: aliasName, typeArguments: [] };
+}
+function getReferencedTypeAliasDeclaration(sourceNode, checker) {
+  const typeNode = sourceNode && (ts3.isPropertyDeclaration(sourceNode) || ts3.isPropertySignature(sourceNode) || ts3.isParameter(sourceNode)) ? sourceNode.type : void 0;
+  if (!typeNode || !ts3.isTypeReferenceNode(typeNode)) {
+    return void 0;
+  }
+  return checker.getSymbolAtLocation(typeNode.typeName)?.declarations?.find(ts3.isTypeAliasDeclaration);
+}
+function shouldEmitPrimitiveAliasDefinition(typeNode, checker) {
+  if (!ts3.isTypeReferenceNode(typeNode)) {
+    return false;
+  }
+  const aliasDecl = checker.getSymbolAtLocation(typeNode.typeName)?.declarations?.find(ts3.isTypeAliasDeclaration);
+  if (!aliasDecl) {
+    return false;
+  }
+  const resolved = checker.getTypeFromTypeNode(aliasDecl.type);
+  return !!(resolved.flags & (ts3.TypeFlags.String | ts3.TypeFlags.Number | ts3.TypeFlags.BigInt | ts3.TypeFlags.BigIntLiteral | ts3.TypeFlags.Boolean | ts3.TypeFlags.Null));
+}
+function resolveAliasedPrimitiveTarget(type, checker, file, typeRegistry, visiting, extensionRegistry, diagnostics) {
+  const nestedAliasDecl = type.aliasSymbol?.declarations?.find(ts3.isTypeAliasDeclaration);
+  if (nestedAliasDecl !== void 0) {
+    return resolveAliasedPrimitiveTarget(
+      checker.getTypeFromTypeNode(nestedAliasDecl.type),
+      checker,
+      file,
+      typeRegistry,
+      visiting,
+      extensionRegistry,
+      diagnostics
+    );
+  }
+  return resolveTypeNode(
+    type,
+    checker,
+    file,
+    typeRegistry,
+    visiting,
+    void 0,
+    extensionRegistry,
+    diagnostics
+  );
+}
+function resolveUnionType(type, checker, file, typeRegistry, visiting, sourceNode, extensionRegistry, diagnostics) {
+  const typeName = getNamedTypeName(type);
+  const namedDecl = getNamedTypeDeclaration(type);
+  if (typeName && typeName in typeRegistry) {
+    return { kind: "reference", name: typeName, typeArguments: [] };
+  }
+  const allTypes = type.types;
+  const unionMemberTypeNodes = extractUnionMemberTypeNodes(sourceNode, checker);
+  const nonNullSourceNodes = unionMemberTypeNodes.filter(
+    (memberTypeNode) => !isNullishTypeNode(resolveAliasedTypeNode(memberTypeNode, checker))
+  );
+  const nonNullTypes = allTypes.filter(
+    (memberType) => !(memberType.flags & (ts3.TypeFlags.Null | ts3.TypeFlags.Undefined))
+  );
+  const nonNullMembers = nonNullTypes.map((memberType, index) => ({
+    memberType,
+    sourceNode: nonNullSourceNodes.length === nonNullTypes.length ? nonNullSourceNodes[index] : void 0
+  }));
+  const hasNull = allTypes.some((t) => t.flags & ts3.TypeFlags.Null);
+  const memberDisplayNames = /* @__PURE__ */ new Map();
+  if (namedDecl) {
+    for (const [value, label] of extractDisplayNameMetadata(namedDecl).memberDisplayNames) {
+      memberDisplayNames.set(value, label);
+    }
+  }
+  if (sourceNode) {
+    for (const [value, label] of extractDisplayNameMetadata(sourceNode).memberDisplayNames) {
+      memberDisplayNames.set(value, label);
+    }
+  }
+  const registerNamed = (result) => {
+    if (!typeName) {
+      return result;
+    }
+    const annotations = namedDecl ? extractJSDocAnnotationNodes(namedDecl, file, makeParseOptions(extensionRegistry)) : void 0;
+    typeRegistry[typeName] = {
+      name: typeName,
+      type: result,
+      ...annotations !== void 0 && annotations.length > 0 && { annotations },
+      provenance: provenanceForDeclaration(namedDecl ?? sourceNode, file)
+    };
+    return { kind: "reference", name: typeName, typeArguments: [] };
+  };
+  const applyMemberLabels = (members2) => members2.map((value) => {
+    const displayName = memberDisplayNames.get(String(value));
+    return displayName !== void 0 ? { value, displayName } : { value };
+  });
+  const isBooleanUnion2 = nonNullTypes.length === 2 && nonNullTypes.every((t) => t.flags & ts3.TypeFlags.BooleanLiteral);
+  if (isBooleanUnion2) {
+    const boolNode = { kind: "primitive", primitiveKind: "boolean" };
+    const result = hasNull ? {
+      kind: "union",
+      members: [boolNode, { kind: "primitive", primitiveKind: "null" }]
+    } : boolNode;
+    return registerNamed(result);
+  }
+  const allStringLiterals = nonNullTypes.every((t) => t.isStringLiteral());
+  if (allStringLiterals && nonNullTypes.length > 0) {
+    const stringTypes = nonNullTypes.filter((t) => t.isStringLiteral());
+    const enumNode = {
+      kind: "enum",
+      members: applyMemberLabels(stringTypes.map((t) => t.value))
+    };
+    const result = hasNull ? {
+      kind: "union",
+      members: [enumNode, { kind: "primitive", primitiveKind: "null" }]
+    } : enumNode;
+    return registerNamed(result);
+  }
+  const allNumberLiterals = nonNullTypes.every((t) => t.isNumberLiteral());
+  if (allNumberLiterals && nonNullTypes.length > 0) {
+    const numberTypes = nonNullTypes.filter((t) => t.isNumberLiteral());
+    const enumNode = {
+      kind: "enum",
+      members: applyMemberLabels(numberTypes.map((t) => t.value))
+    };
+    const result = hasNull ? {
+      kind: "union",
+      members: [enumNode, { kind: "primitive", primitiveKind: "null" }]
+    } : enumNode;
+    return registerNamed(result);
+  }
+  if (nonNullMembers.length === 1 && nonNullMembers[0]) {
+    const inner = resolveTypeNode(
+      nonNullMembers[0].memberType,
+      checker,
+      file,
+      typeRegistry,
+      visiting,
+      nonNullMembers[0].sourceNode ?? sourceNode,
+      extensionRegistry,
+      diagnostics
+    );
+    const result = hasNull ? {
+      kind: "union",
+      members: [inner, { kind: "primitive", primitiveKind: "null" }]
+    } : inner;
+    return registerNamed(result);
+  }
+  const members = nonNullMembers.map(
+    ({ memberType, sourceNode: memberSourceNode }) => resolveTypeNode(
+      memberType,
+      checker,
+      file,
+      typeRegistry,
+      visiting,
+      memberSourceNode ?? sourceNode,
+      extensionRegistry,
+      diagnostics
+    )
+  );
+  if (hasNull) {
+    members.push({ kind: "primitive", primitiveKind: "null" });
+  }
+  return registerNamed({ kind: "union", members });
+}
+function resolveArrayType(type, checker, file, typeRegistry, visiting, sourceNode, extensionRegistry, diagnostics) {
+  const typeArgs = isTypeReference(type) ? type.typeArguments : void 0;
+  const elementType = typeArgs?.[0];
+  const elementSourceNode = extractArrayElementTypeNode(sourceNode, checker);
+  const items = elementType ? resolveTypeNode(
+    elementType,
+    checker,
+    file,
+    typeRegistry,
+    visiting,
+    elementSourceNode,
+    extensionRegistry,
+    diagnostics
+  ) : { kind: "primitive", primitiveKind: "string" };
+  return { kind: "array", items };
+}
+function tryResolveRecordType(type, checker, file, typeRegistry, visiting, extensionRegistry, diagnostics) {
+  if (type.getProperties().length > 0) {
+    return null;
+  }
+  const indexInfo = checker.getIndexInfoOfType(type, ts3.IndexKind.String);
+  if (!indexInfo) {
+    return null;
+  }
+  const valueType = resolveTypeNode(
+    indexInfo.type,
+    checker,
+    file,
+    typeRegistry,
+    visiting,
+    void 0,
+    extensionRegistry,
+    diagnostics
+  );
+  return { kind: "record", valueType };
+}
+function typeNodeContainsReference(type, targetName) {
+  switch (type.kind) {
+    case "reference":
+      return type.name === targetName;
+    case "array":
+      return typeNodeContainsReference(type.items, targetName);
+    case "record":
+      return typeNodeContainsReference(type.valueType, targetName);
+    case "union":
+      return type.members.some((member) => typeNodeContainsReference(member, targetName));
+    case "object":
+      return type.properties.some(
+        (property) => typeNodeContainsReference(property.type, targetName)
+      );
+    case "primitive":
+    case "enum":
+    case "dynamic":
+    case "custom":
+      return false;
+    default: {
+      const _exhaustive = type;
+      return _exhaustive;
+    }
+  }
+}
+function resolveObjectType(type, checker, file, typeRegistry, visiting, extensionRegistry, diagnostics) {
+  const typeName = getNamedTypeName(type);
+  const namedTypeName = typeName ?? void 0;
+  const namedDecl = getNamedTypeDeclaration(type);
+  const shouldRegisterNamedType = namedTypeName !== void 0 && !(namedTypeName === "Record" && namedDecl?.getSourceFile().fileName !== file);
+  const clearNamedTypeRegistration = () => {
+    if (namedTypeName === void 0 || !shouldRegisterNamedType) {
+      return;
+    }
+    Reflect.deleteProperty(typeRegistry, namedTypeName);
+  };
+  if (visiting.has(type)) {
+    if (namedTypeName !== void 0 && shouldRegisterNamedType) {
+      return { kind: "reference", name: namedTypeName, typeArguments: [] };
+    }
+    return { kind: "object", properties: [], additionalProperties: false };
+  }
+  if (namedTypeName !== void 0 && shouldRegisterNamedType && !typeRegistry[namedTypeName]) {
+    typeRegistry[namedTypeName] = {
+      name: namedTypeName,
+      type: RESOLVING_TYPE_PLACEHOLDER,
+      provenance: provenanceForDeclaration(namedDecl, file)
+    };
+  }
+  visiting.add(type);
+  if (namedTypeName !== void 0 && shouldRegisterNamedType && typeRegistry[namedTypeName]?.type !== void 0) {
+    if (typeRegistry[namedTypeName].type !== RESOLVING_TYPE_PLACEHOLDER) {
+      visiting.delete(type);
+      return { kind: "reference", name: namedTypeName, typeArguments: [] };
+    }
+  }
+  const recordNode = tryResolveRecordType(
+    type,
+    checker,
+    file,
+    typeRegistry,
+    visiting,
+    extensionRegistry,
+    diagnostics
+  );
+  if (recordNode) {
+    visiting.delete(type);
+    if (namedTypeName !== void 0 && shouldRegisterNamedType) {
+      const isRecursiveRecord = typeNodeContainsReference(recordNode.valueType, namedTypeName);
+      if (!isRecursiveRecord) {
+        clearNamedTypeRegistration();
+        return recordNode;
+      }
+      const annotations = namedDecl ? extractJSDocAnnotationNodes(namedDecl, file, makeParseOptions(extensionRegistry)) : void 0;
+      typeRegistry[namedTypeName] = {
+        name: namedTypeName,
+        type: recordNode,
+        ...annotations !== void 0 && annotations.length > 0 && { annotations },
+        provenance: provenanceForDeclaration(namedDecl, file)
+      };
+      return { kind: "reference", name: namedTypeName, typeArguments: [] };
+    }
+    return recordNode;
+  }
+  const properties = [];
+  const fieldInfoMap = getNamedTypeFieldNodeInfoMap(
+    type,
+    checker,
+    file,
+    typeRegistry,
+    visiting,
+    diagnostics ?? [],
+    extensionRegistry
+  );
+  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 & ts3.SymbolFlags.Optional);
+    const propTypeNode = resolveTypeNode(
+      propType,
+      checker,
+      file,
+      typeRegistry,
+      visiting,
+      declaration,
+      extensionRegistry,
+      diagnostics
+    );
+    const fieldNodeInfo = fieldInfoMap?.get(prop.name);
+    properties.push({
+      name: prop.name,
+      type: propTypeNode,
+      optional,
+      constraints: fieldNodeInfo?.constraints ?? [],
+      annotations: fieldNodeInfo?.annotations ?? [],
+      provenance: fieldNodeInfo?.provenance ?? provenanceForFile(file)
+    });
+  }
+  visiting.delete(type);
+  const objectNode = {
+    kind: "object",
+    properties,
+    additionalProperties: true
+  };
+  if (namedTypeName !== void 0 && shouldRegisterNamedType) {
+    const annotations = namedDecl ? extractJSDocAnnotationNodes(namedDecl, file, makeParseOptions(extensionRegistry)) : void 0;
+    typeRegistry[namedTypeName] = {
+      name: namedTypeName,
+      type: objectNode,
+      ...annotations !== void 0 && annotations.length > 0 && { annotations },
+      provenance: provenanceForDeclaration(namedDecl, file)
+    };
+    return { kind: "reference", name: namedTypeName, typeArguments: [] };
+  }
+  return objectNode;
+}
+function getNamedTypeFieldNodeInfoMap(type, checker, file, typeRegistry, visiting, diagnostics, extensionRegistry) {
+  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(ts3.isClassDeclaration);
+    if (classDecl) {
+      const map = /* @__PURE__ */ new Map();
+      const hostType = checker.getTypeAtLocation(classDecl);
+      for (const member of classDecl.members) {
+        if (ts3.isPropertyDeclaration(member) && ts3.isIdentifier(member.name)) {
+          const fieldNode = analyzeFieldToIR(
+            member,
+            checker,
+            file,
+            typeRegistry,
+            visiting,
+            diagnostics,
+            hostType,
+            extensionRegistry
+          );
+          if (fieldNode) {
+            map.set(fieldNode.name, {
+              constraints: [...fieldNode.constraints],
+              annotations: [...fieldNode.annotations],
+              provenance: fieldNode.provenance
+            });
+          }
+        }
+      }
+      return map;
+    }
+    const interfaceDecl = declarations.find(ts3.isInterfaceDeclaration);
+    if (interfaceDecl) {
+      return buildFieldNodeInfoMap(
+        interfaceDecl.members,
+        checker,
+        file,
+        typeRegistry,
+        visiting,
+        checker.getTypeAtLocation(interfaceDecl),
+        diagnostics,
+        extensionRegistry
+      );
+    }
+    const typeAliasDecl = declarations.find(ts3.isTypeAliasDeclaration);
+    if (typeAliasDecl && ts3.isTypeLiteralNode(typeAliasDecl.type)) {
+      return buildFieldNodeInfoMap(
+        typeAliasDecl.type.members,
+        checker,
+        file,
+        typeRegistry,
+        visiting,
+        checker.getTypeAtLocation(typeAliasDecl),
+        diagnostics,
+        extensionRegistry
+      );
+    }
+  }
+  return null;
+}
+function extractArrayElementTypeNode(sourceNode, checker) {
+  const typeNode = sourceNode === void 0 ? void 0 : extractTypeNodeFromSource(sourceNode);
+  if (typeNode === void 0) {
+    return void 0;
+  }
+  const resolvedTypeNode = resolveAliasedTypeNode(typeNode, checker);
+  if (ts3.isArrayTypeNode(resolvedTypeNode)) {
+    return resolvedTypeNode.elementType;
+  }
+  if (ts3.isTypeReferenceNode(resolvedTypeNode) && ts3.isIdentifier(resolvedTypeNode.typeName) && resolvedTypeNode.typeName.text === "Array" && resolvedTypeNode.typeArguments?.[0]) {
+    return resolvedTypeNode.typeArguments[0];
+  }
+  return void 0;
+}
+function extractUnionMemberTypeNodes(sourceNode, checker) {
+  const typeNode = sourceNode === void 0 ? void 0 : extractTypeNodeFromSource(sourceNode);
+  if (!typeNode) {
+    return [];
+  }
+  const resolvedTypeNode = resolveAliasedTypeNode(typeNode, checker);
+  return ts3.isUnionTypeNode(resolvedTypeNode) ? [...resolvedTypeNode.types] : [];
+}
+function resolveAliasedTypeNode(typeNode, checker, visited = /* @__PURE__ */ new Set()) {
+  if (ts3.isParenthesizedTypeNode(typeNode)) {
+    return resolveAliasedTypeNode(typeNode.type, checker, visited);
+  }
+  if (!ts3.isTypeReferenceNode(typeNode) || !ts3.isIdentifier(typeNode.typeName)) {
+    return typeNode;
+  }
+  const symbol = checker.getSymbolAtLocation(typeNode.typeName);
+  const aliasDecl = symbol?.declarations?.find(ts3.isTypeAliasDeclaration);
+  if (aliasDecl === void 0 || visited.has(aliasDecl)) {
+    return typeNode;
+  }
+  visited.add(aliasDecl);
+  return resolveAliasedTypeNode(aliasDecl.type, checker, visited);
+}
+function isNullishTypeNode(typeNode) {
+  if (typeNode.kind === ts3.SyntaxKind.NullKeyword || typeNode.kind === ts3.SyntaxKind.UndefinedKeyword) {
+    return true;
+  }
+  return ts3.isLiteralTypeNode(typeNode) && (typeNode.literal.kind === ts3.SyntaxKind.NullKeyword || typeNode.literal.kind === ts3.SyntaxKind.UndefinedKeyword);
+}
+function buildFieldNodeInfoMap(members, checker, file, typeRegistry, visiting, hostType, diagnostics, extensionRegistry) {
+  const map = /* @__PURE__ */ new Map();
+  for (const member of members) {
+    if (ts3.isPropertySignature(member)) {
+      const fieldNode = analyzeInterfacePropertyToIR(
+        member,
+        checker,
+        file,
+        typeRegistry,
+        visiting,
+        diagnostics,
+        hostType,
+        extensionRegistry
+      );
+      if (fieldNode) {
+        map.set(fieldNode.name, {
+          constraints: [...fieldNode.constraints],
+          annotations: [...fieldNode.annotations],
+          provenance: fieldNode.provenance
+        });
+      }
+    }
+  }
+  return map;
+}
+function extractTypeAliasConstraintNodes(typeNode, checker, file, extensionRegistry, depth = 0) {
+  if (!ts3.isTypeReferenceNode(typeNode)) return [];
+  if (depth >= MAX_ALIAS_CHAIN_DEPTH) {
+    const aliasName = typeNode.typeName.getText();
+    throw new Error(
+      `Type alias chain exceeds maximum depth of ${String(MAX_ALIAS_CHAIN_DEPTH)} at alias "${aliasName}" in ${file}. Simplify the alias chain or check for circular references.`
+    );
+  }
+  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 [];
+  const aliasFieldType = resolveTypeNode(
+    checker.getTypeAtLocation(aliasDecl.type),
+    checker,
+    file,
+    {},
+    /* @__PURE__ */ new Set(),
+    aliasDecl.type,
+    extensionRegistry
+  );
+  const constraints = extractJSDocConstraintNodes(
+    aliasDecl,
+    file,
+    makeParseOptions(extensionRegistry, aliasFieldType)
+  );
+  constraints.push(
+    ...extractTypeAliasConstraintNodes(aliasDecl.type, checker, file, extensionRegistry, depth + 1)
+  );
+  return constraints;
+}
+function provenanceForNode(node, file) {
+  const sourceFile = node.getSourceFile();
+  const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+  return {
+    surface: "tsdoc",
+    file,
+    line: line + 1,
+    column: character
+  };
+}
+function provenanceForFile(file) {
+  return { surface: "tsdoc", file, line: 0, column: 0 };
+}
+function provenanceForDeclaration(node, file) {
+  if (!node) {
+    return provenanceForFile(file);
+  }
+  return provenanceForNode(node, file);
+}
+function getNamedTypeName(type) {
+  const symbol = type.getSymbol();
+  if (symbol?.declarations) {
+    const decl = symbol.declarations[0];
+    if (decl && (ts3.isClassDeclaration(decl) || ts3.isInterfaceDeclaration(decl) || ts3.isTypeAliasDeclaration(decl))) {
+      const name = ts3.isClassDeclaration(decl) ? decl.name?.text : decl.name.text;
+      if (name) return name;
+    }
+  }
+  const aliasSymbol = type.aliasSymbol;
+  if (aliasSymbol?.declarations) {
+    const aliasDecl = aliasSymbol.declarations.find(ts3.isTypeAliasDeclaration);
+    if (aliasDecl) {
+      return aliasDecl.name.text;
+    }
+  }
+  return null;
+}
+function getNamedTypeDeclaration(type) {
+  const symbol = type.getSymbol();
+  if (symbol?.declarations) {
+    const decl = symbol.declarations[0];
+    if (decl && (ts3.isClassDeclaration(decl) || ts3.isInterfaceDeclaration(decl) || ts3.isTypeAliasDeclaration(decl))) {
+      return decl;
+    }
+  }
+  const aliasSymbol = type.aliasSymbol;
+  if (aliasSymbol?.declarations) {
+    return aliasSymbol.declarations.find(ts3.isTypeAliasDeclaration);
+  }
+  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;
+}
+var ts3, RESOLVING_TYPE_PLACEHOLDER, MAX_ALIAS_CHAIN_DEPTH;
+var init_class_analyzer = __esm({
+  "src/analyzer/class-analyzer.ts"() {
+    "use strict";
+    ts3 = __toESM(require("typescript"), 1);
+    init_jsdoc_constraints();
+    init_tsdoc_parser();
+    RESOLVING_TYPE_PLACEHOLDER = {
+      kind: "object",
+      properties: [],
+      additionalProperties: true
+    };
+    MAX_ALIAS_CHAIN_DEPTH = 8;
+  }
+});
+
+// src/analyzer/program.ts
+function createProgramContext(filePath) {
+  const absolutePath = path.resolve(filePath);
+  const fileDir = path.dirname(absolutePath);
+  const configPath = ts4.findConfigFile(fileDir, ts4.sys.fileExists.bind(ts4.sys), "tsconfig.json");
+  let compilerOptions;
+  let fileNames;
+  if (configPath) {
+    const configFile = ts4.readConfigFile(configPath, ts4.sys.readFile.bind(ts4.sys));
+    if (configFile.error) {
+      throw new Error(
+        `Error reading tsconfig.json: ${ts4.flattenDiagnosticMessageText(configFile.error.messageText, "\n")}`
+      );
+    }
+    const parsed = ts4.parseJsonConfigFileContent(
+      configFile.config,
+      ts4.sys,
+      path.dirname(configPath)
+    );
+    if (parsed.errors.length > 0) {
+      const errorMessages = parsed.errors.map((e) => ts4.flattenDiagnosticMessageText(e.messageText, "\n")).join("\n");
+      throw new Error(`Error parsing tsconfig.json: ${errorMessages}`);
+    }
+    compilerOptions = parsed.options;
+    fileNames = parsed.fileNames.includes(absolutePath) ? parsed.fileNames : [...parsed.fileNames, absolutePath];
+  } else {
+    compilerOptions = {
+      target: ts4.ScriptTarget.ES2022,
+      module: ts4.ModuleKind.NodeNext,
+      moduleResolution: ts4.ModuleResolutionKind.NodeNext,
+      strict: true,
+      skipLibCheck: true,
+      declaration: true
+    };
+    fileNames = [absolutePath];
+  }
+  const program = ts4.createProgram(fileNames, compilerOptions);
+  const sourceFile = program.getSourceFile(absolutePath);
+  if (!sourceFile) {
+    throw new Error(`Could not find source file: ${absolutePath}`);
+  }
+  return {
+    program,
+    checker: program.getTypeChecker(),
+    sourceFile
+  };
+}
+function findNodeByName(sourceFile, name, predicate, getName) {
+  let result = null;
+  function visit(node) {
+    if (result) return;
+    if (predicate(node) && getName(node) === name) {
+      result = node;
+      return;
+    }
+    ts4.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return result;
+}
+function findClassByName(sourceFile, className) {
+  return findNodeByName(sourceFile, className, ts4.isClassDeclaration, (n) => n.name?.text);
+}
+function findInterfaceByName(sourceFile, interfaceName) {
+  return findNodeByName(sourceFile, interfaceName, ts4.isInterfaceDeclaration, (n) => n.name.text);
+}
+function findTypeAliasByName(sourceFile, aliasName) {
+  return findNodeByName(sourceFile, aliasName, ts4.isTypeAliasDeclaration, (n) => n.name.text);
+}
+function analyzeNamedTypeToIR(filePath, typeName, extensionRegistry) {
+  const ctx = createProgramContext(filePath);
+  const classDecl = findClassByName(ctx.sourceFile, typeName);
+  if (classDecl !== null) {
+    return analyzeClassToIR(classDecl, ctx.checker, filePath, extensionRegistry);
+  }
+  const interfaceDecl = findInterfaceByName(ctx.sourceFile, typeName);
+  if (interfaceDecl !== null) {
+    return analyzeInterfaceToIR(interfaceDecl, ctx.checker, filePath, extensionRegistry);
+  }
+  const typeAlias = findTypeAliasByName(ctx.sourceFile, typeName);
+  if (typeAlias !== null) {
+    const result = analyzeTypeAliasToIR(typeAlias, ctx.checker, filePath, extensionRegistry);
+    if (result.ok) {
+      return result.analysis;
+    }
+    throw new Error(result.error);
+  }
+  throw new Error(
+    `Type "${typeName}" not found as a class, interface, or type alias in ${filePath}`
+  );
+}
+var ts4, path;
+var init_program = __esm({
+  "src/analyzer/program.ts"() {
+    "use strict";
+    ts4 = __toESM(require("typescript"), 1);
+    path = __toESM(require("path"), 1);
+    init_class_analyzer();
+  }
+});
+
+// src/validate/constraint-validator.ts
+function validateFieldNode(ctx, field) {
+  const analysis = (0, import_internal2.analyzeConstraintTargets)(
+    field.name,
+    field.type,
+    field.constraints,
+    ctx.typeRegistry,
+    ctx.extensionRegistry === void 0 ? void 0 : {
+      extensionRegistry: ctx.extensionRegistry
+    }
+  );
+  ctx.diagnostics.push(...analysis.diagnostics);
+  if (field.type.kind === "object") {
+    for (const property of field.type.properties) {
+      validateObjectProperty(ctx, field.name, property);
+    }
+  }
+}
+function validateObjectProperty(ctx, parentName, property) {
+  const qualifiedName = `${parentName}.${property.name}`;
+  const analysis = (0, import_internal2.analyzeConstraintTargets)(
+    qualifiedName,
+    property.type,
+    property.constraints,
+    ctx.typeRegistry,
+    ctx.extensionRegistry === void 0 ? void 0 : {
+      extensionRegistry: ctx.extensionRegistry
+    }
+  );
+  ctx.diagnostics.push(...analysis.diagnostics);
+  if (property.type.kind === "object") {
+    for (const nestedProperty of property.type.properties) {
+      validateObjectProperty(ctx, qualifiedName, nestedProperty);
+    }
+  }
+}
+function validateElement(ctx, element) {
+  switch (element.kind) {
+    case "field":
+      validateFieldNode(ctx, element);
+      break;
+    case "group":
+      for (const child of element.elements) {
+        validateElement(ctx, child);
+      }
+      break;
+    case "conditional":
+      for (const child of element.elements) {
+        validateElement(ctx, child);
+      }
+      break;
+    default: {
+      const exhaustive = element;
+      throw new Error(`Unhandled element kind: ${String(exhaustive)}`);
+    }
+  }
+}
+function validateIR(ir, options) {
+  const ctx = {
+    diagnostics: [],
+    extensionRegistry: options?.extensionRegistry,
+    typeRegistry: ir.typeRegistry
+  };
+  for (const element of ir.elements) {
+    validateElement(ctx, element);
+  }
+  return {
+    diagnostics: ctx.diagnostics,
+    valid: ctx.diagnostics.every((diagnostic) => diagnostic.severity !== "error")
+  };
+}
+var import_internal2;
+var init_constraint_validator = __esm({
+  "src/validate/constraint-validator.ts"() {
+    "use strict";
+    import_internal2 = require("@formspec/analysis/internal");
+  }
+});
+
+// src/validate/index.ts
+var init_validate = __esm({
+  "src/validate/index.ts"() {
+    "use strict";
+    init_constraint_validator();
+  }
+});
+
+// src/generators/class-schema.ts
+function generateClassSchemas(analysis, source, options) {
+  const errorDiagnostics = analysis.diagnostics?.filter(
+    (diagnostic) => diagnostic.severity === "error"
+  );
+  if (errorDiagnostics !== void 0 && errorDiagnostics.length > 0) {
+    throw new Error(formatValidationError(errorDiagnostics));
+  }
+  const ir = canonicalizeTSDoc(analysis, source);
+  const validationResult = validateIR(ir, {
+    ...options?.extensionRegistry !== void 0 && {
+      extensionRegistry: options.extensionRegistry
+    },
+    ...options?.vendorPrefix !== void 0 && { vendorPrefix: options.vendorPrefix }
+  });
+  if (!validationResult.valid) {
+    throw new Error(formatValidationError(validationResult.diagnostics));
+  }
+  return {
+    jsonSchema: generateJsonSchemaFromIR(ir, options),
+    uiSchema: generateUiSchemaFromIR(ir)
+  };
+}
+function formatValidationError(diagnostics) {
+  const lines = diagnostics.map((diagnostic) => {
+    const primary = formatLocation(diagnostic.primaryLocation);
+    const related = diagnostic.relatedLocations.length > 0 ? ` [related: ${diagnostic.relatedLocations.map(formatLocation).join(", ")}]` : "";
+    return `${diagnostic.code}: ${diagnostic.message} (${primary})${related}`;
+  });
+  return `FormSpec validation failed:
+${lines.map((line) => `- ${line}`).join("\n")}`;
+}
+function formatLocation(location) {
+  return `${location.file}:${String(location.line)}:${String(location.column)}`;
+}
+function generateSchemasFromClass(options) {
+  const ctx = createProgramContext(options.filePath);
+  const classDecl = findClassByName(ctx.sourceFile, options.className);
+  if (!classDecl) {
+    throw new Error(`Class "${options.className}" not found in ${options.filePath}`);
+  }
+  const analysis = analyzeClassToIR(
+    classDecl,
+    ctx.checker,
+    options.filePath,
+    options.extensionRegistry
+  );
+  return generateClassSchemas(
+    analysis,
+    { file: options.filePath },
+    {
+      extensionRegistry: options.extensionRegistry,
+      vendorPrefix: options.vendorPrefix
+    }
+  );
+}
+function generateSchemas(options) {
+  const analysis = analyzeNamedTypeToIR(
+    options.filePath,
+    options.typeName,
+    options.extensionRegistry
+  );
+  return generateClassSchemas(analysis, { file: options.filePath }, options);
+}
+var init_class_schema = __esm({
+  "src/generators/class-schema.ts"() {
+    "use strict";
+    init_program();
+    init_class_analyzer();
+    init_canonicalize();
+    init_ir_generator();
+    init_ir_generator2();
+    init_validate();
+  }
+});
+
+// src/generators/mixed-authoring.ts
+function buildMixedAuthoringSchemas(options) {
+  const { filePath, typeName, overlays, ...schemaOptions } = options;
+  const analysis = analyzeNamedTypeToIR(filePath, typeName, schemaOptions.extensionRegistry);
+  const composedAnalysis = composeAnalysisWithOverlays(analysis, overlays);
+  const ir = canonicalizeTSDoc(composedAnalysis, { file: filePath });
+  return {
+    jsonSchema: generateJsonSchemaFromIR(ir, schemaOptions),
+    uiSchema: generateUiSchemaFromIR(ir)
+  };
+}
+function composeAnalysisWithOverlays(analysis, overlays) {
+  const overlayIR = canonicalizeChainDSL(overlays);
+  const overlayFields = collectOverlayFields(overlayIR.elements);
+  if (overlayFields.length === 0) {
+    return analysis;
+  }
+  const overlayByName = /* @__PURE__ */ new Map();
+  for (const field of overlayFields) {
+    if (overlayByName.has(field.name)) {
+      throw new Error(`Mixed-authoring overlays define "${field.name}" more than once`);
+    }
+    overlayByName.set(field.name, field);
+  }
+  const mergedFields = [];
+  for (const baseField of analysis.fields) {
+    const overlayField = overlayByName.get(baseField.name);
+    if (overlayField === void 0) {
+      mergedFields.push(baseField);
+      continue;
+    }
+    mergedFields.push(mergeFieldOverlay(baseField, overlayField, analysis.typeRegistry));
+    overlayByName.delete(baseField.name);
+  }
+  if (overlayByName.size > 0) {
+    const unknownFields = [...overlayByName.keys()].sort().join(", ");
+    throw new Error(
+      `Mixed-authoring overlays reference fields that are not present in the static model: ${unknownFields}`
+    );
+  }
+  return {
+    ...analysis,
+    fields: mergedFields
+  };
+}
+function collectOverlayFields(elements) {
+  const fields = [];
+  for (const element of elements) {
+    switch (element.kind) {
+      case "field":
+        fields.push(element);
+        break;
+      case "group":
+        fields.push(...collectOverlayFields(element.elements));
+        break;
+      case "conditional":
+        fields.push(...collectOverlayFields(element.elements));
+        break;
+      default: {
+        const _exhaustive = element;
+        void _exhaustive;
+      }
+    }
+  }
+  return fields;
+}
+function mergeFieldOverlay(baseField, overlayField, typeRegistry) {
+  assertSupportedOverlayField(baseField, overlayField);
+  return {
+    ...baseField,
+    type: mergeFieldType(baseField, overlayField, typeRegistry),
+    annotations: mergeAnnotations(baseField.annotations, overlayField.annotations)
+  };
+}
+function assertSupportedOverlayField(baseField, overlayField) {
+  if (overlayField.constraints.length > 0) {
+    throw new Error(
+      `Mixed-authoring overlay for "${baseField.name}" cannot define constraints; keep constraints on the static model`
+    );
+  }
+  if (overlayField.required && !baseField.required) {
+    throw new Error(
+      `Mixed-authoring overlay for "${baseField.name}" cannot change requiredness; keep requiredness on the static model`
+    );
+  }
+}
+function mergeFieldType(baseField, overlayField, typeRegistry) {
+  const { type: baseType } = baseField;
+  const { type: overlayType } = overlayField;
+  if (overlayType.kind === "object" || overlayType.kind === "array") {
+    throw new Error(
+      `Mixed-authoring overlays do not support nested object or array overlays for "${baseField.name}"`
+    );
+  }
+  if (overlayType.kind === "dynamic") {
+    if (!isCompatibleDynamicOverlay(baseField, overlayField, typeRegistry)) {
+      throw new Error(
+        `Mixed-authoring overlay for "${baseField.name}" is incompatible with the static field type`
+      );
+    }
+    return overlayType;
+  }
+  if (!isSameStaticTypeShape(baseType, overlayType)) {
+    throw new Error(
+      `Mixed-authoring overlay for "${baseField.name}" must preserve the static field type`
+    );
+  }
+  return baseType;
+}
+function isCompatibleDynamicOverlay(baseField, overlayField, typeRegistry) {
+  const overlayType = overlayField.type;
+  if (overlayType.kind !== "dynamic") {
+    return false;
+  }
+  const resolvedBaseType = resolveReferenceType(baseField.type, typeRegistry);
+  if (resolvedBaseType === null) {
+    return false;
+  }
+  if (overlayType.dynamicKind === "enum") {
+    return resolvedBaseType.kind === "primitive" ? resolvedBaseType.primitiveKind === "string" : resolvedBaseType.kind === "enum";
+  }
+  return resolvedBaseType.kind === "object" || resolvedBaseType.kind === "record";
+}
+function resolveReferenceType(type, typeRegistry, seen = /* @__PURE__ */ new Set()) {
+  if (type.kind !== "reference") {
+    return type;
+  }
+  if (seen.has(type.name)) {
+    return null;
+  }
+  const definition = typeRegistry[type.name];
+  if (definition === void 0) {
+    return null;
+  }
+  seen.add(type.name);
+  return resolveReferenceType(definition.type, typeRegistry, seen);
+}
+function isSameStaticTypeShape(baseType, overlayType) {
+  if (baseType.kind !== overlayType.kind) {
+    return false;
+  }
+  switch (baseType.kind) {
+    case "primitive":
+      return overlayType.kind === "primitive" && baseType.primitiveKind === overlayType.primitiveKind;
+    case "enum":
+      return overlayType.kind === "enum";
+    case "dynamic":
+      return overlayType.kind === "dynamic" && baseType.dynamicKind === overlayType.dynamicKind && baseType.sourceKey === overlayType.sourceKey;
+    case "record":
+      return overlayType.kind === "record";
+    case "reference":
+      return overlayType.kind === "reference" && baseType.name === overlayType.name;
+    case "union":
+      return overlayType.kind === "union";
+    case "custom":
+      return overlayType.kind === "custom" && baseType.typeId === overlayType.typeId;
+    case "object":
+    case "array":
+      return true;
+    default: {
+      const _exhaustive = baseType;
+      return _exhaustive;
+    }
+  }
+}
+function mergeAnnotations(baseAnnotations, overlayAnnotations) {
+  const baseKeys = new Set(baseAnnotations.map(annotationKey));
+  const overlayOnly = overlayAnnotations.filter(
+    (annotation) => !baseKeys.has(annotationKey(annotation))
+  );
+  return [...baseAnnotations, ...overlayOnly];
+}
+function annotationKey(annotation) {
+  return annotation.annotationKind === "custom" ? `${annotation.annotationKind}:${annotation.annotationId}` : annotation.annotationKind;
+}
+var init_mixed_authoring = __esm({
+  "src/generators/mixed-authoring.ts"() {
+    "use strict";
+    init_ir_generator();
+    init_ir_generator2();
+    init_canonicalize();
+    init_program();
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  buildFormSchemas: () => buildFormSchemas,
+  buildMixedAuthoringSchemas: () => buildMixedAuthoringSchemas,
+  categorizationSchema: () => categorizationSchema,
+  categorySchema: () => categorySchema,
+  controlSchema: () => controlSchema,
+  createExtensionRegistry: () => createExtensionRegistry,
+  generateJsonSchema: () => generateJsonSchema,
+  generateJsonSchemaFromIR: () => generateJsonSchemaFromIR,
+  generateSchemas: () => generateSchemas,
+  generateSchemasFromClass: () => generateSchemasFromClass,
+  generateUiSchema: () => generateUiSchema,
+  getSchemaExtension: () => getSchemaExtension,
+  groupLayoutSchema: () => groupLayoutSchema,
+  horizontalLayoutSchema: () => horizontalLayoutSchema,
+  jsonSchema7Schema: () => jsonSchema7Schema,
+  jsonSchemaTypeSchema: () => jsonSchemaTypeSchema,
+  labelElementSchema: () => labelElementSchema,
+  ruleConditionSchema: () => ruleConditionSchema,
+  ruleEffectSchema: () => ruleEffectSchema,
+  ruleSchema: () => ruleSchema,
+  schemaBasedConditionSchema: () => schemaBasedConditionSchema,
+  setSchemaExtension: () => setSchemaExtension,
+  uiSchemaElementSchema: () => uiSchemaElementSchema,
+  uiSchemaElementTypeSchema: () => uiSchemaElementTypeSchema,
+  uiSchemaSchema: () => uiSchema,
+  verticalLayoutSchema: () => verticalLayoutSchema,
+  writeSchemas: () => writeSchemas
+});
+function buildFormSchemas(form, options) {
+  return {
+    jsonSchema: generateJsonSchema(form, options),
+    uiSchema: generateUiSchema(form)
+  };
+}
+function writeSchemas(form, options) {
+  const { outDir, name = "schema", indent = 2, extensionRegistry, vendorPrefix } = options;
+  const buildOptions = extensionRegistry === void 0 && vendorPrefix === void 0 ? void 0 : {
+    extensionRegistry,
+    vendorPrefix
+  };
+  const { jsonSchema, uiSchema: uiSchema2 } = buildFormSchemas(form, buildOptions);
+  if (!fs.existsSync(outDir)) {
+    fs.mkdirSync(outDir, { recursive: true });
+  }
+  const jsonSchemaPath = path2.join(outDir, `${name}-schema.json`);
+  const uiSchemaPath = path2.join(outDir, `${name}-uischema.json`);
+  fs.writeFileSync(jsonSchemaPath, JSON.stringify(jsonSchema, null, indent));
+  fs.writeFileSync(uiSchemaPath, JSON.stringify(uiSchema2, null, indent));
+  return { jsonSchemaPath, uiSchemaPath };
+}
+var fs, path2;
+var init_index = __esm({
+  "src/index.ts"() {
+    "use strict";
+    init_generator();
+    init_generator2();
+    init_ir_generator();
+    fs = __toESM(require("fs"), 1);
+    path2 = __toESM(require("path"), 1);
+    init_types();
+    init_extensions();
+    init_schema();
+    init_schema2();
+    init_generator();
+    init_ir_generator();
+    init_generator2();
+    init_class_schema();
+    init_mixed_authoring();
+  }
+});
+
+// src/cli.ts
+var path3 = __toESM(require("path"), 1);
+var import_node_url = require("url");
+function printHelp() {
+  console.log(`
+FormSpec Build CLI - Generate JSON Schema and UI Schema
+
+Usage:
+  formspec-build <input-file> [options]
+
+Options:
+  -o, --out-dir <dir>   Output directory (default: ./generated)
+  -n, --name <name>     Base name for output files (default: derived from input)
+  -h, --help            Show this help message
+
+Example:
+  formspec-build src/forms/product.ts -o ./schemas -n product
+
+The input file should export a FormSpec as its default export or as 'form':
+  // product-form.ts
+  import { formspec, field } from "formspec";
+  export default formspec(field.text("name"));
+  // or: export const form = formspec(field.text("name"));
+`);
+}
+function parseArgs(args) {
+  const positional = [];
+  let outDir = "./generated";
+  let name = "";
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === void 0) continue;
+    if (arg === "-h" || arg === "--help") {
+      printHelp();
+      process.exit(0);
+    }
+    if (arg === "-o" || arg === "--out-dir") {
+      const nextArg = args[i + 1];
+      if (!nextArg) {
+        console.error("Error: --out-dir requires a value");
+        return null;
+      }
+      outDir = nextArg;
+      i++;
+      continue;
+    }
+    if (arg === "-n" || arg === "--name") {
+      const nextArg = args[i + 1];
+      if (!nextArg) {
+        console.error("Error: --name requires a value");
+        return null;
+      }
+      name = nextArg;
+      i++;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      console.error(`Error: Unknown option: ${arg}`);
+      return null;
+    }
+    positional.push(arg);
+  }
+  if (positional.length === 0) {
+    console.error("Error: No input file specified");
+    printHelp();
+    return null;
+  }
+  const inputFile = positional[0];
+  if (!inputFile) {
+    console.error("Error: No input file specified");
+    return null;
+  }
+  if (!name) {
+    name = path3.basename(inputFile, path3.extname(inputFile));
+  }
+  return { inputFile, outDir, name };
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const options = parseArgs(args);
+  if (!options) {
+    process.exit(1);
+  }
+  const { inputFile, outDir, name } = options;
+  const absoluteInput = path3.resolve(process.cwd(), inputFile);
+  try {
+    const fileUrl = (0, import_node_url.pathToFileURL)(absoluteInput).href;
+    const module2 = await import(fileUrl);
+    const form = module2["default"] ?? module2["form"];
+    if (!form || typeof form !== "object" || !("elements" in form)) {
+      console.error("Error: Input file must export a FormSpec as default export or as 'form'");
+      console.error("Example:");
+      console.error('  export default formspec(field.text("name"));');
+      console.error("  // or");
+      console.error('  export const form = formspec(field.text("name"));');
+      process.exit(1);
+    }
+    const { writeSchemas: writeSchemas2 } = await Promise.resolve().then(() => (init_index(), index_exports));
+    const { jsonSchemaPath, uiSchemaPath } = writeSchemas2(
+      form,
+      { outDir, name }
+    );
+    console.log("Generated:");
+    console.log(`  ${jsonSchemaPath}`);
+    console.log(`  ${uiSchemaPath}`);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`Error: ${error.message}`);
+    } else {
+      console.error("Error:", error);
+    }
+    process.exit(1);
+  }
+}
+void main();
+//# sourceMappingURL=cli.cjs.map