@formspec/build 0.1.0-alpha.43 → 0.1.0-alpha.45

package/dist/cli.js

@@ -243,7 +243,9 @@ function resolveTypeNodeMetadata(type, options) {
     case "object":
       return {
         ...type,
-        properties: type.properties.map((property) => resolveObjectPropertyMetadata(property, options))
+        properties: type.properties.map(
+          (property) => resolveObjectPropertyMetadata(property, options)
+        )
       };
     case "record":
       return {
@@ -1604,7 +1606,7 @@ function applyCustomConstraint(schema, constraint, ctx) {
   if (registration.emitsVocabularyKeywords) {
     const target = schema;
     for (const [key, value] of Object.entries(extensionSchema)) {
-      if (JSON_SCHEMA_STRUCTURAL_KEYWORDS.has(key)) {
+      if (VOCABULARY_MODE_BLOCKED_KEYWORDS.has(key)) {
         throw new Error(
           `Custom constraint "${constraint.constraintId}" with emitsVocabularyKeywords must not overwrite standard JSON Schema keyword "${key}"`
         );
@@ -1647,13 +1649,13 @@ function assignVendorPrefixedExtensionKeywords(schema, extensionSchema, vendorPr
     schema[key] = value;
   }
 }
-var JSON_SCHEMA_STRUCTURAL_KEYWORDS;
+var VOCABULARY_MODE_BLOCKED_KEYWORDS;
 var init_ir_generator = __esm({
   "src/json-schema/ir-generator.ts"() {
     "use strict";
     init_metadata();
     init_collision_guards();
-    JSON_SCHEMA_STRUCTURAL_KEYWORDS = /* @__PURE__ */ new Set([
+    VOCABULARY_MODE_BLOCKED_KEYWORDS = /* @__PURE__ */ new Set([
       "$schema",
       "$ref",
       "$defs",
@@ -1721,10 +1723,7 @@ function generateJsonSchema(form, options) {
   const metadata = options?.metadata;
   const vendorPrefix = options?.vendorPrefix;
   const enumSerialization = options?.enumSerialization;
-  const ir = canonicalizeChainDSL(
-    form,
-    metadata !== void 0 ? { metadata } : void 0
-  );
+  const ir = canonicalizeChainDSL(form, metadata !== void 0 ? { metadata } : void 0);
   const internalOptions = vendorPrefix === void 0 && enumSerialization === void 0 ? void 0 : {
     ...vendorPrefix !== void 0 && { vendorPrefix },
     ...enumSerialization !== void 0 && { enumSerialization }
@@ -1953,7 +1952,10 @@ function irElementsToUiSchema(elements, fieldNameMap, parentRule) {
         break;
       }
       case "conditional": {
-        const newRule = createShowRule(fieldNameMap.get(element.fieldName) ?? element.fieldName, element.value);
+        const newRule = createShowRule(
+          fieldNameMap.get(element.fieldName) ?? element.fieldName,
+          element.value
+        );
         const combinedRule = parentRule !== void 0 ? combineRules(parentRule, newRule) : newRule;
         const childElements = irElementsToUiSchema(element.elements, fieldNameMap, combinedRule);
         result.push(...childElements);
@@ -2044,8 +2046,10 @@ function buildConstraintTagSources(extensions) {
 }
 function createExtensionRegistry(extensions) {
   const reservedTagSources = buildConstraintTagSources(extensions);
+  let symbolMap = /* @__PURE__ */ new Map();
   const typeMap = /* @__PURE__ */ new Map();
   const typeNameMap = /* @__PURE__ */ new Map();
+  const brandMap = /* @__PURE__ */ new Map();
   const constraintMap = /* @__PURE__ */ new Map();
   const constraintTagMap = /* @__PURE__ */ new Map();
   const builtinBroadeningMap = /* @__PURE__ */ new Map();
@@ -2069,6 +2073,20 @@ function createExtensionRegistry(extensions) {
             registration: type
           });
         }
+        if (type.brand !== void 0) {
+          if (type.brand === "__integerBrand") {
+            throw new Error(
+              `Brand "__integerBrand" is reserved for the builtin Integer type and cannot be registered by extensions`
+            );
+          }
+          if (brandMap.has(type.brand)) {
+            throw new Error(`Duplicate custom type brand: "${type.brand}"`);
+          }
+          brandMap.set(type.brand, {
+            extensionId: ext.extensionId,
+            registration: type
+          });
+        }
         if (type.builtinConstraintBroadenings !== void 0) {
           for (const broadening of type.builtinConstraintBroadenings) {
             const key = `${qualifiedId}:${broadening.tagName}`;
@@ -2138,7 +2156,10 @@ function createExtensionRegistry(extensions) {
             `Metadata tag "@${canonicalTagName}" conflicts with existing FormSpec tag "@${canonicalTagName}".`
           );
         }
-        if (Object.hasOwn(BUILTIN_CONSTRAINT_DEFINITIONS, normalizeConstraintTagName(canonicalTagName))) {
+        if (Object.hasOwn(
+          BUILTIN_CONSTRAINT_DEFINITIONS,
+          normalizeConstraintTagName(canonicalTagName)
+        )) {
           throw new Error(
             `Metadata tag "@${canonicalTagName}" conflicts with existing FormSpec tag "@${normalizeConstraintTagName(canonicalTagName)}".`
           );
@@ -2159,6 +2180,11 @@ function createExtensionRegistry(extensions) {
     extensions,
     findType: (typeId) => typeMap.get(typeId),
     findTypeByName: (typeName) => typeNameMap.get(typeName),
+    findTypeByBrand: (brand) => brandMap.get(brand),
+    findTypeBySymbol: (symbol) => symbolMap.get(symbol),
+    setSymbolMap: (map) => {
+      symbolMap = map;
+    },
     findConstraint: (constraintId) => constraintMap.get(constraintId),
     findConstraintTag: (tagName) => constraintTagMap.get(normalizeFormSpecTagName(tagName)),
     findBuiltinConstraintBroadening: (typeId, tagName) => builtinBroadeningMap.get(`${typeId}:${tagName}`),
@@ -3063,6 +3089,71 @@ function isObjectType(type) {
 function isIntersectionType(type) {
   return !!(type.flags & ts3.TypeFlags.Intersection);
 }
+function collectBrandIdentifiers(type) {
+  if (!type.isIntersection()) {
+    return [];
+  }
+  const brands = [];
+  for (const prop of type.getProperties()) {
+    const decl = prop.valueDeclaration ?? prop.declarations?.[0];
+    if (decl === void 0) continue;
+    if (!ts3.isPropertySignature(decl) && !ts3.isPropertyDeclaration(decl)) continue;
+    if (!ts3.isComputedPropertyName(decl.name)) continue;
+    if (!ts3.isIdentifier(decl.name.expression)) continue;
+    brands.push(decl.name.expression.text);
+  }
+  return brands;
+}
+function resolveCanonicalSymbol(type, checker) {
+  const raw = type.aliasSymbol ?? type.getSymbol();
+  if (raw === void 0) return void 0;
+  return raw.flags & ts3.SymbolFlags.Alias ? checker.getAliasedSymbol(raw) : raw;
+}
+function resolveSymbolBasedCustomType(type, extensionRegistry, checker) {
+  if (extensionRegistry === void 0) {
+    return null;
+  }
+  const canonical = resolveCanonicalSymbol(type, checker);
+  if (canonical === void 0) {
+    return null;
+  }
+  const registration = extensionRegistry.findTypeBySymbol(canonical);
+  if (registration === void 0) {
+    return null;
+  }
+  return {
+    kind: "custom",
+    typeId: `${registration.extensionId}/${registration.registration.typeName}`,
+    payload: null
+  };
+}
+function isIntegerBrandedType(type) {
+  if (!type.isIntersection()) {
+    return false;
+  }
+  const hasNumberBase = type.types.some((member) => !!(member.flags & ts3.TypeFlags.Number));
+  if (!hasNumberBase) {
+    return false;
+  }
+  return collectBrandIdentifiers(type).includes("__integerBrand");
+}
+function resolveBrandedCustomType(type, extensionRegistry) {
+  if (extensionRegistry === void 0) {
+    return null;
+  }
+  for (const brand of collectBrandIdentifiers(type)) {
+    const registration = extensionRegistry.findTypeByBrand(brand);
+    if (registration === void 0) {
+      continue;
+    }
+    return {
+      kind: "custom",
+      typeId: `${registration.extensionId}/${registration.registration.typeName}`,
+      payload: null
+    };
+  }
+  return null;
+}
 function isResolvableObjectLikeAliasTypeNode(typeNode) {
   if (ts3.isParenthesizedTypeNode(typeNode)) {
     return isResolvableObjectLikeAliasTypeNode(typeNode.type);
@@ -4169,6 +4260,14 @@ function resolveTypeNode(type, checker, file, typeRegistry, visiting, sourceNode
   if (customType) {
     return customType;
   }
+  const symbolCustomType = resolveSymbolBasedCustomType(type, extensionRegistry, checker);
+  if (symbolCustomType) {
+    return symbolCustomType;
+  }
+  const brandedCustomType = resolveBrandedCustomType(type, extensionRegistry);
+  if (brandedCustomType) {
+    return brandedCustomType;
+  }
   const primitiveAlias = tryResolveNamedPrimitiveAlias(
     type,
     checker,
@@ -4183,6 +4282,9 @@ function resolveTypeNode(type, checker, file, typeRegistry, visiting, sourceNode
   if (primitiveAlias) {
     return primitiveAlias;
   }
+  if (isIntegerBrandedType(type)) {
+    return { kind: "primitive", primitiveKind: "integer" };
+  }
   if (type.flags & ts3.TypeFlags.String) {
     return { kind: "primitive", primitiveKind: "string" };
   }
@@ -4285,7 +4387,7 @@ function resolveTypeNode(type, checker, file, typeRegistry, visiting, sourceNode
   return { kind: "primitive", primitiveKind: "string" };
 }
 function tryResolveNamedPrimitiveAlias(type, checker, file, typeRegistry, visiting, sourceNode, metadataPolicy = createAnalyzerMetadataPolicy(void 0), extensionRegistry, diagnostics) {
-  if (!(type.flags & (ts3.TypeFlags.String | ts3.TypeFlags.Number | ts3.TypeFlags.BigInt | ts3.TypeFlags.BigIntLiteral | ts3.TypeFlags.Boolean | ts3.TypeFlags.Null))) {
+  if (!(type.flags & (ts3.TypeFlags.String | ts3.TypeFlags.Number | ts3.TypeFlags.BigInt | ts3.TypeFlags.BigIntLiteral | ts3.TypeFlags.Boolean | ts3.TypeFlags.Null)) && !isIntegerBrandedType(type)) {
     return null;
   }
   const aliasDecl = type.aliasSymbol?.declarations?.find(ts3.isTypeAliasDeclaration) ?? getReferencedTypeAliasDeclaration(sourceNode, checker);
@@ -4371,6 +4473,9 @@ function resolveAliasedPrimitiveTarget(type, checker, file, typeRegistry, visiti
       visitedAliases
     );
   }
+  if (isIntegerBrandedType(type)) {
+    return { kind: "primitive", primitiveKind: "integer" };
+  }
   if (type.flags & ts3.TypeFlags.String) {
     return { kind: "primitive", primitiveKind: "string" };
   }
@@ -5123,7 +5228,7 @@ function createProgramContextFromProgram(program, filePath) {
     sourceFile
   };
 }
-function createProgramContext(filePath) {
+function createProgramContext(filePath, additionalFiles) {
   const absolutePath = path.resolve(filePath);
   const fileDir = path.dirname(absolutePath);
   const configPath = ts4.findConfigFile(fileDir, ts4.sys.fileExists.bind(ts4.sys), "tsconfig.json");
@@ -5146,7 +5251,8 @@ function createProgramContext(filePath) {
       throw new Error(`Error parsing tsconfig.json: ${errorMessages}`);
     }
     compilerOptions = parsed.options;
-    fileNames = parsed.fileNames.includes(absolutePath) ? parsed.fileNames : [...parsed.fileNames, absolutePath];
+    const normalizedAdditional = (additionalFiles ?? []).map((f) => path.resolve(f));
+    fileNames = [.../* @__PURE__ */ new Set([...parsed.fileNames, absolutePath, ...normalizedAdditional])];
   } else {
     compilerOptions = {
       target: ts4.ScriptTarget.ES2022,
@@ -5156,7 +5262,8 @@ function createProgramContext(filePath) {
       skipLibCheck: true,
       declaration: true
     };
-    fileNames = [absolutePath];
+    const normalizedAdditional = (additionalFiles ?? []).map((f) => path.resolve(f));
+    fileNames = [.../* @__PURE__ */ new Set([absolutePath, ...normalizedAdditional])];
   }
   const program = ts4.createProgram(fileNames, compilerOptions);
   const sourceFile = program.getSourceFile(absolutePath);
@@ -5466,10 +5573,139 @@ var init_program = __esm({
   }
 });
 
+// src/extensions/symbol-registry.ts
+import * as ts5 from "typescript";
+import * as path2 from "path";
+function buildSymbolMapFromConfig(configPath, program, checker, extensionRegistry) {
+  const symbolMap = /* @__PURE__ */ new Map();
+  const normalizedPath = path2.resolve(configPath);
+  const configFile = program.getSourceFile(normalizedPath);
+  if (configFile === void 0) {
+    return symbolMap;
+  }
+  function visit(node) {
+    if (ts5.isCallExpression(node) && isDefineCustomTypeCall(node, checker)) {
+      processDefineCustomTypeCall(node);
+    }
+    ts5.forEachChild(node, visit);
+  }
+  function processDefineCustomTypeCall(call) {
+    const typeArgNode = call.typeArguments?.[0];
+    if (typeArgNode === void 0) {
+      return;
+    }
+    const resolvedType = checker.getTypeFromTypeNode(typeArgNode);
+    const canonical = resolveCanonicalSymbol2(resolvedType, checker);
+    if (canonical === void 0) {
+      return;
+    }
+    const typeName = extractTypeNameFromCallArg(call);
+    if (typeName === null) {
+      return;
+    }
+    let entry;
+    const extensionId = extractEnclosingExtensionId(call, checker);
+    if (extensionId !== null) {
+      const reg = extensionRegistry.findType(`${extensionId}/${typeName}`);
+      if (reg !== void 0) {
+        entry = { extensionId, registration: reg };
+      }
+    }
+    entry ??= findRegistrationByTypeName(extensionRegistry, typeName);
+    if (entry === void 0) {
+      return;
+    }
+    symbolMap.set(canonical, entry);
+  }
+  visit(configFile);
+  return symbolMap;
+}
+function isDefineCustomTypeCall(node, checker) {
+  if (node.typeArguments === void 0 || node.typeArguments.length === 0) return false;
+  const callSymbol = checker.getSymbolAtLocation(node.expression);
+  if (callSymbol !== void 0) {
+    const resolved = callSymbol.flags & ts5.SymbolFlags.Alias ? checker.getAliasedSymbol(callSymbol) : callSymbol;
+    const decl = resolved.declarations?.[0];
+    if (decl !== void 0) {
+      const sourceFile = decl.getSourceFile().fileName.replace(/\\/g, "/");
+      return resolved.name === "defineCustomType" && // Match whether in node_modules/@formspec/core or monorepo packages/core.
+      (sourceFile.includes("@formspec/core") || sourceFile.includes("/packages/core/"));
+    }
+  }
+  return ts5.isIdentifier(node.expression) && node.expression.text === "defineCustomType";
+}
+function resolveCanonicalSymbol2(type, checker) {
+  const raw = type.aliasSymbol ?? type.getSymbol();
+  if (raw === void 0) return void 0;
+  return raw.flags & ts5.SymbolFlags.Alias ? checker.getAliasedSymbol(raw) : raw;
+}
+function extractTypeNameFromCallArg(call) {
+  const arg = call.arguments[0];
+  if (arg === void 0 || !ts5.isObjectLiteralExpression(arg)) {
+    return null;
+  }
+  const typeNameProp = arg.properties.find(
+    (p) => ts5.isPropertyAssignment(p) && ts5.isIdentifier(p.name) && p.name.text === "typeName"
+  );
+  if (typeNameProp === void 0 || !ts5.isStringLiteral(typeNameProp.initializer)) {
+    return null;
+  }
+  return typeNameProp.initializer.text;
+}
+function extractEnclosingExtensionId(call, checker) {
+  for (let node = call.parent; !ts5.isSourceFile(node); node = node.parent) {
+    if (ts5.isCallExpression(node) && isDefineExtensionCall(node, checker)) {
+      return extractExtensionIdFromCallArg(node);
+    }
+  }
+  return null;
+}
+function isDefineExtensionCall(node, checker) {
+  const callSymbol = checker.getSymbolAtLocation(node.expression);
+  if (callSymbol !== void 0) {
+    const resolved = callSymbol.flags & ts5.SymbolFlags.Alias ? checker.getAliasedSymbol(callSymbol) : callSymbol;
+    const decl = resolved.declarations?.[0];
+    if (decl !== void 0) {
+      const sourceFile = decl.getSourceFile().fileName.replace(/\\/g, "/");
+      return resolved.name === "defineExtension" && (sourceFile.includes("@formspec/core") || sourceFile.includes("/packages/core/"));
+    }
+  }
+  return ts5.isIdentifier(node.expression) && node.expression.text === "defineExtension";
+}
+function extractExtensionIdFromCallArg(call) {
+  const arg = call.arguments[0];
+  if (arg === void 0 || !ts5.isObjectLiteralExpression(arg)) {
+    return null;
+  }
+  const prop = arg.properties.find(
+    (p) => ts5.isPropertyAssignment(p) && ts5.isIdentifier(p.name) && p.name.text === "extensionId"
+  );
+  if (prop === void 0 || !ts5.isStringLiteral(prop.initializer)) {
+    return null;
+  }
+  return prop.initializer.text;
+}
+function findRegistrationByTypeName(registry, typeName) {
+  for (const ext of registry.extensions) {
+    if (ext.types === void 0) {
+      continue;
+    }
+    for (const type of ext.types) {
+      if (type.typeName === typeName) {
+        return { extensionId: ext.extensionId, registration: type };
+      }
+    }
+  }
+  return void 0;
+}
+var init_symbol_registry = __esm({
+  "src/extensions/symbol-registry.ts"() {
+    "use strict";
+  }
+});
+
 // src/validate/constraint-validator.ts
-import {
-  analyzeConstraintTargets
-} from "@formspec/analysis/internal";
+import { analyzeConstraintTargets } from "@formspec/analysis/internal";
 function validateFieldNode(ctx, field) {
   const analysis = analyzeConstraintTargets(
     field.name,
@@ -5555,7 +5791,7 @@ var init_validate = __esm({
 });
 
 // src/generators/class-schema.ts
-import * as ts5 from "typescript";
+import * as ts6 from "typescript";
 function generateClassSchemas(analysis, source, options) {
   const result = generateClassSchemasDetailed(analysis, source, options);
   if (!result.ok || result.jsonSchema === void 0 || result.uiSchema === void 0) {
@@ -5614,7 +5850,8 @@ function formatLocation(location) {
   return `${location.file}:${String(location.line)}:${String(location.column)}`;
 }
 function generateSchemasFromClass(options) {
-  const ctx = createProgramContext(options.filePath);
+  const additionalFiles = options.configPath !== void 0 ? [options.configPath] : void 0;
+  const ctx = createProgramContext(options.filePath, additionalFiles);
   const classDecl = findClassByName(ctx.sourceFile, options.className);
   if (!classDecl) {
     throw new Error(`Class "${options.className}" not found in ${options.filePath}`);
@@ -5679,7 +5916,8 @@ function generateSchemasDetailed(options) {
 function generateSchemasDetailedInternal(options) {
   let ctx;
   try {
-    ctx = createProgramContext(options.filePath);
+    const additionalFiles = options.configPath !== void 0 ? [options.configPath] : void 0;
+    ctx = createProgramContext(options.filePath, additionalFiles);
   } catch (error) {
     return {
       ok: false,
@@ -5718,13 +5956,16 @@ function generateSchemasFromProgramDetailedInternal(options) {
 }
 function generateSchemasBatch(options) {
   const contextCache = /* @__PURE__ */ new Map();
+  const resolved = resolveOptions(options);
+  let symbolMapProgram;
   return options.targets.map((target) => {
     let ctx;
     try {
-      const cacheKey = ts5.sys.useCaseSensitiveFileNames ? target.filePath : target.filePath.toLowerCase();
+      const cacheKey = ts6.sys.useCaseSensitiveFileNames ? target.filePath : target.filePath.toLowerCase();
       const cachedContext = contextCache.get(cacheKey);
       if (cachedContext === void 0) {
-        ctx = createProgramContext(target.filePath);
+        const additionalFiles = options.configPath !== void 0 ? [options.configPath] : void 0;
+        ctx = createProgramContext(target.filePath, additionalFiles);
         contextCache.set(cacheKey, ctx);
       } else {
         ctx = cachedContext;
@@ -5735,9 +5976,25 @@ function generateSchemasBatch(options) {
         diagnostics: [createProgramContextFailureDiagnostic(target.filePath, error)]
       });
     }
+    if (options.configPath !== void 0 && resolved.extensionRegistry !== void 0 && isMutableRegistry(resolved.extensionRegistry) && ctx.program !== symbolMapProgram) {
+      const symbolMap = buildSymbolMapFromConfig(
+        options.configPath,
+        ctx.program,
+        ctx.checker,
+        resolved.extensionRegistry
+      );
+      resolved.extensionRegistry.setSymbolMap(symbolMap);
+      symbolMapProgram = ctx.program;
+    }
     return withTarget(
       target,
-      generateSchemasFromDetailedProgramContext(ctx, target.filePath, target.typeName, options)
+      generateSchemasFromResolvedOptions(
+        ctx,
+        target.filePath,
+        target.typeName,
+        resolved,
+        options.discriminator
+      )
     );
   });
 }
@@ -5758,11 +6015,19 @@ function generateSchemasBatchFromProgram(options) {
     );
   });
 }
+function isMutableRegistry(reg) {
+  return "setSymbolMap" in reg && typeof reg.setSymbolMap === "function";
+}
 function resolveOptions(options) {
   const configRegistry = options.config?.extensions !== void 0 ? createExtensionRegistry(options.config.extensions) : void 0;
+  const legacyRegistry = options.extensionRegistry;
   return {
-    // eslint-disable-next-line @typescript-eslint/no-deprecated -- migration bridge reads deprecated fields
-    extensionRegistry: options.extensionRegistry ?? configRegistry,
+    // When the caller provides the deprecated extensionRegistry field directly,
+    // it is typed as the read-only ExtensionRegistry interface. We cast here
+    // because the legacy path was introduced before MutableExtensionRegistry was
+    // split out; callers using createExtensionRegistry() always get a mutable
+    // registry, and this cast is safe for all registries produced by this module.
+    extensionRegistry: legacyRegistry ?? configRegistry,
     // eslint-disable-next-line @typescript-eslint/no-deprecated -- migration bridge reads deprecated fields
     vendorPrefix: options.vendorPrefix ?? options.config?.vendorPrefix,
     // eslint-disable-next-line @typescript-eslint/no-deprecated -- migration bridge reads deprecated fields
@@ -5773,13 +6038,31 @@ function resolveOptions(options) {
 }
 function generateSchemasFromDetailedProgramContext(ctx, filePath, typeName, options) {
   const resolved = resolveOptions(options);
+  if (options.configPath !== void 0 && resolved.extensionRegistry !== void 0 && isMutableRegistry(resolved.extensionRegistry)) {
+    const symbolMap = buildSymbolMapFromConfig(
+      options.configPath,
+      ctx.program,
+      ctx.checker,
+      resolved.extensionRegistry
+    );
+    resolved.extensionRegistry.setSymbolMap(symbolMap);
+  }
+  return generateSchemasFromResolvedOptions(
+    ctx,
+    filePath,
+    typeName,
+    resolved,
+    options.discriminator
+  );
+}
+function generateSchemasFromResolvedOptions(ctx, filePath, typeName, resolved, discriminator) {
   const analysisResult = analyzeNamedTypeToIRFromProgramContextDetailed(
     ctx,
     filePath,
     typeName,
     resolved.extensionRegistry,
     resolved.metadata,
-    options.discriminator
+    discriminator
   );
   if (!analysisResult.ok) {
     return {
@@ -5827,13 +6110,14 @@ var init_class_schema = __esm({
     init_canonicalize();
     init_ir_generator();
     init_extensions();
+    init_symbol_registry();
     init_ir_generator2();
     init_validate();
   }
 });
 
 // src/static-build.ts
-import * as ts6 from "typescript";
+import * as ts7 from "typescript";
 function toStaticBuildContext(context) {
   return context;
 }
@@ -5848,7 +6132,7 @@ function getModuleSymbol(context) {
   return context.checker.getSymbolAtLocation(context.sourceFile) ?? sourceFileWithSymbol.symbol;
 }
 function isSchemaSourceDeclaration(declaration) {
-  return ts6.isClassDeclaration(declaration) || ts6.isInterfaceDeclaration(declaration) || ts6.isTypeAliasDeclaration(declaration);
+  return ts7.isClassDeclaration(declaration) || ts7.isInterfaceDeclaration(declaration) || ts7.isTypeAliasDeclaration(declaration);
 }
 function resolveModuleExport(context, exportName = "default") {
   const moduleSymbol = getModuleSymbol(context);
@@ -5859,7 +6143,7 @@ function resolveModuleExport(context, exportName = "default") {
   if (exportSymbol === null) {
     return null;
   }
-  return exportSymbol.flags & ts6.SymbolFlags.Alias ? context.checker.getAliasedSymbol(exportSymbol) : exportSymbol;
+  return exportSymbol.flags & ts7.SymbolFlags.Alias ? context.checker.getAliasedSymbol(exportSymbol) : exportSymbol;
 }
 function resolveModuleExportDeclaration(context, exportName = "default") {
   return resolveModuleExport(context, exportName)?.declarations?.find(isSchemaSourceDeclaration) ?? null;
@@ -5872,7 +6156,7 @@ var init_static_build = __esm({
 });
 
 // src/generators/discovered-schema.ts
-import * as ts7 from "typescript";
+import * as ts8 from "typescript";
 import { analyzeMetadataForNodeWithChecker as analyzeMetadataForNodeWithChecker2 } from "@formspec/analysis/internal";
 import { IR_VERSION as IR_VERSION3 } from "@formspec/core/internals";
 function toDiscoveredTypeSchemas(result, resolvedMetadata) {
@@ -5882,17 +6166,17 @@ function toDiscoveredTypeSchemas(result, resolvedMetadata) {
   };
 }
 function isNamedTypeDeclaration(declaration) {
-  return ts7.isClassDeclaration(declaration) || ts7.isInterfaceDeclaration(declaration) || ts7.isTypeAliasDeclaration(declaration);
+  return ts8.isClassDeclaration(declaration) || ts8.isInterfaceDeclaration(declaration) || ts8.isTypeAliasDeclaration(declaration);
 }
 function hasConcreteTypeArguments(type, checker) {
   if ("aliasTypeArguments" in type && Array.isArray(type.aliasTypeArguments) && type.aliasTypeArguments.length > 0) {
     return true;
   }
-  if ((type.flags & ts7.TypeFlags.Object) === 0) {
+  if ((type.flags & ts8.TypeFlags.Object) === 0) {
     return false;
   }
   const objectType = type;
-  if ((objectType.objectFlags & ts7.ObjectFlags.Reference) === 0) {
+  if ((objectType.objectFlags & ts8.ObjectFlags.Reference) === 0) {
     return false;
   }
   return checker.getTypeArguments(objectType).length > 0;
@@ -5905,13 +6189,13 @@ function getNamedTypeDeclaration2(type) {
       return declaration;
     }
   }
-  const aliasDeclaration = type.aliasSymbol?.declarations?.find(ts7.isTypeAliasDeclaration);
+  const aliasDeclaration = type.aliasSymbol?.declarations?.find(ts8.isTypeAliasDeclaration);
   return aliasDeclaration;
 }
 function getFallbackName(sourceNode, fallback = "AnonymousType") {
   if (sourceNode !== void 0 && "name" in sourceNode) {
     const namedNode = sourceNode;
-    if (namedNode.name !== void 0 && ts7.isIdentifier(namedNode.name)) {
+    if (namedNode.name !== void 0 && ts8.isIdentifier(namedNode.name)) {
       return namedNode.name.text;
     }
   }
@@ -6030,17 +6314,14 @@ function toStandaloneJsonSchema(root, typeRegistry, options) {
       rootLogicalName: root.name
     }
   );
-  const schema = generateJsonSchemaFromIR(
-    ir,
-    {
-      // eslint-disable-next-line @typescript-eslint/no-deprecated -- migration bridge reads deprecated fields
-      extensionRegistry: options?.extensionRegistry,
-      // eslint-disable-next-line @typescript-eslint/no-deprecated -- migration bridge reads deprecated fields
-      enumSerialization: options?.enumSerialization,
-      // eslint-disable-next-line @typescript-eslint/no-deprecated -- migration bridge reads deprecated fields
-      vendorPrefix: options?.vendorPrefix
-    }
-  );
+  const schema = generateJsonSchemaFromIR(ir, {
+    // eslint-disable-next-line @typescript-eslint/no-deprecated -- migration bridge reads deprecated fields
+    extensionRegistry: options?.extensionRegistry,
+    // eslint-disable-next-line @typescript-eslint/no-deprecated -- migration bridge reads deprecated fields
+    enumSerialization: options?.enumSerialization,
+    // eslint-disable-next-line @typescript-eslint/no-deprecated -- migration bridge reads deprecated fields
+    vendorPrefix: options?.vendorPrefix
+  });
   const result = schema.properties?.["__result"];
   if (result === void 0) {
     throw new Error("FormSpec failed to extract the standalone schema root from the synthetic IR.");
@@ -6139,7 +6420,7 @@ function generateSchemasFromResolvedType(options, skipNamedDeclaration = false,
 }
 function generateSchemasFromDeclaration(options) {
   const filePath = options.declaration.getSourceFile().fileName;
-  if (ts7.isClassDeclaration(options.declaration)) {
+  if (ts8.isClassDeclaration(options.declaration)) {
     return generateSchemasFromAnalysis(
       analyzeClassToIR(
         options.declaration,
@@ -6155,7 +6436,7 @@ function generateSchemasFromDeclaration(options) {
       options
     );
   }
-  if (ts7.isInterfaceDeclaration(options.declaration)) {
+  if (ts8.isInterfaceDeclaration(options.declaration)) {
     return generateSchemasFromAnalysis(
       analyzeInterfaceToIR(
         options.declaration,
@@ -6171,7 +6452,7 @@ function generateSchemasFromDeclaration(options) {
       options
     );
   }
-  if (ts7.isTypeAliasDeclaration(options.declaration)) {
+  if (ts8.isTypeAliasDeclaration(options.declaration)) {
     const analyzedAlias = analyzeTypeAliasToIR(
       options.declaration,
       options.context.checker,
@@ -6234,7 +6515,7 @@ function generateSchemasFromReturnType(options) {
   const returnType = signature !== void 0 ? options.context.checker.getReturnTypeOfSignature(signature) : options.context.checker.getTypeAtLocation(options.declaration);
   const type = unwrapPromiseType(options.context.checker, returnType);
   const sourceNode = type !== returnType ? unwrapPromiseTypeNode(options.declaration.type) ?? options.declaration.type ?? options.declaration : options.declaration.type ?? options.declaration;
-  const fallbackName = options.declaration.name !== void 0 && ts7.isIdentifier(options.declaration.name) ? `${options.declaration.name.text}ReturnType` : "ReturnType";
+  const fallbackName = options.declaration.name !== void 0 && ts8.isIdentifier(options.declaration.name) ? `${options.declaration.name.text}ReturnType` : "ReturnType";
   return generateSchemasFromResolvedType({
     ...options,
     type,
@@ -6269,14 +6550,14 @@ function unwrapPromiseTypeNode(typeNode) {
   if (typeNode === void 0) {
     return void 0;
   }
-  if (ts7.isParenthesizedTypeNode(typeNode)) {
+  if (ts8.isParenthesizedTypeNode(typeNode)) {
     const unwrapped = unwrapPromiseTypeNode(typeNode.type);
     return unwrapped ?? typeNode;
   }
   return isPromiseTypeReferenceNode(typeNode) ? typeNode.typeArguments[0] : typeNode;
 }
 function isPromiseTypeReferenceNode(typeNode) {
-  return ts7.isTypeReferenceNode(typeNode) && ts7.isIdentifier(typeNode.typeName) && typeNode.typeName.text === "Promise" && typeNode.typeArguments !== void 0 && typeNode.typeArguments.length > 0;
+  return ts8.isTypeReferenceNode(typeNode) && ts8.isIdentifier(typeNode.typeName) && typeNode.typeName.text === "Promise" && typeNode.typeArguments !== void 0 && typeNode.typeArguments.length > 0;
 }
 var init_discovered_schema = __esm({
   "src/generators/discovered-schema.ts"() {
@@ -6521,7 +6802,7 @@ __export(index_exports, {
   writeSchemas: () => writeSchemas
 });
 import * as fs from "fs";
-import * as path2 from "path";
+import * as path3 from "path";
 function buildFormSchemas(form, options) {
   return {
     jsonSchema: generateJsonSchema(form, options),
@@ -6546,8 +6827,8 @@ function writeSchemas(form, options) {
   if (!fs.existsSync(outDir)) {
     fs.mkdirSync(outDir, { recursive: true });
   }
-  const jsonSchemaPath = path2.join(outDir, `${name}-schema.json`);
-  const uiSchemaPath = path2.join(outDir, `${name}-uischema.json`);
+  const jsonSchemaPath = path3.join(outDir, `${name}-schema.json`);
+  const uiSchemaPath = path3.join(outDir, `${name}-uischema.json`);
   fs.writeFileSync(jsonSchemaPath, JSON.stringify(jsonSchema, null, indent));
   fs.writeFileSync(uiSchemaPath, JSON.stringify(uiSchema2, null, indent));
   return { jsonSchemaPath, uiSchemaPath };
@@ -6574,7 +6855,7 @@ var init_index = __esm({
 });
 
 // src/cli.ts
-import * as path3 from "path";
+import * as path4 from "path";
 import { pathToFileURL } from "url";
 function printHelp() {
   console.log(`
@@ -6663,7 +6944,7 @@ function parseArgs(args) {
     return null;
   }
   if (!name) {
-    name = path3.basename(inputFile, path3.extname(inputFile));
+    name = path4.basename(inputFile, path4.extname(inputFile));
   }
   return { inputFile, outDir, name, enumSerialization };
 }
@@ -6674,7 +6955,7 @@ async function main() {
     process.exit(1);
   }
   const { inputFile, outDir, name, enumSerialization } = options;
-  const absoluteInput = path3.resolve(process.cwd(), inputFile);
+  const absoluteInput = path4.resolve(process.cwd(), inputFile);
   try {
     const fileUrl = pathToFileURL(absoluteInput).href;
     const module = await import(fileUrl);