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

package/dist/analyzer/jsdoc-constraints.d.ts

@@ -14,6 +14,7 @@
  */
 import * as ts from "typescript";
 import type { ConstraintNode, AnnotationNode } from "@formspec/core";
+import { type ParseTSDocOptions } from "./tsdoc-parser.js";
 /**
  * Extracts constraints from JSDoc comments on a TypeScript AST node and returns
  * canonical {@link ConstraintNode} objects.
@@ -25,7 +26,7 @@ import type { ConstraintNode, AnnotationNode } from "@formspec/core";
  * @param file - Absolute path to the source file for provenance
  * @returns Canonical constraint nodes for each valid constraint tag
  */
-export declare function extractJSDocConstraintNodes(node: ts.Node, file?: string): ConstraintNode[];
+export declare function extractJSDocConstraintNodes(node: ts.Node, file?: string, options?: ParseTSDocOptions): ConstraintNode[];
 /**
  * Extracts canonical annotation tags from a node and returns
  * {@link AnnotationNode} objects.
@@ -34,7 +35,7 @@ export declare function extractJSDocConstraintNodes(node: ts.Node, file?: string
  * @param file - Absolute path to the source file for provenance
  * @returns Canonical annotation nodes
  */
-export declare function extractJSDocAnnotationNodes(node: ts.Node, file?: string): AnnotationNode[];
+export declare function extractJSDocAnnotationNodes(node: ts.Node, file?: string, options?: ParseTSDocOptions): AnnotationNode[];
 /**
  * Checks if a node has a TSDoc `@deprecated` tag.
  *

package/dist/analyzer/jsdoc-constraints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jsdoc-constraints.d.ts","sourceRoot":"","sources":["../../src/analyzer/jsdoc-constraints.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAa,MAAM,gBAAgB,CAAC;AAOhF;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,IAAI,SAAK,GAAG,cAAc,EAAE,CAGtF;AAED;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,IAAI,SAAK,GAAG,cAAc,EAAE,CAGtF;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,OAAO,CAEvD;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,WAAW,EAAE,EAAE,CAAC,UAAU,GAAG,SAAS,EACtC,IAAI,SAAK,GACR,cAAc,GAAG,IAAI,CAwCvB"}
+{"version":3,"file":"jsdoc-constraints.d.ts","sourceRoot":"","sources":["../../src/analyzer/jsdoc-constraints.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAa,MAAM,gBAAgB,CAAC;AAChF,OAAO,EAAyC,KAAK,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAMlG;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,EAAE,CAAC,IAAI,EACb,IAAI,SAAK,EACT,OAAO,CAAC,EAAE,iBAAiB,GAC1B,cAAc,EAAE,CAGlB;AAED;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,EAAE,CAAC,IAAI,EACb,IAAI,SAAK,EACT,OAAO,CAAC,EAAE,iBAAiB,GAC1B,cAAc,EAAE,CAGlB;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,OAAO,CAEvD;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,WAAW,EAAE,EAAE,CAAC,UAAU,GAAG,SAAS,EACtC,IAAI,SAAK,GACR,cAAc,GAAG,IAAI,CAwCvB"}

package/dist/analyzer/program.d.ts

@@ -5,6 +5,8 @@
  * using the project's tsconfig.json for compiler options.
  */
 import * as ts from "typescript";
+import { type IRClassAnalysis } from "./class-analyzer.js";
+import type { ExtensionRegistry } from "../extensions/index.js";
 /**
  * Result of creating a TypeScript program for analysis.
  */
@@ -50,4 +52,17 @@ export declare function findInterfaceByName(sourceFile: ts.SourceFile, interface
  * @returns The type alias declaration node, or null if not found
  */
 export declare function findTypeAliasByName(sourceFile: ts.SourceFile, aliasName: string): ts.TypeAliasDeclaration | null;
+/**
+ * Analyzes a named type (class, interface, or type alias) from a TypeScript
+ * source file and returns an `IRClassAnalysis`.
+ *
+ * Tries each declaration kind in order: class → interface → type alias.
+ * Throws if the name is not found or if the type alias analysis fails.
+ *
+ * @param filePath - Absolute or relative path to the TypeScript source file (resolved internally)
+ * @param typeName - Name of the class, interface, or type alias to analyze
+ * @param extensionRegistry - Optional extension registry for custom type handling
+ * @returns IR analysis result
+ */
+export declare function analyzeNamedTypeToIR(filePath: string, typeName: string, extensionRegistry?: ExtensionRegistry): IRClassAnalysis;
 //# sourceMappingURL=program.d.ts.map

package/dist/analyzer/program.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"program.d.ts","sourceRoot":"","sources":["../../src/analyzer/program.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAGjC;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,6BAA6B;IAC7B,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC;IACpB,uCAAuC;IACvC,OAAO,EAAE,EAAE,CAAC,WAAW,CAAC;IACxB,qCAAqC;IACrC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC;CAC3B;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,CA6DrE;AA6BD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,UAAU,EAAE,EAAE,CAAC,UAAU,EACzB,SAAS,EAAE,MAAM,GAChB,EAAE,CAAC,gBAAgB,GAAG,IAAI,CAE5B;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,EAAE,CAAC,UAAU,EACzB,aAAa,EAAE,MAAM,GACpB,EAAE,CAAC,oBAAoB,GAAG,IAAI,CAEhC;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,EAAE,CAAC,UAAU,EACzB,SAAS,EAAE,MAAM,GAChB,EAAE,CAAC,oBAAoB,GAAG,IAAI,CAEhC"}
+{"version":3,"file":"program.d.ts","sourceRoot":"","sources":["../../src/analyzer/program.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,EAIL,KAAK,eAAe,EACrB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,6BAA6B;IAC7B,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC;IACpB,uCAAuC;IACvC,OAAO,EAAE,EAAE,CAAC,WAAW,CAAC;IACxB,qCAAqC;IACrC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC;CAC3B;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,CA6DrE;AA6BD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,UAAU,EAAE,EAAE,CAAC,UAAU,EACzB,SAAS,EAAE,MAAM,GAChB,EAAE,CAAC,gBAAgB,GAAG,IAAI,CAE5B;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,EAAE,CAAC,UAAU,EACzB,aAAa,EAAE,MAAM,GACpB,EAAE,CAAC,oBAAoB,GAAG,IAAI,CAEhC;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,EAAE,CAAC,UAAU,EACzB,SAAS,EAAE,MAAM,GAChB,EAAE,CAAC,oBAAoB,GAAG,IAAI,CAEhC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,iBAAiB,CAAC,EAAE,iBAAiB,GACpC,eAAe,CAyBjB"}

package/dist/analyzer/tsdoc-parser.d.ts

@@ -20,6 +20,11 @@
  *
  * The `@deprecated` tag is a standard TSDoc block tag, parsed structurally.
  *
+ * Description precedence is:
+ * 1. Explicit `@description`
+ * 2. Explicit `@remarks`
+ * 3. Implicit summary text (free text in the comment block)
+ *
  * **Fallback strategy**: TSDoc treats `{` / `}` as inline tag delimiters and
  * `@` as a tag prefix, so content containing these characters (e.g. JSON
  * objects in `@EnumOptions`, regex patterns with `@` in `@Pattern`) gets
@@ -28,7 +33,8 @@
  * verbatim.
  */
 import * as ts from "typescript";
-import { type ConstraintNode, type AnnotationNode, type PathTarget } from "@formspec/core";
+import { type ConstraintNode, type AnnotationNode, type PathTarget, type TypeNode } from "@formspec/core";
+import type { ExtensionRegistry } from "../extensions/index.js";
 /**
  * Result of parsing a single JSDoc comment attached to a TS AST node.
  */
@@ -38,6 +44,21 @@ export interface TSDocParseResult {
     /** Annotation IR nodes extracted from canonical TSDoc block tags. */
     readonly annotations: readonly AnnotationNode[];
 }
+/**
+ * Optional extension-aware parsing inputs for TSDoc extraction.
+ */
+export interface ParseTSDocOptions {
+    /**
+     * Extension registry used to resolve custom tags and custom-type-specific
+     * broadening of built-in constraint tags.
+     */
+    readonly extensionRegistry?: ExtensionRegistry;
+    /**
+     * Effective field/type node for the declaration being parsed. Required when
+     * built-in tags may broaden onto a custom type.
+     */
+    readonly fieldType?: TypeNode;
+}
 /**
  * Display-name metadata extracted from a node's JSDoc tags.
  *
@@ -62,7 +83,7 @@ export interface DisplayNameMetadata {
  * @param file - Absolute source file path for provenance
  * @returns Parsed constraint and annotation nodes
  */
-export declare function parseTSDocTags(node: ts.Node, file?: string): TSDocParseResult;
+export declare function parseTSDocTags(node: ts.Node, file?: string, options?: ParseTSDocOptions): TSDocParseResult;
 /**
  * Checks if a TS AST node has a `@deprecated` tag using the TSDoc parser.
  *

package/dist/analyzer/tsdoc-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tsdoc-parser.d.ts","sourceRoot":"","sources":["../../src/analyzer/tsdoc-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAYjC,OAAO,EAIL,KAAK,cAAc,EACnB,KAAK,cAAc,EAInB,KAAK,UAAU,EAEhB,MAAM,gBAAgB,CAAC;AAyFxB;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,4DAA4D;IAC5D,QAAQ,CAAC,WAAW,EAAE,SAAS,cAAc,EAAE,CAAC;IAChD,qEAAqE;IACrE,QAAQ,CAAC,WAAW,EAAE,SAAS,cAAc,EAAE,CAAC;CACjD;AAED;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,kBAAkB,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC1D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,IAAI,SAAK,GAAG,gBAAgB,CAiKzE;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,OAAO,CAsB5D;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,mBAAmB,CA2B7E;AAMD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,GACX;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAQpD"}
+{"version":3,"file":"tsdoc-parser.d.ts","sourceRoot":"","sources":["../../src/analyzer/tsdoc-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAYjC,OAAO,EAIL,KAAK,cAAc,EACnB,KAAK,cAAc,EAInB,KAAK,UAAU,EAEf,KAAK,QAAQ,EACd,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AA+GhE;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,4DAA4D;IAC5D,QAAQ,CAAC,WAAW,EAAE,SAAS,cAAc,EAAE,CAAC;IAChD,qEAAqE;IACrE,QAAQ,CAAC,WAAW,EAAE,SAAS,cAAc,EAAE,CAAC;CACjD;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IAC/C;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC;CAC/B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,kBAAkB,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC1D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,EAAE,CAAC,IAAI,EACb,IAAI,SAAK,EACT,OAAO,CAAC,EAAE,iBAAiB,GAC1B,gBAAgB,CAiLlB;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,OAAO,CAsB5D;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,mBAAmB,CA2B7E;AAMD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,GACX;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAQpD"}

package/dist/browser.cjs

@@ -70,6 +70,7 @@ function canonicalizeChainDSL(form) {
     kind: "form-ir",
     irVersion: import_core.IR_VERSION,
     elements: canonicalizeElements(form.elements),
+    rootAnnotations: [],
     typeRegistry: {},
     provenance: CHAIN_DSL_PROVENANCE
   };
@@ -380,6 +381,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);
     }
@@ -548,7 +552,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);
@@ -721,7 +727,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":
@@ -754,7 +760,12 @@ function applyCustomConstraint(schema, constraint, ctx) {
       `Cannot generate JSON Schema for custom constraint "${constraint.constraintId}" without a matching extension registration`
     );
   }
-  Object.assign(schema, registration.toJsonSchema(constraint.payload, ctx.vendorPrefix));
+  assignVendorPrefixedExtensionKeywords(
+    schema,
+    registration.toJsonSchema(constraint.payload, ctx.vendorPrefix),
+    ctx.vendorPrefix,
+    `custom constraint "${constraint.constraintId}"`
+  );
 }
 function applyCustomAnnotation(schema, annotation, ctx) {
   const registration = ctx.extensionRegistry?.findAnnotation(annotation.annotationId);
@@ -766,7 +777,22 @@ function applyCustomAnnotation(schema, annotation, ctx) {
   if (registration.toJsonSchema === void 0) {
     return;
   }
-  Object.assign(schema, registration.toJsonSchema(annotation.value, ctx.vendorPrefix));
+  assignVendorPrefixedExtensionKeywords(
+    schema,
+    registration.toJsonSchema(annotation.value, ctx.vendorPrefix),
+    ctx.vendorPrefix,
+    `custom annotation "${annotation.annotationId}"`
+  );
+}
+function assignVendorPrefixedExtensionKeywords(schema, extensionSchema, vendorPrefix, source) {
+  for (const [key, value] of Object.entries(extensionSchema)) {
+    if (!key.startsWith(`${vendorPrefix}-`)) {
+      throw new Error(
+        `Cannot apply ${source}: extension hooks may only emit "${vendorPrefix}-*" JSON Schema keywords`
+      );
+    }
+    schema[key] = value;
+  }
 }
 
 // src/json-schema/generator.ts
@@ -1015,7 +1041,10 @@ function getSchemaExtension(schema, key) {
 // src/extensions/registry.ts
 function createExtensionRegistry(extensions) {
   const typeMap = /* @__PURE__ */ new Map();
+  const typeNameMap = /* @__PURE__ */ new Map();
   const constraintMap = /* @__PURE__ */ new Map();
+  const constraintTagMap = /* @__PURE__ */ new Map();
+  const builtinBroadeningMap = /* @__PURE__ */ new Map();
   const annotationMap = /* @__PURE__ */ new Map();
   for (const ext of extensions) {
     if (ext.types !== void 0) {
@@ -1025,6 +1054,27 @@ function createExtensionRegistry(extensions) {
           throw new Error(`Duplicate custom type ID: "${qualifiedId}"`);
         }
         typeMap.set(qualifiedId, type);
+        for (const sourceTypeName of type.tsTypeNames ?? [type.typeName]) {
+          if (typeNameMap.has(sourceTypeName)) {
+            throw new Error(`Duplicate custom type source name: "${sourceTypeName}"`);
+          }
+          typeNameMap.set(sourceTypeName, {
+            extensionId: ext.extensionId,
+            registration: type
+          });
+        }
+        if (type.builtinConstraintBroadenings !== void 0) {
+          for (const broadening of type.builtinConstraintBroadenings) {
+            const key = `${qualifiedId}:${broadening.tagName}`;
+            if (builtinBroadeningMap.has(key)) {
+              throw new Error(`Duplicate built-in constraint broadening: "${key}"`);
+            }
+            builtinBroadeningMap.set(key, {
+              extensionId: ext.extensionId,
+              registration: broadening
+            });
+          }
+        }
       }
     }
     if (ext.constraints !== void 0) {
@@ -1036,6 +1086,17 @@ function createExtensionRegistry(extensions) {
         constraintMap.set(qualifiedId, constraint);
       }
     }
+    if (ext.constraintTags !== void 0) {
+      for (const tag of ext.constraintTags) {
+        if (constraintTagMap.has(tag.tagName)) {
+          throw new Error(`Duplicate custom constraint tag: "@${tag.tagName}"`);
+        }
+        constraintTagMap.set(tag.tagName, {
+          extensionId: ext.extensionId,
+          registration: tag
+        });
+      }
+    }
     if (ext.annotations !== void 0) {
       for (const annotation of ext.annotations) {
         const qualifiedId = `${ext.extensionId}/${annotation.annotationName}`;
@@ -1049,7 +1110,10 @@ function createExtensionRegistry(extensions) {
   return {
     extensions,
     findType: (typeId) => typeMap.get(typeId),
+    findTypeByName: (typeName) => typeNameMap.get(typeName),
     findConstraint: (constraintId) => constraintMap.get(constraintId),
+    findConstraintTag: (tagName) => constraintTagMap.get(tagName),
+    findBuiltinConstraintBroadening: (typeId, tagName) => builtinBroadeningMap.get(`${typeId}:${tagName}`),
     findAnnotation: (annotationId) => annotationMap.get(annotationId)
   };
 }
@@ -1117,6 +1181,7 @@ var jsonSchema7Schema = import_zod3.z.lazy(
 );
 
 // src/validate/constraint-validator.ts
+var import_core3 = require("@formspec/core");
 function addContradiction(ctx, message, primary, related) {
   ctx.diagnostics.push({
     code: "CONTRADICTING_CONSTRAINTS",
@@ -1162,6 +1227,13 @@ function addConstraintBroadening(ctx, message, primary, related) {
     relatedLocations: [related]
   });
 }
+function getExtensionIdFromConstraintId(constraintId) {
+  const separator = constraintId.lastIndexOf("/");
+  if (separator <= 0) {
+    return null;
+  }
+  return constraintId.slice(0, separator);
+}
 function findNumeric(constraints, constraintKind) {
   return constraints.find((c) => c.constraintKind === constraintKind);
 }
@@ -1332,6 +1404,112 @@ function checkConstraintBroadening(ctx, fieldName, constraints) {
     strongestByKey.set(key, constraint);
   }
 }
+function compareCustomConstraintStrength(current, previous) {
+  const order = current.comparePayloads(current.constraint.payload, previous.constraint.payload);
+  const equalPayloadTiebreaker = order === 0 ? compareSemanticInclusivity(current.role.inclusive, previous.role.inclusive) : order;
+  switch (current.role.bound) {
+    case "lower":
+      return equalPayloadTiebreaker;
+    case "upper":
+      return equalPayloadTiebreaker === 0 ? 0 : -equalPayloadTiebreaker;
+    case "exact":
+      return order === 0 ? 0 : Number.NaN;
+    default: {
+      const _exhaustive = current.role.bound;
+      return _exhaustive;
+    }
+  }
+}
+function compareSemanticInclusivity(currentInclusive, previousInclusive) {
+  if (currentInclusive === previousInclusive) {
+    return 0;
+  }
+  return currentInclusive ? -1 : 1;
+}
+function customConstraintsContradict(lower, upper) {
+  const order = lower.comparePayloads(lower.constraint.payload, upper.constraint.payload);
+  if (order > 0) {
+    return true;
+  }
+  if (order < 0) {
+    return false;
+  }
+  return !lower.role.inclusive || !upper.role.inclusive;
+}
+function describeCustomConstraintTag(constraint) {
+  return constraint.provenance.tagName ?? constraint.constraintId;
+}
+function checkCustomConstraintSemantics(ctx, fieldName, constraints) {
+  if (ctx.extensionRegistry === void 0) {
+    return;
+  }
+  const strongestByKey = /* @__PURE__ */ new Map();
+  const lowerByFamily = /* @__PURE__ */ new Map();
+  const upperByFamily = /* @__PURE__ */ new Map();
+  for (const constraint of constraints) {
+    if (constraint.constraintKind !== "custom") {
+      continue;
+    }
+    const registration = ctx.extensionRegistry.findConstraint(constraint.constraintId);
+    if (registration?.comparePayloads === void 0 || registration.semanticRole === void 0) {
+      continue;
+    }
+    const entry = {
+      constraint,
+      comparePayloads: registration.comparePayloads,
+      role: registration.semanticRole
+    };
+    const familyKey = `${registration.semanticRole.family}:${pathKey(constraint)}`;
+    const boundKey = `${familyKey}:${registration.semanticRole.bound}`;
+    const previous = strongestByKey.get(boundKey);
+    if (previous !== void 0) {
+      const strength = compareCustomConstraintStrength(entry, previous);
+      if (Number.isNaN(strength)) {
+        addContradiction(
+          ctx,
+          `Field "${formatPathTargetFieldName(fieldName, constraint.path?.segments ?? [])}": ${describeCustomConstraintTag(constraint)} conflicts with ${describeCustomConstraintTag(previous.constraint)}`,
+          constraint.provenance,
+          previous.constraint.provenance
+        );
+        continue;
+      }
+      if (strength < 0) {
+        addConstraintBroadening(
+          ctx,
+          `Field "${formatPathTargetFieldName(fieldName, constraint.path?.segments ?? [])}": ${describeCustomConstraintTag(constraint)} is broader than earlier ${describeCustomConstraintTag(previous.constraint)}. Constraints can only narrow.`,
+          constraint.provenance,
+          previous.constraint.provenance
+        );
+        continue;
+      }
+      if (strength > 0) {
+        strongestByKey.set(boundKey, entry);
+      }
+    } else {
+      strongestByKey.set(boundKey, entry);
+    }
+    if (registration.semanticRole.bound === "lower") {
+      lowerByFamily.set(familyKey, strongestByKey.get(boundKey) ?? entry);
+    } else if (registration.semanticRole.bound === "upper") {
+      upperByFamily.set(familyKey, strongestByKey.get(boundKey) ?? entry);
+    }
+  }
+  for (const [familyKey, lower] of lowerByFamily) {
+    const upper = upperByFamily.get(familyKey);
+    if (upper === void 0) {
+      continue;
+    }
+    if (!customConstraintsContradict(lower, upper)) {
+      continue;
+    }
+    addContradiction(
+      ctx,
+      `Field "${formatPathTargetFieldName(fieldName, lower.constraint.path?.segments ?? [])}": ${describeCustomConstraintTag(lower.constraint)} contradicts ${describeCustomConstraintTag(upper.constraint)}`,
+      lower.constraint.provenance,
+      upper.constraint.provenance
+    );
+  }
+}
 function checkNumericContradictions(ctx, fieldName, constraints) {
   const min = findNumeric(constraints, "minimum");
   const max = findNumeric(constraints, "maximum");
@@ -1479,6 +1657,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) {
@@ -1500,12 +1698,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, path) {
   return path.length === 0 ? fieldName : `${fieldName}.${path.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";
@@ -1563,7 +1782,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,
@@ -1574,7 +1795,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}"`,
@@ -1643,8 +1865,37 @@ function checkCustomConstraint(ctx, fieldName, type, constraint) {
     );
     return;
   }
-  if (registration.applicableTypes === null) return;
-  if (!registration.applicableTypes.includes(type.kind)) {
+  const candidateTypes = collectCustomConstraintCandidateTypes(ctx, type);
+  const normalizedTagName = constraint.provenance.tagName === void 0 ? void 0 : (0, import_core3.normalizeConstraintTagName)(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 && !candidateTypes.some(
+      (candidateType) => tagRegistration.registration.isApplicableToType?.(candidateType) !== false
+    )) {
+      addTypeMismatch(
+        ctx,
+        `Field "${fieldName}": custom constraint "${constraint.constraintId}" is not applicable to type "${typeLabel(type)}"`,
+        constraint.provenance
+      );
+      return;
+    }
+  }
+  if (registration.applicableTypes === null) {
+    if (!candidateTypes.some((candidateType) => registration.isApplicableToType?.(candidateType) !== false)) {
+      addTypeMismatch(
+        ctx,
+        `Field "${fieldName}": custom constraint "${constraint.constraintId}" is not applicable to type "${typeLabel(type)}"`,
+        constraint.provenance
+      );
+    }
+    return;
+  }
+  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)}"`,
@@ -1653,7 +1904,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);
@@ -1662,7 +1916,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);
@@ -1675,6 +1932,7 @@ function validateConstraints(ctx, name, type, constraints) {
   checkAllowedMembersContradiction(ctx, name, constraints);
   checkConstContradictions(ctx, name, constraints);
   checkConstraintBroadening(ctx, name, constraints);
+  checkCustomConstraintSemantics(ctx, name, constraints);
   checkTypeApplicability(ctx, name, type, constraints);
 }
 function validateElement(ctx, element) {