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

package/dist/cli.js

@@ -1,22 +1,2131 @@
 #!/usr/bin/env node
-/**
- * FormSpec CLI - Generate JSON Schema and UI Schema from form definitions
- *
- * Usage:
- *   formspec-build <input-file> [options]
- *
- * Options:
- *   -o, --out-dir <dir>   Output directory (default: ./generated)
- *   -n, --name <name>     Base name for output files (default: derived from input)
- *   -h, --help            Show help
- *
- * Example:
- *   formspec-build src/forms/product.ts -o ./schemas -n product
- */
-import * as path from "node:path";
-import { pathToFileURL } from "node:url";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/json-schema/schema.ts
+import { z } from "zod";
+var jsonSchemaTypeSchema, jsonSchema7Schema;
+var init_schema = __esm({
+  "src/json-schema/schema.ts"() {
+    "use strict";
+    jsonSchemaTypeSchema = z.enum([
+      "string",
+      "number",
+      "integer",
+      "boolean",
+      "object",
+      "array",
+      "null"
+    ]);
+    jsonSchema7Schema = z.lazy(
+      () => z.object({
+        $schema: z.string().optional(),
+        $id: z.string().optional(),
+        $ref: z.string().optional(),
+        // Metadata
+        title: z.string().optional(),
+        description: z.string().optional(),
+        deprecated: z.boolean().optional(),
+        // Type
+        type: z.union([jsonSchemaTypeSchema, z.array(jsonSchemaTypeSchema)]).optional(),
+        // String validation
+        minLength: z.number().optional(),
+        maxLength: z.number().optional(),
+        pattern: z.string().optional(),
+        // Number validation
+        minimum: z.number().optional(),
+        maximum: z.number().optional(),
+        exclusiveMinimum: z.number().optional(),
+        exclusiveMaximum: z.number().optional(),
+        // Enum
+        enum: z.array(z.union([z.string(), z.number(), z.boolean(), z.null()])).readonly().optional(),
+        const: z.union([z.string(), z.number(), z.boolean(), z.null()]).optional(),
+        // Object
+        properties: z.record(z.string(), jsonSchema7Schema).optional(),
+        required: z.array(z.string()).optional(),
+        additionalProperties: z.union([z.boolean(), jsonSchema7Schema]).optional(),
+        // Array
+        items: z.union([jsonSchema7Schema, z.array(jsonSchema7Schema)]).optional(),
+        minItems: z.number().optional(),
+        maxItems: z.number().optional(),
+        // Composition
+        allOf: z.array(jsonSchema7Schema).optional(),
+        anyOf: z.array(jsonSchema7Schema).optional(),
+        oneOf: z.array(jsonSchema7Schema).optional(),
+        not: jsonSchema7Schema.optional(),
+        // Conditional
+        if: jsonSchema7Schema.optional(),
+        then: jsonSchema7Schema.optional(),
+        else: jsonSchema7Schema.optional(),
+        // Format
+        format: z.string().optional(),
+        // Default
+        default: z.unknown().optional(),
+        // FormSpec extensions
+        "x-formspec-source": z.string().optional(),
+        "x-formspec-params": z.array(z.string()).readonly().optional(),
+        "x-formspec-schemaSource": z.string().optional()
+      }).passthrough()
+    );
+  }
+});
+
+// src/json-schema/generator.ts
+import { z as z2 } from "zod";
+function parseOrThrow(schema, value, label) {
+  try {
+    return schema.parse(value);
+  } catch (error) {
+    if (error instanceof z2.ZodError) {
+      throw new Error(
+        `Generated ${label} failed validation:
+${error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n")}`
+      );
+    }
+    throw error;
+  }
+}
+function 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");
+}
+var init_generator = __esm({
+  "src/json-schema/generator.ts"() {
+    "use strict";
+    init_schema();
+  }
+});
+
+// src/ui-schema/schema.ts
+import { z as z3 } from "zod";
+var jsonPointerSchema, ruleEffectSchema, uiSchemaElementTypeSchema, ruleConditionSchema, schemaBasedConditionSchema, ruleSchema, uiSchemaElementSchema, controlSchema, verticalLayoutSchema, horizontalLayoutSchema, groupLayoutSchema, categorySchema, categorizationSchema, labelElementSchema, uiSchema;
+var init_schema2 = __esm({
+  "src/ui-schema/schema.ts"() {
+    "use strict";
+    jsonPointerSchema = z3.string();
+    ruleEffectSchema = z3.enum(["SHOW", "HIDE", "ENABLE", "DISABLE"]);
+    uiSchemaElementTypeSchema = z3.enum([
+      "Control",
+      "VerticalLayout",
+      "HorizontalLayout",
+      "Group",
+      "Categorization",
+      "Category",
+      "Label"
+    ]);
+    ruleConditionSchema = z3.lazy(
+      () => z3.object({
+        const: z3.unknown().optional(),
+        enum: z3.array(z3.unknown()).readonly().optional(),
+        type: z3.string().optional(),
+        not: ruleConditionSchema.optional(),
+        minimum: z3.number().optional(),
+        maximum: z3.number().optional(),
+        exclusiveMinimum: z3.number().optional(),
+        exclusiveMaximum: z3.number().optional(),
+        minLength: z3.number().optional(),
+        properties: z3.record(z3.string(), ruleConditionSchema).optional(),
+        required: z3.array(z3.string()).optional(),
+        allOf: z3.array(ruleConditionSchema).optional()
+      }).strict()
+    );
+    schemaBasedConditionSchema = z3.object({
+      scope: jsonPointerSchema,
+      schema: ruleConditionSchema
+    }).strict();
+    ruleSchema = z3.object({
+      effect: ruleEffectSchema,
+      condition: schemaBasedConditionSchema
+    }).strict();
+    uiSchemaElementSchema = z3.lazy(
+      () => z3.union([
+        controlSchema,
+        verticalLayoutSchema,
+        horizontalLayoutSchema,
+        groupLayoutSchema,
+        categorizationSchema,
+        categorySchema,
+        labelElementSchema
+      ])
+    );
+    controlSchema = z3.object({
+      type: z3.literal("Control"),
+      scope: jsonPointerSchema,
+      label: z3.union([z3.string(), z3.literal(false)]).optional(),
+      rule: ruleSchema.optional(),
+      options: z3.record(z3.string(), z3.unknown()).optional()
+    }).passthrough();
+    verticalLayoutSchema = z3.lazy(
+      () => z3.object({
+        type: z3.literal("VerticalLayout"),
+        elements: z3.array(uiSchemaElementSchema),
+        rule: ruleSchema.optional(),
+        options: z3.record(z3.string(), z3.unknown()).optional()
+      }).passthrough()
+    );
+    horizontalLayoutSchema = z3.lazy(
+      () => z3.object({
+        type: z3.literal("HorizontalLayout"),
+        elements: z3.array(uiSchemaElementSchema),
+        rule: ruleSchema.optional(),
+        options: z3.record(z3.string(), z3.unknown()).optional()
+      }).passthrough()
+    );
+    groupLayoutSchema = z3.lazy(
+      () => z3.object({
+        type: z3.literal("Group"),
+        label: z3.string(),
+        elements: z3.array(uiSchemaElementSchema),
+        rule: ruleSchema.optional(),
+        options: z3.record(z3.string(), z3.unknown()).optional()
+      }).passthrough()
+    );
+    categorySchema = z3.lazy(
+      () => z3.object({
+        type: z3.literal("Category"),
+        label: z3.string(),
+        elements: z3.array(uiSchemaElementSchema),
+        rule: ruleSchema.optional(),
+        options: z3.record(z3.string(), z3.unknown()).optional()
+      }).passthrough()
+    );
+    categorizationSchema = z3.lazy(
+      () => z3.object({
+        type: z3.literal("Categorization"),
+        elements: z3.array(categorySchema),
+        label: z3.string().optional(),
+        rule: ruleSchema.optional(),
+        options: z3.record(z3.string(), z3.unknown()).optional()
+      }).passthrough()
+    );
+    labelElementSchema = z3.object({
+      type: z3.literal("Label"),
+      text: z3.string(),
+      rule: ruleSchema.optional(),
+      options: z3.record(z3.string(), z3.unknown()).optional()
+    }).passthrough();
+    uiSchema = z3.lazy(
+      () => z3.union([verticalLayoutSchema, horizontalLayoutSchema, groupLayoutSchema, categorizationSchema])
+    );
+  }
+});
+
+// src/ui-schema/generator.ts
+import { z as z4 } from "zod";
+function parseOrThrow2(schema, value, label) {
+  try {
+    return schema.parse(value);
+  } catch (error) {
+    if (error instanceof z4.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");
+}
+var init_generator2 = __esm({
+  "src/ui-schema/generator.ts"() {
+    "use strict";
+    init_schema2();
+  }
+});
+
+// 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/analyzer/decorator-extractor.ts
+import * as ts from "typescript";
+import "@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;
+}
+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;
+}
+var FORMSPEC_DECORATORS;
+var init_decorator_extractor = __esm({
+  "src/analyzer/decorator-extractor.ts"() {
+    "use strict";
+    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"] }
+    };
+  }
+});
+
+// src/analyzer/jsdoc-constraints.ts
+import * as ts2 from "typescript";
+import { CONSTRAINT_TAG_DEFINITIONS } from "@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 CONSTRAINT_TAG_DEFINITIONS)) {
+      continue;
+    }
+    const constraintName = tagName;
+    const expectedType = 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
+  };
+}
+var init_jsdoc_constraints = __esm({
+  "src/analyzer/jsdoc-constraints.ts"() {
+    "use strict";
+  }
+});
+
+// src/analyzer/class-analyzer.ts
+import * as ts3 from "typescript";
+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
+  };
+}
+var init_class_analyzer = __esm({
+  "src/analyzer/class-analyzer.ts"() {
+    "use strict";
+    init_decorator_extractor();
+    init_jsdoc_constraints();
+  }
+});
+
+// src/analyzer/type-converter.ts
+import * as ts4 from "typescript";
+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;
+}
+var init_type_converter = __esm({
+  "src/analyzer/type-converter.ts"() {
+    "use strict";
+    init_class_analyzer();
+    init_types();
+  }
+});
+
+// src/analyzer/program.ts
+import * as ts5 from "typescript";
+import * as path from "path";
+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);
+}
+var init_program = __esm({
+  "src/analyzer/program.ts"() {
+    "use strict";
+  }
+});
+
+// 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}`
+  );
+}
+var init_class_schema = __esm({
+  "src/generators/class-schema.ts"() {
+    "use strict";
+    init_type_converter();
+    init_generator2();
+    init_program();
+    init_class_analyzer();
+  }
+});
+
+// src/codegen/index.ts
+import * as ts6 from "typescript";
+import * as path2 from "path";
+import * as fs from "fs";
+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;
+}
+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}`);
+}
+var VALID_IDENTIFIER, RESERVED_WORDS;
+var init_codegen = __esm({
+  "src/codegen/index.ts"() {
+    "use strict";
+    VALID_IDENTIFIER = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+    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"
+    ]);
+  }
+});
+
+// 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
+});
+import * as fs2 from "fs";
+import * as path3 from "path";
+function buildFormSchemas(form) {
+  return {
+    jsonSchema: generateJsonSchema(form),
+    uiSchema: generateUiSchema(form)
+  };
+}
+function writeSchemas(form, options) {
+  const { outDir, name = "schema", indent = 2 } = options;
+  const { jsonSchema, uiSchema: uiSchema2 } = buildFormSchemas(form);
+  if (!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 };
+}
+var init_index = __esm({
+  "src/index.ts"() {
+    "use strict";
+    init_generator();
+    init_generator2();
+    init_types();
+    init_schema2();
+    init_schema();
+    init_generator();
+    init_generator2();
+    init_class_schema();
+    init_codegen();
+  }
+});
+
+// src/cli.ts
+import * as path4 from "path";
+import { pathToFileURL } from "url";
 function printHelp() {
-    console.log(`
+  console.log(`
 FormSpec Build CLI - Generate JSON Schema and UI Schema
 
 Usage:
@@ -38,101 +2147,93 @@ The input file should export a FormSpec as its default export or as 'form':
 `);
 }
 function parseArgs(args) {
-    const positional = [];
-    let outDir = "./generated";
-    let name = "";
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (arg === undefined)
-            continue;
-        if (arg === "-h" || arg === "--help") {
-            printHelp();
-            process.exit(0);
-        }
-        if (arg === "-o" || arg === "--out-dir") {
-            const nextArg = args[i + 1];
-            if (!nextArg) {
-                console.error("Error: --out-dir requires a value");
-                return null;
-            }
-            outDir = nextArg;
-            i++;
-            continue;
-        }
-        if (arg === "-n" || arg === "--name") {
-            const nextArg = args[i + 1];
-            if (!nextArg) {
-                console.error("Error: --name requires a value");
-                return null;
-            }
-            name = nextArg;
-            i++;
-            continue;
-        }
-        if (arg.startsWith("-")) {
-            console.error(`Error: Unknown option: ${arg}`);
-            return null;
-        }
-        positional.push(arg);
+  const positional = [];
+  let outDir = "./generated";
+  let name = "";
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === void 0) continue;
+    if (arg === "-h" || arg === "--help") {
+      printHelp();
+      process.exit(0);
     }
-    if (positional.length === 0) {
-        console.error("Error: No input file specified");
-        printHelp();
+    if (arg === "-o" || arg === "--out-dir") {
+      const nextArg = args[i + 1];
+      if (!nextArg) {
+        console.error("Error: --out-dir requires a value");
         return null;
+      }
+      outDir = nextArg;
+      i++;
+      continue;
     }
-    const inputFile = positional[0];
-    if (!inputFile) {
-        console.error("Error: No input file specified");
+    if (arg === "-n" || arg === "--name") {
+      const nextArg = args[i + 1];
+      if (!nextArg) {
+        console.error("Error: --name requires a value");
         return null;
+      }
+      name = nextArg;
+      i++;
+      continue;
     }
-    // Default name from input file
-    if (!name) {
-        name = path.basename(inputFile, path.extname(inputFile));
+    if (arg.startsWith("-")) {
+      console.error(`Error: Unknown option: ${arg}`);
+      return null;
     }
-    return { inputFile, outDir, name };
+    positional.push(arg);
+  }
+  if (positional.length === 0) {
+    console.error("Error: No input file specified");
+    printHelp();
+    return null;
+  }
+  const inputFile = positional[0];
+  if (!inputFile) {
+    console.error("Error: No input file specified");
+    return null;
+  }
+  if (!name) {
+    name = path4.basename(inputFile, path4.extname(inputFile));
+  }
+  return { inputFile, outDir, name };
 }
 async function main() {
-    const args = process.argv.slice(2);
-    const options = parseArgs(args);
-    if (!options) {
-        process.exit(1);
-    }
-    const { inputFile, outDir, name } = options;
-    // Resolve input file path
-    const absoluteInput = path.resolve(process.cwd(), inputFile);
-    try {
-        // Dynamically import the input file
-        // Use file URL for cross-platform compatibility (Windows paths need file:// URLs)
-        const fileUrl = pathToFileURL(absoluteInput).href;
-        const module = (await import(fileUrl));
-        // Look for the form export
-        const form = module["default"] ?? module["form"];
-        if (!form ||
-            typeof form !== "object" ||
-            !("elements" in form)) {
-            console.error("Error: Input file must export a FormSpec as default export or as 'form'");
-            console.error("Example:");
-            console.error('  export default formspec(field.text("name"));');
-            console.error("  // or");
-            console.error('  export const form = formspec(field.text("name"));');
-            process.exit(1);
-        }
-        // Import writeSchemas dynamically to avoid circular deps
-        const { writeSchemas } = await import("./index.js");
-        const { jsonSchemaPath, uiSchemaPath } = writeSchemas(form, { outDir, name });
-        console.log("Generated:");
-        console.log(`  ${jsonSchemaPath}`);
-        console.log(`  ${uiSchemaPath}`);
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            console.error(`Error: ${error.message}`);
-        }
-        else {
-            console.error("Error:", error);
-        }
-        process.exit(1);
+  const args = process.argv.slice(2);
+  const options = parseArgs(args);
+  if (!options) {
+    process.exit(1);
+  }
+  const { inputFile, outDir, name } = options;
+  const absoluteInput = path4.resolve(process.cwd(), inputFile);
+  try {
+    const fileUrl = pathToFileURL(absoluteInput).href;
+    const module = await import(fileUrl);
+    const form = module["default"] ?? module["form"];
+    if (!form || typeof form !== "object" || !("elements" in form)) {
+      console.error("Error: Input file must export a FormSpec as default export or as 'form'");
+      console.error("Example:");
+      console.error('  export default formspec(field.text("name"));');
+      console.error("  // or");
+      console.error('  export const form = formspec(field.text("name"));');
+      process.exit(1);
+    }
+    const { writeSchemas: writeSchemas2 } = await Promise.resolve().then(() => (init_index(), index_exports));
+    const { jsonSchemaPath, uiSchemaPath } = writeSchemas2(
+      form,
+      { outDir, name }
+    );
+    console.log("Generated:");
+    console.log(`  ${jsonSchemaPath}`);
+    console.log(`  ${uiSchemaPath}`);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`Error: ${error.message}`);
+    } else {
+      console.error("Error:", error);
     }
+    process.exit(1);
+  }
 }
 void main();
 //# sourceMappingURL=cli.js.map