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

package/dist/index.cjs

@@ -0,0 +1,2093 @@
+"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 __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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  buildFormSchemas: () => buildFormSchemas,
+  categorizationSchema: () => categorizationSchema,
+  categorySchema: () => categorySchema,
+  controlSchema: () => controlSchema,
+  findDecoratedClasses: () => findDecoratedClasses,
+  generateCodegenOutput: () => generateCodegenOutput,
+  generateJsonSchema: () => generateJsonSchema,
+  generateSchemas: () => generateSchemas,
+  generateSchemasFromClass: () => generateSchemasFromClass,
+  generateUiSchema: () => generateUiSchema,
+  generateUiSchemaFromFields: () => generateUiSchemaFromFields,
+  getSchemaExtension: () => getSchemaExtension,
+  groupLayoutSchema: () => groupLayoutSchema,
+  horizontalLayoutSchema: () => horizontalLayoutSchema,
+  jsonSchema7Schema: () => jsonSchema7Schema,
+  jsonSchemaTypeSchema: () => jsonSchemaTypeSchema,
+  labelElementSchema: () => labelElementSchema,
+  ruleConditionSchema: () => ruleConditionSchema,
+  ruleEffectSchema: () => ruleEffectSchema,
+  ruleSchema: () => ruleSchema,
+  runCodegen: () => runCodegen,
+  schemaBasedConditionSchema: () => schemaBasedConditionSchema,
+  setSchemaExtension: () => setSchemaExtension,
+  uiSchemaElementSchema: () => uiSchemaElementSchema,
+  uiSchemaElementTypeSchema: () => uiSchemaElementTypeSchema,
+  uiSchemaSchema: () => uiSchema,
+  verticalLayoutSchema: () => verticalLayoutSchema,
+  writeSchemas: () => writeSchemas
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/json-schema/schema.ts
+var import_zod = require("zod");
+var jsonSchemaTypeSchema = import_zod.z.enum([
+  "string",
+  "number",
+  "integer",
+  "boolean",
+  "object",
+  "array",
+  "null"
+]);
+var jsonSchema7Schema = import_zod.z.lazy(
+  () => import_zod.z.object({
+    $schema: import_zod.z.string().optional(),
+    $id: import_zod.z.string().optional(),
+    $ref: import_zod.z.string().optional(),
+    // Metadata
+    title: import_zod.z.string().optional(),
+    description: import_zod.z.string().optional(),
+    deprecated: import_zod.z.boolean().optional(),
+    // Type
+    type: import_zod.z.union([jsonSchemaTypeSchema, import_zod.z.array(jsonSchemaTypeSchema)]).optional(),
+    // String validation
+    minLength: import_zod.z.number().optional(),
+    maxLength: import_zod.z.number().optional(),
+    pattern: import_zod.z.string().optional(),
+    // Number validation
+    minimum: import_zod.z.number().optional(),
+    maximum: import_zod.z.number().optional(),
+    exclusiveMinimum: import_zod.z.number().optional(),
+    exclusiveMaximum: import_zod.z.number().optional(),
+    // Enum
+    enum: import_zod.z.array(import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean(), import_zod.z.null()])).readonly().optional(),
+    const: import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean(), import_zod.z.null()]).optional(),
+    // Object
+    properties: import_zod.z.record(import_zod.z.string(), jsonSchema7Schema).optional(),
+    required: import_zod.z.array(import_zod.z.string()).optional(),
+    additionalProperties: import_zod.z.union([import_zod.z.boolean(), jsonSchema7Schema]).optional(),
+    // Array
+    items: import_zod.z.union([jsonSchema7Schema, import_zod.z.array(jsonSchema7Schema)]).optional(),
+    minItems: import_zod.z.number().optional(),
+    maxItems: import_zod.z.number().optional(),
+    // Composition
+    allOf: import_zod.z.array(jsonSchema7Schema).optional(),
+    anyOf: import_zod.z.array(jsonSchema7Schema).optional(),
+    oneOf: import_zod.z.array(jsonSchema7Schema).optional(),
+    not: jsonSchema7Schema.optional(),
+    // Conditional
+    if: jsonSchema7Schema.optional(),
+    then: jsonSchema7Schema.optional(),
+    else: jsonSchema7Schema.optional(),
+    // Format
+    format: import_zod.z.string().optional(),
+    // Default
+    default: import_zod.z.unknown().optional(),
+    // FormSpec extensions
+    "x-formspec-source": import_zod.z.string().optional(),
+    "x-formspec-params": import_zod.z.array(import_zod.z.string()).readonly().optional(),
+    "x-formspec-schemaSource": import_zod.z.string().optional()
+  }).passthrough()
+);
+
+// src/json-schema/generator.ts
+var import_zod2 = require("zod");
+function parseOrThrow(schema, value, label) {
+  try {
+    return schema.parse(value);
+  } catch (error) {
+    if (error instanceof import_zod2.z.ZodError) {
+      throw new Error(
+        `Generated ${label} failed validation:
+${error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n")}`
+      );
+    }
+    throw error;
+  }
+}
+function generateNestedSchema(elements) {
+  const properties = {};
+  const required = [];
+  collectFields(elements, properties, required);
+  const uniqueRequired = [...new Set(required)];
+  return {
+    type: "object",
+    properties,
+    ...uniqueRequired.length > 0 && { required: uniqueRequired }
+  };
+}
+function fieldToJsonSchema(field) {
+  const base = {};
+  if (field.label !== void 0) {
+    base.title = field.label;
+  }
+  switch (field._field) {
+    case "text":
+      return { ...base, type: "string" };
+    case "number":
+      return {
+        ...base,
+        type: "number",
+        ...field.min !== void 0 && { minimum: field.min },
+        ...field.max !== void 0 && { maximum: field.max }
+      };
+    case "boolean":
+      return { ...base, type: "boolean" };
+    case "enum": {
+      const opts = field.options;
+      const isObjectOptions = opts.length > 0 && opts.every(
+        (opt) => typeof opt === "object" && "id" in opt && "label" in opt
+      );
+      if (isObjectOptions) {
+        return {
+          ...base,
+          type: "string",
+          oneOf: opts.map((o) => ({
+            const: o.id,
+            title: o.label
+          }))
+        };
+      }
+      return { ...base, type: "string", enum: opts };
+    }
+    case "dynamic_enum":
+      return {
+        ...base,
+        type: "string",
+        "x-formspec-source": field.source,
+        ...field.params !== void 0 && field.params.length > 0 && { "x-formspec-params": field.params }
+      };
+    case "dynamic_schema":
+      return {
+        ...base,
+        type: "object",
+        additionalProperties: true,
+        "x-formspec-schemaSource": field.schemaSource
+      };
+    case "array": {
+      const arrayField = field;
+      return {
+        ...base,
+        type: "array",
+        items: generateNestedSchema(arrayField.items),
+        ...arrayField.minItems !== void 0 && { minItems: arrayField.minItems },
+        ...arrayField.maxItems !== void 0 && { maxItems: arrayField.maxItems }
+      };
+    }
+    case "object": {
+      const objectField = field;
+      const nestedSchema = generateNestedSchema(objectField.properties);
+      return {
+        ...base,
+        ...nestedSchema
+      };
+    }
+    default: {
+      const _exhaustive = field;
+      return _exhaustive;
+    }
+  }
+}
+function collectFields(elements, properties, required) {
+  for (const element of elements) {
+    switch (element._type) {
+      case "field":
+        properties[element.name] = fieldToJsonSchema(element);
+        if (element.required === true) {
+          required.push(element.name);
+        }
+        break;
+      case "group":
+        collectFields(element.elements, properties, required);
+        break;
+      case "conditional":
+        collectFields(
+          element.elements,
+          properties,
+          required
+        );
+        break;
+    }
+  }
+}
+function generateJsonSchema(form) {
+  const properties = {};
+  const required = [];
+  collectFields(form.elements, properties, required);
+  const uniqueRequired = [...new Set(required)];
+  const result = {
+    $schema: "https://json-schema.org/draft-07/schema#",
+    type: "object",
+    properties,
+    ...uniqueRequired.length > 0 && { required: uniqueRequired }
+  };
+  return parseOrThrow(jsonSchema7Schema, result, "JSON Schema");
+}
+
+// src/ui-schema/schema.ts
+var import_zod3 = require("zod");
+var jsonPointerSchema = import_zod3.z.string();
+var ruleEffectSchema = import_zod3.z.enum(["SHOW", "HIDE", "ENABLE", "DISABLE"]);
+var uiSchemaElementTypeSchema = import_zod3.z.enum([
+  "Control",
+  "VerticalLayout",
+  "HorizontalLayout",
+  "Group",
+  "Categorization",
+  "Category",
+  "Label"
+]);
+var ruleConditionSchema = import_zod3.z.lazy(
+  () => import_zod3.z.object({
+    const: import_zod3.z.unknown().optional(),
+    enum: import_zod3.z.array(import_zod3.z.unknown()).readonly().optional(),
+    type: import_zod3.z.string().optional(),
+    not: ruleConditionSchema.optional(),
+    minimum: import_zod3.z.number().optional(),
+    maximum: import_zod3.z.number().optional(),
+    exclusiveMinimum: import_zod3.z.number().optional(),
+    exclusiveMaximum: import_zod3.z.number().optional(),
+    minLength: import_zod3.z.number().optional(),
+    properties: import_zod3.z.record(import_zod3.z.string(), ruleConditionSchema).optional(),
+    required: import_zod3.z.array(import_zod3.z.string()).optional(),
+    allOf: import_zod3.z.array(ruleConditionSchema).optional()
+  }).strict()
+);
+var schemaBasedConditionSchema = import_zod3.z.object({
+  scope: jsonPointerSchema,
+  schema: ruleConditionSchema
+}).strict();
+var ruleSchema = import_zod3.z.object({
+  effect: ruleEffectSchema,
+  condition: schemaBasedConditionSchema
+}).strict();
+var uiSchemaElementSchema = import_zod3.z.lazy(
+  () => import_zod3.z.union([
+    controlSchema,
+    verticalLayoutSchema,
+    horizontalLayoutSchema,
+    groupLayoutSchema,
+    categorizationSchema,
+    categorySchema,
+    labelElementSchema
+  ])
+);
+var controlSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("Control"),
+  scope: jsonPointerSchema,
+  label: import_zod3.z.union([import_zod3.z.string(), import_zod3.z.literal(false)]).optional(),
+  rule: ruleSchema.optional(),
+  options: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
+}).passthrough();
+var verticalLayoutSchema = import_zod3.z.lazy(
+  () => import_zod3.z.object({
+    type: import_zod3.z.literal("VerticalLayout"),
+    elements: import_zod3.z.array(uiSchemaElementSchema),
+    rule: ruleSchema.optional(),
+    options: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
+  }).passthrough()
+);
+var horizontalLayoutSchema = import_zod3.z.lazy(
+  () => import_zod3.z.object({
+    type: import_zod3.z.literal("HorizontalLayout"),
+    elements: import_zod3.z.array(uiSchemaElementSchema),
+    rule: ruleSchema.optional(),
+    options: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
+  }).passthrough()
+);
+var groupLayoutSchema = import_zod3.z.lazy(
+  () => import_zod3.z.object({
+    type: import_zod3.z.literal("Group"),
+    label: import_zod3.z.string(),
+    elements: import_zod3.z.array(uiSchemaElementSchema),
+    rule: ruleSchema.optional(),
+    options: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
+  }).passthrough()
+);
+var categorySchema = import_zod3.z.lazy(
+  () => import_zod3.z.object({
+    type: import_zod3.z.literal("Category"),
+    label: import_zod3.z.string(),
+    elements: import_zod3.z.array(uiSchemaElementSchema),
+    rule: ruleSchema.optional(),
+    options: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
+  }).passthrough()
+);
+var categorizationSchema = import_zod3.z.lazy(
+  () => import_zod3.z.object({
+    type: import_zod3.z.literal("Categorization"),
+    elements: import_zod3.z.array(categorySchema),
+    label: import_zod3.z.string().optional(),
+    rule: ruleSchema.optional(),
+    options: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
+  }).passthrough()
+);
+var labelElementSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("Label"),
+  text: import_zod3.z.string(),
+  rule: ruleSchema.optional(),
+  options: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional()
+}).passthrough();
+var uiSchema = import_zod3.z.lazy(
+  () => import_zod3.z.union([verticalLayoutSchema, horizontalLayoutSchema, groupLayoutSchema, categorizationSchema])
+);
+
+// src/ui-schema/generator.ts
+var import_zod4 = require("zod");
+function parseOrThrow2(schema, value, label) {
+  try {
+    return schema.parse(value);
+  } catch (error) {
+    if (error instanceof import_zod4.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 combineRules(parentRule, childRule) {
+  const parentCondition = parentRule.condition;
+  const childCondition = childRule.condition;
+  return {
+    effect: "SHOW",
+    condition: {
+      scope: "#",
+      schema: {
+        allOf: [
+          {
+            properties: {
+              [parentCondition.scope.replace("#/properties/", "")]: parentCondition.schema
+            }
+          },
+          {
+            properties: {
+              [childCondition.scope.replace("#/properties/", "")]: childCondition.schema
+            }
+          }
+        ]
+      }
+    }
+  };
+}
+function elementsToUiSchema(elements, parentRule) {
+  const result = [];
+  for (const element of elements) {
+    switch (element._type) {
+      case "field": {
+        const control = {
+          type: "Control",
+          scope: fieldToScope(element.name),
+          ...element.label !== void 0 && { label: element.label },
+          ...parentRule !== void 0 && { rule: parentRule }
+        };
+        result.push(control);
+        break;
+      }
+      case "group": {
+        const groupElement = element;
+        const group = {
+          type: "Group",
+          label: groupElement.label,
+          elements: elementsToUiSchema(groupElement.elements, parentRule),
+          ...parentRule !== void 0 && { rule: parentRule }
+        };
+        result.push(group);
+        break;
+      }
+      case "conditional": {
+        const conditionalElement = element;
+        const newRule = createShowRule(conditionalElement.field, conditionalElement.value);
+        const combinedRule = parentRule !== void 0 ? combineRules(parentRule, newRule) : newRule;
+        const childElements = elementsToUiSchema(conditionalElement.elements, combinedRule);
+        result.push(...childElements);
+        break;
+      }
+    }
+  }
+  return result;
+}
+function formSpecFieldToElement(field, scopePrefix = "#/properties") {
+  const control = {
+    type: "Control",
+    scope: `${scopePrefix}/${field.id}`
+  };
+  if (field.label !== void 0) {
+    control.label = field.label;
+  }
+  if (field.showWhen !== void 0 && typeof field.showWhen === "object" && "field" in field.showWhen && "value" in field.showWhen) {
+    const sw = field.showWhen;
+    control.rule = {
+      effect: "SHOW",
+      condition: {
+        scope: `#/properties/${sw.field}`,
+        schema: { const: sw.value }
+      }
+    };
+  }
+  return control;
+}
+function generateUiSchemaFromFields(fields) {
+  const groupMap = /* @__PURE__ */ new Map();
+  const orderedKeys = [];
+  const ungrouped = [];
+  for (const field of fields) {
+    const element = formSpecFieldToElement(field);
+    if (field.group !== void 0) {
+      if (!groupMap.has(field.group)) {
+        groupMap.set(field.group, []);
+        orderedKeys.push(field.group);
+      }
+      groupMap.get(field.group).push(element);
+    } else {
+      orderedKeys.push(null);
+      ungrouped.push(element);
+    }
+  }
+  const elements = [];
+  let ungroupedIndex = 0;
+  for (const key of orderedKeys) {
+    if (key === null) {
+      const el = ungrouped[ungroupedIndex++];
+      if (el !== void 0) {
+        elements.push(el);
+      }
+    } else {
+      const groupElements = groupMap.get(key) ?? [];
+      const groupLayout = {
+        type: "Group",
+        label: key,
+        elements: groupElements
+      };
+      elements.push(groupLayout);
+    }
+  }
+  const result = {
+    type: "VerticalLayout",
+    elements
+  };
+  return parseOrThrow2(uiSchema, result, "UI Schema");
+}
+function generateUiSchema(form) {
+  const result = {
+    type: "VerticalLayout",
+    elements: elementsToUiSchema(form.elements)
+  };
+  return parseOrThrow2(uiSchema, result, "UI Schema");
+}
+
+// src/index.ts
+var fs2 = __toESM(require("fs"), 1);
+var path3 = __toESM(require("path"), 1);
+
+// src/json-schema/types.ts
+function setSchemaExtension(schema, key, value) {
+  schema[key] = value;
+}
+function getSchemaExtension(schema, key) {
+  return schema[key];
+}
+
+// src/analyzer/type-converter.ts
+var ts4 = __toESM(require("typescript"), 1);
+
+// src/analyzer/class-analyzer.ts
+var ts3 = __toESM(require("typescript"), 1);
+
+// src/analyzer/decorator-extractor.ts
+var ts = __toESM(require("typescript"), 1);
+var import_core = require("@formspec/core");
+function extractDecorators(member) {
+  const decorators = [];
+  const modifiers = ts.canHaveDecorators(member) ? ts.getDecorators(member) : void 0;
+  if (!modifiers) return decorators;
+  for (const decorator of modifiers) {
+    const info = parseDecorator(decorator);
+    if (info) {
+      decorators.push(info);
+    }
+  }
+  return decorators;
+}
+function parseDecorator(decorator) {
+  const expr = decorator.expression;
+  if (ts.isIdentifier(expr)) {
+    return {
+      name: expr.text,
+      args: [],
+      node: decorator
+    };
+  }
+  if (ts.isCallExpression(expr)) {
+    const callee = expr.expression;
+    let name = null;
+    if (ts.isIdentifier(callee)) {
+      name = callee.text;
+    } else if (ts.isPropertyAccessExpression(callee)) {
+      name = callee.name.text;
+    }
+    if (!name) return null;
+    const args = expr.arguments.map(extractArgValue);
+    return {
+      name,
+      args,
+      node: decorator
+    };
+  }
+  return null;
+}
+function extractArgValue(node) {
+  if (ts.isStringLiteral(node)) {
+    return node.text;
+  }
+  if (ts.isNumericLiteral(node)) {
+    return Number(node.text);
+  }
+  if (node.kind === ts.SyntaxKind.TrueKeyword) {
+    return true;
+  }
+  if (node.kind === ts.SyntaxKind.FalseKeyword) {
+    return false;
+  }
+  if (node.kind === ts.SyntaxKind.NullKeyword) {
+    return null;
+  }
+  if (ts.isPrefixUnaryExpression(node)) {
+    if (node.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(node.operand)) {
+      return -Number(node.operand.text);
+    }
+    if (node.operator === ts.SyntaxKind.PlusToken && ts.isNumericLiteral(node.operand)) {
+      return Number(node.operand.text);
+    }
+  }
+  if (ts.isArrayLiteralExpression(node)) {
+    return node.elements.map((el) => {
+      if (ts.isSpreadElement(el)) {
+        return null;
+      }
+      return extractArgValue(el);
+    });
+  }
+  if (ts.isObjectLiteralExpression(node)) {
+    const obj = {};
+    for (const prop of node.properties) {
+      if (ts.isPropertyAssignment(prop)) {
+        const key = getPropertyName(prop.name);
+        if (key) {
+          obj[key] = extractArgValue(prop.initializer);
+        }
+      } else if (ts.isShorthandPropertyAssignment(prop)) {
+        const key = prop.name.text;
+        obj[key] = null;
+      }
+    }
+    return obj;
+  }
+  if (ts.isNoSubstitutionTemplateLiteral(node)) {
+    return node.text;
+  }
+  if (ts.isRegularExpressionLiteral(node)) {
+    const regexText = node.text;
+    const lastSlash = regexText.lastIndexOf("/");
+    if (lastSlash > 0) {
+      return regexText.substring(1, lastSlash);
+    }
+    return regexText;
+  }
+  if (ts.isNewExpression(node)) {
+    if (ts.isIdentifier(node.expression) && node.expression.text === "RegExp" && node.arguments && node.arguments.length > 0) {
+      const firstArg = node.arguments[0];
+      if (firstArg && ts.isStringLiteral(firstArg)) {
+        return firstArg.text;
+      }
+    }
+  }
+  if (ts.isIdentifier(node)) {
+    return null;
+  }
+  return null;
+}
+function getPropertyName(name) {
+  if (ts.isIdentifier(name)) {
+    return name.text;
+  }
+  if (ts.isStringLiteral(name)) {
+    return name.text;
+  }
+  if (ts.isNumericLiteral(name)) {
+    return name.text;
+  }
+  return null;
+}
+var FORMSPEC_DECORATORS = {
+  // Display metadata
+  Field: { argTypes: ["object"] },
+  // Grouping
+  Group: { argTypes: ["string"] },
+  // Conditional display
+  ShowWhen: { argTypes: ["object"] },
+  // Enum options
+  EnumOptions: { argTypes: ["array"] },
+  // Numeric constraints
+  Minimum: { argTypes: ["number"] },
+  Maximum: { argTypes: ["number"] },
+  ExclusiveMinimum: { argTypes: ["number"] },
+  ExclusiveMaximum: { argTypes: ["number"] },
+  // String constraints
+  MinLength: { argTypes: ["number"] },
+  MaxLength: { argTypes: ["number"] },
+  Pattern: { argTypes: ["string"] }
+};
+function isFormSpecDecoratorsPath(fileName) {
+  const normalized = fileName.replace(/\\/g, "/");
+  return normalized.includes("node_modules/@formspec/decorators") || normalized.includes("/packages/decorators/");
+}
+function resolveDecorator(decorator, checker) {
+  const expr = decorator.expression;
+  let targetNode;
+  let name;
+  if (ts.isIdentifier(expr)) {
+    targetNode = expr;
+    name = expr.text;
+  } else if (ts.isCallExpression(expr)) {
+    if (ts.isIdentifier(expr.expression)) {
+      targetNode = expr.expression;
+      name = expr.expression.text;
+    } else {
+      return null;
+    }
+  } else {
+    return null;
+  }
+  if (name in FORMSPEC_DECORATORS) {
+    const symbol = checker.getSymbolAtLocation(targetNode);
+    if (symbol) {
+      const declarations = symbol.declarations;
+      if (declarations && declarations.length > 0) {
+        const decl = declarations[0];
+        if (decl) {
+          const sourceFile = decl.getSourceFile();
+          const fileName = sourceFile.fileName;
+          if (isFormSpecDecoratorsPath(fileName)) {
+            return {
+              name,
+              isFormSpec: true,
+              isMarker: !ts.isCallExpression(expr)
+            };
+          }
+        }
+      }
+    }
+  }
+  const resolvedSymbol = checker.getSymbolAtLocation(targetNode);
+  if (!resolvedSymbol) return null;
+  const type = checker.getTypeOfSymbol(resolvedSymbol);
+  const props = type.getProperties();
+  let extendsBuiltin;
+  let extensionName;
+  let isMarker = false;
+  for (const prop of props) {
+    const escapedName = prop.getEscapedName();
+    if (escapedName.startsWith("__@") && (escapedName.includes("formspec.extends") || escapedName.includes("FORMSPEC_EXTENDS"))) {
+      const propType = checker.getTypeOfSymbol(prop);
+      if (propType.isStringLiteral()) {
+        extendsBuiltin = propType.value;
+      }
+    }
+    if (escapedName.startsWith("__@") && (escapedName.includes("formspec.extension") || escapedName.includes("FORMSPEC_EXTENSION"))) {
+      const propType = checker.getTypeOfSymbol(prop);
+      if (propType.isStringLiteral()) {
+        extensionName = propType.value;
+      }
+    }
+    if (escapedName.startsWith("__@") && (escapedName.includes("formspec.marker") || escapedName.includes("FORMSPEC_MARKER"))) {
+      isMarker = true;
+    }
+  }
+  if (extendsBuiltin) {
+    return {
+      name,
+      extendsBuiltin,
+      isFormSpec: true,
+      isMarker: false
+    };
+  }
+  if (extensionName) {
+    return {
+      name,
+      extensionName,
+      isFormSpec: true,
+      isMarker
+    };
+  }
+  if (isMarker) {
+    return {
+      name,
+      isFormSpec: true,
+      isMarker: true
+    };
+  }
+  return null;
+}
+
+// src/analyzer/jsdoc-constraints.ts
+var ts2 = __toESM(require("typescript"), 1);
+var import_core2 = require("@formspec/core");
+function extractJSDocConstraints(node) {
+  const results = [];
+  const jsDocTags = ts2.getJSDocTags(node);
+  for (const tag of jsDocTags) {
+    const tagName = tag.tagName.text;
+    if (!(tagName in import_core2.CONSTRAINT_TAG_DEFINITIONS)) {
+      continue;
+    }
+    const constraintName = tagName;
+    const expectedType = import_core2.CONSTRAINT_TAG_DEFINITIONS[constraintName];
+    const commentText = getTagCommentText(tag);
+    if (commentText === void 0 || commentText === "") {
+      continue;
+    }
+    const trimmed = commentText.trim();
+    if (trimmed === "") {
+      continue;
+    }
+    if (expectedType === "number") {
+      const value = Number(trimmed);
+      if (Number.isNaN(value)) {
+        continue;
+      }
+      results.push(createSyntheticDecorator(constraintName, value));
+    } else if (expectedType === "json") {
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (!Array.isArray(parsed)) {
+          continue;
+        }
+        results.push(createSyntheticDecorator(constraintName, parsed));
+      } catch {
+        continue;
+      }
+    } else {
+      results.push(createSyntheticDecorator(constraintName, trimmed));
+    }
+  }
+  return results;
+}
+function extractJSDocFieldMetadata(node) {
+  const jsDocTags = ts2.getJSDocTags(node);
+  let displayName;
+  let description;
+  for (const tag of jsDocTags) {
+    const tagName = tag.tagName.text;
+    const commentText = getTagCommentText(tag);
+    if (commentText === void 0 || commentText.trim() === "") {
+      continue;
+    }
+    const trimmed = commentText.trim();
+    if (tagName === "Field_displayName") {
+      displayName = trimmed;
+    } else if (tagName === "Field_description") {
+      description = trimmed;
+    }
+  }
+  if (displayName === void 0 && description === void 0) {
+    return null;
+  }
+  const fieldOpts = {
+    ...displayName !== void 0 ? { displayName } : {},
+    ...description !== void 0 ? { description } : {}
+  };
+  return createSyntheticDecorator("Field", fieldOpts);
+}
+function getTagCommentText(tag) {
+  if (tag.comment === void 0) {
+    return void 0;
+  }
+  if (typeof tag.comment === "string") {
+    return tag.comment;
+  }
+  return ts2.getTextOfJSDocComment(tag.comment);
+}
+function createSyntheticDecorator(name, value) {
+  return {
+    name,
+    args: [value],
+    node: void 0
+  };
+}
+
+// src/analyzer/class-analyzer.ts
+function analyzeClass(classDecl, checker) {
+  const name = classDecl.name?.text ?? "AnonymousClass";
+  const fields = [];
+  const instanceMethods = [];
+  const staticMethods = [];
+  for (const member of classDecl.members) {
+    if (ts3.isPropertyDeclaration(member)) {
+      const fieldInfo = analyzeField(member, checker);
+      if (fieldInfo) {
+        fields.push(fieldInfo);
+      }
+    } 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,
+    instanceMethods,
+    staticMethods
+  };
+}
+function analyzeField(prop, checker) {
+  if (!ts3.isIdentifier(prop.name)) {
+    return null;
+  }
+  const name = prop.name.text;
+  const typeNode = prop.type;
+  const type = checker.getTypeAtLocation(prop);
+  const optional = prop.questionToken !== void 0;
+  const decorators = extractDecorators(prop);
+  for (const dec of decorators) {
+    if (dec.node) {
+      const resolved = resolveDecorator(dec.node, checker);
+      if (resolved) {
+        dec.resolved = resolved;
+      }
+    }
+  }
+  if (prop.type) {
+    const aliasConstraints = extractTypeAliasConstraints(prop.type, checker);
+    decorators.push(...aliasConstraints);
+  }
+  const jsdocConstraints = extractJSDocConstraints(prop);
+  decorators.push(...jsdocConstraints);
+  const deprecated = hasDeprecatedTag(prop);
+  const defaultValue = extractDefaultValue(prop.initializer);
+  return {
+    name,
+    typeNode,
+    type,
+    optional,
+    decorators,
+    deprecated,
+    defaultValue
+  };
+}
+function extractTypeAliasConstraints(typeNode, checker) {
+  if (!ts3.isTypeReferenceNode(typeNode)) return [];
+  const symbol = checker.getSymbolAtLocation(typeNode.typeName);
+  if (!symbol?.declarations) return [];
+  const aliasDecl = symbol.declarations.find(ts3.isTypeAliasDeclaration);
+  if (!aliasDecl) return [];
+  if (ts3.isTypeLiteralNode(aliasDecl.type)) return [];
+  return extractJSDocConstraints(aliasDecl);
+}
+function hasDeprecatedTag(node) {
+  const jsDocTags = ts3.getJSDocTags(node);
+  return jsDocTags.some((tag) => tag.tagName.text === "deprecated");
+}
+function extractDefaultValue(initializer) {
+  if (!initializer) return void 0;
+  if (ts3.isStringLiteral(initializer)) {
+    return initializer.text;
+  }
+  if (ts3.isNumericLiteral(initializer)) {
+    return Number(initializer.text);
+  }
+  if (initializer.kind === ts3.SyntaxKind.TrueKeyword) {
+    return true;
+  }
+  if (initializer.kind === ts3.SyntaxKind.FalseKeyword) {
+    return false;
+  }
+  if (initializer.kind === ts3.SyntaxKind.NullKeyword) {
+    return null;
+  }
+  if (ts3.isPrefixUnaryExpression(initializer)) {
+    if (initializer.operator === ts3.SyntaxKind.MinusToken && ts3.isNumericLiteral(initializer.operand)) {
+      return -Number(initializer.operand.text);
+    }
+  }
+  return void 0;
+}
+function analyzeMethod(method, checker) {
+  if (!ts3.isIdentifier(method.name)) {
+    return null;
+  }
+  const name = method.name.text;
+  const parameters = [];
+  for (const param of method.parameters) {
+    if (ts3.isIdentifier(param.name)) {
+      const paramInfo = analyzeParameter(param, checker);
+      parameters.push(paramInfo);
+    }
+  }
+  const returnTypeNode = method.type;
+  const signature = checker.getSignatureFromDeclaration(method);
+  const returnType = signature ? checker.getReturnTypeOfSignature(signature) : checker.getTypeAtLocation(method);
+  return {
+    name,
+    parameters,
+    returnTypeNode,
+    returnType
+  };
+}
+function analyzeParameter(param, checker) {
+  const name = ts3.isIdentifier(param.name) ? param.name.text : "param";
+  const typeNode = param.type;
+  const type = checker.getTypeAtLocation(param);
+  const formSpecExportName = detectFormSpecReference(typeNode);
+  const optional = param.questionToken !== void 0 || param.initializer !== void 0;
+  return {
+    name,
+    typeNode,
+    type,
+    formSpecExportName,
+    optional
+  };
+}
+function detectFormSpecReference(typeNode) {
+  if (!typeNode) return null;
+  if (!ts3.isTypeReferenceNode(typeNode)) return null;
+  const typeName = ts3.isIdentifier(typeNode.typeName) ? typeNode.typeName.text : ts3.isQualifiedName(typeNode.typeName) ? typeNode.typeName.right.text : null;
+  if (typeName !== "InferSchema" && typeName !== "InferFormSchema") return null;
+  const typeArg = typeNode.typeArguments?.[0];
+  if (!typeArg || !ts3.isTypeQueryNode(typeArg)) return null;
+  if (ts3.isIdentifier(typeArg.exprName)) {
+    return typeArg.exprName.text;
+  }
+  if (ts3.isQualifiedName(typeArg.exprName)) {
+    return typeArg.exprName.right.text;
+  }
+  return null;
+}
+function analyzeInterface(interfaceDecl, checker) {
+  const name = interfaceDecl.name.text;
+  const fields = [];
+  for (const member of interfaceDecl.members) {
+    if (ts3.isPropertySignature(member)) {
+      const fieldInfo = analyzeInterfaceProperty(member, checker);
+      if (fieldInfo) {
+        fields.push(fieldInfo);
+      }
+    }
+  }
+  return {
+    name,
+    fields,
+    instanceMethods: [],
+    staticMethods: []
+  };
+}
+function analyzeTypeAlias(typeAlias, checker) {
+  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 = [];
+  for (const member of typeAlias.type.members) {
+    if (ts3.isPropertySignature(member)) {
+      const fieldInfo = analyzeInterfaceProperty(member, checker);
+      if (fieldInfo) {
+        fields.push(fieldInfo);
+      }
+    }
+  }
+  return {
+    ok: true,
+    analysis: {
+      name,
+      fields,
+      instanceMethods: [],
+      staticMethods: []
+    }
+  };
+}
+function analyzeInterfaceProperty(prop, checker) {
+  if (!ts3.isIdentifier(prop.name)) {
+    return null;
+  }
+  const name = prop.name.text;
+  const typeNode = prop.type;
+  const type = checker.getTypeAtLocation(prop);
+  const optional = prop.questionToken !== void 0;
+  const decorators = [];
+  if (typeNode) {
+    const aliasConstraints = extractTypeAliasConstraints(typeNode, checker);
+    decorators.push(...aliasConstraints);
+  }
+  const fieldMetadata = extractJSDocFieldMetadata(prop);
+  if (fieldMetadata) {
+    decorators.push(fieldMetadata);
+  }
+  const jsdocConstraints = extractJSDocConstraints(prop);
+  decorators.push(...jsdocConstraints);
+  const deprecated = hasDeprecatedTag(prop);
+  return {
+    name,
+    typeNode,
+    type,
+    optional,
+    decorators,
+    deprecated,
+    defaultValue: void 0
+  };
+}
+
+// src/analyzer/type-converter.ts
+function getNamedTypeFieldInfoMap(type, checker) {
+  const symbols = [type.getSymbol(), type.aliasSymbol].filter(
+    (s) => s?.declarations != null && s.declarations.length > 0
+  );
+  for (const symbol of symbols) {
+    const declarations = symbol.declarations;
+    if (!declarations) continue;
+    const classDecl = declarations.find(ts4.isClassDeclaration);
+    if (classDecl) {
+      const map = /* @__PURE__ */ new Map();
+      for (const member of classDecl.members) {
+        if (ts4.isPropertyDeclaration(member) && ts4.isIdentifier(member.name)) {
+          const fieldInfo = analyzeField(member, checker);
+          if (fieldInfo) map.set(fieldInfo.name, fieldInfo);
+        }
+      }
+      return map;
+    }
+    const interfaceDecl = declarations.find(ts4.isInterfaceDeclaration);
+    if (interfaceDecl) {
+      return buildFieldInfoMapFromSignatures(interfaceDecl.members, checker);
+    }
+    const typeAliasDecl = declarations.find(ts4.isTypeAliasDeclaration);
+    if (typeAliasDecl && ts4.isTypeLiteralNode(typeAliasDecl.type)) {
+      return buildFieldInfoMapFromSignatures(typeAliasDecl.type.members, checker);
+    }
+  }
+  return null;
+}
+function buildFieldInfoMapFromSignatures(members, checker) {
+  const map = /* @__PURE__ */ new Map();
+  for (const member of members) {
+    if (ts4.isPropertySignature(member)) {
+      const fieldInfo = analyzeInterfaceProperty(member, checker);
+      if (fieldInfo) {
+        map.set(fieldInfo.name, fieldInfo);
+      }
+    }
+  }
+  return map;
+}
+function getObjectPropertyInfos(type, checker) {
+  const fieldInfoMap = getNamedTypeFieldInfoMap(type, checker);
+  const result = [];
+  for (const prop of type.getProperties()) {
+    const declaration = prop.valueDeclaration ?? prop.declarations?.[0];
+    if (!declaration) continue;
+    const propType = checker.getTypeOfSymbolAtLocation(prop, declaration);
+    const optional = !!(prop.flags & ts4.SymbolFlags.Optional);
+    const fieldInfo = fieldInfoMap?.get(prop.name) ?? void 0;
+    result.push({ name: prop.name, type: propType, optional, fieldInfo });
+  }
+  return result;
+}
+function convertType(type, checker) {
+  return convertTypeInternal(type, checker, /* @__PURE__ */ new Set());
+}
+function convertTypeInternal(type, checker, visiting) {
+  if (type.flags & ts4.TypeFlags.String) {
+    return { jsonSchema: { type: "string" }, formSpecFieldType: "text" };
+  }
+  if (type.flags & ts4.TypeFlags.Number) {
+    return { jsonSchema: { type: "number" }, formSpecFieldType: "number" };
+  }
+  if (type.flags & ts4.TypeFlags.Boolean) {
+    return { jsonSchema: { type: "boolean" }, formSpecFieldType: "boolean" };
+  }
+  if (type.flags & ts4.TypeFlags.Null) {
+    return { jsonSchema: { type: "null" }, formSpecFieldType: "null" };
+  }
+  if (type.flags & ts4.TypeFlags.Undefined) {
+    return { jsonSchema: {}, formSpecFieldType: "undefined" };
+  }
+  if (type.isStringLiteral()) {
+    return {
+      jsonSchema: { const: type.value },
+      formSpecFieldType: "enum"
+    };
+  }
+  if (type.isNumberLiteral()) {
+    return {
+      jsonSchema: { const: type.value },
+      formSpecFieldType: "number"
+    };
+  }
+  if (type.isUnion()) {
+    return convertUnionType(type, checker, visiting);
+  }
+  if (checker.isArrayType(type)) {
+    return convertArrayType(type, checker, visiting);
+  }
+  if (type.flags & ts4.TypeFlags.Object) {
+    return convertObjectType(type, checker, visiting);
+  }
+  return { jsonSchema: {}, formSpecFieldType: "unknown" };
+}
+function convertUnionType(type, checker, visiting) {
+  const types = type.types;
+  const nonNullTypes = types.filter(
+    (t) => !(t.flags & (ts4.TypeFlags.Null | ts4.TypeFlags.Undefined))
+  );
+  const hasNull = types.some((t) => t.flags & ts4.TypeFlags.Null);
+  const isBooleanUnion = nonNullTypes.length === 2 && nonNullTypes.every((t) => t.flags & ts4.TypeFlags.BooleanLiteral);
+  if (isBooleanUnion) {
+    const result = {
+      jsonSchema: { type: "boolean" },
+      formSpecFieldType: "boolean"
+    };
+    if (hasNull) {
+      result.jsonSchema = { oneOf: [{ type: "boolean" }, { type: "null" }] };
+    }
+    return result;
+  }
+  const allStringLiterals = nonNullTypes.every((t) => t.isStringLiteral());
+  if (allStringLiterals && nonNullTypes.length > 0) {
+    const enumValues = nonNullTypes.map((t) => t.value);
+    const result = {
+      jsonSchema: { enum: enumValues },
+      formSpecFieldType: "enum"
+    };
+    if (hasNull) {
+      result.jsonSchema = { oneOf: [{ enum: enumValues }, { type: "null" }] };
+    }
+    return result;
+  }
+  const allNumberLiterals = nonNullTypes.every((t) => t.isNumberLiteral());
+  if (allNumberLiterals && nonNullTypes.length > 0) {
+    const enumValues = nonNullTypes.map((t) => t.value);
+    const result = {
+      jsonSchema: { enum: enumValues },
+      formSpecFieldType: "enum"
+    };
+    if (hasNull) {
+      result.jsonSchema = { oneOf: [{ enum: enumValues }, { type: "null" }] };
+    }
+    return result;
+  }
+  if (nonNullTypes.length === 1 && nonNullTypes[0]) {
+    const result = convertTypeInternal(nonNullTypes[0], checker, visiting);
+    if (hasNull) {
+      result.jsonSchema = { oneOf: [result.jsonSchema, { type: "null" }] };
+    }
+    return result;
+  }
+  const schemas = nonNullTypes.map((t) => convertTypeInternal(t, checker, visiting).jsonSchema);
+  if (hasNull) {
+    schemas.push({ type: "null" });
+  }
+  return {
+    jsonSchema: { oneOf: schemas },
+    formSpecFieldType: "union"
+  };
+}
+function convertArrayType(type, checker, visiting) {
+  const typeArgs = type.typeArguments;
+  const elementType = typeArgs?.[0];
+  const itemSchema = elementType ? convertTypeInternal(elementType, checker, visiting).jsonSchema : {};
+  return {
+    jsonSchema: {
+      type: "array",
+      items: itemSchema
+    },
+    formSpecFieldType: "array"
+  };
+}
+function convertObjectType(type, checker, visiting) {
+  if (visiting.has(type)) {
+    return { jsonSchema: { type: "object" }, formSpecFieldType: "object" };
+  }
+  visiting.add(type);
+  const properties = {};
+  const required = [];
+  for (const propInfo of getObjectPropertyInfos(type, checker)) {
+    const propSchema = convertTypeInternal(propInfo.type, checker, visiting).jsonSchema;
+    properties[propInfo.name] = propInfo.fieldInfo ? applyDecoratorsToSchema(propSchema, propInfo.fieldInfo.decorators, propInfo.fieldInfo) : propSchema;
+    if (!propInfo.optional) {
+      required.push(propInfo.name);
+    }
+  }
+  visiting.delete(type);
+  return {
+    jsonSchema: {
+      type: "object",
+      properties,
+      ...required.length > 0 ? { required } : {}
+    },
+    formSpecFieldType: "object"
+  };
+}
+function createFormSpecField(fieldName, type, decorators, optional, checker, visitedTypes = /* @__PURE__ */ new Set()) {
+  const { formSpecFieldType } = convertType(type, checker);
+  const field = {
+    _field: formSpecFieldType,
+    id: fieldName
+  };
+  if (!optional) {
+    field.required = true;
+  }
+  if (formSpecFieldType === "object" && type.flags & ts4.TypeFlags.Object) {
+    if (!visitedTypes.has(type)) {
+      visitedTypes.add(type);
+      const nestedFields = [];
+      for (const propInfo of getObjectPropertyInfos(type, checker)) {
+        nestedFields.push(
+          createFormSpecField(
+            propInfo.name,
+            propInfo.type,
+            propInfo.fieldInfo?.decorators ?? [],
+            propInfo.optional,
+            checker,
+            visitedTypes
+          )
+        );
+      }
+      visitedTypes.delete(type);
+      if (nestedFields.length > 0) {
+        field.fields = nestedFields;
+      }
+    }
+  }
+  for (const dec of decorators) {
+    applyDecoratorToField(field, dec);
+  }
+  return field;
+}
+function applyDecoratorToField(field, decorator) {
+  const { args } = decorator;
+  const resolved = decorator.resolved;
+  const effectiveName = resolved?.extendsBuiltin ?? decorator.name;
+  switch (effectiveName) {
+    case "Field": {
+      const opts = args[0];
+      if (typeof opts === "object" && opts !== null && !Array.isArray(opts)) {
+        if (typeof opts["displayName"] === "string") {
+          field.label = opts["displayName"];
+        }
+        if (typeof opts["description"] === "string") {
+          field.description = opts["description"];
+        }
+        if (typeof opts["placeholder"] === "string") {
+          field.placeholder = opts["placeholder"];
+        }
+      }
+      break;
+    }
+    case "Minimum":
+      if (typeof args[0] === "number") {
+        field.min = args[0];
+      }
+      break;
+    case "Maximum":
+      if (typeof args[0] === "number") {
+        field.max = args[0];
+      }
+      break;
+    case "MinLength":
+      if (typeof args[0] === "number") {
+        field.minLength = args[0];
+      }
+      break;
+    case "MaxLength":
+      if (typeof args[0] === "number") {
+        field.maxLength = args[0];
+      }
+      break;
+    case "Pattern":
+      if (typeof args[0] === "string") {
+        field.pattern = args[0];
+      }
+      break;
+    case "EnumOptions":
+      if (Array.isArray(args[0])) {
+        field.options = args[0];
+      }
+      break;
+    case "ShowWhen":
+      if (typeof args[0] === "object" && args[0] !== null) {
+        field.showWhen = args[0];
+      }
+      break;
+    case "Group":
+      if (typeof args[0] === "string") {
+        field.group = args[0];
+      }
+      break;
+  }
+}
+function applyDecoratorsToSchema(schema, decorators, fieldInfo) {
+  const result = { ...schema };
+  for (const dec of decorators) {
+    const { args } = dec;
+    const resolved = dec.resolved;
+    const effectiveName = resolved?.extendsBuiltin ?? dec.name;
+    switch (effectiveName) {
+      case "Field": {
+        const opts = args[0];
+        if (typeof opts === "object" && opts !== null && !Array.isArray(opts)) {
+          if (typeof opts["displayName"] === "string") {
+            result.title = opts["displayName"];
+          }
+          if (typeof opts["description"] === "string") {
+            result.description = opts["description"];
+          }
+        }
+        break;
+      }
+      case "Minimum":
+        if (typeof args[0] === "number") {
+          result.minimum = args[0];
+        }
+        break;
+      case "Maximum":
+        if (typeof args[0] === "number") {
+          result.maximum = args[0];
+        }
+        break;
+      case "ExclusiveMinimum":
+        if (typeof args[0] === "number") {
+          result.exclusiveMinimum = args[0];
+        }
+        break;
+      case "ExclusiveMaximum":
+        if (typeof args[0] === "number") {
+          result.exclusiveMaximum = args[0];
+        }
+        break;
+      case "MinLength":
+        if (typeof args[0] === "number") {
+          result.minLength = args[0];
+        }
+        break;
+      case "MaxLength":
+        if (typeof args[0] === "number") {
+          result.maxLength = args[0];
+        }
+        break;
+      case "Pattern":
+        if (typeof args[0] === "string") {
+          result.pattern = args[0];
+        }
+        break;
+    }
+    if (resolved?.extensionName && /^[a-z][a-z0-9-]*$/.test(resolved.extensionName)) {
+      const key = `x-formspec-${resolved.extensionName}`;
+      if (resolved.isMarker) {
+        setSchemaExtension(result, key, true);
+      } else {
+        setSchemaExtension(result, key, args[0] ?? true);
+      }
+    }
+  }
+  if (fieldInfo) {
+    if (fieldInfo.deprecated) {
+      result.deprecated = true;
+    }
+    if (fieldInfo.defaultValue !== void 0) {
+      result.default = fieldInfo.defaultValue;
+    }
+  }
+  return result;
+}
+
+// src/analyzer/program.ts
+var ts5 = __toESM(require("typescript"), 1);
+var path = __toESM(require("path"), 1);
+function createProgramContext(filePath) {
+  const absolutePath = path.resolve(filePath);
+  const fileDir = path.dirname(absolutePath);
+  const configPath = ts5.findConfigFile(fileDir, ts5.sys.fileExists.bind(ts5.sys), "tsconfig.json");
+  let compilerOptions;
+  let fileNames;
+  if (configPath) {
+    const configFile = ts5.readConfigFile(configPath, ts5.sys.readFile.bind(ts5.sys));
+    if (configFile.error) {
+      throw new Error(
+        `Error reading tsconfig.json: ${ts5.flattenDiagnosticMessageText(configFile.error.messageText, "\n")}`
+      );
+    }
+    const parsed = ts5.parseJsonConfigFileContent(
+      configFile.config,
+      ts5.sys,
+      path.dirname(configPath)
+    );
+    if (parsed.errors.length > 0) {
+      const errorMessages = parsed.errors.map((e) => ts5.flattenDiagnosticMessageText(e.messageText, "\n")).join("\n");
+      throw new Error(`Error parsing tsconfig.json: ${errorMessages}`);
+    }
+    compilerOptions = parsed.options;
+    fileNames = parsed.fileNames.includes(absolutePath) ? parsed.fileNames : [...parsed.fileNames, absolutePath];
+  } else {
+    compilerOptions = {
+      target: ts5.ScriptTarget.ES2022,
+      module: ts5.ModuleKind.NodeNext,
+      moduleResolution: ts5.ModuleResolutionKind.NodeNext,
+      strict: true,
+      skipLibCheck: true,
+      declaration: true
+    };
+    fileNames = [absolutePath];
+  }
+  const program = ts5.createProgram(fileNames, compilerOptions);
+  const sourceFile = program.getSourceFile(absolutePath);
+  if (!sourceFile) {
+    throw new Error(`Could not find source file: ${absolutePath}`);
+  }
+  return {
+    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;
+    }
+    ts5.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return result;
+}
+function findClassByName(sourceFile, className) {
+  return findNodeByName(sourceFile, className, ts5.isClassDeclaration, (n) => n.name?.text);
+}
+function findInterfaceByName(sourceFile, interfaceName) {
+  return findNodeByName(sourceFile, interfaceName, ts5.isInterfaceDeclaration, (n) => n.name.text);
+}
+function findTypeAliasByName(sourceFile, aliasName) {
+  return findNodeByName(sourceFile, aliasName, ts5.isTypeAliasDeclaration, (n) => n.name.text);
+}
+
+// src/generators/class-schema.ts
+function generateClassSchemas(analysis, checker) {
+  const properties = {};
+  const required = [];
+  const uiElements = [];
+  for (const field of analysis.fields) {
+    const { jsonSchema: baseSchema } = convertType(field.type, checker);
+    const fieldSchema = applyDecoratorsToSchema(baseSchema, field.decorators, field);
+    properties[field.name] = fieldSchema;
+    if (!field.optional) {
+      required.push(field.name);
+    }
+    const formSpecField = createFormSpecField(
+      field.name,
+      field.type,
+      field.decorators,
+      field.optional,
+      checker
+    );
+    uiElements.push(formSpecField);
+  }
+  const jsonSchema = {
+    type: "object",
+    properties,
+    ...required.length > 0 ? { required } : {}
+  };
+  const uiSchema2 = generateUiSchemaFromFields(uiElements);
+  return { jsonSchema, uiSchema: uiSchema2 };
+}
+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 = analyzeClass(classDecl, ctx.checker);
+  return generateClassSchemas(analysis, ctx.checker);
+}
+function generateSchemas(options) {
+  const ctx = createProgramContext(options.filePath);
+  const classDecl = findClassByName(ctx.sourceFile, options.typeName);
+  if (classDecl) {
+    const analysis = analyzeClass(classDecl, ctx.checker);
+    return generateClassSchemas(analysis, ctx.checker);
+  }
+  const interfaceDecl = findInterfaceByName(ctx.sourceFile, options.typeName);
+  if (interfaceDecl) {
+    const analysis = analyzeInterface(interfaceDecl, ctx.checker);
+    return generateClassSchemas(analysis, ctx.checker);
+  }
+  const typeAlias = findTypeAliasByName(ctx.sourceFile, options.typeName);
+  if (typeAlias) {
+    const result = analyzeTypeAlias(typeAlias, ctx.checker);
+    if (result.ok) {
+      return generateClassSchemas(result.analysis, ctx.checker);
+    }
+    throw new Error(result.error);
+  }
+  throw new Error(
+    `Type "${options.typeName}" not found as a class, interface, or type alias in ${options.filePath}`
+  );
+}
+
+// src/codegen/index.ts
+var ts6 = __toESM(require("typescript"), 1);
+var path2 = __toESM(require("path"), 1);
+var fs = __toESM(require("fs"), 1);
+function findDecoratedClasses(files, baseDir) {
+  const program = ts6.createProgram(files, {
+    target: ts6.ScriptTarget.ESNext,
+    module: ts6.ModuleKind.ESNext,
+    moduleResolution: ts6.ModuleResolutionKind.NodeNext,
+    // TC39 Stage 3 decorators — do not use experimentalDecorators
+    strict: true
+  });
+  const checker = program.getTypeChecker();
+  const results = [];
+  for (const sourceFile of program.getSourceFiles()) {
+    if (sourceFile.isDeclarationFile) continue;
+    if (!files.some((f) => path2.resolve(f) === sourceFile.fileName)) continue;
+    ts6.forEachChild(sourceFile, (node) => {
+      if (ts6.isClassDeclaration(node) && hasDecoratedProperties(node)) {
+        const className = node.name?.text;
+        if (!className) return;
+        const typeMetadata = extractTypeMetadata(node, checker);
+        const relativePath = path2.relative(baseDir, sourceFile.fileName);
+        const exported = isClassExported(node, sourceFile);
+        results.push({
+          name: className,
+          sourcePath: relativePath.replace(/\.tsx?$/, ""),
+          typeMetadata,
+          isExported: exported
+        });
+      }
+    });
+  }
+  return results;
+}
+function hasDecoratedProperties(node) {
+  return node.members.some((member) => {
+    if (!ts6.isPropertyDeclaration(member)) return false;
+    const decorators = ts6.getDecorators(member);
+    return decorators !== void 0 && decorators.length > 0;
+  });
+}
+function isClassExported(classNode, sourceFile) {
+  const className = classNode.name?.text;
+  if (!className) return false;
+  const modifiers = ts6.getModifiers(classNode);
+  if (modifiers) {
+    const hasExport = modifiers.some((mod) => mod.kind === ts6.SyntaxKind.ExportKeyword);
+    if (hasExport) return true;
+  }
+  for (const statement of sourceFile.statements) {
+    if (ts6.isExportDeclaration(statement) && statement.exportClause) {
+      if (ts6.isNamedExports(statement.exportClause)) {
+        for (const element of statement.exportClause.elements) {
+          const localName = element.propertyName?.text ?? element.name.text;
+          if (localName === className) {
+            return true;
+          }
+        }
+      }
+    }
+  }
+  return false;
+}
+function extractTypeMetadata(classNode, checker) {
+  const metadata = {};
+  for (const member of classNode.members) {
+    if (!ts6.isPropertyDeclaration(member)) continue;
+    if (!member.name || !ts6.isIdentifier(member.name)) continue;
+    const symbol = checker.getSymbolAtLocation(member.name);
+    if (!symbol) continue;
+    const type = checker.getTypeOfSymbolAtLocation(symbol, member);
+    const fieldName = member.name.text;
+    const isOptional = !!(symbol.flags & ts6.SymbolFlags.Optional);
+    const typeInfo = convertTypeToMetadata(type, checker);
+    if (isOptional) {
+      typeInfo.optional = true;
+    }
+    metadata[fieldName] = typeInfo;
+  }
+  return metadata;
+}
+function convertTypeToMetadata(type, checker, visited = /* @__PURE__ */ new Set()) {
+  const isObjectType = (type.flags & ts6.TypeFlags.Object) !== 0;
+  if (isObjectType) {
+    if (visited.has(type)) {
+      return { type: "unknown" };
+    }
+    visited.add(type);
+  }
+  if (type.isUnion()) {
+    const types = type.types;
+    const nonNullTypes = types.filter(
+      (t) => !(t.flags & (ts6.TypeFlags.Null | ts6.TypeFlags.Undefined))
+    );
+    const hasNull = types.some((t) => t.flags & ts6.TypeFlags.Null);
+    const isBooleanUnion = nonNullTypes.length === 2 && nonNullTypes.every((t) => t.flags & ts6.TypeFlags.BooleanLiteral);
+    if (isBooleanUnion) {
+      const result = { type: "boolean" };
+      if (hasNull) result.nullable = true;
+      return result;
+    }
+    const allStringLiterals = nonNullTypes.every((t) => t.isStringLiteral());
+    if (allStringLiterals && nonNullTypes.length > 0) {
+      const result = {
+        type: "enum",
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion -- TypeScript doesn't narrow array types from `every` predicate
+        values: nonNullTypes.map((t) => t.value)
+      };
+      if (hasNull) result.nullable = true;
+      return result;
+    }
+    const allNumberLiterals = nonNullTypes.every((t) => t.isNumberLiteral());
+    if (allNumberLiterals && nonNullTypes.length > 0) {
+      const result = {
+        type: "enum",
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion -- TypeScript doesn't narrow array types from `every` predicate
+        values: nonNullTypes.map((t) => t.value)
+      };
+      if (hasNull) result.nullable = true;
+      return result;
+    }
+    if (nonNullTypes.length === 1) {
+      const singleType = nonNullTypes[0];
+      if (!singleType) return { type: "unknown" };
+      const result = convertTypeToMetadata(singleType, checker, visited);
+      if (hasNull) result.nullable = true;
+      return result;
+    }
+    return { type: "unknown" };
+  }
+  if (type.flags & ts6.TypeFlags.String) return { type: "string" };
+  if (type.flags & ts6.TypeFlags.Number) return { type: "number" };
+  if (type.flags & ts6.TypeFlags.Boolean) return { type: "boolean" };
+  if (type.isStringLiteral()) {
+    return { type: "enum", values: [type.value] };
+  }
+  if (type.isNumberLiteral()) {
+    return { type: "enum", values: [type.value] };
+  }
+  if (checker.isArrayType(type)) {
+    const typeArgs = type.typeArguments;
+    return {
+      type: "array",
+      itemType: typeArgs?.[0] ? convertTypeToMetadata(typeArgs[0], checker, visited) : { type: "unknown" }
+    };
+  }
+  if (type.flags & ts6.TypeFlags.Object) {
+    const properties = {};
+    for (const prop of type.getProperties()) {
+      const declaration = prop.valueDeclaration ?? prop.declarations?.[0];
+      if (!declaration) continue;
+      const propType = checker.getTypeOfSymbolAtLocation(prop, declaration);
+      const propOptional = !!(prop.flags & ts6.SymbolFlags.Optional);
+      const propMeta = convertTypeToMetadata(propType, checker, visited);
+      if (propOptional) propMeta.optional = true;
+      properties[prop.name] = propMeta;
+    }
+    if (Object.keys(properties).length > 0) {
+      return { type: "object", properties };
+    }
+    return { type: "object" };
+  }
+  return { type: "unknown" };
+}
+function generateCodegenOutput(classes, outputPath, baseDir) {
+  const outputDir = path2.dirname(path2.resolve(outputPath));
+  const lines = [
+    "/**",
+    " * Auto-generated by FormSpec CLI.",
+    " * DO NOT EDIT - changes will be overwritten.",
+    " *",
+    " * This file provides:",
+    " * - Type metadata patches for runtime schema generation",
+    " * - Inferred schema types (e.g., UserFormSchema)",
+    " * - Type-safe FormSpec accessors (e.g., getUserFormFormSpec())",
+    " *",
+    " * Usage:",
+    " *   import { UserFormSchema, getUserFormFormSpec } from './__formspec_types__';",
+    " *",
+    " *   const data: UserFormSchema = { name: 'Alice', country: 'us' };",
+    " *   const spec = getUserFormFormSpec();",
+    " */",
+    "",
+    "/* eslint-disable @typescript-eslint/no-explicit-any */",
+    ""
+  ];
+  for (const cls of classes) {
+    const absoluteSourcePath = path2.resolve(baseDir, cls.sourcePath);
+    const importPath = getRelativeImportPath(outputDir, absoluteSourcePath);
+    lines.push(`import { ${cls.name} } from "${importPath}";`);
+  }
+  lines.push("");
+  lines.push("// =============================================================================");
+  lines.push("// Type Metadata Patches");
+  lines.push("// =============================================================================");
+  lines.push("");
+  for (const cls of classes) {
+    const metadataJson = JSON.stringify(cls.typeMetadata, null, 2).split("\n").map((line, i) => i === 0 ? line : "  " + line).join("\n");
+    lines.push(`(${cls.name} as any).__formspec_types__ = ${metadataJson};`);
+    lines.push("");
+  }
+  lines.push("// =============================================================================");
+  lines.push("// Inferred Schema Types");
+  lines.push("// =============================================================================");
+  lines.push("");
+  for (const cls of classes) {
+    lines.push(generateSchemaType(cls));
+    lines.push("");
+  }
+  lines.push("// =============================================================================");
+  lines.push("// Type-Safe FormSpec Accessors");
+  lines.push("// =============================================================================");
+  lines.push("");
+  for (const cls of classes) {
+    lines.push(generateTypedAccessor(cls));
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function metadataToTypeString(metadata) {
+  const baseType = metadataToBaseTypeString(metadata);
+  if (metadata.nullable && metadata.optional) {
+    return `${baseType} | null | undefined`;
+  }
+  if (metadata.nullable) {
+    return `${baseType} | null`;
+  }
+  if (metadata.optional) {
+    return `${baseType} | undefined`;
+  }
+  return baseType;
+}
+var VALID_IDENTIFIER = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+var RESERVED_WORDS = /* @__PURE__ */ new Set([
+  // Keywords
+  "break",
+  "case",
+  "catch",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "in",
+  "instanceof",
+  "new",
+  "return",
+  "switch",
+  "this",
+  "throw",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+  "class",
+  "const",
+  "enum",
+  "export",
+  "extends",
+  "import",
+  "super",
+  "implements",
+  "interface",
+  "let",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "static",
+  "yield",
+  // ES6+ keywords
+  "async",
+  "await",
+  // Literal values (not technically keywords but best to quote)
+  "null",
+  "true",
+  "false",
+  // Accessor keywords
+  "get",
+  "set",
+  // Strict mode reserved
+  "arguments",
+  "eval"
+]);
+function needsPropertyQuoting(key) {
+  if (!VALID_IDENTIFIER.test(key)) {
+    return true;
+  }
+  return RESERVED_WORDS.has(key);
+}
+function escapePropertyKey(key) {
+  if (needsPropertyQuoting(key)) {
+    return JSON.stringify(key);
+  }
+  return key;
+}
+function metadataToBaseTypeString(metadata) {
+  switch (metadata.type) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "enum":
+      if (metadata.values && metadata.values.length > 0) {
+        return metadata.values.map((v) => typeof v === "string" ? JSON.stringify(v) : String(v)).join(" | ");
+      }
+      return "string";
+    case "array":
+      if (metadata.itemType) {
+        const itemType = metadataToTypeString(metadata.itemType);
+        if (itemType.includes("|")) {
+          return `(${itemType})[]`;
+        }
+        return `${itemType}[]`;
+      }
+      return "unknown[]";
+    case "object":
+      if (metadata.properties && Object.keys(metadata.properties).length > 0) {
+        const props = Object.entries(metadata.properties).map(([key, propMeta]) => {
+          const optional = propMeta.optional ? "?" : "";
+          return `${escapePropertyKey(key)}${optional}: ${metadataToTypeString(propMeta)}`;
+        }).join("; ");
+        return `{ ${props} }`;
+      }
+      return "Record<string, unknown>";
+    default:
+      return "unknown";
+  }
+}
+function generateSchemaType(cls) {
+  const props = Object.entries(cls.typeMetadata).map(([fieldName, metadata]) => {
+    const optional = metadata.optional ? "?" : "";
+    const typeStr = metadataToTypeString(metadata);
+    return `  ${escapePropertyKey(fieldName)}${optional}: ${typeStr};`;
+  }).join("\n");
+  return `export type ${cls.name}Schema = {
+${props}
+};`;
+}
+function metadataTypeToFieldType(type) {
+  switch (type) {
+    case "string":
+      return "text";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "enum":
+      return "enum";
+    case "array":
+      return "array";
+    case "object":
+      return "object";
+    default:
+      return "text";
+  }
+}
+function generateTypedAccessor(cls) {
+  const lines = [];
+  const elementTypes = Object.entries(cls.typeMetadata).map(([fieldName, metadata]) => {
+    const fieldType = metadataTypeToFieldType(metadata.type);
+    const required = !metadata.optional;
+    let elementType = `{ readonly _field: "${fieldType}"; readonly id: "${fieldName}"; readonly required: ${String(required)}`;
+    if (metadata.type === "enum" && metadata.values) {
+      const optionValues = metadata.values.map((v) => typeof v === "string" ? JSON.stringify(v) : String(v)).join(", ");
+      elementType += `; readonly options: readonly [${optionValues}]`;
+    }
+    elementType += " }";
+    return elementType;
+  });
+  lines.push(`export type ${cls.name}Elements = readonly [
+  ${elementTypes.join(",\n  ")}
+];`);
+  lines.push("");
+  lines.push(`export type ${cls.name}FormSpec = { readonly elements: ${cls.name}Elements };`);
+  lines.push("");
+  lines.push(`/**`);
+  lines.push(` * Type-safe FormSpec accessor for ${cls.name}.`);
+  lines.push(` * Reads the patched type metadata from the class.`);
+  lines.push(` */`);
+  lines.push(`export function get${cls.name}FormSpec(): ${cls.name}FormSpec {`);
+  lines.push(
+    `  const types = (${cls.name} as any).__formspec_types__ as Record<string, unknown>[];`
+  );
+  lines.push(`  return { elements: types } as unknown as ${cls.name}FormSpec;`);
+  lines.push(`}`);
+  return lines.join("\n");
+}
+function getRelativeImportPath(outputDir, sourcePath) {
+  let relativePath = path2.relative(outputDir, sourcePath);
+  if (!relativePath.startsWith(".")) {
+    relativePath = "./" + relativePath;
+  }
+  relativePath = relativePath.replace(/\\/g, "/");
+  return relativePath + ".js";
+}
+function runCodegen(options) {
+  const baseDir = options.baseDir ?? path2.dirname(options.output);
+  const absoluteFiles = options.files.map((f) => path2.resolve(f));
+  console.log(`Scanning ${String(absoluteFiles.length)} file(s) for decorated classes...`);
+  const classes = findDecoratedClasses(absoluteFiles, baseDir);
+  if (classes.length === 0) {
+    console.log("No decorated classes found.");
+    return;
+  }
+  console.log(`Found ${String(classes.length)} decorated class(es):`);
+  for (const cls of classes) {
+    const fieldCount = Object.keys(cls.typeMetadata).length;
+    console.log(`  - ${cls.name} (${String(fieldCount)} field(s))`);
+  }
+  const unexported = classes.filter((cls) => !cls.isExported);
+  if (unexported.length > 0) {
+    console.warn(
+      `
+\u26A0\uFE0F  Warning: The following decorated classes are not exported from their source files:`
+    );
+    for (const cls of unexported) {
+      console.warn(`   - ${cls.name} (${cls.sourcePath})`);
+    }
+    console.warn(
+      `
+   The generated code will fail to compile because it cannot import these classes.`
+    );
+    console.warn(`   To fix this, add 'export' to the class declaration, for example:`);
+    console.warn(`     export class YourClassName { ... }
+`);
+  }
+  const output = generateCodegenOutput(classes, options.output, baseDir);
+  const outputDir = path2.dirname(options.output);
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+  fs.writeFileSync(options.output, output);
+  console.log(`
+Generated: ${options.output}`);
+}
+
+// src/index.ts
+function buildFormSchemas(form) {
+  return {
+    jsonSchema: generateJsonSchema(form),
+    uiSchema: generateUiSchema(form)
+  };
+}
+function writeSchemas(form, options) {
+  const { outDir, name = "schema", indent = 2 } = options;
+  const { jsonSchema, uiSchema: uiSchema2 } = buildFormSchemas(form);
+  if (!fs2.existsSync(outDir)) {
+    fs2.mkdirSync(outDir, { recursive: true });
+  }
+  const jsonSchemaPath = path3.join(outDir, `${name}-schema.json`);
+  const uiSchemaPath = path3.join(outDir, `${name}-uischema.json`);
+  fs2.writeFileSync(jsonSchemaPath, JSON.stringify(jsonSchema, null, indent));
+  fs2.writeFileSync(uiSchemaPath, JSON.stringify(uiSchema2, null, indent));
+  return { jsonSchemaPath, uiSchemaPath };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildFormSchemas,
+  categorizationSchema,
+  categorySchema,
+  controlSchema,
+  findDecoratedClasses,
+  generateCodegenOutput,
+  generateJsonSchema,
+  generateSchemas,
+  generateSchemasFromClass,
+  generateUiSchema,
+  generateUiSchemaFromFields,
+  getSchemaExtension,
+  groupLayoutSchema,
+  horizontalLayoutSchema,
+  jsonSchema7Schema,
+  jsonSchemaTypeSchema,
+  labelElementSchema,
+  ruleConditionSchema,
+  ruleEffectSchema,
+  ruleSchema,
+  runCodegen,
+  schemaBasedConditionSchema,
+  setSchemaExtension,
+  uiSchemaElementSchema,
+  uiSchemaElementTypeSchema,
+  uiSchemaSchema,
+  verticalLayoutSchema,
+  writeSchemas
+});
+//# sourceMappingURL=index.cjs.map