@formspec/build 0.1.0-alpha.14 → 0.1.0-alpha.15

package/dist/index.d.ts

@@ -23,16 +23,26 @@
  * @packageDocumentation
  */
 import type { FormElement, FormSpec } from "@formspec/core";
-import type { JsonSchema2020 } from "./json-schema/ir-generator.js";
+import { type GenerateJsonSchemaOptions } from "./json-schema/generator.js";
+import { type GenerateJsonSchemaFromIROptions, type JsonSchema2020 } from "./json-schema/ir-generator.js";
 import type { UISchema } from "./ui-schema/types.js";
 export type { JsonSchema2020 } from "./json-schema/ir-generator.js";
+export type { GenerateJsonSchemaFromIROptions } from "./json-schema/ir-generator.js";
+export type { GenerateJsonSchemaOptions } from "./json-schema/generator.js";
 export type { JSONSchema7, JSONSchemaType, ExtendedJSONSchema7, FormSpecSchemaExtensions, } from "./json-schema/types.js";
 export { setSchemaExtension, getSchemaExtension } from "./json-schema/types.js";
+export { createExtensionRegistry } from "./extensions/index.js";
+export type { ExtensionRegistry } from "./extensions/index.js";
 export type { UISchema, UISchemaElement, UISchemaElementBase, UISchemaElementType, ControlElement, VerticalLayout, HorizontalLayout, GroupLayout, Categorization, Category, LabelElement, Rule, RuleEffect, RuleConditionSchema, SchemaBasedCondition, } from "./ui-schema/types.js";
 export type { ClassSchemas, GenerateFromClassOptions, GenerateFromClassResult, GenerateSchemasOptions, } from "./generators/class-schema.js";
 export { ruleEffectSchema, uiSchemaElementTypeSchema, ruleConditionSchema, schemaBasedConditionSchema, ruleSchema, controlSchema, verticalLayoutSchema, horizontalLayoutSchema, groupLayoutSchema, categorizationSchema, categorySchema, labelElementSchema, uiSchemaElementSchema, uiSchema as uiSchemaSchema, } from "./ui-schema/schema.js";
 export { jsonSchemaTypeSchema, jsonSchema7Schema } from "./json-schema/schema.js";
 export { generateJsonSchema } from "./json-schema/generator.js";
+/**
+ * Advanced API — consumers are responsible for supplying canonical FormIR.
+ * Most callers should prefer `generateJsonSchema()` or `buildFormSchemas()`.
+ */
+export { generateJsonSchemaFromIR } from "./json-schema/ir-generator.js";
 export { generateUiSchema } from "./ui-schema/generator.js";
 export { generateSchemasFromClass, generateSchemas } from "./generators/class-schema.js";
 /**
@@ -44,6 +54,13 @@ export interface BuildResult {
     /** JSON Forms UI Schema for rendering */
     readonly uiSchema: UISchema;
 }
+/**
+ * Options for building schemas from a FormSpec.
+ *
+ * Currently identical to `GenerateJsonSchemaOptions`. Defined separately so the
+ * Chain DSL surface can grow independently in the future if needed.
+ */
+export type BuildFormSchemasOptions = GenerateJsonSchemaOptions;
 /**
  * Builds both JSON Schema and UI Schema from a FormSpec.
  *
@@ -71,11 +88,11 @@ export interface BuildResult {
  * @param form - The FormSpec to build schemas from
  * @returns Object containing both jsonSchema and uiSchema
  */
-export declare function buildFormSchemas<E extends readonly FormElement[]>(form: FormSpec<E>): BuildResult;
+export declare function buildFormSchemas<E extends readonly FormElement[]>(form: FormSpec<E>, options?: BuildFormSchemasOptions): BuildResult;
 /**
  * Options for writing schemas to disk.
  */
-export interface WriteSchemasOptions {
+export interface WriteSchemasOptions extends GenerateJsonSchemaFromIROptions {
     /** Output directory for the schema files */
     readonly outDir: string;
     /** Base name for the output files (without extension). Defaults to "schema" */

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAG5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AACpE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAQrD,YAAY,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAEpE,YAAY,EACV,WAAW,EACX,cAAc,EACd,mBAAmB,EACnB,wBAAwB,GACzB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEhF,YAAY,EACV,QAAQ,EACR,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,WAAW,EACX,cAAc,EACd,QAAQ,EACR,YAAY,EACZ,IAAI,EACJ,UAAU,EACV,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,sBAAsB,CAAC;AAE9B,YAAY,EACV,YAAY,EACZ,wBAAwB,EACxB,uBAAuB,EACvB,sBAAsB,GACvB,MAAM,8BAA8B,CAAC;AAMtC,OAAO,EACL,gBAAgB,EAChB,yBAAyB,EACzB,mBAAmB,EACnB,0BAA0B,EAC1B,UAAU,EACV,aAAa,EACb,oBAAoB,EACpB,sBAAsB,EACtB,iBAAiB,EACjB,oBAAoB,EACpB,cAAc,EACd,kBAAkB,EAClB,qBAAqB,EACrB,QAAQ,IAAI,cAAc,GAC3B,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAMlF,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAM5D,OAAO,EAAE,wBAAwB,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAKzF;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,yCAAyC;IACzC,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC;IACpC,yCAAyC;IACzC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,SAAS,WAAW,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,WAAW,CAKjG;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,4CAA4C;IAC5C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,+EAA+E;IAC/E,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,2DAA2D;IAC3D,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,6CAA6C;IAC7C,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,2CAA2C;IAC3C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,SAAS,WAAW,EAAE,EAC3D,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,EACjB,OAAO,EAAE,mBAAmB,GAC3B,kBAAkB,CAmBpB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -177,7 +177,7 @@ function canonicalizeArrayField(field) {
   const itemsType = {
     kind: "object",
     properties: itemProperties,
-    additionalProperties: false
+    additionalProperties: true
   };
   const type = { kind: "array", items: itemsType };
   const constraints = [];
@@ -212,7 +212,7 @@ function canonicalizeObjectField(field) {
   const type = {
     kind: "object",
     properties,
-    additionalProperties: false
+    additionalProperties: true
   };
   return buildFieldNode(field.name, type, field.required, buildAnnotations(field.label));
 }
@@ -384,11 +384,21 @@ function wrapInConditional(field, layout, provenance) {
 }
 
 // src/json-schema/ir-generator.ts
-function makeContext() {
-  return { defs: {} };
+function makeContext(options) {
+  const vendorPrefix = options?.vendorPrefix ?? "x-formspec";
+  if (!vendorPrefix.startsWith("x-")) {
+    throw new Error(
+      `Invalid vendorPrefix "${vendorPrefix}". Extension JSON Schema keywords must start with "x-".`
+    );
+  }
+  return {
+    defs: {},
+    extensionRegistry: options?.extensionRegistry,
+    vendorPrefix
+  };
 }
-function generateJsonSchemaFromIR(ir) {
-  const ctx = makeContext();
+function generateJsonSchemaFromIR(ir, options) {
+  const ctx = makeContext(options);
   for (const [name, typeDef] of Object.entries(ir.typeRegistry)) {
     ctx.defs[name] = generateTypeNode(typeDef.type, ctx);
   }
@@ -440,16 +450,16 @@ function generateFieldSchema(field, ctx) {
       directConstraints.push(c);
     }
   }
-  applyConstraints(schema, directConstraints);
-  applyAnnotations(schema, field.annotations);
+  applyConstraints(schema, directConstraints, ctx);
+  applyAnnotations(schema, field.annotations, ctx);
   if (pathConstraints.length === 0) {
     return schema;
   }
-  return applyPathTargetedConstraints(schema, pathConstraints);
+  return applyPathTargetedConstraints(schema, pathConstraints, ctx);
 }
-function applyPathTargetedConstraints(schema, pathConstraints) {
+function applyPathTargetedConstraints(schema, pathConstraints, ctx) {
   if (schema.type === "array" && schema.items) {
-    schema.items = applyPathTargetedConstraints(schema.items, pathConstraints);
+    schema.items = applyPathTargetedConstraints(schema.items, pathConstraints, ctx);
     return schema;
   }
   const byTarget = /* @__PURE__ */ new Map();
@@ -463,7 +473,7 @@ function applyPathTargetedConstraints(schema, pathConstraints) {
   const propertyOverrides = {};
   for (const [target, constraints] of byTarget) {
     const subSchema = {};
-    applyConstraints(subSchema, constraints);
+    applyConstraints(subSchema, constraints, ctx);
     propertyOverrides[target] = subSchema;
   }
   if (schema.$ref) {
@@ -507,6 +517,8 @@ function generateTypeNode(type, ctx) {
       return generateArrayType(type, ctx);
     case "object":
       return generateObjectType(type, ctx);
+    case "record":
+      return generateRecordType(type, ctx);
     case "union":
       return generateUnionType(type, ctx);
     case "reference":
@@ -514,7 +526,7 @@ function generateTypeNode(type, ctx) {
     case "dynamic":
       return generateDynamicType(type);
     case "custom":
-      return generateCustomType(type);
+      return generateCustomType(type, ctx);
     default: {
       const _exhaustive = type;
       return _exhaustive;
@@ -563,16 +575,27 @@ function generateObjectType(type, ctx) {
   }
   return schema;
 }
+function generateRecordType(type, ctx) {
+  return {
+    type: "object",
+    additionalProperties: generateTypeNode(type.valueType, ctx)
+  };
+}
 function generatePropertySchema(prop, ctx) {
   const schema = generateTypeNode(prop.type, ctx);
-  applyConstraints(schema, prop.constraints);
-  applyAnnotations(schema, prop.annotations);
+  applyConstraints(schema, prop.constraints, ctx);
+  applyAnnotations(schema, prop.annotations, ctx);
   return schema;
 }
 function generateUnionType(type, ctx) {
   if (isBooleanUnion(type)) {
     return { type: "boolean" };
   }
+  if (isNullableUnion(type)) {
+    return {
+      oneOf: type.members.map((m) => generateTypeNode(m, ctx))
+    };
+  }
   return {
     anyOf: type.members.map((m) => generateTypeNode(m, ctx))
   };
@@ -582,6 +605,13 @@ function isBooleanUnion(type) {
   const kinds = type.members.map((m) => m.kind);
   return kinds.every((k) => k === "primitive") && type.members.every((m) => m.kind === "primitive" && m.primitiveKind === "boolean");
 }
+function isNullableUnion(type) {
+  if (type.members.length !== 2) return false;
+  const nullCount = type.members.filter(
+    (m) => m.kind === "primitive" && m.primitiveKind === "null"
+  ).length;
+  return nullCount === 1;
+}
 function generateReferenceType(type) {
   return { $ref: `#/$defs/${type.name}` };
 }
@@ -602,10 +632,7 @@ function generateDynamicType(type) {
     "x-formspec-schemaSource": type.sourceKey
   };
 }
-function generateCustomType(_type) {
-  return { type: "object" };
-}
-function applyConstraints(schema, constraints) {
+function applyConstraints(schema, constraints, ctx) {
   for (const constraint of constraints) {
     switch (constraint.constraintKind) {
       case "minimum":
@@ -650,6 +677,7 @@ function applyConstraints(schema, constraints) {
       case "allowedMembers":
         break;
       case "custom":
+        applyCustomConstraint(schema, constraint, ctx);
         break;
       default: {
         const _exhaustive = constraint;
@@ -658,7 +686,7 @@ function applyConstraints(schema, constraints) {
     }
   }
 }
-function applyAnnotations(schema, annotations) {
+function applyAnnotations(schema, annotations, ctx) {
   for (const annotation of annotations) {
     switch (annotation.annotationKind) {
       case "displayName":
@@ -678,6 +706,7 @@ function applyAnnotations(schema, annotations) {
       case "formatHint":
         break;
       case "custom":
+        applyCustomAnnotation(schema, annotation, ctx);
         break;
       default: {
         const _exhaustive = annotation;
@@ -686,11 +715,41 @@ function applyAnnotations(schema, annotations) {
     }
   }
 }
+function generateCustomType(type, ctx) {
+  const registration = ctx.extensionRegistry?.findType(type.typeId);
+  if (registration === void 0) {
+    throw new Error(
+      `Cannot generate JSON Schema for custom type "${type.typeId}" without a matching extension registration`
+    );
+  }
+  return registration.toJsonSchema(type.payload, ctx.vendorPrefix);
+}
+function applyCustomConstraint(schema, constraint, ctx) {
+  const registration = ctx.extensionRegistry?.findConstraint(constraint.constraintId);
+  if (registration === void 0) {
+    throw new Error(
+      `Cannot generate JSON Schema for custom constraint "${constraint.constraintId}" without a matching extension registration`
+    );
+  }
+  Object.assign(schema, registration.toJsonSchema(constraint.payload, ctx.vendorPrefix));
+}
+function applyCustomAnnotation(schema, annotation, ctx) {
+  const registration = ctx.extensionRegistry?.findAnnotation(annotation.annotationId);
+  if (registration === void 0) {
+    throw new Error(
+      `Cannot generate JSON Schema for custom annotation "${annotation.annotationId}" without a matching extension registration`
+    );
+  }
+  if (registration.toJsonSchema === void 0) {
+    return;
+  }
+  Object.assign(schema, registration.toJsonSchema(annotation.value, ctx.vendorPrefix));
+}
 
 // src/json-schema/generator.ts
-function generateJsonSchema(form) {
+function generateJsonSchema(form, options) {
   const ir = canonicalizeChainDSL(form);
-  return generateJsonSchemaFromIR(ir);
+  return generateJsonSchemaFromIR(ir, options);
 }
 
 // src/ui-schema/schema.ts
@@ -924,6 +983,48 @@ function getSchemaExtension(schema, key) {
   return schema[key];
 }
 
+// src/extensions/registry.ts
+function createExtensionRegistry(extensions) {
+  const typeMap = /* @__PURE__ */ new Map();
+  const constraintMap = /* @__PURE__ */ new Map();
+  const annotationMap = /* @__PURE__ */ new Map();
+  for (const ext of extensions) {
+    if (ext.types !== void 0) {
+      for (const type of ext.types) {
+        const qualifiedId = `${ext.extensionId}/${type.typeName}`;
+        if (typeMap.has(qualifiedId)) {
+          throw new Error(`Duplicate custom type ID: "${qualifiedId}"`);
+        }
+        typeMap.set(qualifiedId, type);
+      }
+    }
+    if (ext.constraints !== void 0) {
+      for (const constraint of ext.constraints) {
+        const qualifiedId = `${ext.extensionId}/${constraint.constraintName}`;
+        if (constraintMap.has(qualifiedId)) {
+          throw new Error(`Duplicate custom constraint ID: "${qualifiedId}"`);
+        }
+        constraintMap.set(qualifiedId, constraint);
+      }
+    }
+    if (ext.annotations !== void 0) {
+      for (const annotation of ext.annotations) {
+        const qualifiedId = `${ext.extensionId}/${annotation.annotationName}`;
+        if (annotationMap.has(qualifiedId)) {
+          throw new Error(`Duplicate custom annotation ID: "${qualifiedId}"`);
+        }
+        annotationMap.set(qualifiedId, annotation);
+      }
+    }
+  }
+  return {
+    extensions,
+    findType: (typeId) => typeMap.get(typeId),
+    findConstraint: (constraintId) => constraintMap.get(constraintId),
+    findAnnotation: (annotationId) => annotationMap.get(annotationId)
+  };
+}
+
 // src/json-schema/schema.ts
 import { z as z3 } from "zod";
 var jsonSchemaTypeSchema = z3.enum([
@@ -1063,11 +1164,6 @@ import * as ts4 from "typescript";
 
 // src/analyzer/jsdoc-constraints.ts
 import * as ts3 from "typescript";
-import {
-  BUILTIN_CONSTRAINT_DEFINITIONS as BUILTIN_CONSTRAINT_DEFINITIONS2,
-  isBuiltinConstraintName as isBuiltinConstraintName2,
-  normalizeConstraintTagName as normalizeConstraintTagName2
-} from "@formspec/core";
 
 // src/analyzer/tsdoc-parser.ts
 import * as ts2 from "typescript";
@@ -1121,6 +1217,15 @@ function createFormSpecTSDocConfig() {
       })
     );
   }
+  for (const tagName of ["displayName", "description"]) {
+    config.addTagDefinition(
+      new TSDocTagDefinition({
+        tagName: "@" + tagName,
+        syntaxKind: TSDocTagSyntaxKind.BlockTag,
+        allowMultiple: true
+      })
+    );
+  }
   return config;
 }
 var sharedParser;
@@ -1150,6 +1255,27 @@ function parseTSDocTags(node, file = "") {
       const docComment = parserContext.docComment;
       for (const block of docComment.customBlocks) {
         const tagName = normalizeConstraintTagName(block.blockTag.tagName.substring(1));
+        if (tagName === "displayName" || tagName === "description") {
+          const text2 = extractBlockText(block).trim();
+          if (text2 === "") continue;
+          const provenance2 = provenanceForComment(range, sourceFile, file, tagName);
+          if (tagName === "displayName") {
+            annotations.push({
+              kind: "annotation",
+              annotationKind: "displayName",
+              value: text2,
+              provenance: provenance2
+            });
+          } else {
+            annotations.push({
+              kind: "annotation",
+              annotationKind: "description",
+              value: text2,
+              provenance: provenance2
+            });
+          }
+          continue;
+        }
         if (TAGS_REQUIRING_RAW_TEXT.has(tagName)) continue;
         const text = extractBlockText(block).trim();
         if (text === "") continue;
@@ -1181,41 +1307,6 @@ function parseTSDocTags(node, file = "") {
       constraints.push(constraintNode);
     }
   }
-  let displayName;
-  let description;
-  let displayNameTag;
-  let descriptionTag;
-  for (const tag of jsDocTagsAll) {
-    const tagName = tag.tagName.text;
-    const commentText = getTagCommentText(tag);
-    if (commentText === void 0 || commentText.trim() === "") {
-      continue;
-    }
-    const trimmed = commentText.trim();
-    if (tagName === "Field_displayName") {
-      displayName = trimmed;
-      displayNameTag = tag;
-    } else if (tagName === "Field_description") {
-      description = trimmed;
-      descriptionTag = tag;
-    }
-  }
-  if (displayName !== void 0 && displayNameTag) {
-    annotations.push({
-      kind: "annotation",
-      annotationKind: "displayName",
-      value: displayName,
-      provenance: provenanceForJSDocTag(displayNameTag, file)
-    });
-  }
-  if (description !== void 0 && descriptionTag) {
-    annotations.push({
-      kind: "annotation",
-      annotationKind: "description",
-      value: description,
-      provenance: provenanceForJSDocTag(descriptionTag, file)
-    });
-  }
   return { constraints, annotations };
 }
 function extractPathTarget(text) {
@@ -1480,18 +1571,19 @@ function analyzeFieldToIR(prop, checker, file, typeRegistry, visiting) {
   const tsType = checker.getTypeAtLocation(prop);
   const optional = prop.questionToken !== void 0;
   const provenance = provenanceForNode(prop, file);
-  const type = resolveTypeNode(tsType, checker, file, typeRegistry, visiting);
+  let type = resolveTypeNode(tsType, checker, file, typeRegistry, visiting);
   const constraints = [];
   if (prop.type) {
     constraints.push(...extractTypeAliasConstraintNodes(prop.type, checker, file));
   }
   constraints.push(...extractJSDocConstraintNodes(prop, file));
-  const annotations = [];
+  let annotations = [];
   annotations.push(...extractJSDocAnnotationNodes(prop, file));
   const defaultAnnotation = extractDefaultValueAnnotation(prop.initializer, file);
   if (defaultAnnotation) {
     annotations.push(defaultAnnotation);
   }
+  ({ type, annotations } = applyEnumMemberDisplayNames(type, annotations));
   return {
     kind: "field",
     name,
@@ -1510,14 +1602,15 @@ function analyzeInterfacePropertyToIR(prop, checker, file, typeRegistry, visitin
   const tsType = checker.getTypeAtLocation(prop);
   const optional = prop.questionToken !== void 0;
   const provenance = provenanceForNode(prop, file);
-  const type = resolveTypeNode(tsType, checker, file, typeRegistry, visiting);
+  let type = resolveTypeNode(tsType, checker, file, typeRegistry, visiting);
   const constraints = [];
   if (prop.type) {
     constraints.push(...extractTypeAliasConstraintNodes(prop.type, checker, file));
   }
   constraints.push(...extractJSDocConstraintNodes(prop, file));
-  const annotations = [];
+  let annotations = [];
   annotations.push(...extractJSDocAnnotationNodes(prop, file));
+  ({ type, annotations } = applyEnumMemberDisplayNames(type, annotations));
   return {
     kind: "field",
     name,
@@ -1528,6 +1621,68 @@ function analyzeInterfacePropertyToIR(prop, checker, file, typeRegistry, visitin
     provenance
   };
 }
+function applyEnumMemberDisplayNames(type, annotations) {
+  if (!annotations.some(
+    (annotation) => annotation.annotationKind === "displayName" && annotation.value.trim().startsWith(":")
+  )) {
+    return { type, annotations: [...annotations] };
+  }
+  const consumed = /* @__PURE__ */ new Set();
+  const nextType = rewriteEnumDisplayNames(type, annotations, consumed);
+  if (consumed.size === 0) {
+    return { type, annotations: [...annotations] };
+  }
+  return {
+    type: nextType,
+    annotations: annotations.filter((annotation) => !consumed.has(annotation))
+  };
+}
+function rewriteEnumDisplayNames(type, annotations, consumed) {
+  switch (type.kind) {
+    case "enum":
+      return applyEnumMemberDisplayNamesToEnum(type, annotations, consumed);
+    case "union": {
+      return {
+        ...type,
+        members: type.members.map(
+          (member) => rewriteEnumDisplayNames(member, annotations, consumed)
+        )
+      };
+    }
+    default:
+      return type;
+  }
+}
+function applyEnumMemberDisplayNamesToEnum(type, annotations, consumed) {
+  const displayNames = /* @__PURE__ */ new Map();
+  for (const annotation of annotations) {
+    if (annotation.annotationKind !== "displayName") continue;
+    const parsed = parseEnumMemberDisplayName(annotation.value);
+    if (!parsed) continue;
+    consumed.add(annotation);
+    const member = type.members.find((m) => String(m.value) === parsed.value);
+    if (!member) continue;
+    displayNames.set(String(member.value), parsed.label);
+  }
+  if (displayNames.size === 0) {
+    return type;
+  }
+  return {
+    ...type,
+    members: type.members.map((member) => {
+      const displayName = displayNames.get(String(member.value));
+      return displayName !== void 0 ? { ...member, displayName } : member;
+    })
+  };
+}
+function parseEnumMemberDisplayName(value) {
+  const trimmed = value.trim();
+  const match = /^:([^\s]+)\s+([\s\S]+)$/.exec(trimmed);
+  if (!match?.[1] || !match[2]) return null;
+  const label = match[2].trim();
+  if (label === "") return null;
+  return { value: match[1], label };
+}
 function resolveTypeNode(type, checker, file, typeRegistry, visiting) {
   if (type.flags & ts4.TypeFlags.String) {
     return { kind: "primitive", primitiveKind: "string" };
@@ -1638,7 +1793,30 @@ function resolveArrayType(type, checker, file, typeRegistry, visiting) {
   const items = elementType ? resolveTypeNode(elementType, checker, file, typeRegistry, visiting) : { kind: "primitive", primitiveKind: "string" };
   return { kind: "array", items };
 }
+function tryResolveRecordType(type, checker, file, typeRegistry, visiting) {
+  if (type.getProperties().length > 0) {
+    return null;
+  }
+  const indexInfo = checker.getIndexInfoOfType(type, ts4.IndexKind.String);
+  if (!indexInfo) {
+    return null;
+  }
+  if (visiting.has(type)) {
+    return null;
+  }
+  visiting.add(type);
+  try {
+    const valueType = resolveTypeNode(indexInfo.type, checker, file, typeRegistry, visiting);
+    return { kind: "record", valueType };
+  } finally {
+    visiting.delete(type);
+  }
+}
 function resolveObjectType(type, checker, file, typeRegistry, visiting) {
+  const recordNode = tryResolveRecordType(type, checker, file, typeRegistry, visiting);
+  if (recordNode) {
+    return recordNode;
+  }
   if (visiting.has(type)) {
     return { kind: "object", properties: [], additionalProperties: false };
   }
@@ -1670,7 +1848,7 @@ function resolveObjectType(type, checker, file, typeRegistry, visiting) {
   const objectNode = {
     kind: "object",
     properties,
-    additionalProperties: false
+    additionalProperties: true
   };
   if (typeName) {
     typeRegistry[typeName] = {
@@ -1873,15 +2051,19 @@ function generateSchemas(options) {
 }
 
 // src/index.ts
-function buildFormSchemas(form) {
+function buildFormSchemas(form, options) {
   return {
-    jsonSchema: generateJsonSchema(form),
+    jsonSchema: generateJsonSchema(form, options),
     uiSchema: generateUiSchema(form)
   };
 }
 function writeSchemas(form, options) {
-  const { outDir, name = "schema", indent = 2 } = options;
-  const { jsonSchema, uiSchema: uiSchema2 } = buildFormSchemas(form);
+  const { outDir, name = "schema", indent = 2, extensionRegistry, vendorPrefix } = options;
+  const buildOptions = extensionRegistry === void 0 && vendorPrefix === void 0 ? void 0 : {
+    extensionRegistry,
+    vendorPrefix
+  };
+  const { jsonSchema, uiSchema: uiSchema2 } = buildFormSchemas(form, buildOptions);
   if (!fs.existsSync(outDir)) {
     fs.mkdirSync(outDir, { recursive: true });
   }
@@ -1896,7 +2078,9 @@ export {
   categorizationSchema,
   categorySchema,
   controlSchema,
+  createExtensionRegistry,
   generateJsonSchema,
+  generateJsonSchemaFromIR,
   generateSchemas,
   generateSchemasFromClass,
   generateUiSchema,