@formspec/build 0.1.0-alpha.17 → 0.1.0-alpha.19

package/dist/internals.js

@@ -20,6 +20,7 @@ function canonicalizeChainDSL(form) {
     kind: "form-ir",
     irVersion: IR_VERSION,
     elements: canonicalizeElements(form.elements),
+    rootAnnotations: [],
     typeRegistry: {},
     provenance: CHAIN_DSL_PROVENANCE
   };
@@ -325,6 +326,7 @@ function canonicalizeTSDoc(analysis, source) {
     irVersion: IR_VERSION2,
     elements,
     typeRegistry: analysis.typeRegistry,
+    ...analysis.annotations !== void 0 && analysis.annotations.length > 0 && { rootAnnotations: analysis.annotations },
     ...analysis.annotations !== void 0 && analysis.annotations.length > 0 && { annotations: analysis.annotations },
     provenance
   };
@@ -385,85 +387,17 @@ function wrapInConditional(field, layout, provenance) {
 }
 
 // src/analyzer/program.ts
-import * as ts from "typescript";
+import * as ts4 from "typescript";
 import * as path from "path";
-function createProgramContext(filePath) {
-  const absolutePath = path.resolve(filePath);
-  const fileDir = path.dirname(absolutePath);
-  const configPath = ts.findConfigFile(fileDir, ts.sys.fileExists.bind(ts.sys), "tsconfig.json");
-  let compilerOptions;
-  let fileNames;
-  if (configPath) {
-    const configFile = ts.readConfigFile(configPath, ts.sys.readFile.bind(ts.sys));
-    if (configFile.error) {
-      throw new Error(
-        `Error reading tsconfig.json: ${ts.flattenDiagnosticMessageText(configFile.error.messageText, "\n")}`
-      );
-    }
-    const parsed = ts.parseJsonConfigFileContent(
-      configFile.config,
-      ts.sys,
-      path.dirname(configPath)
-    );
-    if (parsed.errors.length > 0) {
-      const errorMessages = parsed.errors.map((e) => ts.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: ts.ScriptTarget.ES2022,
-      module: ts.ModuleKind.NodeNext,
-      moduleResolution: ts.ModuleResolutionKind.NodeNext,
-      strict: true,
-      skipLibCheck: true,
-      declaration: true
-    };
-    fileNames = [absolutePath];
-  }
-  const program = ts.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;
-    }
-    ts.forEachChild(node, visit);
-  }
-  visit(sourceFile);
-  return result;
-}
-function findClassByName(sourceFile, className) {
-  return findNodeByName(sourceFile, className, ts.isClassDeclaration, (n) => n.name?.text);
-}
-function findInterfaceByName(sourceFile, interfaceName) {
-  return findNodeByName(sourceFile, interfaceName, ts.isInterfaceDeclaration, (n) => n.name.text);
-}
-function findTypeAliasByName(sourceFile, aliasName) {
-  return findNodeByName(sourceFile, aliasName, ts.isTypeAliasDeclaration, (n) => n.name.text);
-}
 
 // src/analyzer/class-analyzer.ts
-import * as ts4 from "typescript";
+import * as ts3 from "typescript";
 
 // src/analyzer/jsdoc-constraints.ts
-import * as ts3 from "typescript";
+import * as ts2 from "typescript";
 
 // src/analyzer/tsdoc-parser.ts
-import * as ts2 from "typescript";
+import * as ts from "typescript";
 import {
   TSDocParser,
   TSDocConfiguration,
@@ -561,10 +495,10 @@ function parseTSDocTags(node, file = "", options) {
   let placeholderProvenance;
   const sourceFile = node.getSourceFile();
   const sourceText = sourceFile.getFullText();
-  const commentRanges = ts2.getLeadingCommentRanges(sourceText, node.getFullStart());
+  const commentRanges = ts.getLeadingCommentRanges(sourceText, node.getFullStart());
   if (commentRanges) {
     for (const range of commentRanges) {
-      if (range.kind !== ts2.SyntaxKind.MultiLineCommentTrivia) {
+      if (range.kind !== ts.SyntaxKind.MultiLineCommentTrivia) {
         continue;
       }
       const commentText = sourceText.substring(range.pos, range.end);
@@ -582,26 +516,31 @@ function parseTSDocTags(node, file = "", options) {
           const text2 = extractBlockText(block).trim();
           if (text2 === "") continue;
           const provenance2 = provenanceForComment(range, sourceFile, file, tagName);
-          if (tagName === "displayName") {
-            if (!isMemberTargetDisplayName(text2) && displayName === void 0) {
-              displayName = text2;
-              displayNameProvenance = provenance2;
-            }
-          } else if (tagName === "format") {
-            annotations.push({
-              kind: "annotation",
-              annotationKind: "format",
-              value: text2,
-              provenance: provenance2
-            });
-          } else {
-            if (tagName === "description" && description === void 0) {
+          switch (tagName) {
+            case "displayName":
+              if (!isMemberTargetDisplayName(text2) && displayName === void 0) {
+                displayName = text2;
+                displayNameProvenance = provenance2;
+              }
+              break;
+            case "format":
+              annotations.push({
+                kind: "annotation",
+                annotationKind: "format",
+                value: text2,
+                provenance: provenance2
+              });
+              break;
+            case "description":
               description = text2;
               descriptionProvenance = provenance2;
-            } else if (tagName === "placeholder" && placeholder === void 0) {
-              placeholder = text2;
-              placeholderProvenance = provenance2;
-            }
+              break;
+            case "placeholder":
+              if (placeholder === void 0) {
+                placeholder = text2;
+                placeholderProvenance = provenance2;
+              }
+              break;
           }
           continue;
         }
@@ -631,6 +570,13 @@ function parseTSDocTags(node, file = "", options) {
           descriptionProvenance = provenanceForComment(range, sourceFile, file, "remarks");
         }
       }
+      if (description === void 0) {
+        const summary = extractPlainText(docComment.summarySection).trim();
+        if (summary !== "") {
+          description = summary;
+          descriptionProvenance = provenanceForComment(range, sourceFile, file, "summary");
+        }
+      }
     }
   }
   if (displayName !== void 0 && displayNameProvenance !== void 0) {
@@ -657,7 +603,7 @@ function parseTSDocTags(node, file = "", options) {
       provenance: placeholderProvenance
     });
   }
-  const jsDocTagsAll = ts2.getJSDocTags(node);
+  const jsDocTagsAll = ts.getJSDocTags(node);
   for (const tag of jsDocTagsAll) {
     const tagName = normalizeConstraintTagName(tag.tagName.text);
     if (!TAGS_REQUIRING_RAW_TEXT.has(tagName)) continue;
@@ -680,7 +626,7 @@ function parseTSDocTags(node, file = "", options) {
 function extractDisplayNameMetadata(node) {
   let displayName;
   const memberDisplayNames = /* @__PURE__ */ new Map();
-  for (const tag of ts2.getJSDocTags(node)) {
+  for (const tag of ts.getJSDocTags(node)) {
     const tagName = normalizeConstraintTagName(tag.tagName.text);
     if (tagName !== "displayName") continue;
     const commentText = getTagCommentText(tag);
@@ -701,11 +647,11 @@ function extractDisplayNameMetadata(node) {
 }
 function extractPathTarget(text) {
   const trimmed = text.trimStart();
-  const match = /^:([a-zA-Z_]\w*)\s+([\s\S]*)$/.exec(trimmed);
-  if (!match?.[1] || !match[2]) return null;
+  const match = /^:([a-zA-Z_]\w*)(?:\s+([\s\S]*))?$/.exec(trimmed);
+  if (!match?.[1]) return null;
   return {
     path: { segments: [match[1]] },
-    remainingText: match[2]
+    remainingText: match[2] ?? ""
   };
 }
 function extractBlockText(block) {
@@ -968,7 +914,7 @@ function getTagCommentText(tag) {
   if (typeof tag.comment === "string") {
     return tag.comment;
   }
-  return ts2.getTextOfJSDocComment(tag.comment);
+  return ts.getTextOfJSDocComment(tag.comment);
 }
 
 // src/analyzer/jsdoc-constraints.ts
@@ -983,18 +929,18 @@ function extractJSDocAnnotationNodes(node, file = "", options) {
 function extractDefaultValueAnnotation(initializer, file = "") {
   if (!initializer) return null;
   let value;
-  if (ts3.isStringLiteral(initializer)) {
+  if (ts2.isStringLiteral(initializer)) {
     value = initializer.text;
-  } else if (ts3.isNumericLiteral(initializer)) {
+  } else if (ts2.isNumericLiteral(initializer)) {
     value = Number(initializer.text);
-  } else if (initializer.kind === ts3.SyntaxKind.TrueKeyword) {
+  } else if (initializer.kind === ts2.SyntaxKind.TrueKeyword) {
     value = true;
-  } else if (initializer.kind === ts3.SyntaxKind.FalseKeyword) {
+  } else if (initializer.kind === ts2.SyntaxKind.FalseKeyword) {
     value = false;
-  } else if (initializer.kind === ts3.SyntaxKind.NullKeyword) {
+  } else if (initializer.kind === ts2.SyntaxKind.NullKeyword) {
     value = null;
-  } else if (ts3.isPrefixUnaryExpression(initializer)) {
-    if (initializer.operator === ts3.SyntaxKind.MinusToken && ts3.isNumericLiteral(initializer.operand)) {
+  } else if (ts2.isPrefixUnaryExpression(initializer)) {
+    if (initializer.operator === ts2.SyntaxKind.MinusToken && ts2.isNumericLiteral(initializer.operand)) {
       value = -Number(initializer.operand.text);
     }
   }
@@ -1016,10 +962,10 @@ function extractDefaultValueAnnotation(initializer, file = "") {
 
 // src/analyzer/class-analyzer.ts
 function isObjectType(type) {
-  return !!(type.flags & ts4.TypeFlags.Object);
+  return !!(type.flags & ts3.TypeFlags.Object);
 }
 function isTypeReference(type) {
-  return !!(type.flags & ts4.TypeFlags.Object) && !!(type.objectFlags & ts4.ObjectFlags.Reference);
+  return !!(type.flags & ts3.TypeFlags.Object) && !!(type.objectFlags & ts3.ObjectFlags.Reference);
 }
 var RESOLVING_TYPE_PLACEHOLDER = {
   kind: "object",
@@ -1049,7 +995,7 @@ function analyzeClassToIR(classDecl, checker, file = "", extensionRegistry) {
   const instanceMethods = [];
   const staticMethods = [];
   for (const member of classDecl.members) {
-    if (ts4.isPropertyDeclaration(member)) {
+    if (ts3.isPropertyDeclaration(member)) {
       const fieldNode = analyzeFieldToIR(
         member,
         checker,
@@ -1062,10 +1008,10 @@ function analyzeClassToIR(classDecl, checker, file = "", extensionRegistry) {
         fields.push(fieldNode);
         fieldLayouts.push({});
       }
-    } else if (ts4.isMethodDeclaration(member)) {
+    } else if (ts3.isMethodDeclaration(member)) {
       const methodInfo = analyzeMethod(member, checker);
       if (methodInfo) {
-        const isStatic = member.modifiers?.some((m) => m.kind === ts4.SyntaxKind.StaticKeyword);
+        const isStatic = member.modifiers?.some((m) => m.kind === ts3.SyntaxKind.StaticKeyword);
         if (isStatic) {
           staticMethods.push(methodInfo);
         } else {
@@ -1095,7 +1041,7 @@ function analyzeInterfaceToIR(interfaceDecl, checker, file = "", extensionRegist
   );
   const visiting = /* @__PURE__ */ new Set();
   for (const member of interfaceDecl.members) {
-    if (ts4.isPropertySignature(member)) {
+    if (ts3.isPropertySignature(member)) {
       const fieldNode = analyzeInterfacePropertyToIR(
         member,
         checker,
@@ -1121,10 +1067,10 @@ function analyzeInterfaceToIR(interfaceDecl, checker, file = "", extensionRegist
   };
 }
 function analyzeTypeAliasToIR(typeAlias, checker, file = "", extensionRegistry) {
-  if (!ts4.isTypeLiteralNode(typeAlias.type)) {
+  if (!ts3.isTypeLiteralNode(typeAlias.type)) {
     const sourceFile = typeAlias.getSourceFile();
     const { line } = sourceFile.getLineAndCharacterOfPosition(typeAlias.getStart());
-    const kindDesc = ts4.SyntaxKind[typeAlias.type.kind] ?? "unknown";
+    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})`
@@ -1140,7 +1086,7 @@ function analyzeTypeAliasToIR(typeAlias, checker, file = "", extensionRegistry)
   );
   const visiting = /* @__PURE__ */ new Set();
   for (const member of typeAlias.type.members) {
-    if (ts4.isPropertySignature(member)) {
+    if (ts3.isPropertySignature(member)) {
       const fieldNode = analyzeInterfacePropertyToIR(
         member,
         checker,
@@ -1168,7 +1114,7 @@ function analyzeTypeAliasToIR(typeAlias, checker, file = "", extensionRegistry)
   };
 }
 function analyzeFieldToIR(prop, checker, file, typeRegistry, visiting, extensionRegistry) {
-  if (!ts4.isIdentifier(prop.name)) {
+  if (!ts3.isIdentifier(prop.name)) {
     return null;
   }
   const name = prop.name.text;
@@ -1185,12 +1131,14 @@ function analyzeFieldToIR(prop, checker, file, typeRegistry, visiting, extension
     extensionRegistry
   );
   const constraints = [];
-  if (prop.type) {
+  if (prop.type && !shouldEmitPrimitiveAliasDefinition(prop.type, checker)) {
     constraints.push(
       ...extractTypeAliasConstraintNodes(prop.type, checker, file, extensionRegistry)
     );
   }
-  constraints.push(...extractJSDocConstraintNodes(prop, file, makeParseOptions(extensionRegistry, type)));
+  constraints.push(
+    ...extractJSDocConstraintNodes(prop, file, makeParseOptions(extensionRegistry, type))
+  );
   let annotations = [];
   annotations.push(
     ...extractJSDocAnnotationNodes(prop, file, makeParseOptions(extensionRegistry, type))
@@ -1211,7 +1159,7 @@ function analyzeFieldToIR(prop, checker, file, typeRegistry, visiting, extension
   };
 }
 function analyzeInterfacePropertyToIR(prop, checker, file, typeRegistry, visiting, extensionRegistry) {
-  if (!ts4.isIdentifier(prop.name)) {
+  if (!ts3.isIdentifier(prop.name)) {
     return null;
   }
   const name = prop.name.text;
@@ -1228,12 +1176,14 @@ function analyzeInterfacePropertyToIR(prop, checker, file, typeRegistry, visitin
     extensionRegistry
   );
   const constraints = [];
-  if (prop.type) {
+  if (prop.type && !shouldEmitPrimitiveAliasDefinition(prop.type, checker)) {
     constraints.push(
       ...extractTypeAliasConstraintNodes(prop.type, checker, file, extensionRegistry)
     );
   }
-  constraints.push(...extractJSDocConstraintNodes(prop, file, makeParseOptions(extensionRegistry, type)));
+  constraints.push(
+    ...extractJSDocConstraintNodes(prop, file, makeParseOptions(extensionRegistry, type))
+  );
   let annotations = [];
   annotations.push(
     ...extractJSDocAnnotationNodes(prop, file, makeParseOptions(extensionRegistry, type))
@@ -1322,7 +1272,7 @@ function resolveRegisteredCustomType(sourceNode, extensionRegistry, checker) {
   return resolveRegisteredCustomTypeFromTypeNode(typeNode, extensionRegistry, checker);
 }
 function resolveRegisteredCustomTypeFromTypeNode(typeNode, extensionRegistry, checker) {
-  if (ts4.isParenthesizedTypeNode(typeNode)) {
+  if (ts3.isParenthesizedTypeNode(typeNode)) {
     return resolveRegisteredCustomTypeFromTypeNode(typeNode.type, extensionRegistry, checker);
   }
   const typeName = getTypeNodeRegistrationName(typeNode);
@@ -1337,8 +1287,8 @@ function resolveRegisteredCustomTypeFromTypeNode(typeNode, extensionRegistry, ch
       payload: null
     };
   }
-  if (ts4.isTypeReferenceNode(typeNode) && ts4.isIdentifier(typeNode.typeName)) {
-    const aliasDecl = checker.getSymbolAtLocation(typeNode.typeName)?.declarations?.find(ts4.isTypeAliasDeclaration);
+  if (ts3.isTypeReferenceNode(typeNode) && ts3.isIdentifier(typeNode.typeName)) {
+    const aliasDecl = checker.getSymbolAtLocation(typeNode.typeName)?.declarations?.find(ts3.isTypeAliasDeclaration);
     if (aliasDecl !== void 0) {
       return resolveRegisteredCustomTypeFromTypeNode(aliasDecl.type, extensionRegistry, checker);
     }
@@ -1346,22 +1296,22 @@ function resolveRegisteredCustomTypeFromTypeNode(typeNode, extensionRegistry, ch
   return null;
 }
 function extractTypeNodeFromSource(sourceNode) {
-  if (ts4.isPropertyDeclaration(sourceNode) || ts4.isPropertySignature(sourceNode) || ts4.isParameter(sourceNode) || ts4.isTypeAliasDeclaration(sourceNode)) {
+  if (ts3.isPropertyDeclaration(sourceNode) || ts3.isPropertySignature(sourceNode) || ts3.isParameter(sourceNode) || ts3.isTypeAliasDeclaration(sourceNode)) {
     return sourceNode.type;
   }
-  if (ts4.isTypeNode(sourceNode)) {
+  if (ts3.isTypeNode(sourceNode)) {
     return sourceNode;
   }
   return void 0;
 }
 function getTypeNodeRegistrationName(typeNode) {
-  if (ts4.isTypeReferenceNode(typeNode)) {
-    return ts4.isIdentifier(typeNode.typeName) ? typeNode.typeName.text : typeNode.typeName.right.text;
+  if (ts3.isTypeReferenceNode(typeNode)) {
+    return ts3.isIdentifier(typeNode.typeName) ? typeNode.typeName.text : typeNode.typeName.right.text;
   }
-  if (ts4.isParenthesizedTypeNode(typeNode)) {
+  if (ts3.isParenthesizedTypeNode(typeNode)) {
     return getTypeNodeRegistrationName(typeNode.type);
   }
-  if (typeNode.kind === ts4.SyntaxKind.BigIntKeyword || typeNode.kind === ts4.SyntaxKind.StringKeyword || typeNode.kind === ts4.SyntaxKind.NumberKeyword || typeNode.kind === ts4.SyntaxKind.BooleanKeyword) {
+  if (typeNode.kind === ts3.SyntaxKind.BigIntKeyword || typeNode.kind === ts3.SyntaxKind.StringKeyword || typeNode.kind === ts3.SyntaxKind.NumberKeyword || typeNode.kind === ts3.SyntaxKind.BooleanKeyword) {
     return typeNode.getText();
   }
   return null;
@@ -1371,19 +1321,34 @@ function resolveTypeNode(type, checker, file, typeRegistry, visiting, sourceNode
   if (customType) {
     return customType;
   }
-  if (type.flags & ts4.TypeFlags.String) {
+  const primitiveAlias = tryResolveNamedPrimitiveAlias(
+    type,
+    checker,
+    file,
+    typeRegistry,
+    visiting,
+    sourceNode,
+    extensionRegistry
+  );
+  if (primitiveAlias) {
+    return primitiveAlias;
+  }
+  if (type.flags & ts3.TypeFlags.String) {
     return { kind: "primitive", primitiveKind: "string" };
   }
-  if (type.flags & ts4.TypeFlags.Number) {
+  if (type.flags & ts3.TypeFlags.Number) {
     return { kind: "primitive", primitiveKind: "number" };
   }
-  if (type.flags & ts4.TypeFlags.Boolean) {
+  if (type.flags & (ts3.TypeFlags.BigInt | ts3.TypeFlags.BigIntLiteral)) {
+    return { kind: "primitive", primitiveKind: "bigint" };
+  }
+  if (type.flags & ts3.TypeFlags.Boolean) {
     return { kind: "primitive", primitiveKind: "boolean" };
   }
-  if (type.flags & ts4.TypeFlags.Null) {
+  if (type.flags & ts3.TypeFlags.Null) {
     return { kind: "primitive", primitiveKind: "null" };
   }
-  if (type.flags & ts4.TypeFlags.Undefined) {
+  if (type.flags & ts3.TypeFlags.Undefined) {
     return { kind: "primitive", primitiveKind: "null" };
   }
   if (type.isStringLiteral()) {
@@ -1425,6 +1390,75 @@ function resolveTypeNode(type, checker, file, typeRegistry, visiting, sourceNode
   }
   return { kind: "primitive", primitiveKind: "string" };
 }
+function tryResolveNamedPrimitiveAlias(type, checker, file, typeRegistry, visiting, sourceNode, extensionRegistry) {
+  if (!(type.flags & (ts3.TypeFlags.String | ts3.TypeFlags.Number | ts3.TypeFlags.BigInt | ts3.TypeFlags.BigIntLiteral | ts3.TypeFlags.Boolean | ts3.TypeFlags.Null))) {
+    return null;
+  }
+  const aliasDecl = type.aliasSymbol?.declarations?.find(ts3.isTypeAliasDeclaration) ?? getReferencedTypeAliasDeclaration(sourceNode, checker);
+  if (!aliasDecl) {
+    return null;
+  }
+  const aliasName = aliasDecl.name.text;
+  if (!typeRegistry[aliasName]) {
+    const aliasType = checker.getTypeFromTypeNode(aliasDecl.type);
+    const constraints = [
+      ...extractJSDocConstraintNodes(aliasDecl, file, makeParseOptions(extensionRegistry)),
+      ...extractTypeAliasConstraintNodes(aliasDecl.type, checker, file, extensionRegistry)
+    ];
+    const annotations = extractJSDocAnnotationNodes(
+      aliasDecl,
+      file,
+      makeParseOptions(extensionRegistry)
+    );
+    typeRegistry[aliasName] = {
+      name: aliasName,
+      type: resolveAliasedPrimitiveTarget(
+        aliasType,
+        checker,
+        file,
+        typeRegistry,
+        visiting,
+        extensionRegistry
+      ),
+      ...constraints.length > 0 && { constraints },
+      ...annotations.length > 0 && { annotations },
+      provenance: provenanceForDeclaration(aliasDecl, file)
+    };
+  }
+  return { kind: "reference", name: aliasName, typeArguments: [] };
+}
+function getReferencedTypeAliasDeclaration(sourceNode, checker) {
+  const typeNode = sourceNode && (ts3.isPropertyDeclaration(sourceNode) || ts3.isPropertySignature(sourceNode) || ts3.isParameter(sourceNode)) ? sourceNode.type : void 0;
+  if (!typeNode || !ts3.isTypeReferenceNode(typeNode)) {
+    return void 0;
+  }
+  return checker.getSymbolAtLocation(typeNode.typeName)?.declarations?.find(ts3.isTypeAliasDeclaration);
+}
+function shouldEmitPrimitiveAliasDefinition(typeNode, checker) {
+  if (!ts3.isTypeReferenceNode(typeNode)) {
+    return false;
+  }
+  const aliasDecl = checker.getSymbolAtLocation(typeNode.typeName)?.declarations?.find(ts3.isTypeAliasDeclaration);
+  if (!aliasDecl) {
+    return false;
+  }
+  const resolved = checker.getTypeFromTypeNode(aliasDecl.type);
+  return !!(resolved.flags & (ts3.TypeFlags.String | ts3.TypeFlags.Number | ts3.TypeFlags.BigInt | ts3.TypeFlags.BigIntLiteral | ts3.TypeFlags.Boolean | ts3.TypeFlags.Null));
+}
+function resolveAliasedPrimitiveTarget(type, checker, file, typeRegistry, visiting, extensionRegistry) {
+  const nestedAliasDecl = type.aliasSymbol?.declarations?.find(ts3.isTypeAliasDeclaration);
+  if (nestedAliasDecl !== void 0) {
+    return resolveAliasedPrimitiveTarget(
+      checker.getTypeFromTypeNode(nestedAliasDecl.type),
+      checker,
+      file,
+      typeRegistry,
+      visiting,
+      extensionRegistry
+    );
+  }
+  return resolveTypeNode(type, checker, file, typeRegistry, visiting, void 0, extensionRegistry);
+}
 function resolveUnionType(type, checker, file, typeRegistry, visiting, sourceNode, extensionRegistry) {
   const typeName = getNamedTypeName(type);
   const namedDecl = getNamedTypeDeclaration(type);
@@ -1437,13 +1471,13 @@ function resolveUnionType(type, checker, file, typeRegistry, visiting, sourceNod
     (memberTypeNode) => !isNullishTypeNode(resolveAliasedTypeNode(memberTypeNode, checker))
   );
   const nonNullTypes = allTypes.filter(
-    (memberType) => !(memberType.flags & (ts4.TypeFlags.Null | ts4.TypeFlags.Undefined))
+    (memberType) => !(memberType.flags & (ts3.TypeFlags.Null | ts3.TypeFlags.Undefined))
   );
   const nonNullMembers = nonNullTypes.map((memberType, index) => ({
     memberType,
     sourceNode: nonNullSourceNodes.length === nonNullTypes.length ? nonNullSourceNodes[index] : void 0
   }));
-  const hasNull = allTypes.some((t) => t.flags & ts4.TypeFlags.Null);
+  const hasNull = allTypes.some((t) => t.flags & ts3.TypeFlags.Null);
   const memberDisplayNames = /* @__PURE__ */ new Map();
   if (namedDecl) {
     for (const [value, label] of extractDisplayNameMetadata(namedDecl).memberDisplayNames) {
@@ -1472,7 +1506,7 @@ function resolveUnionType(type, checker, file, typeRegistry, visiting, sourceNod
     const displayName = memberDisplayNames.get(String(value));
     return displayName !== void 0 ? { value, displayName } : { value };
   });
-  const isBooleanUnion2 = nonNullTypes.length === 2 && nonNullTypes.every((t) => t.flags & ts4.TypeFlags.BooleanLiteral);
+  const isBooleanUnion2 = nonNullTypes.length === 2 && nonNullTypes.every((t) => t.flags & ts3.TypeFlags.BooleanLiteral);
   if (isBooleanUnion2) {
     const boolNode = { kind: "primitive", primitiveKind: "boolean" };
     const result = hasNull ? {
@@ -1558,7 +1592,7 @@ function tryResolveRecordType(type, checker, file, typeRegistry, visiting, exten
   if (type.getProperties().length > 0) {
     return null;
   }
-  const indexInfo = checker.getIndexInfoOfType(type, ts4.IndexKind.String);
+  const indexInfo = checker.getIndexInfoOfType(type, ts3.IndexKind.String);
   if (!indexInfo) {
     return null;
   }
@@ -1669,7 +1703,7 @@ function resolveObjectType(type, checker, file, typeRegistry, visiting, extensio
     const declaration = prop.valueDeclaration ?? prop.declarations?.[0];
     if (!declaration) continue;
     const propType = checker.getTypeOfSymbolAtLocation(prop, declaration);
-    const optional = !!(prop.flags & ts4.SymbolFlags.Optional);
+    const optional = !!(prop.flags & ts3.SymbolFlags.Optional);
     const propTypeNode = resolveTypeNode(
       propType,
       checker,
@@ -1714,11 +1748,11 @@ function getNamedTypeFieldNodeInfoMap(type, checker, file, typeRegistry, visitin
   for (const symbol of symbols) {
     const declarations = symbol.declarations;
     if (!declarations) continue;
-    const classDecl = declarations.find(ts4.isClassDeclaration);
+    const classDecl = declarations.find(ts3.isClassDeclaration);
     if (classDecl) {
       const map = /* @__PURE__ */ new Map();
       for (const member of classDecl.members) {
-        if (ts4.isPropertyDeclaration(member) && ts4.isIdentifier(member.name)) {
+        if (ts3.isPropertyDeclaration(member) && ts3.isIdentifier(member.name)) {
           const fieldNode = analyzeFieldToIR(
             member,
             checker,
@@ -1738,7 +1772,7 @@ function getNamedTypeFieldNodeInfoMap(type, checker, file, typeRegistry, visitin
       }
       return map;
     }
-    const interfaceDecl = declarations.find(ts4.isInterfaceDeclaration);
+    const interfaceDecl = declarations.find(ts3.isInterfaceDeclaration);
     if (interfaceDecl) {
       return buildFieldNodeInfoMap(
         interfaceDecl.members,
@@ -1749,8 +1783,8 @@ function getNamedTypeFieldNodeInfoMap(type, checker, file, typeRegistry, visitin
         extensionRegistry
       );
     }
-    const typeAliasDecl = declarations.find(ts4.isTypeAliasDeclaration);
-    if (typeAliasDecl && ts4.isTypeLiteralNode(typeAliasDecl.type)) {
+    const typeAliasDecl = declarations.find(ts3.isTypeAliasDeclaration);
+    if (typeAliasDecl && ts3.isTypeLiteralNode(typeAliasDecl.type)) {
       return buildFieldNodeInfoMap(
         typeAliasDecl.type.members,
         checker,
@@ -1769,10 +1803,10 @@ function extractArrayElementTypeNode(sourceNode, checker) {
     return void 0;
   }
   const resolvedTypeNode = resolveAliasedTypeNode(typeNode, checker);
-  if (ts4.isArrayTypeNode(resolvedTypeNode)) {
+  if (ts3.isArrayTypeNode(resolvedTypeNode)) {
     return resolvedTypeNode.elementType;
   }
-  if (ts4.isTypeReferenceNode(resolvedTypeNode) && ts4.isIdentifier(resolvedTypeNode.typeName) && resolvedTypeNode.typeName.text === "Array" && resolvedTypeNode.typeArguments?.[0]) {
+  if (ts3.isTypeReferenceNode(resolvedTypeNode) && ts3.isIdentifier(resolvedTypeNode.typeName) && resolvedTypeNode.typeName.text === "Array" && resolvedTypeNode.typeArguments?.[0]) {
     return resolvedTypeNode.typeArguments[0];
   }
   return void 0;
@@ -1783,17 +1817,17 @@ function extractUnionMemberTypeNodes(sourceNode, checker) {
     return [];
   }
   const resolvedTypeNode = resolveAliasedTypeNode(typeNode, checker);
-  return ts4.isUnionTypeNode(resolvedTypeNode) ? [...resolvedTypeNode.types] : [];
+  return ts3.isUnionTypeNode(resolvedTypeNode) ? [...resolvedTypeNode.types] : [];
 }
 function resolveAliasedTypeNode(typeNode, checker, visited = /* @__PURE__ */ new Set()) {
-  if (ts4.isParenthesizedTypeNode(typeNode)) {
+  if (ts3.isParenthesizedTypeNode(typeNode)) {
     return resolveAliasedTypeNode(typeNode.type, checker, visited);
   }
-  if (!ts4.isTypeReferenceNode(typeNode) || !ts4.isIdentifier(typeNode.typeName)) {
+  if (!ts3.isTypeReferenceNode(typeNode) || !ts3.isIdentifier(typeNode.typeName)) {
     return typeNode;
   }
   const symbol = checker.getSymbolAtLocation(typeNode.typeName);
-  const aliasDecl = symbol?.declarations?.find(ts4.isTypeAliasDeclaration);
+  const aliasDecl = symbol?.declarations?.find(ts3.isTypeAliasDeclaration);
   if (aliasDecl === void 0 || visited.has(aliasDecl)) {
     return typeNode;
   }
@@ -1801,15 +1835,15 @@ function resolveAliasedTypeNode(typeNode, checker, visited = /* @__PURE__ */ new
   return resolveAliasedTypeNode(aliasDecl.type, checker, visited);
 }
 function isNullishTypeNode(typeNode) {
-  if (typeNode.kind === ts4.SyntaxKind.NullKeyword || typeNode.kind === ts4.SyntaxKind.UndefinedKeyword) {
+  if (typeNode.kind === ts3.SyntaxKind.NullKeyword || typeNode.kind === ts3.SyntaxKind.UndefinedKeyword) {
     return true;
   }
-  return ts4.isLiteralTypeNode(typeNode) && (typeNode.literal.kind === ts4.SyntaxKind.NullKeyword || typeNode.literal.kind === ts4.SyntaxKind.UndefinedKeyword);
+  return ts3.isLiteralTypeNode(typeNode) && (typeNode.literal.kind === ts3.SyntaxKind.NullKeyword || typeNode.literal.kind === ts3.SyntaxKind.UndefinedKeyword);
 }
 function buildFieldNodeInfoMap(members, checker, file, typeRegistry, visiting, extensionRegistry) {
   const map = /* @__PURE__ */ new Map();
   for (const member of members) {
-    if (ts4.isPropertySignature(member)) {
+    if (ts3.isPropertySignature(member)) {
       const fieldNode = analyzeInterfacePropertyToIR(
         member,
         checker,
@@ -1831,7 +1865,7 @@ function buildFieldNodeInfoMap(members, checker, file, typeRegistry, visiting, e
 }
 var MAX_ALIAS_CHAIN_DEPTH = 8;
 function extractTypeAliasConstraintNodes(typeNode, checker, file, extensionRegistry, depth = 0) {
-  if (!ts4.isTypeReferenceNode(typeNode)) return [];
+  if (!ts3.isTypeReferenceNode(typeNode)) return [];
   if (depth >= MAX_ALIAS_CHAIN_DEPTH) {
     const aliasName = typeNode.typeName.getText();
     throw new Error(
@@ -1840,9 +1874,9 @@ function extractTypeAliasConstraintNodes(typeNode, checker, file, extensionRegis
   }
   const symbol = checker.getSymbolAtLocation(typeNode.typeName);
   if (!symbol?.declarations) return [];
-  const aliasDecl = symbol.declarations.find(ts4.isTypeAliasDeclaration);
+  const aliasDecl = symbol.declarations.find(ts3.isTypeAliasDeclaration);
   if (!aliasDecl) return [];
-  if (ts4.isTypeLiteralNode(aliasDecl.type)) return [];
+  if (ts3.isTypeLiteralNode(aliasDecl.type)) return [];
   const aliasFieldType = resolveTypeNode(
     checker.getTypeAtLocation(aliasDecl.type),
     checker,
@@ -1858,13 +1892,7 @@ function extractTypeAliasConstraintNodes(typeNode, checker, file, extensionRegis
     makeParseOptions(extensionRegistry, aliasFieldType)
   );
   constraints.push(
-    ...extractTypeAliasConstraintNodes(
-      aliasDecl.type,
-      checker,
-      file,
-      extensionRegistry,
-      depth + 1
-    )
+    ...extractTypeAliasConstraintNodes(aliasDecl.type, checker, file, extensionRegistry, depth + 1)
   );
   return constraints;
 }
@@ -1891,14 +1919,14 @@ function getNamedTypeName(type) {
   const symbol = type.getSymbol();
   if (symbol?.declarations) {
     const decl = symbol.declarations[0];
-    if (decl && (ts4.isClassDeclaration(decl) || ts4.isInterfaceDeclaration(decl) || ts4.isTypeAliasDeclaration(decl))) {
-      const name = ts4.isClassDeclaration(decl) ? decl.name?.text : decl.name.text;
+    if (decl && (ts3.isClassDeclaration(decl) || ts3.isInterfaceDeclaration(decl) || ts3.isTypeAliasDeclaration(decl))) {
+      const name = ts3.isClassDeclaration(decl) ? decl.name?.text : decl.name.text;
       if (name) return name;
     }
   }
   const aliasSymbol = type.aliasSymbol;
   if (aliasSymbol?.declarations) {
-    const aliasDecl = aliasSymbol.declarations.find(ts4.isTypeAliasDeclaration);
+    const aliasDecl = aliasSymbol.declarations.find(ts3.isTypeAliasDeclaration);
     if (aliasDecl) {
       return aliasDecl.name.text;
     }
@@ -1909,24 +1937,24 @@ function getNamedTypeDeclaration(type) {
   const symbol = type.getSymbol();
   if (symbol?.declarations) {
     const decl = symbol.declarations[0];
-    if (decl && (ts4.isClassDeclaration(decl) || ts4.isInterfaceDeclaration(decl) || ts4.isTypeAliasDeclaration(decl))) {
+    if (decl && (ts3.isClassDeclaration(decl) || ts3.isInterfaceDeclaration(decl) || ts3.isTypeAliasDeclaration(decl))) {
       return decl;
     }
   }
   const aliasSymbol = type.aliasSymbol;
   if (aliasSymbol?.declarations) {
-    return aliasSymbol.declarations.find(ts4.isTypeAliasDeclaration);
+    return aliasSymbol.declarations.find(ts3.isTypeAliasDeclaration);
   }
   return void 0;
 }
 function analyzeMethod(method, checker) {
-  if (!ts4.isIdentifier(method.name)) {
+  if (!ts3.isIdentifier(method.name)) {
     return null;
   }
   const name = method.name.text;
   const parameters = [];
   for (const param of method.parameters) {
-    if (ts4.isIdentifier(param.name)) {
+    if (ts3.isIdentifier(param.name)) {
       const paramInfo = analyzeParameter(param, checker);
       parameters.push(paramInfo);
     }
@@ -1937,7 +1965,7 @@ function analyzeMethod(method, checker) {
   return { name, parameters, returnTypeNode, returnType };
 }
 function analyzeParameter(param, checker) {
-  const name = ts4.isIdentifier(param.name) ? param.name.text : "param";
+  const name = ts3.isIdentifier(param.name) ? param.name.text : "param";
   const typeNode = param.type;
   const type = checker.getTypeAtLocation(param);
   const formSpecExportName = detectFormSpecReference(typeNode);
@@ -1946,20 +1974,90 @@ function analyzeParameter(param, checker) {
 }
 function detectFormSpecReference(typeNode) {
   if (!typeNode) return null;
-  if (!ts4.isTypeReferenceNode(typeNode)) return null;
-  const typeName = ts4.isIdentifier(typeNode.typeName) ? typeNode.typeName.text : ts4.isQualifiedName(typeNode.typeName) ? typeNode.typeName.right.text : 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 || !ts4.isTypeQueryNode(typeArg)) return null;
-  if (ts4.isIdentifier(typeArg.exprName)) {
+  if (!typeArg || !ts3.isTypeQueryNode(typeArg)) return null;
+  if (ts3.isIdentifier(typeArg.exprName)) {
     return typeArg.exprName.text;
   }
-  if (ts4.isQualifiedName(typeArg.exprName)) {
+  if (ts3.isQualifiedName(typeArg.exprName)) {
     return typeArg.exprName.right.text;
   }
   return null;
 }
 
+// src/analyzer/program.ts
+function createProgramContext(filePath) {
+  const absolutePath = path.resolve(filePath);
+  const fileDir = path.dirname(absolutePath);
+  const configPath = ts4.findConfigFile(fileDir, ts4.sys.fileExists.bind(ts4.sys), "tsconfig.json");
+  let compilerOptions;
+  let fileNames;
+  if (configPath) {
+    const configFile = ts4.readConfigFile(configPath, ts4.sys.readFile.bind(ts4.sys));
+    if (configFile.error) {
+      throw new Error(
+        `Error reading tsconfig.json: ${ts4.flattenDiagnosticMessageText(configFile.error.messageText, "\n")}`
+      );
+    }
+    const parsed = ts4.parseJsonConfigFileContent(
+      configFile.config,
+      ts4.sys,
+      path.dirname(configPath)
+    );
+    if (parsed.errors.length > 0) {
+      const errorMessages = parsed.errors.map((e) => ts4.flattenDiagnosticMessageText(e.messageText, "\n")).join("\n");
+      throw new Error(`Error parsing tsconfig.json: ${errorMessages}`);
+    }
+    compilerOptions = parsed.options;
+    fileNames = parsed.fileNames.includes(absolutePath) ? parsed.fileNames : [...parsed.fileNames, absolutePath];
+  } else {
+    compilerOptions = {
+      target: ts4.ScriptTarget.ES2022,
+      module: ts4.ModuleKind.NodeNext,
+      moduleResolution: ts4.ModuleResolutionKind.NodeNext,
+      strict: true,
+      skipLibCheck: true,
+      declaration: true
+    };
+    fileNames = [absolutePath];
+  }
+  const program = ts4.createProgram(fileNames, compilerOptions);
+  const sourceFile = program.getSourceFile(absolutePath);
+  if (!sourceFile) {
+    throw new Error(`Could not find source file: ${absolutePath}`);
+  }
+  return {
+    program,
+    checker: program.getTypeChecker(),
+    sourceFile
+  };
+}
+function findNodeByName(sourceFile, name, predicate, getName) {
+  let result = null;
+  function visit(node) {
+    if (result) return;
+    if (predicate(node) && getName(node) === name) {
+      result = node;
+      return;
+    }
+    ts4.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return result;
+}
+function findClassByName(sourceFile, className) {
+  return findNodeByName(sourceFile, className, ts4.isClassDeclaration, (n) => n.name?.text);
+}
+function findInterfaceByName(sourceFile, interfaceName) {
+  return findNodeByName(sourceFile, interfaceName, ts4.isInterfaceDeclaration, (n) => n.name.text);
+}
+function findTypeAliasByName(sourceFile, aliasName) {
+  return findNodeByName(sourceFile, aliasName, ts4.isTypeAliasDeclaration, (n) => n.name.text);
+}
+
 // src/json-schema/ir-generator.ts
 function makeContext(options) {
   const vendorPrefix = options?.vendorPrefix ?? "x-formspec";
@@ -1978,6 +2076,9 @@ function generateJsonSchemaFromIR(ir, options) {
   const ctx = makeContext(options);
   for (const [name, typeDef] of Object.entries(ir.typeRegistry)) {
     ctx.defs[name] = generateTypeNode(typeDef.type, ctx);
+    if (typeDef.constraints && typeDef.constraints.length > 0) {
+      applyConstraints(ctx.defs[name], typeDef.constraints, ctx);
+    }
     if (typeDef.annotations && typeDef.annotations.length > 0) {
       applyAnnotations(ctx.defs[name], typeDef.annotations, ctx);
     }
@@ -2146,7 +2247,9 @@ function generateTypeNode(type, ctx) {
   }
 }
 function generatePrimitiveType(type) {
-  return { type: type.primitiveKind };
+  return {
+    type: type.primitiveKind === "integer" || type.primitiveKind === "bigint" ? "integer" : type.primitiveKind
+  };
 }
 function generateEnumType(type) {
   const hasDisplayNames = type.members.some((m) => m.displayName !== void 0);
@@ -2319,7 +2422,7 @@ function applyAnnotations(schema, annotations, ctx) {
       case "deprecated":
         schema.deprecated = true;
         if (annotation.message !== void 0 && annotation.message !== "") {
-          schema["x-formspec-deprecation-description"] = annotation.message;
+          schema[`${ctx.vendorPrefix}-deprecation-description`] = annotation.message;
         }
         break;
       case "placeholder":
@@ -2610,15 +2713,6 @@ function generateUiSchemaFromIR(ir) {
   return parseOrThrow(uiSchema, result, "UI Schema");
 }
 
-// src/generators/class-schema.ts
-function generateClassSchemas(analysis, source, options) {
-  const ir = canonicalizeTSDoc(analysis, source);
-  return {
-    jsonSchema: generateJsonSchemaFromIR(ir, options),
-    uiSchema: generateUiSchemaFromIR(ir)
-  };
-}
-
 // src/validate/constraint-validator.ts
 import { normalizeConstraintTagName as normalizeConstraintTagName2 } from "@formspec/core";
 function addContradiction(ctx, message, primary, related) {
@@ -3096,6 +3190,26 @@ function dereferenceType(ctx, type) {
   }
   return current;
 }
+function collectReferencedTypeConstraints(ctx, type) {
+  const collected = [];
+  let current = type;
+  const seen = /* @__PURE__ */ new Set();
+  while (current.kind === "reference") {
+    if (seen.has(current.name)) {
+      break;
+    }
+    seen.add(current.name);
+    const definition = ctx.typeRegistry[current.name];
+    if (definition === void 0) {
+      break;
+    }
+    if (definition.constraints !== void 0) {
+      collected.push(...definition.constraints);
+    }
+    current = definition.type;
+  }
+  return collected;
+}
 function resolvePathTargetType(ctx, type, segments) {
   const effectiveType = dereferenceType(ctx, type);
   if (segments.length === 0) {
@@ -3117,12 +3231,33 @@ function resolvePathTargetType(ctx, type, segments) {
   }
   return { kind: "unresolvable", type: effectiveType };
 }
+function isNullType(type) {
+  return type.kind === "primitive" && type.primitiveKind === "null";
+}
+function collectCustomConstraintCandidateTypes(ctx, type) {
+  const effectiveType = dereferenceType(ctx, type);
+  const candidates = [effectiveType];
+  if (effectiveType.kind === "array") {
+    candidates.push(...collectCustomConstraintCandidateTypes(ctx, effectiveType.items));
+  }
+  if (effectiveType.kind === "union") {
+    const memberTypes = effectiveType.members.map((member) => dereferenceType(ctx, member));
+    const nonNullMembers = memberTypes.filter((member) => !isNullType(member));
+    if (nonNullMembers.length === 1 && nonNullMembers.length < memberTypes.length) {
+      const [nullableMember] = nonNullMembers;
+      if (nullableMember !== void 0) {
+        candidates.push(...collectCustomConstraintCandidateTypes(ctx, nullableMember));
+      }
+    }
+  }
+  return candidates;
+}
 function formatPathTargetFieldName(fieldName, path2) {
   return path2.length === 0 ? fieldName : `${fieldName}.${path2.join(".")}`;
 }
 function checkConstraintOnType(ctx, fieldName, type, constraint) {
   const effectiveType = dereferenceType(ctx, type);
-  const isNumber = effectiveType.kind === "primitive" && effectiveType.primitiveKind === "number";
+  const isNumber = effectiveType.kind === "primitive" && ["number", "integer", "bigint"].includes(effectiveType.primitiveKind);
   const isString = effectiveType.kind === "primitive" && effectiveType.primitiveKind === "string";
   const isArray = effectiveType.kind === "array";
   const isEnum = effectiveType.kind === "enum";
@@ -3180,7 +3315,9 @@ function checkConstraintOnType(ctx, fieldName, type, constraint) {
       break;
     }
     case "const": {
-      const isPrimitiveConstType = effectiveType.kind === "primitive" && ["string", "number", "boolean", "null"].includes(effectiveType.primitiveKind) || effectiveType.kind === "enum";
+      const isPrimitiveConstType = effectiveType.kind === "primitive" && ["string", "number", "integer", "bigint", "boolean", "null"].includes(
+        effectiveType.primitiveKind
+      ) || effectiveType.kind === "enum";
       if (!isPrimitiveConstType) {
         addTypeMismatch(
           ctx,
@@ -3191,7 +3328,8 @@ function checkConstraintOnType(ctx, fieldName, type, constraint) {
       }
       if (effectiveType.kind === "primitive") {
         const valueType = constraint.value === null ? "null" : Array.isArray(constraint.value) ? "array" : typeof constraint.value;
-        if (valueType !== effectiveType.primitiveKind) {
+        const expectedValueType = effectiveType.primitiveKind === "integer" || effectiveType.primitiveKind === "bigint" ? "number" : effectiveType.primitiveKind;
+        if (valueType !== expectedValueType) {
           addTypeMismatch(
             ctx,
             `Field "${fieldName}": @const value type "${valueType}" is incompatible with field type "${effectiveType.primitiveKind}"`,
@@ -3260,11 +3398,14 @@ function checkCustomConstraint(ctx, fieldName, type, constraint) {
     );
     return;
   }
+  const candidateTypes = collectCustomConstraintCandidateTypes(ctx, type);
   const normalizedTagName = constraint.provenance.tagName === void 0 ? void 0 : normalizeConstraintTagName2(constraint.provenance.tagName.replace(/^@/, ""));
   if (normalizedTagName !== void 0) {
     const tagRegistration = ctx.extensionRegistry.findConstraintTag(normalizedTagName);
     const extensionId = getExtensionIdFromConstraintId(constraint.constraintId);
-    if (extensionId !== null && tagRegistration?.extensionId === extensionId && tagRegistration.registration.constraintName === registration.constraintName && tagRegistration.registration.isApplicableToType?.(type) === false) {
+    if (extensionId !== null && tagRegistration?.extensionId === extensionId && tagRegistration.registration.constraintName === registration.constraintName && !candidateTypes.some(
+      (candidateType) => tagRegistration.registration.isApplicableToType?.(candidateType) !== false
+    )) {
       addTypeMismatch(
         ctx,
         `Field "${fieldName}": custom constraint "${constraint.constraintId}" is not applicable to type "${typeLabel(type)}"`,
@@ -3274,7 +3415,7 @@ function checkCustomConstraint(ctx, fieldName, type, constraint) {
     }
   }
   if (registration.applicableTypes === null) {
-    if (registration.isApplicableToType?.(type) === false) {
+    if (!candidateTypes.some((candidateType) => registration.isApplicableToType?.(candidateType) !== false)) {
       addTypeMismatch(
         ctx,
         `Field "${fieldName}": custom constraint "${constraint.constraintId}" is not applicable to type "${typeLabel(type)}"`,
@@ -3283,7 +3424,11 @@ function checkCustomConstraint(ctx, fieldName, type, constraint) {
     }
     return;
   }
-  if (!registration.applicableTypes.includes(type.kind) || registration.isApplicableToType?.(type) === false) {
+  const applicableTypes = registration.applicableTypes;
+  const matchesApplicableType = candidateTypes.some(
+    (candidateType) => applicableTypes.includes(candidateType.kind) && registration.isApplicableToType?.(candidateType) !== false
+  );
+  if (!matchesApplicableType) {
     addTypeMismatch(
       ctx,
       `Field "${fieldName}": custom constraint "${constraint.constraintId}" is not applicable to type "${typeLabel(type)}"`,
@@ -3292,7 +3437,10 @@ function checkCustomConstraint(ctx, fieldName, type, constraint) {
   }
 }
 function validateFieldNode(ctx, field) {
-  validateConstraints(ctx, field.name, field.type, field.constraints);
+  validateConstraints(ctx, field.name, field.type, [
+    ...collectReferencedTypeConstraints(ctx, field.type),
+    ...field.constraints
+  ]);
   if (field.type.kind === "object") {
     for (const prop of field.type.properties) {
       validateObjectProperty(ctx, field.name, prop);
@@ -3301,7 +3449,10 @@ function validateFieldNode(ctx, field) {
 }
 function validateObjectProperty(ctx, parentName, prop) {
   const qualifiedName = `${parentName}.${prop.name}`;
-  validateConstraints(ctx, qualifiedName, prop.type, prop.constraints);
+  validateConstraints(ctx, qualifiedName, prop.type, [
+    ...collectReferencedTypeConstraints(ctx, prop.type),
+    ...prop.constraints
+  ]);
   if (prop.type.kind === "object") {
     for (const nestedProp of prop.type.properties) {
       validateObjectProperty(ctx, qualifiedName, nestedProp);
@@ -3353,6 +3504,36 @@ function validateIR(ir, options) {
   };
 }
 
+// src/generators/class-schema.ts
+function generateClassSchemas(analysis, source, options) {
+  const ir = canonicalizeTSDoc(analysis, source);
+  const validationResult = validateIR(ir, {
+    ...options?.extensionRegistry !== void 0 && {
+      extensionRegistry: options.extensionRegistry
+    },
+    ...options?.vendorPrefix !== void 0 && { vendorPrefix: options.vendorPrefix }
+  });
+  if (!validationResult.valid) {
+    throw new Error(formatValidationError(validationResult.diagnostics));
+  }
+  return {
+    jsonSchema: generateJsonSchemaFromIR(ir, options),
+    uiSchema: generateUiSchemaFromIR(ir)
+  };
+}
+function formatValidationError(diagnostics) {
+  const lines = diagnostics.map((diagnostic) => {
+    const primary = formatLocation(diagnostic.primaryLocation);
+    const related = diagnostic.relatedLocations.length > 0 ? ` [related: ${diagnostic.relatedLocations.map(formatLocation).join(", ")}]` : "";
+    return `${diagnostic.code}: ${diagnostic.message} (${primary})${related}`;
+  });
+  return `FormSpec validation failed:
+${lines.map((line) => `- ${line}`).join("\n")}`;
+}
+function formatLocation(location) {
+  return `${location.file}:${String(location.line)}:${String(location.column)}`;
+}
+
 // src/extensions/registry.ts
 function createExtensionRegistry(extensions) {
   const typeMap = /* @__PURE__ */ new Map();
@@ -3454,6 +3635,7 @@ function typeToJsonSchema(type, checker) {
         provenance: fieldProvenance
       }
     ],
+    rootAnnotations: [],
     typeRegistry,
     provenance: fieldProvenance
   };