@formspec/build 0.1.0-alpha.42 → 0.1.0-alpha.44

package/dist/internals.cjs

@@ -857,48 +857,8 @@ var ts2 = __toESM(require("typescript"), 1);
 // src/analyzer/tsdoc-parser.ts
 var ts = __toESM(require("typescript"), 1);
 var import_internal = require("@formspec/analysis/internal");
-var import_tsdoc = require("@microsoft/tsdoc");
 var import_internals3 = require("@formspec/core/internals");
 var import_internals4 = require("@formspec/core/internals");
-var TAGS_REQUIRING_RAW_TEXT = /* @__PURE__ */ new Set(["pattern", "enumOptions", "defaultValue"]);
-function createFormSpecTSDocConfig(extensionTagNames = []) {
-  const config = new import_tsdoc.TSDocConfiguration();
-  for (const tagName of Object.keys(import_internals3.BUILTIN_CONSTRAINT_DEFINITIONS)) {
-    config.addTagDefinition(
-      new import_tsdoc.TSDocTagDefinition({
-        tagName: "@" + tagName,
-        syntaxKind: import_tsdoc.TSDocTagSyntaxKind.BlockTag,
-        allowMultiple: true
-      })
-    );
-  }
-  for (const tagName of ["apiName", "displayName", "format", "placeholder"]) {
-    config.addTagDefinition(
-      new import_tsdoc.TSDocTagDefinition({
-        tagName: "@" + tagName,
-        syntaxKind: import_tsdoc.TSDocTagSyntaxKind.BlockTag,
-        allowMultiple: true
-      })
-    );
-  }
-  for (const tagName of extensionTagNames) {
-    config.addTagDefinition(
-      new import_tsdoc.TSDocTagDefinition({
-        tagName: "@" + tagName,
-        syntaxKind: import_tsdoc.TSDocTagSyntaxKind.BlockTag,
-        allowMultiple: true
-      })
-    );
-  }
-  return config;
-}
-function sharedCommentSyntaxOptions(options, offset) {
-  const extensions = options?.extensionRegistry?.extensions;
-  return {
-    ...offset !== void 0 ? { offset } : {},
-    ...extensions !== void 0 ? { extensions } : {}
-  };
-}
 function sharedTagValueOptions(options) {
   return {
     ...options?.extensionRegistry !== void 0 ? { registry: options.extensionRegistry } : {},
@@ -998,6 +958,30 @@ function pushUniqueCompilerDiagnostics(target, additions) {
     target.push(diagnostic);
   }
 }
+function processConstraintTag(tagName, text, parsedTag, provenance, node, sourceFile, supportingDeclarations, options, constraints, diagnostics) {
+  const compilerDiagnostics = buildCompilerBackedConstraintDiagnostics(
+    node,
+    sourceFile,
+    tagName,
+    parsedTag,
+    provenance,
+    supportingDeclarations,
+    options
+  );
+  if (compilerDiagnostics.length > 0) {
+    pushUniqueCompilerDiagnostics(diagnostics, compilerDiagnostics);
+    return;
+  }
+  const constraintNode = (0, import_internal.parseConstraintTagValue)(
+    tagName,
+    text,
+    provenance,
+    sharedTagValueOptions(options)
+  );
+  if (constraintNode) {
+    constraints.push(constraintNode);
+  }
+}
 function renderSyntheticArgumentExpression(valueKind, argumentText) {
   const trimmed = argumentText.trim();
   if (trimmed === "") {
@@ -1283,10 +1267,9 @@ function buildCompilerBackedConstraintDiagnostics(node, sourceFile, tagName, par
     )
   ];
 }
-var parserCache = /* @__PURE__ */ new Map();
 var parseResultCache = /* @__PURE__ */ new Map();
-function getParser(options) {
-  const extensionTagNames = [
+function getExtensionTagNames(options) {
+  return [
     ...options?.extensionRegistry?.extensions.flatMap(
       (extension) => (extension.constraintTags ?? []).map((tag) => (0, import_internal.normalizeFormSpecTagName)(tag.tagName))
     ) ?? [],
@@ -1294,14 +1277,6 @@ function getParser(options) {
       (extension) => (extension.metadataSlots ?? []).map((slot) => (0, import_internal.normalizeFormSpecTagName)(slot.tagName))
     ) ?? []
   ].sort();
-  const cacheKey = extensionTagNames.join("|");
-  const existing = parserCache.get(cacheKey);
-  if (existing) {
-    return existing;
-  }
-  const parser = new import_tsdoc.TSDocParser(createFormSpecTSDocConfig(extensionTagNames));
-  parserCache.set(cacheKey, parser);
-  return parser;
 }
 function getExtensionRegistryCacheKey(registry) {
   if (registry === void 0) {
@@ -1352,13 +1327,13 @@ function parseTSDocTags(node, file = "", options) {
   let placeholder;
   let displayNameProvenance;
   let placeholderProvenance;
-  const rawTextTags = [];
   const sourceFile = node.getSourceFile();
   const sourceText = sourceFile.getFullText();
   const extensionTypeNames = getExtensionTypeNames(options?.extensionRegistry);
   const supportingDeclarations = buildSupportingDeclarations(sourceFile, extensionTypeNames);
   const commentRanges = ts.getLeadingCommentRanges(sourceText, node.getFullStart());
   const rawTextFallbacks = collectRawTextFallbacks(node, file);
+  const extensionTagNames = getExtensionTagNames(options);
   if (commentRanges) {
     for (const range of commentRanges) {
       if (range.kind !== ts.SyntaxKind.MultiLineCommentTrivia) {
@@ -1368,38 +1343,18 @@ function parseTSDocTags(node, file = "", options) {
       if (!commentText.startsWith("/**")) {
         continue;
       }
-      const parser = getParser(options);
-      const parserContext = parser.parseRange(
-        import_tsdoc.TextRange.fromStringRange(sourceText, range.pos, range.end)
-      );
-      const docComment = parserContext.docComment;
-      const parsedComment = (0, import_internal.parseCommentBlock)(
-        commentText,
-        sharedCommentSyntaxOptions(options, range.pos)
-      );
-      let parsedTagCursor = 0;
-      const nextParsedTag = (normalizedTagName) => {
-        while (parsedTagCursor < parsedComment.tags.length) {
-          const candidate = parsedComment.tags[parsedTagCursor];
-          parsedTagCursor += 1;
-          if (candidate?.normalizedTagName === normalizedTagName) {
-            return candidate;
-          }
-        }
-        return null;
-      };
-      for (const parsedTag of parsedComment.tags) {
-        if (TAGS_REQUIRING_RAW_TEXT.has(parsedTag.normalizedTagName)) {
-          rawTextTags.push({ tag: parsedTag, commentText, commentOffset: range.pos });
-        }
-      }
-      for (const block of docComment.customBlocks) {
-        const tagName = (0, import_internals3.normalizeConstraintTagName)(block.blockTag.tagName.substring(1));
-        const parsedTag = nextParsedTag(tagName);
+      const extensions = options?.extensionRegistry?.extensions;
+      const unified = (0, import_internal.parseUnifiedComment)(commentText, {
+        offset: range.pos,
+        extensionTagNames,
+        ...extensions !== void 0 ? { extensions } : {}
+      });
+      for (const tag of unified.tags) {
+        const tagName = tag.normalizedTagName;
         if (tagName === "displayName" || tagName === "format" || tagName === "placeholder") {
-          const text2 = getBestBlockPayloadText(parsedTag, commentText, range.pos, block);
+          const text2 = tag.resolvedPayloadText;
           if (text2 === "") continue;
-          const provenance2 = parsedTag !== null ? provenanceForParsedTag(parsedTag, sourceFile, file) : provenanceForComment(range, sourceFile, file, tagName);
+          const provenance2 = provenanceForParsedTag(tag, sourceFile, file);
           switch (tagName) {
             case "displayName":
               if (!isMemberTargetDisplayName(text2) && displayName === void 0) {
@@ -1424,64 +1379,69 @@ function parseTSDocTags(node, file = "", options) {
           }
           continue;
         }
-        if (TAGS_REQUIRING_RAW_TEXT.has(tagName)) continue;
-        const text = getBestBlockPayloadText(parsedTag, commentText, range.pos, block);
-        const expectedType = (0, import_internals3.isBuiltinConstraintName)(tagName) ? import_internals3.BUILTIN_CONSTRAINT_DEFINITIONS[tagName] : void 0;
-        if (text === "" && expectedType !== "boolean") continue;
-        const provenance = parsedTag !== null ? provenanceForParsedTag(parsedTag, sourceFile, file) : provenanceForComment(range, sourceFile, file, tagName);
-        const compilerDiagnostics = buildCompilerBackedConstraintDiagnostics(
-          node,
-          sourceFile,
-          tagName,
-          parsedTag,
-          provenance,
-          supportingDeclarations,
-          options
-        );
-        if (compilerDiagnostics.length > 0) {
-          pushUniqueCompilerDiagnostics(diagnostics, compilerDiagnostics);
+        if (import_internal.TAGS_REQUIRING_RAW_TEXT.has(tagName)) {
+          const fallback = rawTextFallbacks.get(tagName)?.shift();
+          const text2 = (0, import_internal.choosePreferredPayloadText)(tag.resolvedPayloadText, fallback?.text ?? "");
+          if (text2 === "") continue;
+          const provenance2 = provenanceForParsedTag(tag, sourceFile, file);
+          if (tagName === "defaultValue") {
+            annotations.push((0, import_internal.parseDefaultValueTagValue)(text2, provenance2));
+            continue;
+          }
+          processConstraintTag(
+            tagName,
+            text2,
+            tag,
+            provenance2,
+            node,
+            sourceFile,
+            supportingDeclarations,
+            options,
+            constraints,
+            diagnostics
+          );
           continue;
         }
-        const constraintNode = (0, import_internal.parseConstraintTagValue)(
+        const text = tag.resolvedPayloadText;
+        const expectedType = (0, import_internals3.isBuiltinConstraintName)(tagName) ? import_internals3.BUILTIN_CONSTRAINT_DEFINITIONS[tagName] : void 0;
+        if (text === "" && expectedType !== "boolean") continue;
+        const provenance = provenanceForParsedTag(tag, sourceFile, file);
+        processConstraintTag(
           tagName,
           text,
+          tag,
           provenance,
-          sharedTagValueOptions(options)
+          node,
+          sourceFile,
+          supportingDeclarations,
+          options,
+          constraints,
+          diagnostics
         );
-        if (constraintNode) {
-          constraints.push(constraintNode);
-        }
       }
-      if (docComment.deprecatedBlock !== void 0) {
-        const message = extractBlockText(docComment.deprecatedBlock).trim();
+      if (unified.isDeprecated) {
         annotations.push({
           kind: "annotation",
           annotationKind: "deprecated",
-          ...message !== "" && { message },
+          ...unified.deprecationMessage !== "" && { message: unified.deprecationMessage },
           provenance: provenanceForComment(range, sourceFile, file, "deprecated")
         });
       }
-      {
-        const summary = extractPlainText(docComment.summarySection).trim();
-        if (summary !== "") {
-          annotations.push({
-            kind: "annotation",
-            annotationKind: "description",
-            value: summary,
-            provenance: provenanceForComment(range, sourceFile, file, "summary")
-          });
-        }
+      if (unified.summaryText !== "") {
+        annotations.push({
+          kind: "annotation",
+          annotationKind: "description",
+          value: unified.summaryText,
+          provenance: provenanceForComment(range, sourceFile, file, "summary")
+        });
       }
-      if (docComment.remarksBlock !== void 0) {
-        const remarksText = extractBlockText(docComment.remarksBlock).trim();
-        if (remarksText !== "") {
-          annotations.push({
-            kind: "annotation",
-            annotationKind: "remarks",
-            value: remarksText,
-            provenance: provenanceForComment(range, sourceFile, file, "remarks")
-          });
-        }
+      if (unified.remarksText !== "") {
+        annotations.push({
+          kind: "annotation",
+          annotationKind: "remarks",
+          value: unified.remarksText,
+          provenance: provenanceForComment(range, sourceFile, file, "remarks")
+        });
       }
     }
   }
@@ -1501,77 +1461,27 @@ function parseTSDocTags(node, file = "", options) {
       provenance: placeholderProvenance
     });
   }
-  if (rawTextTags.length > 0) {
-    for (const rawTextTag of rawTextTags) {
-      const fallbackQueue = rawTextFallbacks.get(rawTextTag.tag.normalizedTagName);
-      const fallback = fallbackQueue?.shift();
-      const text = choosePreferredPayloadText(
-        getSharedPayloadText(rawTextTag.tag, rawTextTag.commentText, rawTextTag.commentOffset),
-        fallback?.text ?? ""
-      );
-      if (text === "") continue;
-      const provenance = provenanceForParsedTag(rawTextTag.tag, sourceFile, file);
-      if (rawTextTag.tag.normalizedTagName === "defaultValue") {
-        const defaultValueNode = (0, import_internal.parseDefaultValueTagValue)(text, provenance);
-        annotations.push(defaultValueNode);
-        continue;
-      }
-      const compilerDiagnostics = buildCompilerBackedConstraintDiagnostics(
-        node,
-        sourceFile,
-        rawTextTag.tag.normalizedTagName,
-        rawTextTag.tag,
-        provenance,
-        supportingDeclarations,
-        options
-      );
-      if (compilerDiagnostics.length > 0) {
-        pushUniqueCompilerDiagnostics(diagnostics, compilerDiagnostics);
-        continue;
-      }
-      const constraintNode = (0, import_internal.parseConstraintTagValue)(
-        rawTextTag.tag.normalizedTagName,
-        text,
-        provenance,
-        sharedTagValueOptions(options)
-      );
-      if (constraintNode) {
-        constraints.push(constraintNode);
-      }
-    }
-  }
   for (const [tagName, fallbacks] of rawTextFallbacks) {
     for (const fallback of fallbacks) {
       const text = fallback.text.trim();
       if (text === "") continue;
       const provenance = fallback.provenance;
       if (tagName === "defaultValue") {
-        const defaultValueNode = (0, import_internal.parseDefaultValueTagValue)(text, provenance);
-        annotations.push(defaultValueNode);
+        annotations.push((0, import_internal.parseDefaultValueTagValue)(text, provenance));
         continue;
       }
-      const compilerDiagnostics = buildCompilerBackedConstraintDiagnostics(
-        node,
-        sourceFile,
+      processConstraintTag(
         tagName,
+        text,
         null,
         provenance,
+        node,
+        sourceFile,
         supportingDeclarations,
-        options
-      );
-      if (compilerDiagnostics.length > 0) {
-        pushUniqueCompilerDiagnostics(diagnostics, compilerDiagnostics);
-        continue;
-      }
-      const constraintNode = (0, import_internal.parseConstraintTagValue)(
-        tagName,
-        text,
-        provenance,
-        sharedTagValueOptions(options)
+        options,
+        constraints,
+        diagnostics
       );
-      if (constraintNode) {
-        constraints.push(constraintNode);
-      }
     }
   }
   const result = { constraints, annotations, diagnostics };
@@ -1589,8 +1499,8 @@ function extractDisplayNameMetadata(node) {
       if (range.kind !== ts.SyntaxKind.MultiLineCommentTrivia) continue;
       const commentText = sourceText.substring(range.pos, range.end);
       if (!commentText.startsWith("/**")) continue;
-      const parsed = (0, import_internal.parseCommentBlock)(commentText);
-      for (const tag of parsed.tags) {
+      const unified = (0, import_internal.parseUnifiedComment)(commentText);
+      for (const tag of unified.tags) {
         if (tag.normalizedTagName !== "displayName") {
           continue;
         }
@@ -1609,56 +1519,11 @@ function extractDisplayNameMetadata(node) {
     memberDisplayNames
   };
 }
-function extractBlockText(block) {
-  return extractPlainText(block.content);
-}
-function extractPlainText(node) {
-  let result = "";
-  if (node instanceof import_tsdoc.DocExcerpt) {
-    return node.content.toString();
-  }
-  if (node instanceof import_tsdoc.DocPlainText) {
-    return node.text;
-  }
-  if (node instanceof import_tsdoc.DocSoftBreak) {
-    return " ";
-  }
-  if (typeof node.getChildNodes === "function") {
-    for (const child of node.getChildNodes()) {
-      result += extractPlainText(child);
-    }
-  }
-  return result;
-}
-function choosePreferredPayloadText(primary, fallback) {
-  const preferred = primary.trim();
-  const alternate = fallback.trim();
-  if (preferred === "") return alternate;
-  if (alternate === "") return preferred;
-  if (alternate.includes("\n")) return alternate;
-  if (alternate.length > preferred.length && alternate.startsWith(preferred)) {
-    return alternate;
-  }
-  return preferred;
-}
-function getSharedPayloadText(tag, commentText, commentOffset) {
-  if (tag.payloadSpan === null) {
-    return "";
-  }
-  return (0, import_internal.sliceCommentSpan)(commentText, tag.payloadSpan, {
-    offset: commentOffset
-  }).trim();
-}
-function getBestBlockPayloadText(tag, commentText, commentOffset, block) {
-  const sharedText = tag === null ? "" : getSharedPayloadText(tag, commentText, commentOffset);
-  const blockText = extractBlockText(block).replace(/\s+/g, " ").trim();
-  return choosePreferredPayloadText(sharedText, blockText);
-}
 function collectRawTextFallbacks(node, file) {
   const fallbacks = /* @__PURE__ */ new Map();
   for (const tag of ts.getJSDocTags(node)) {
     const tagName = (0, import_internals3.normalizeConstraintTagName)(tag.tagName.text);
-    if (!TAGS_REQUIRING_RAW_TEXT.has(tagName)) continue;
+    if (!import_internal.TAGS_REQUIRING_RAW_TEXT.has(tagName)) continue;
     const commentText = getTagCommentText(tag)?.trim() ?? "";
     if (commentText === "") continue;
     const entries = fallbacks.get(tagName) ?? [];
@@ -1767,6 +1632,31 @@ function isObjectType(type) {
 function isIntersectionType(type) {
   return !!(type.flags & ts3.TypeFlags.Intersection);
 }
+function isIntegerBrandedType(type) {
+  if (!type.isIntersection()) {
+    return false;
+  }
+  const hasNumberBase = type.types.some(
+    (member) => !!(member.flags & ts3.TypeFlags.Number)
+  );
+  if (!hasNumberBase) {
+    return false;
+  }
+  return type.getProperties().some((prop) => {
+    const declaration = prop.valueDeclaration ?? prop.declarations?.[0];
+    if (declaration === void 0) {
+      return false;
+    }
+    if (!ts3.isPropertySignature(declaration) && !ts3.isPropertyDeclaration(declaration)) {
+      return false;
+    }
+    const name = declaration.name;
+    if (!ts3.isComputedPropertyName(name)) {
+      return false;
+    }
+    return ts3.isIdentifier(name.expression) && name.expression.text === "__integerBrand";
+  });
+}
 function isResolvableObjectLikeAliasTypeNode(typeNode) {
   if (ts3.isParenthesizedTypeNode(typeNode)) {
     return isResolvableObjectLikeAliasTypeNode(typeNode.type);
@@ -2892,6 +2782,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" };
   }
@@ -2994,7 +2887,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);
@@ -3080,6 +2973,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" };
   }
@@ -3303,7 +3199,7 @@ function typeNodeContainsReference(type, targetName) {
   }
 }
 function shouldEmitResolvedObjectProperty(property, declaration) {
-  if (property.name.startsWith("__@")) {
+  if (property.name.startsWith("__")) {
     return false;
   }
   if (declaration !== void 0 && "name" in declaration && declaration.name !== void 0) {
@@ -4859,7 +4755,7 @@ function generateCustomType(type, ctx) {
   }
   return registration.toJsonSchema(type.payload, ctx.vendorPrefix);
 }
-var JSON_SCHEMA_STRUCTURAL_KEYWORDS = /* @__PURE__ */ new Set([
+var VOCABULARY_MODE_BLOCKED_KEYWORDS = /* @__PURE__ */ new Set([
   "$schema",
   "$ref",
   "$defs",
@@ -4930,7 +4826,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}"`
         );
@@ -4974,6 +4870,144 @@ function assignVendorPrefixedExtensionKeywords(schema, extensionSchema, vendorPr
   }
 }
 
+// src/extensions/registry.ts
+var import_internals5 = require("@formspec/core/internals");
+var import_internal3 = require("@formspec/analysis/internal");
+var BUILTIN_METADATA_TAGS = /* @__PURE__ */ new Set(["apiName", "displayName"]);
+function buildConstraintTagSources(extensions) {
+  return extensions.map((extension) => ({
+    extensionId: extension.extensionId,
+    ...extension.constraintTags !== void 0 ? {
+      constraintTags: extension.constraintTags.map((tag) => ({
+        tagName: (0, import_internal3.normalizeFormSpecTagName)(tag.tagName)
+      }))
+    } : {}
+  }));
+}
+function createExtensionRegistry(extensions) {
+  const reservedTagSources = buildConstraintTagSources(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();
+  const metadataSlotMap = /* @__PURE__ */ new Map();
+  const metadataTagMap = /* @__PURE__ */ new Map();
+  for (const ext of extensions) {
+    if (ext.types !== void 0) {
+      for (const type of ext.types) {
+        const qualifiedId = `${ext.extensionId}/${type.typeName}`;
+        if (typeMap.has(qualifiedId)) {
+          throw new Error(`Duplicate custom type ID: "${qualifiedId}"`);
+        }
+        typeMap.set(qualifiedId, type);
+        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) {
+      for (const constraint of ext.constraints) {
+        const qualifiedId = `${ext.extensionId}/${constraint.constraintName}`;
+        if (constraintMap.has(qualifiedId)) {
+          throw new Error(`Duplicate custom constraint ID: "${qualifiedId}"`);
+        }
+        constraintMap.set(qualifiedId, constraint);
+      }
+    }
+    if (ext.constraintTags !== void 0) {
+      for (const tag of ext.constraintTags) {
+        const canonicalTagName = (0, import_internal3.normalizeFormSpecTagName)(tag.tagName);
+        if (constraintTagMap.has(canonicalTagName)) {
+          throw new Error(`Duplicate custom constraint tag: "@${canonicalTagName}"`);
+        }
+        constraintTagMap.set(canonicalTagName, {
+          extensionId: ext.extensionId,
+          registration: tag
+        });
+      }
+    }
+    if (ext.annotations !== void 0) {
+      for (const annotation of ext.annotations) {
+        const qualifiedId = `${ext.extensionId}/${annotation.annotationName}`;
+        if (annotationMap.has(qualifiedId)) {
+          throw new Error(`Duplicate custom annotation ID: "${qualifiedId}"`);
+        }
+        annotationMap.set(qualifiedId, annotation);
+      }
+    }
+    if (ext.metadataSlots !== void 0) {
+      for (const slot of ext.metadataSlots) {
+        if (metadataSlotMap.has(slot.slotId)) {
+          throw new Error(`Duplicate metadata slot ID: "${slot.slotId}"`);
+        }
+        metadataSlotMap.set(slot.slotId, true);
+        const canonicalTagName = (0, import_internal3.normalizeFormSpecTagName)(slot.tagName);
+        if (slot.allowBare === false && (slot.qualifiers?.length ?? 0) === 0) {
+          throw new Error(
+            `Metadata tag "@${canonicalTagName}" must allow bare usage or declare at least one qualifier.`
+          );
+        }
+        if (metadataTagMap.has(canonicalTagName)) {
+          throw new Error(`Duplicate metadata tag: "@${canonicalTagName}"`);
+        }
+        if (BUILTIN_METADATA_TAGS.has(canonicalTagName)) {
+          throw new Error(
+            `Metadata tag "@${canonicalTagName}" conflicts with built-in metadata tags.`
+          );
+        }
+        if (constraintTagMap.has(canonicalTagName)) {
+          throw new Error(
+            `Metadata tag "@${canonicalTagName}" conflicts with existing FormSpec tag "@${canonicalTagName}".`
+          );
+        }
+        if (Object.hasOwn(import_internals5.BUILTIN_CONSTRAINT_DEFINITIONS, (0, import_internals5.normalizeConstraintTagName)(canonicalTagName))) {
+          throw new Error(
+            `Metadata tag "@${canonicalTagName}" conflicts with existing FormSpec tag "@${(0, import_internals5.normalizeConstraintTagName)(canonicalTagName)}".`
+          );
+        }
+        const existingTag = (0, import_internal3.getTagDefinition)(canonicalTagName, reservedTagSources);
+        if (existingTag !== null) {
+          throw BUILTIN_METADATA_TAGS.has(existingTag.canonicalName) ? new Error(
+            `Metadata tag "@${canonicalTagName}" conflicts with built-in metadata tags.`
+          ) : new Error(
+            `Metadata tag "@${canonicalTagName}" conflicts with existing FormSpec tag "@${existingTag.canonicalName}".`
+          );
+        }
+        metadataTagMap.set(canonicalTagName, true);
+      }
+    }
+  }
+  return {
+    extensions,
+    findType: (typeId) => typeMap.get(typeId),
+    findTypeByName: (typeName) => typeNameMap.get(typeName),
+    findConstraint: (constraintId) => constraintMap.get(constraintId),
+    findConstraintTag: (tagName) => constraintTagMap.get((0, import_internal3.normalizeFormSpecTagName)(tagName)),
+    findBuiltinConstraintBroadening: (typeId, tagName) => builtinBroadeningMap.get(`${typeId}:${tagName}`),
+    findAnnotation: (annotationId) => annotationMap.get(annotationId)
+  };
+}
+
 // src/ui-schema/schema.ts
 var import_zod = require("zod");
 var jsonPointerSchema = import_zod.z.string();
@@ -5229,9 +5263,9 @@ function collectFieldNameMap(elements) {
 }
 
 // src/validate/constraint-validator.ts
-var import_internal3 = require("@formspec/analysis/internal");
+var import_internal4 = require("@formspec/analysis/internal");
 function validateFieldNode(ctx, field) {
-  const analysis = (0, import_internal3.analyzeConstraintTargets)(
+  const analysis = (0, import_internal4.analyzeConstraintTargets)(
     field.name,
     field.type,
     field.constraints,
@@ -5249,7 +5283,7 @@ function validateFieldNode(ctx, field) {
 }
 function validateObjectProperty(ctx, parentName, property) {
   const qualifiedName = `${parentName}.${property.name}`;
-  const analysis = (0, import_internal3.analyzeConstraintTargets)(
+  const analysis = (0, import_internal4.analyzeConstraintTargets)(
     qualifiedName,
     property.type,
     property.constraints,
@@ -5360,144 +5394,6 @@ function formatLocation(location) {
   return `${location.file}:${String(location.line)}:${String(location.column)}`;
 }
 
-// src/extensions/registry.ts
-var import_internals5 = require("@formspec/core/internals");
-var import_internal4 = require("@formspec/analysis/internal");
-var BUILTIN_METADATA_TAGS = /* @__PURE__ */ new Set(["apiName", "displayName"]);
-function buildConstraintTagSources(extensions) {
-  return extensions.map((extension) => ({
-    extensionId: extension.extensionId,
-    ...extension.constraintTags !== void 0 ? {
-      constraintTags: extension.constraintTags.map((tag) => ({
-        tagName: (0, import_internal4.normalizeFormSpecTagName)(tag.tagName)
-      }))
-    } : {}
-  }));
-}
-function createExtensionRegistry(extensions) {
-  const reservedTagSources = buildConstraintTagSources(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();
-  const metadataSlotMap = /* @__PURE__ */ new Map();
-  const metadataTagMap = /* @__PURE__ */ new Map();
-  for (const ext of extensions) {
-    if (ext.types !== void 0) {
-      for (const type of ext.types) {
-        const qualifiedId = `${ext.extensionId}/${type.typeName}`;
-        if (typeMap.has(qualifiedId)) {
-          throw new Error(`Duplicate custom type ID: "${qualifiedId}"`);
-        }
-        typeMap.set(qualifiedId, type);
-        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) {
-      for (const constraint of ext.constraints) {
-        const qualifiedId = `${ext.extensionId}/${constraint.constraintName}`;
-        if (constraintMap.has(qualifiedId)) {
-          throw new Error(`Duplicate custom constraint ID: "${qualifiedId}"`);
-        }
-        constraintMap.set(qualifiedId, constraint);
-      }
-    }
-    if (ext.constraintTags !== void 0) {
-      for (const tag of ext.constraintTags) {
-        const canonicalTagName = (0, import_internal4.normalizeFormSpecTagName)(tag.tagName);
-        if (constraintTagMap.has(canonicalTagName)) {
-          throw new Error(`Duplicate custom constraint tag: "@${canonicalTagName}"`);
-        }
-        constraintTagMap.set(canonicalTagName, {
-          extensionId: ext.extensionId,
-          registration: tag
-        });
-      }
-    }
-    if (ext.annotations !== void 0) {
-      for (const annotation of ext.annotations) {
-        const qualifiedId = `${ext.extensionId}/${annotation.annotationName}`;
-        if (annotationMap.has(qualifiedId)) {
-          throw new Error(`Duplicate custom annotation ID: "${qualifiedId}"`);
-        }
-        annotationMap.set(qualifiedId, annotation);
-      }
-    }
-    if (ext.metadataSlots !== void 0) {
-      for (const slot of ext.metadataSlots) {
-        if (metadataSlotMap.has(slot.slotId)) {
-          throw new Error(`Duplicate metadata slot ID: "${slot.slotId}"`);
-        }
-        metadataSlotMap.set(slot.slotId, true);
-        const canonicalTagName = (0, import_internal4.normalizeFormSpecTagName)(slot.tagName);
-        if (slot.allowBare === false && (slot.qualifiers?.length ?? 0) === 0) {
-          throw new Error(
-            `Metadata tag "@${canonicalTagName}" must allow bare usage or declare at least one qualifier.`
-          );
-        }
-        if (metadataTagMap.has(canonicalTagName)) {
-          throw new Error(`Duplicate metadata tag: "@${canonicalTagName}"`);
-        }
-        if (BUILTIN_METADATA_TAGS.has(canonicalTagName)) {
-          throw new Error(
-            `Metadata tag "@${canonicalTagName}" conflicts with built-in metadata tags.`
-          );
-        }
-        if (constraintTagMap.has(canonicalTagName)) {
-          throw new Error(
-            `Metadata tag "@${canonicalTagName}" conflicts with existing FormSpec tag "@${canonicalTagName}".`
-          );
-        }
-        if (Object.hasOwn(import_internals5.BUILTIN_CONSTRAINT_DEFINITIONS, (0, import_internals5.normalizeConstraintTagName)(canonicalTagName))) {
-          throw new Error(
-            `Metadata tag "@${canonicalTagName}" conflicts with existing FormSpec tag "@${(0, import_internals5.normalizeConstraintTagName)(canonicalTagName)}".`
-          );
-        }
-        const existingTag = (0, import_internal4.getTagDefinition)(canonicalTagName, reservedTagSources);
-        if (existingTag !== null) {
-          throw BUILTIN_METADATA_TAGS.has(existingTag.canonicalName) ? new Error(
-            `Metadata tag "@${canonicalTagName}" conflicts with built-in metadata tags.`
-          ) : new Error(
-            `Metadata tag "@${canonicalTagName}" conflicts with existing FormSpec tag "@${existingTag.canonicalName}".`
-          );
-        }
-        metadataTagMap.set(canonicalTagName, true);
-      }
-    }
-  }
-  return {
-    extensions,
-    findType: (typeId) => typeMap.get(typeId),
-    findTypeByName: (typeName) => typeNameMap.get(typeName),
-    findConstraint: (constraintId) => constraintMap.get(constraintId),
-    findConstraintTag: (tagName) => constraintTagMap.get((0, import_internal4.normalizeFormSpecTagName)(tagName)),
-    findBuiltinConstraintBroadening: (typeId, tagName) => builtinBroadeningMap.get(`${typeId}:${tagName}`),
-    findAnnotation: (annotationId) => annotationMap.get(annotationId)
-  };
-}
-
 // src/generators/method-schema.ts
 var import_internals6 = require("@formspec/core/internals");
 function typeToJsonSchema(type, checker, options) {