@formspec/analysis 0.1.0-alpha.20 → 0.1.0-alpha.21

package/dist/index.cjs

@@ -32,83 +32,42 @@ var index_exports = {};
 __export(index_exports, {
   FORMSPEC_ANALYSIS_PROTOCOL_VERSION: () => FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
   FORMSPEC_ANALYSIS_SCHEMA_VERSION: () => FORMSPEC_ANALYSIS_SCHEMA_VERSION,
-  analyzeConstraintTargets: () => analyzeConstraintTargets,
-  buildConstraintTargetStates: () => buildConstraintTargetStates,
-  buildFormSpecAnalysisFileSnapshot: () => buildFormSpecAnalysisFileSnapshot,
-  buildSyntheticHelperPrelude: () => buildSyntheticHelperPrelude,
-  checkSyntheticTagApplication: () => checkSyntheticTagApplication,
-  collectCompatiblePathTargets: () => collectCompatiblePathTargets,
-  collectReferencedTypeAnnotations: () => collectReferencedTypeAnnotations,
-  collectReferencedTypeConstraints: () => collectReferencedTypeConstraints,
   computeFormSpecTextHash: () => computeFormSpecTextHash,
-  dereferenceAnalysisType: () => dereferenceAnalysisType,
-  extractPathTarget: () => extractPathTarget,
-  findCommentTagAtOffset: () => findCommentTagAtOffset,
-  findDeclarationForCommentOffset: () => findDeclarationForCommentOffset,
-  findEnclosingDocComment: () => findEnclosingDocComment,
-  formatConstraintTargetName: () => formatConstraintTargetName,
-  formatPathTarget: () => formatPathTarget,
-  getAllTagDefinitions: () => getAllTagDefinitions,
-  getCommentCompletionContextAtOffset: () => getCommentCompletionContextAtOffset,
-  getCommentCursorTargetAtOffset: () => getCommentCursorTargetAtOffset,
-  getCommentHoverInfoAtOffset: () => getCommentHoverInfoAtOffset,
-  getCommentTagSemanticContext: () => getCommentTagSemanticContext,
-  getConstraintTagDefinitions: () => getConstraintTagDefinitions,
   getFormSpecManifestPath: () => getFormSpecManifestPath,
   getFormSpecWorkspaceId: () => getFormSpecWorkspaceId,
   getFormSpecWorkspaceRuntimeDirectory: () => getFormSpecWorkspaceRuntimeDirectory,
-  getHostType: () => getHostType,
-  getLastLeadingDocCommentRange: () => getLastLeadingDocCommentRange,
-  getMatchingTagSignatures: () => getMatchingTagSignatures,
-  getSemanticCommentCompletionContextAtOffset: () => getSemanticCommentCompletionContextAtOffset,
-  getSubjectType: () => getSubjectType,
-  getTagCompletionPrefixAtOffset: () => getTagCompletionPrefixAtOffset,
-  getTagDefinition: () => getTagDefinition,
-  getTagHoverMarkdown: () => getTagHoverMarkdown,
-  getTypeSemanticCapabilities: () => getTypeSemanticCapabilities,
-  hasTypeSemanticCapability: () => hasTypeSemanticCapability,
   isFormSpecAnalysisManifest: () => isFormSpecAnalysisManifest,
   isFormSpecSemanticQuery: () => isFormSpecSemanticQuery,
   isFormSpecSemanticResponse: () => isFormSpecSemanticResponse,
-  lowerTagApplicationToSyntheticCall: () => lowerTagApplicationToSyntheticCall,
-  normalizeFormSpecTagName: () => normalizeFormSpecTagName,
-  parseCommentBlock: () => parseCommentBlock,
-  parseConstraintTagValue: () => parseConstraintTagValue,
-  parseDefaultValueTagValue: () => parseDefaultValueTagValue,
-  parseTagSyntax: () => parseTagSyntax,
-  resolveConstraintTargetState: () => resolveConstraintTargetState,
-  resolveDeclarationPlacement: () => resolveDeclarationPlacement,
-  resolvePathTargetType: () => resolvePathTargetType,
   serializeCommentTagSemanticContext: () => serializeCommentTagSemanticContext,
   serializeCommentTargetSpecifier: () => serializeCommentTargetSpecifier,
   serializeCompletionContext: () => serializeCompletionContext,
   serializeHoverInfo: () => serializeHoverInfo,
-  serializeParsedCommentTag: () => serializeParsedCommentTag,
-  sliceCommentSpan: () => sliceCommentSpan
+  serializeParsedCommentTag: () => serializeParsedCommentTag
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/path-target.ts
-function extractPathTarget(text) {
-  const trimmed = text.trimStart();
-  const match = /^:([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)(?:\s+([\s\S]*))?$/u.exec(trimmed);
-  if (!match?.[1]) {
-    return null;
-  }
-  return {
-    path: { segments: match[1].split(".") },
-    remainingText: match[2] ?? ""
-  };
-}
-function formatPathTarget(path2) {
-  if ("segments" in path2) {
-    return path2.segments.join(".");
-  }
-  return path2.join(".");
-}
-
 // src/tag-registry.ts
 var import_core = require("@formspec/core");
+var FORM_SPEC_PLACEMENTS = [
+  "class",
+  "class-field",
+  "class-method",
+  "interface",
+  "interface-field",
+  "type-alias",
+  "type-alias-field",
+  "variable",
+  "function",
+  "function-parameter",
+  "method-parameter"
+];
+var FORM_SPEC_TARGET_KINDS = [
+  "none",
+  "path",
+  "member",
+  "variant"
+];
 var FIELD_PLACEMENTS = [
   "class-field",
   "interface-field",
@@ -688,2525 +647,203 @@ var EXTRA_TAG_DEFINITIONS = Object.fromEntries(
     buildExtraTagDefinition(canonicalName, spec)
   ])
 );
-function normalizeFormSpecTagName(rawName) {
-  return (0, import_core.normalizeConstraintTagName)(rawName);
-}
-function getTagDefinition(rawName, extensions) {
-  const normalized = normalizeFormSpecTagName(rawName);
-  const builtin = BUILTIN_TAG_DEFINITIONS[normalized];
-  if (builtin !== void 0) {
-    return builtin;
-  }
-  const extra = EXTRA_TAG_DEFINITIONS[normalized];
-  if (extra !== void 0) {
-    return extra;
-  }
-  const extensionRegistration = getExtensionConstraintTags(extensions).find(
-    (tag) => tag.tagName === normalized
-  );
-  if (extensionRegistration === void 0) {
-    return null;
-  }
-  return {
-    canonicalName: extensionRegistration.tagName,
-    valueKind: null,
-    requiresArgument: true,
-    supportedTargets: ["none"],
-    allowDuplicates: true,
-    category: "constraint",
-    placements: FIELD_PLACEMENTS,
-    capabilities: [],
-    completionDetail: `Extension constraint tag from ${extensionRegistration.extensionId}`,
-    hoverMarkdown: [
-      `**@${extensionRegistration.tagName}** \`<value>\``,
-      "",
-      `Extension-defined constraint tag from \`${extensionRegistration.extensionId}\`.`,
-      "",
-      `**Signature:** \`@${extensionRegistration.tagName} <value>\``
-    ].join("\n"),
-    signatures: [
-      {
-        label: `@${extensionRegistration.tagName} <value>`,
-        placements: FIELD_PLACEMENTS,
-        parameters: [{ kind: "value", label: "<value>" }]
-      }
-    ]
-  };
-}
-function getConstraintTagDefinitions(extensions) {
-  const builtins = Object.values(BUILTIN_TAG_DEFINITIONS);
-  const custom = getExtensionConstraintTags(extensions).map((tag) => getTagDefinition(tag.tagName, extensions)).filter((tag) => tag !== null);
-  return [...builtins, ...custom];
-}
-function getAllTagDefinitions(extensions) {
-  const builtins = Object.values(BUILTIN_TAG_DEFINITIONS);
-  const extras = Object.values(EXTRA_TAG_DEFINITIONS);
-  const custom = getExtensionConstraintTags(extensions).map((tag) => getTagDefinition(tag.tagName, extensions)).filter((tag) => tag !== null);
-  return [...builtins, ...extras, ...custom];
-}
-function getTagHoverMarkdown(rawName, extensions) {
-  return getTagDefinition(rawName, extensions)?.hoverMarkdown ?? null;
-}
-function getExtensionConstraintTags(extensions) {
-  return extensions?.flatMap((extension) => {
-    const tagRecords = extension.constraintTags ?? [];
-    return tagRecords.map((tag) => ({
-      extensionId: extension.extensionId,
-      tagName: tag.tagName
-    }));
-  }) ?? [];
-}
 
-// src/comment-syntax.ts
-function isWhitespace(char) {
-  return char === " " || char === "	" || char === "\n" || char === "\r";
+// src/semantic-protocol.ts
+var FORMSPEC_ANALYSIS_PROTOCOL_VERSION = 1;
+var FORMSPEC_ANALYSIS_SCHEMA_VERSION = 1;
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isTagStart(lineText, index) {
-  if (lineText[index] !== "@") {
-    return false;
-  }
-  const nextChar = lineText[index + 1];
-  if (nextChar === void 0 || !/[A-Za-z]/u.test(nextChar)) {
+function isCommentSpan(value) {
+  if (!isObjectRecord(value)) {
     return false;
   }
-  const previousChar = lineText[index - 1];
-  return previousChar === void 0 || isWhitespace(previousChar);
-}
-function findTagEnd(lineText, index) {
-  let cursor = index + 1;
-  while (cursor < lineText.length && /[A-Za-z0-9]/u.test(lineText[cursor] ?? "")) {
-    cursor += 1;
-  }
-  return cursor;
+  const candidate = value;
+  return typeof candidate.start === "number" && typeof candidate.end === "number";
 }
-function trimTrailingWhitespace(lineText, end) {
-  let cursor = end;
-  while (cursor > 0 && isWhitespace(lineText[cursor - 1])) {
-    cursor -= 1;
-  }
-  return cursor;
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
 }
-function spanFromLine(line, start, end, baseOffset) {
-  const rawStart = line.rawOffsets[start];
-  if (rawStart === void 0) {
-    throw new Error(`Invalid projected span start: ${String(start)}`);
-  }
-  const rawEnd = end >= line.text.length ? line.rawContentEnd : (line.rawOffsets[end - 1] ?? line.rawContentEnd - 1) + 1;
-  return {
-    start: baseOffset + rawStart,
-    end: baseOffset + rawEnd
-  };
+var FORM_SPEC_PLACEMENT_VALUES = new Set(FORM_SPEC_PLACEMENTS);
+var FORM_SPEC_TARGET_KIND_VALUES = new Set(FORM_SPEC_TARGET_KINDS);
+function isPlacementValue(value) {
+  return typeof value === "string" && FORM_SPEC_PLACEMENT_VALUES.has(value);
 }
-function classifyTargetKind(canonicalName, targetText, extensions) {
-  if (targetText === "singular" || targetText === "plural") {
-    return "variant";
-  }
-  if (targetText.includes(".")) {
-    return "path";
-  }
-  const definition = getTagDefinition(canonicalName, extensions);
-  const supportedTargets = definition?.supportedTargets.filter((target) => target !== "none") ?? [];
-  if (supportedTargets.includes("path")) {
-    return "path";
-  }
-  if (supportedTargets.includes("member") && supportedTargets.includes("variant")) {
-    return "ambiguous";
-  }
-  if (supportedTargets.includes("member")) {
-    return "member";
-  }
-  if (supportedTargets.includes("variant")) {
-    return "variant";
-  }
-  return "path";
+function isTargetKindValue(value) {
+  return typeof value === "string" && FORM_SPEC_TARGET_KIND_VALUES.has(value);
 }
-function parseTargetSpecifier(line, payloadStart, payloadEnd, canonicalName, baseOffset, extensions) {
-  if (payloadStart >= payloadEnd || line.text[payloadStart] !== ":") {
-    return null;
-  }
-  let targetEnd = payloadStart + 1;
-  while (targetEnd < payloadEnd && !isWhitespace(line.text[targetEnd])) {
-    targetEnd += 1;
-  }
-  const fullText = line.text.slice(payloadStart, targetEnd);
-  const targetText = fullText.slice(1);
-  const parsedPath = extractPathTarget(fullText);
-  const specifierSpan = spanFromLine(line, payloadStart + 1, targetEnd, baseOffset);
-  return {
-    rawText: targetText,
-    valid: parsedPath !== null && parsedPath.remainingText === "",
-    kind: classifyTargetKind(canonicalName, targetText, extensions),
-    fullSpan: spanFromLine(line, payloadStart, targetEnd, baseOffset),
-    colonSpan: spanFromLine(line, payloadStart, payloadStart + 1, baseOffset),
-    span: specifierSpan,
-    path: parsedPath?.path ?? null,
-    localEnd: targetEnd
-  };
+function isPlacementArray(value) {
+  return Array.isArray(value) && value.every(isPlacementValue);
 }
-function projectCommentLines(commentText) {
-  const projections = [];
-  const commentBodyStart = commentText.startsWith("/**") ? 3 : commentText.startsWith("/*") ? 2 : 0;
-  const commentBodyEnd = commentText.endsWith("*/") ? commentText.length - 2 : commentText.length;
-  let cursor = commentBodyStart;
-  while (cursor <= commentBodyEnd) {
-    const lineStart = cursor;
-    let lineEnd = cursor;
-    while (lineEnd < commentBodyEnd && commentText[lineEnd] !== "\n") {
-      lineEnd += 1;
-    }
-    let contentEnd = lineEnd;
-    if (contentEnd > lineStart && commentText[contentEnd - 1] === "\r") {
-      contentEnd -= 1;
-    }
-    let contentStart = lineStart;
-    while (contentStart < contentEnd && (commentText[contentStart] === " " || commentText[contentStart] === "	")) {
-      contentStart += 1;
-    }
-    if (contentStart < contentEnd && commentText[contentStart] === "*") {
-      contentStart += 1;
-      while (contentStart < contentEnd && (commentText[contentStart] === " " || commentText[contentStart] === "	")) {
-        contentStart += 1;
-      }
-    }
-    const rawOffsets = [];
-    let text = "";
-    for (let index = contentStart; index < contentEnd; index += 1) {
-      rawOffsets.push(index);
-      text += commentText[index] ?? "";
-    }
-    projections.push({
-      text,
-      rawOffsets,
-      rawContentEnd: contentEnd
-    });
-    if (lineEnd >= commentBodyEnd) {
-      break;
-    }
-    cursor = lineEnd + 1;
-  }
-  return projections;
+function isTargetKindArray(value) {
+  return Array.isArray(value) && value.every(isTargetKindValue);
 }
-function parseCommentBlock(commentText, options) {
-  const tags = [];
-  const baseOffset = options?.offset ?? 0;
-  for (const line of projectCommentLines(commentText)) {
-    const tagStarts = [];
-    for (let index = 0; index < line.text.length; index += 1) {
-      if (isTagStart(line.text, index)) {
-        tagStarts.push(index);
-      }
-    }
-    for (let tagIndex = 0; tagIndex < tagStarts.length; tagIndex += 1) {
-      const tagStart = tagStarts[tagIndex];
-      if (tagStart === void 0) {
-        continue;
-      }
-      const tagEnd = findTagEnd(line.text, tagStart);
-      const nextTagStart = tagStarts[tagIndex + 1] ?? line.text.length;
-      const trimmedTagSegmentEnd = trimTrailingWhitespace(line.text, nextTagStart);
-      const rawName = line.text.slice(tagStart + 1, tagEnd);
-      const canonicalName = normalizeFormSpecTagName(rawName);
-      let payloadStart = tagEnd;
-      while (payloadStart < trimmedTagSegmentEnd && isWhitespace(line.text[payloadStart])) {
-        payloadStart += 1;
-      }
-      const target = parseTargetSpecifier(
-        line,
-        payloadStart,
-        trimmedTagSegmentEnd,
-        canonicalName,
-        baseOffset,
-        options?.extensions
-      );
-      let valueStart = payloadStart;
-      if (target !== null) {
-        valueStart = target.localEnd;
-        while (valueStart < trimmedTagSegmentEnd && isWhitespace(line.text[valueStart])) {
-          valueStart += 1;
-        }
-      }
-      const payloadSpan = payloadStart < trimmedTagSegmentEnd ? spanFromLine(line, payloadStart, trimmedTagSegmentEnd, baseOffset) : null;
-      const valueSpan = valueStart < trimmedTagSegmentEnd ? spanFromLine(line, valueStart, trimmedTagSegmentEnd, baseOffset) : null;
-      const parsedTarget = target === null ? null : {
-        rawText: target.rawText,
-        valid: target.valid,
-        kind: target.kind,
-        fullSpan: target.fullSpan,
-        colonSpan: target.colonSpan,
-        span: target.span,
-        path: target.path
-      };
-      tags.push({
-        rawTagName: rawName,
-        normalizedTagName: canonicalName,
-        recognized: getTagDefinition(canonicalName, options?.extensions) !== null,
-        fullSpan: spanFromLine(line, tagStart, trimmedTagSegmentEnd, baseOffset),
-        tagNameSpan: spanFromLine(line, tagStart, tagEnd, baseOffset),
-        payloadSpan,
-        colonSpan: parsedTarget?.colonSpan ?? null,
-        target: parsedTarget,
-        argumentSpan: valueSpan,
-        argumentText: valueSpan === null ? "" : commentText.slice(valueSpan.start - baseOffset, valueSpan.end - baseOffset)
-      });
-    }
+function isIpcEndpoint(value) {
+  if (!isObjectRecord(value)) {
+    return false;
   }
-  return {
-    commentText,
-    offset: baseOffset,
-    tags
-  };
+  const candidate = value;
+  return (candidate.kind === "unix-socket" || candidate.kind === "windows-pipe") && typeof candidate.address === "string";
 }
-function parseTagSyntax(rawTagName, payloadText, options) {
-  const separator = payloadText === "" || isWhitespace(payloadText[0]) ? "" : " ";
-  const parsed = parseCommentBlock(`/** @${rawTagName}${separator}${payloadText} */`, options);
-  const [tag] = parsed.tags;
-  if (tag === void 0) {
-    throw new Error(`Unable to parse synthetic tag syntax for @${rawTagName}`);
+function isSerializedTagDefinition(value) {
+  if (!isObjectRecord(value)) {
+    return false;
   }
-  return tag;
-}
-function sliceCommentSpan(commentText, span, options) {
-  const baseOffset = options?.offset ?? 0;
-  return commentText.slice(span.start - baseOffset, span.end - baseOffset);
+  const candidate = value;
+  return typeof candidate.canonicalName === "string" && typeof candidate.completionDetail === "string" && typeof candidate.hoverMarkdown === "string";
 }
-
-// src/ts-binding.ts
-var ts = __toESM(require("typescript"), 1);
-function stripNullishUnion(type) {
-  if (!type.isUnion()) {
-    return type;
-  }
-  const nonNullish = type.types.filter(
-    (member) => (member.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) === 0
-  );
-  if (nonNullish.length === 1 && nonNullish[0] !== void 0) {
-    return nonNullish[0];
+function isSerializedTagSignature(value) {
+  if (!isObjectRecord(value)) {
+    return false;
   }
-  return type;
-}
-function isIntersectionWithBase(type, predicate) {
-  return type.isIntersection() && type.types.some((member) => predicate(member));
+  const candidate = value;
+  return typeof candidate.label === "string" && isPlacementArray(candidate.placements);
 }
-function isNumberLike(type) {
-  const stripped = stripNullishUnion(type);
-  if (stripped.flags & (ts.TypeFlags.Number | ts.TypeFlags.NumberLiteral | ts.TypeFlags.BigInt | ts.TypeFlags.BigIntLiteral)) {
-    return true;
-  }
-  if (stripped.isUnion()) {
-    return stripped.types.every((member) => isNumberLike(member));
+function isSerializedCommentTargetSpecifier(value) {
+  if (!isObjectRecord(value)) {
+    return false;
   }
-  return isIntersectionWithBase(stripped, isNumberLike);
+  const candidate = value;
+  return typeof candidate.rawText === "string" && typeof candidate.valid === "boolean" && typeof candidate.kind === "string" && isCommentSpan(candidate.fullSpan) && isCommentSpan(candidate.colonSpan) && isCommentSpan(candidate.span);
 }
-function isStringLike(type) {
-  const stripped = stripNullishUnion(type);
-  if (stripped.flags & (ts.TypeFlags.String | ts.TypeFlags.StringLiteral)) {
-    return true;
-  }
-  if (stripped.isUnion()) {
-    return stripped.types.every((member) => isStringLike(member));
+function isSerializedTagSemanticContext(value) {
+  if (!isObjectRecord(value)) {
+    return false;
   }
-  return isIntersectionWithBase(stripped, isStringLike);
+  const candidate = value;
+  return typeof candidate.tagName === "string" && (candidate.tagDefinition === null || isSerializedTagDefinition(candidate.tagDefinition)) && (candidate.placement === null || isPlacementValue(candidate.placement)) && isTargetKindArray(candidate.supportedTargets) && isStringArray(candidate.targetCompletions) && isStringArray(candidate.compatiblePathTargets) && isStringArray(candidate.valueLabels) && Array.isArray(candidate.signatures) && candidate.signatures.every(isSerializedTagSignature) && (candidate.tagHoverMarkdown === null || typeof candidate.tagHoverMarkdown === "string") && (candidate.targetHoverMarkdown === null || typeof candidate.targetHoverMarkdown === "string") && (candidate.argumentHoverMarkdown === null || typeof candidate.argumentHoverMarkdown === "string");
 }
-function isBooleanLike(type) {
-  const stripped = stripNullishUnion(type);
-  if (stripped.flags & (ts.TypeFlags.Boolean | ts.TypeFlags.BooleanLiteral)) {
-    return true;
-  }
-  if (stripped.isUnion()) {
-    return stripped.types.every((member) => isBooleanLike(member));
+function isSerializedCompletionContext(value) {
+  if (!isObjectRecord(value)) {
+    return false;
   }
-  return isIntersectionWithBase(stripped, isBooleanLike);
-}
-function isNullLike(type) {
-  const stripped = stripNullishUnion(type);
-  if (stripped.flags & ts.TypeFlags.Null) {
-    return true;
+  const candidate = value;
+  if (typeof candidate.kind !== "string") {
+    return false;
   }
-  if (stripped.isUnion()) {
-    return stripped.types.every((member) => isNullLike(member));
+  switch (candidate.kind) {
+    case "tag-name":
+      return typeof candidate.prefix === "string" && Array.isArray(candidate.availableTags) ? candidate.availableTags.every(isSerializedTagDefinition) : false;
+    case "target":
+      return isSerializedTagSemanticContext(candidate.semantic);
+    case "argument":
+      return isSerializedTagSemanticContext(candidate.semantic) && isStringArray(candidate.valueLabels);
+    case "none":
+      return true;
+    default:
+      return false;
   }
-  return isIntersectionWithBase(stripped, isNullLike);
 }
-function isArrayLike(type, checker) {
-  const stripped = stripNullishUnion(type);
-  if (checker.isArrayType(stripped)) {
-    return true;
+function isSerializedHoverInfo(value) {
+  if (!isObjectRecord(value)) {
+    return false;
   }
-  const symbol = stripped.getSymbol();
-  return symbol?.name === "Array" || symbol?.name === "ReadonlyArray";
-}
-function isStringLiteralUnion(type) {
-  const stripped = stripNullishUnion(type);
-  return stripped.isUnion() && stripped.types.length > 0 && stripped.types.every(isStringLike);
+  const candidate = value;
+  return (candidate.kind === "tag-name" || candidate.kind === "target" || candidate.kind === "argument") && typeof candidate.markdown === "string";
 }
-function isObjectLike(type, checker) {
-  const stripped = stripNullishUnion(type);
-  return !isArrayLike(stripped, checker) && (stripped.flags & ts.TypeFlags.Object) !== 0;
+function hasCurrentProtocolVersion(value) {
+  return isObjectRecord(value) && value["protocolVersion"] === FORMSPEC_ANALYSIS_PROTOCOL_VERSION;
 }
-function isJsonLike(type, checker) {
-  const stripped = stripNullishUnion(type);
-  if (isNullLike(stripped) || isNumberLike(stripped) || isStringLike(stripped) || isBooleanLike(stripped)) {
-    return true;
-  }
-  if (stripped.isUnion()) {
-    return stripped.types.every((member) => isJsonLike(member, checker));
-  }
-  if (isArrayLike(stripped, checker) || isObjectLike(stripped, checker)) {
-    return true;
+function isAnalysisDiagnostic(value) {
+  if (!isObjectRecord(value)) {
+    return false;
   }
-  return isIntersectionWithBase(stripped, (member) => isJsonLike(member, checker));
+  const candidate = value;
+  return typeof candidate.code === "string" && typeof candidate.message === "string" && isCommentSpan(candidate.range) && (candidate.severity === "error" || candidate.severity === "warning" || candidate.severity === "info");
 }
-function getArrayElementType(type, checker) {
-  const stripped = stripNullishUnion(type);
-  if (!checker.isArrayType(stripped)) {
-    return null;
+function isAnalysisTagSnapshot(value) {
+  if (!isObjectRecord(value)) {
+    return false;
   }
-  return checker.getTypeArguments(stripped)[0] ?? null;
+  const candidate = value;
+  return typeof candidate.rawTagName === "string" && typeof candidate.normalizedTagName === "string" && typeof candidate.recognized === "boolean" && isCommentSpan(candidate.fullSpan) && isCommentSpan(candidate.tagNameSpan) && (candidate.payloadSpan === null || isCommentSpan(candidate.payloadSpan)) && (candidate.target === null || isSerializedCommentTargetSpecifier(candidate.target)) && (candidate.argumentSpan === null || isCommentSpan(candidate.argumentSpan)) && typeof candidate.argumentText === "string" && isSerializedTagSemanticContext(candidate.semantic);
 }
-function resolveDeclarationPlacement(node) {
-  if (ts.isClassDeclaration(node)) return "class";
-  if (ts.isPropertyDeclaration(node)) return "class-field";
-  if (ts.isMethodDeclaration(node)) return "class-method";
-  if (ts.isInterfaceDeclaration(node)) return "interface";
-  if (ts.isPropertySignature(node)) return "interface-field";
-  if (ts.isTypeAliasDeclaration(node)) return "type-alias";
-  if (ts.isVariableDeclaration(node)) return "variable";
-  if (ts.isFunctionDeclaration(node)) return "function";
-  if (ts.isParameter(node)) {
-    if (ts.isMethodDeclaration(node.parent) || ts.isConstructorDeclaration(node.parent)) {
-      return "method-parameter";
-    }
-    return "function-parameter";
+function isAnalysisCommentSnapshot(value) {
+  if (!isObjectRecord(value)) {
+    return false;
   }
-  return null;
+  const candidate = value;
+  return isCommentSpan(candidate.commentSpan) && isCommentSpan(candidate.declarationSpan) && (candidate.placement === null || isPlacementValue(candidate.placement)) && (candidate.subjectType === null || typeof candidate.subjectType === "string") && (candidate.hostType === null || typeof candidate.hostType === "string") && Array.isArray(candidate.tags) && candidate.tags.every(isAnalysisTagSnapshot);
 }
-function getTypeSemanticCapabilities(type, checker) {
-  const capabilities = /* @__PURE__ */ new Set();
-  if (isNumberLike(type)) {
-    capabilities.add("numeric-comparable");
-  }
-  if (isStringLike(type)) {
-    capabilities.add("string-like");
-  }
-  if (isJsonLike(type, checker)) {
-    capabilities.add("json-like");
-  }
-  if (isArrayLike(type, checker)) {
-    capabilities.add("array-like");
-  }
-  if (isStringLiteralUnion(type)) {
-    capabilities.add("enum-member-addressable");
-  }
-  if (isObjectLike(type, checker)) {
-    capabilities.add("object-like");
+function isAnalysisFileSnapshot(value) {
+  if (!isObjectRecord(value)) {
+    return false;
   }
-  return [...capabilities];
-}
-function hasTypeSemanticCapability(type, checker, capability) {
-  return getTypeSemanticCapabilities(type, checker).includes(capability);
+  const candidate = value;
+  return typeof candidate.filePath === "string" && typeof candidate.sourceHash === "string" && typeof candidate.generatedAt === "string" && Array.isArray(candidate.comments) && candidate.comments.every(isAnalysisCommentSnapshot) && Array.isArray(candidate.diagnostics) && candidate.diagnostics.every(isAnalysisDiagnostic);
 }
-function resolvePathTargetType(type, checker, segments) {
-  const stripped = stripNullishUnion(type);
-  if (segments.length === 0) {
-    return {
-      kind: "resolved",
-      type: stripped
-    };
-  }
-  const arrayElementType = getArrayElementType(stripped, checker);
-  if (arrayElementType !== null) {
-    return resolvePathTargetType(arrayElementType, checker, segments);
-  }
-  if ((stripped.flags & ts.TypeFlags.Object) === 0) {
-    return {
-      kind: "unresolvable",
-      type: stripped
-    };
-  }
-  const [segment, ...rest] = segments;
-  if (segment === void 0) {
-    throw new Error("Invariant violation: path traversal requires a segment");
-  }
-  const property = stripped.getProperty(segment);
-  if (property === void 0) {
-    return {
-      kind: "missing-property",
-      segment
-    };
-  }
-  const declaration = property.valueDeclaration ?? property.declarations?.[0];
-  if (declaration === void 0) {
-    return {
-      kind: "unresolvable",
-      type: stripped
-    };
+function isFormSpecAnalysisManifest(value) {
+  if (!isObjectRecord(value)) {
+    return false;
   }
-  return resolvePathTargetType(
-    checker.getTypeOfSymbolAtLocation(property, declaration),
-    checker,
-    rest
-  );
+  const candidate = value;
+  return candidate.protocolVersion === FORMSPEC_ANALYSIS_PROTOCOL_VERSION && candidate.analysisSchemaVersion === FORMSPEC_ANALYSIS_SCHEMA_VERSION && typeof candidate.workspaceRoot === "string" && typeof candidate.workspaceId === "string" && isIpcEndpoint(candidate.endpoint) && typeof candidate.typescriptVersion === "string" && typeof candidate.extensionFingerprint === "string" && typeof candidate.generation === "number" && typeof candidate.updatedAt === "string";
 }
-function collectPropertyPaths(type, checker, capability, prefix, visited) {
-  const stripped = stripNullishUnion(type);
-  if (visited.has(stripped)) {
-    return [];
+function isFormSpecSemanticQuery(value) {
+  if (!hasCurrentProtocolVersion(value)) {
+    return false;
   }
-  visited.add(stripped);
-  const suggestions = [];
-  if (hasTypeSemanticCapability(stripped, checker, capability) && prefix.length > 0) {
-    suggestions.push(prefix.join("."));
+  const candidate = value;
+  if (typeof candidate.kind !== "string") {
+    return false;
   }
-  for (const property of stripped.getProperties()) {
-    const declaration = property.valueDeclaration ?? property.declarations?.[0];
-    if (declaration === void 0) {
-      continue;
-    }
-    const propertyType = checker.getTypeOfSymbolAtLocation(property, declaration);
-    const nextPrefix = [...prefix, property.name];
-    suggestions.push(
-      ...collectPropertyPaths(propertyType, checker, capability, nextPrefix, visited)
-    );
+  switch (candidate.kind) {
+    case "health":
+      return true;
+    case "completion":
+    case "hover":
+      return typeof candidate.filePath === "string" && typeof candidate.offset === "number";
+    case "diagnostics":
+    case "file-snapshot":
+      return typeof candidate.filePath === "string";
+    default:
+      return false;
   }
-  return suggestions;
-}
-function collectCompatiblePathTargets(type, checker, capability) {
-  return collectPropertyPaths(type, checker, capability, [], /* @__PURE__ */ new Set());
-}
-
-// src/cursor-context.ts
-function isWordChar(char) {
-  return char !== void 0 && /[A-Za-z0-9]/u.test(char);
-}
-function isWhitespaceLike(char) {
-  return char === void 0 || /\s/u.test(char) || char === "*";
 }
-function containsOffset(tag, offset) {
-  return offset >= tag.tagNameSpan.start && offset <= tag.tagNameSpan.end;
-}
-function filterSignaturesByPlacement(signatures, placement) {
-  if (placement === void 0 || placement === null) {
-    return signatures;
+function isFormSpecSemanticResponse(value) {
+  if (!hasCurrentProtocolVersion(value)) {
+    return false;
   }
-  const filtered = signatures.filter((signature) => signature.placements.includes(placement));
-  return filtered.length > 0 ? filtered : signatures;
-}
-function getCompatiblePathTargetsForSignatures(signatures, checker, subjectType) {
-  if (checker === void 0 || subjectType === void 0) {
-    return [];
+  const candidate = value;
+  if (typeof candidate.kind !== "string") {
+    return false;
   }
-  const suggestions = /* @__PURE__ */ new Set();
-  for (const signature of signatures) {
-    for (const parameter of signature.parameters) {
-      if (parameter.kind !== "target-path" || parameter.capability === void 0) {
-        continue;
-      }
-      for (const target of collectCompatiblePathTargets(
-        subjectType,
-        checker,
-        parameter.capability
-      )) {
-        suggestions.add(target);
-      }
-    }
+  switch (candidate.kind) {
+    case "health":
+      return isFormSpecAnalysisManifest(candidate.manifest);
+    case "completion":
+      return typeof candidate.sourceHash === "string" && isSerializedCompletionContext(candidate.context);
+    case "hover":
+      return typeof candidate.sourceHash === "string" && (candidate.hover === null || isSerializedHoverInfo(candidate.hover));
+    case "diagnostics":
+      return typeof candidate.sourceHash === "string" && Array.isArray(candidate.diagnostics) && candidate.diagnostics.every(isAnalysisDiagnostic);
+    case "file-snapshot":
+      return candidate.snapshot === null || isAnalysisFileSnapshot(candidate.snapshot);
+    case "error":
+      return typeof candidate.error === "string";
+    default:
+      return false;
   }
-  return [...suggestions].sort();
 }
-function getSupportedTargets(signatures) {
-  const supportedTargets = /* @__PURE__ */ new Set(["none"]);
-  for (const signature of signatures) {
-    for (const parameter of signature.parameters) {
-      switch (parameter.kind) {
-        case "target-path":
-          supportedTargets.add("path");
-          break;
-        case "target-member":
-          supportedTargets.add("member");
-          break;
-        case "target-variant":
-          supportedTargets.add("variant");
-          break;
-        default:
-          break;
-      }
-    }
+function computeFormSpecTextHash(text) {
+  let hash = 2166136261;
+  for (let index = 0; index < text.length; index += 1) {
+    hash ^= text.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
   }
-  return [...supportedTargets];
+  return (hash >>> 0).toString(16).padStart(8, "0");
 }
-function getTargetCompletions(signatures, compatiblePathTargets) {
-  const completions = /* @__PURE__ */ new Set();
-  for (const signature of signatures) {
-    for (const parameter of signature.parameters) {
-      switch (parameter.kind) {
-        case "target-path":
-          for (const target of compatiblePathTargets) {
-            completions.add(target);
-          }
-          break;
-        case "target-variant":
-          completions.add("singular");
-          completions.add("plural");
-          break;
-        default:
-          break;
-      }
-    }
+function serializeCommentTargetSpecifier(target) {
+  if (target === null) {
+    return null;
   }
-  return [...completions];
-}
-function getCommentTagSemanticContext(tag, options) {
-  const tagDefinition = getTagDefinition(tag.normalizedTagName, options?.extensions);
-  const signatures = filterSignaturesByPlacement(
-    tagDefinition?.signatures ?? [],
-    options?.placement
-  );
-  const compatiblePathTargets = getCompatiblePathTargetsForSignatures(
-    signatures,
-    options?.checker,
-    options?.subjectType
-  );
-  const semantic = {
-    tag,
-    tagDefinition,
-    placement: options?.placement ?? null,
-    signatures,
-    supportedTargets: getSupportedTargets(signatures),
-    targetCompletions: getTargetCompletions(signatures, compatiblePathTargets),
-    compatiblePathTargets,
-    valueLabels: getValueLabels(signatures),
-    tagHoverMarkdown: tagDefinition?.hoverMarkdown ?? null,
-    targetHoverMarkdown: null,
-    argumentHoverMarkdown: null
-  };
   return {
-    ...semantic,
-    targetHoverMarkdown: buildTargetHoverMarkdown(semantic),
-    argumentHoverMarkdown: buildArgumentHoverMarkdown(semantic)
-  };
-}
-function getValueLabels(signatures) {
-  const labels = /* @__PURE__ */ new Set();
-  for (const signature of signatures) {
-    for (const parameter of signature.parameters) {
-      if (parameter.kind === "value") {
-        labels.add(parameter.label);
-      }
-    }
-  }
-  return [...labels];
-}
-function getTargetKindLabels(supportedTargets) {
-  const labels = supportedTargets.filter((kind) => kind !== "none").map((kind) => `\`${kind}\``);
-  return labels.length === 0 ? "none" : labels.join(", ");
-}
-function buildTargetHoverMarkdown(semantic) {
-  if (semantic.tagDefinition === null) {
-    return null;
-  }
-  const currentTarget = semantic.tag.target?.rawText ?? "";
-  const lines = [
-    `**Target for @${semantic.tagDefinition.canonicalName}**`,
-    "",
-    `Supported target forms: ${getTargetKindLabels(semantic.supportedTargets)}`
-  ];
-  if (currentTarget !== "") {
-    lines.push("", `Current target: \`:${currentTarget}\``);
-  }
-  const MAX_HOVER_PATH_TARGETS = 8;
-  if (semantic.compatiblePathTargets.length > 0) {
-    lines.push("", "**Compatible path targets:**");
-    for (const target of semantic.compatiblePathTargets.slice(0, MAX_HOVER_PATH_TARGETS)) {
-      lines.push(`- \`:${target}\``);
-    }
-  } else if (semantic.supportedTargets.includes("variant")) {
-    lines.push("", "Use `:singular` or `:plural` for variant-specific names.");
-  } else if (semantic.supportedTargets.includes("path")) {
-    lines.push(
-      "",
-      "Type-aware path completions become available when TypeScript binding is provided."
-    );
-  }
-  return lines.join("\n");
-}
-function buildArgumentHoverMarkdown(semantic) {
-  if (semantic.tagDefinition === null) {
-    return null;
-  }
-  const valueLabels = getValueLabels(semantic.signatures);
-  const formattedValueLabels = valueLabels.map((label) => `\`${label}\``);
-  const soleSignature = semantic.signatures.length === 1 ? semantic.signatures[0] : void 0;
-  const signatureLines = semantic.signatures.length === 0 ? [] : soleSignature !== void 0 ? [`**Signature:** \`${soleSignature.label}\``] : [
-    "**Signatures:**",
-    ...semantic.signatures.map((signature) => `- \`${signature.label}\``)
-  ];
-  return [
-    `**Argument for @${semantic.tagDefinition.canonicalName}**`,
-    "",
-    `Expected value: ${formattedValueLabels.join(" or ") || "`<value>`"}`,
-    "",
-    ...signatureLines
-  ].join("\n");
-}
-function findEnclosingDocComment(documentText, offset, options) {
-  const commentPattern = /\/\*\*[\s\S]*?\*\//gu;
-  for (const match of documentText.matchAll(commentPattern)) {
-    const fullMatch = match[0];
-    const index = match.index;
-    const start = index;
-    const end = start + fullMatch.length;
-    if (offset >= start && offset <= end) {
-      return {
-        text: fullMatch,
-        start,
-        end,
-        parsed: parseCommentBlock(fullMatch, {
-          offset: start,
-          ...options?.extensions !== void 0 ? { extensions: options.extensions } : {}
-        })
-      };
-    }
-  }
-  return null;
-}
-function findCommentTagAtOffset(documentText, offset, options) {
-  const comment = findEnclosingDocComment(documentText, offset, options);
-  if (comment === null) {
-    return null;
-  }
-  return comment.parsed.tags.find((tag) => containsOffset(tag, offset)) ?? null;
-}
-function getCommentCursorTargetAtOffset(documentText, offset, options) {
-  const comment = findEnclosingDocComment(documentText, offset, options);
-  if (comment === null) {
-    return null;
-  }
-  for (const tag of comment.parsed.tags) {
-    if (containsOffset(tag, offset)) {
-      return {
-        kind: "tag-name",
-        tag
-      };
-    }
-    if (tag.colonSpan !== null && offset >= tag.colonSpan.start && offset <= tag.colonSpan.end) {
-      return {
-        kind: "colon",
-        tag
-      };
-    }
-    if (tag.target !== null && offset >= tag.target.span.start && offset <= tag.target.span.end) {
-      return {
-        kind: "target",
-        tag
-      };
-    }
-    if (tag.argumentSpan !== null && offset >= tag.argumentSpan.start && offset <= tag.argumentSpan.end) {
-      return {
-        kind: "argument",
-        tag
-      };
-    }
-  }
-  return null;
-}
-function getTagCompletionPrefixAtOffset(documentText, offset) {
-  const comment = findEnclosingDocComment(documentText, offset);
-  if (comment === null) {
-    return null;
-  }
-  const relativeOffset = offset - comment.start;
-  if (relativeOffset < 0 || relativeOffset > comment.text.length) {
-    return null;
-  }
-  let cursor = relativeOffset;
-  while (cursor > 0 && isWordChar(comment.text[cursor - 1])) {
-    cursor -= 1;
-  }
-  const atIndex = cursor - 1;
-  if (atIndex < 0 || comment.text[atIndex] !== "@") {
-    return null;
-  }
-  const previousChar = atIndex > 0 ? comment.text[atIndex - 1] : void 0;
-  if (!isWhitespaceLike(previousChar)) {
-    return null;
-  }
-  return comment.text.slice(cursor, relativeOffset);
-}
-function getCommentCompletionContextAtOffset(documentText, offset, options) {
-  const prefix = getTagCompletionPrefixAtOffset(documentText, offset);
-  if (prefix !== null) {
-    return {
-      kind: "tag-name",
-      prefix
-    };
-  }
-  const target = getCommentCursorTargetAtOffset(documentText, offset, options);
-  if (target?.kind === "target" || target?.kind === "colon") {
-    return {
-      kind: "target",
-      tag: target.tag
-    };
-  }
-  if (target?.kind === "argument") {
-    return {
-      kind: "argument",
-      tag: target.tag
-    };
-  }
-  return {
-    kind: "none"
-  };
-}
-function getSemanticCommentCompletionContextAtOffset(documentText, offset, options) {
-  const prefix = getTagCompletionPrefixAtOffset(documentText, offset);
-  if (prefix !== null) {
-    return {
-      kind: "tag-name",
-      prefix,
-      availableTags: getAllTagDefinitions(options?.extensions)
-    };
-  }
-  const target = getCommentCursorTargetAtOffset(
-    documentText,
-    offset,
-    options?.extensions ? { extensions: options.extensions } : void 0
-  );
-  if (target?.kind === "target" || target?.kind === "colon") {
-    return {
-      kind: "target",
-      semantic: getCommentTagSemanticContext(target.tag, options)
-    };
-  }
-  if (target?.kind === "argument") {
-    const semantic = getCommentTagSemanticContext(target.tag, options);
-    return {
-      kind: "argument",
-      semantic,
-      valueLabels: semantic.valueLabels
-    };
-  }
-  return { kind: "none" };
-}
-function getCommentHoverInfoAtOffset(documentText, offset, options) {
-  const target = getCommentCursorTargetAtOffset(
-    documentText,
-    offset,
-    options?.extensions ? { extensions: options.extensions } : void 0
-  );
-  if (target === null) {
-    return null;
-  }
-  const semantic = getCommentTagSemanticContext(target.tag, options);
-  let markdown = null;
-  switch (target.kind) {
-    case "tag-name":
-      markdown = semantic.tagHoverMarkdown;
-      break;
-    case "colon":
-    case "target":
-      markdown = semantic.targetHoverMarkdown;
-      break;
-    case "argument":
-      markdown = semantic.argumentHoverMarkdown;
-      break;
-    default: {
-      const exhaustive = target.kind;
-      void exhaustive;
-      break;
-    }
-  }
-  return markdown === null ? null : {
-    kind: target.kind === "colon" ? "target" : target.kind,
-    markdown
-  };
-}
-
-// src/tag-value-parser.ts
-var import_core2 = require("@formspec/core");
-var NUMERIC_CONSTRAINT_MAP = {
-  minimum: "minimum",
-  maximum: "maximum",
-  exclusiveMinimum: "exclusiveMinimum",
-  exclusiveMaximum: "exclusiveMaximum",
-  multipleOf: "multipleOf"
-};
-var LENGTH_CONSTRAINT_MAP = {
-  minLength: "minLength",
-  maxLength: "maxLength",
-  minItems: "minItems",
-  maxItems: "maxItems"
-};
-function tryParseJson(text) {
-  try {
-    return JSON.parse(text);
-  } catch {
-    return null;
-  }
-}
-function syntaxOptions(registry) {
-  return registry?.extensions !== void 0 ? { extensions: registry.extensions } : void 0;
-}
-function parseConstraintTagValue(tagName, text, provenance, options) {
-  const customConstraint = parseExtensionConstraintTagValue(tagName, text, provenance, options);
-  if (customConstraint !== null) {
-    return customConstraint;
-  }
-  if (!(0, import_core2.isBuiltinConstraintName)(tagName)) {
-    return null;
-  }
-  const parsedTag = parseTagSyntax(tagName, text, syntaxOptions(options?.registry));
-  if (parsedTag.target !== null && !parsedTag.target.valid) {
-    return null;
-  }
-  const effectiveText = parsedTag.argumentText;
-  const path2 = parsedTag.target?.path ?? void 0;
-  const expectedType = import_core2.BUILTIN_CONSTRAINT_DEFINITIONS[tagName];
-  if (expectedType !== "boolean" && effectiveText.trim() === "") {
-    return null;
-  }
-  if (expectedType === "number") {
-    const value = Number(effectiveText);
-    if (Number.isNaN(value)) {
-      return null;
-    }
-    const numericKind = NUMERIC_CONSTRAINT_MAP[tagName];
-    if (numericKind !== void 0) {
-      return {
-        kind: "constraint",
-        constraintKind: numericKind,
-        value,
-        ...path2 !== void 0 && { path: path2 },
-        provenance
-      };
-    }
-    const lengthKind = LENGTH_CONSTRAINT_MAP[tagName];
-    if (lengthKind !== void 0) {
-      return {
-        kind: "constraint",
-        constraintKind: lengthKind,
-        value,
-        ...path2 !== void 0 && { path: path2 },
-        provenance
-      };
-    }
-    return null;
-  }
-  if (expectedType === "boolean") {
-    const trimmed = effectiveText.trim();
-    if (trimmed !== "" && trimmed !== "true") {
-      return null;
-    }
-    if (tagName === "uniqueItems") {
-      return {
-        kind: "constraint",
-        constraintKind: "uniqueItems",
-        value: true,
-        ...path2 !== void 0 && { path: path2 },
-        provenance
-      };
-    }
-    return null;
-  }
-  if (expectedType === "json") {
-    if (tagName === "const") {
-      const trimmedText = effectiveText.trim();
-      if (trimmedText === "") {
-        return null;
-      }
-      try {
-        const parsed2 = JSON.parse(trimmedText);
-        return {
-          kind: "constraint",
-          constraintKind: "const",
-          value: parsed2,
-          ...path2 !== void 0 && { path: path2 },
-          provenance
-        };
-      } catch {
-        return {
-          kind: "constraint",
-          constraintKind: "const",
-          value: trimmedText,
-          ...path2 !== void 0 && { path: path2 },
-          provenance
-        };
-      }
-    }
-    const parsed = tryParseJson(effectiveText);
-    if (!Array.isArray(parsed)) {
-      return null;
-    }
-    const members = [];
-    for (const item of parsed) {
-      if (typeof item === "string" || typeof item === "number") {
-        members.push(item);
-        continue;
-      }
-      if (typeof item === "object" && item !== null && "id" in item) {
-        const id = item["id"];
-        if (typeof id === "string" || typeof id === "number") {
-          members.push(id);
-        }
-      }
-    }
-    return {
-      kind: "constraint",
-      constraintKind: "allowedMembers",
-      members,
-      ...path2 !== void 0 && { path: path2 },
-      provenance
-    };
-  }
-  return {
-    kind: "constraint",
-    constraintKind: "pattern",
-    pattern: effectiveText,
-    ...path2 !== void 0 && { path: path2 },
-    provenance
-  };
-}
-function parseDefaultValueTagValue(text, provenance) {
-  const trimmed = text.trim();
-  let value;
-  if (trimmed === "null") {
-    value = null;
-  } else if (trimmed === "true") {
-    value = true;
-  } else if (trimmed === "false") {
-    value = false;
-  } else {
-    const parsed = tryParseJson(trimmed);
-    value = parsed !== null ? parsed : trimmed;
-  }
-  return {
-    kind: "annotation",
-    annotationKind: "defaultValue",
-    value,
-    provenance
-  };
-}
-function parseExtensionConstraintTagValue(tagName, text, provenance, options) {
-  const parsedTag = parseTagSyntax(tagName, text, syntaxOptions(options?.registry));
-  if (parsedTag.target !== null && !parsedTag.target.valid) {
-    return null;
-  }
-  const effectiveText = parsedTag.argumentText;
-  const path2 = parsedTag.target?.path ?? void 0;
-  const registry = options?.registry;
-  if (registry === void 0) {
-    return null;
-  }
-  if (effectiveText.trim() === "") {
-    return null;
-  }
-  const directTag = registry.findConstraintTag(tagName);
-  if (directTag !== void 0) {
-    return makeCustomConstraintNode(
-      directTag.extensionId,
-      directTag.registration.constraintName,
-      directTag.registration.parseValue(effectiveText),
-      provenance,
-      path2,
-      registry
-    );
-  }
-  if (!(0, import_core2.isBuiltinConstraintName)(tagName)) {
-    return null;
-  }
-  const broadenedTypeId = getBroadenedCustomTypeId(options?.fieldType);
-  if (broadenedTypeId === void 0) {
-    return null;
-  }
-  const broadened = registry.findBuiltinConstraintBroadening(broadenedTypeId, tagName);
-  if (broadened === void 0) {
-    return null;
-  }
-  return makeCustomConstraintNode(
-    broadened.extensionId,
-    broadened.registration.constraintName,
-    broadened.registration.parseValue(effectiveText),
-    provenance,
-    path2,
-    registry
-  );
-}
-function getBroadenedCustomTypeId(fieldType) {
-  if (fieldType?.kind === "custom") {
-    return fieldType.typeId;
-  }
-  if (fieldType?.kind !== "union") {
-    return void 0;
-  }
-  const customMembers = fieldType.members.filter(
-    (member) => member.kind === "custom"
-  );
-  if (customMembers.length !== 1) {
-    return void 0;
-  }
-  const nonCustomMembers = fieldType.members.filter((member) => member.kind !== "custom");
-  const allOtherMembersAreNull = nonCustomMembers.every(
-    (member) => member.kind === "primitive" && member.primitiveKind === "null"
-  );
-  const customMember = customMembers[0];
-  return allOtherMembersAreNull && customMember !== void 0 ? customMember.typeId : void 0;
-}
-function makeCustomConstraintNode(extensionId, constraintName, payload, provenance, path2, registry) {
-  const constraintId = `${extensionId}/${constraintName}`;
-  const registration = registry.findConstraint(constraintId);
-  if (registration === void 0) {
-    throw new Error(
-      `Custom TSDoc tag resolved to unregistered constraint "${constraintId}". Register the constraint before using its tag.`
-    );
-  }
-  return {
-    kind: "constraint",
-    constraintKind: "custom",
-    constraintId,
-    payload,
-    compositionRule: registration.compositionRule,
-    ...path2 !== void 0 && { path: path2 },
-    provenance
-  };
-}
-
-// src/semantic-targets.ts
-var import_core3 = require("@formspec/core");
-function pathKey(path2) {
-  return path2?.segments.join(".") ?? "";
-}
-function formatConstraintTargetName(fieldName, path2) {
-  if (path2 === null || path2.segments.length === 0) {
-    return fieldName;
-  }
-  return `${fieldName}.${path2.segments.join(".")}`;
-}
-function dereferenceAnalysisType(type, typeRegistry) {
-  let current = type;
-  const seen = /* @__PURE__ */ new Set();
-  while (current.kind === "reference") {
-    if (seen.has(current.name)) {
-      return current;
-    }
-    seen.add(current.name);
-    const definition = typeRegistry[current.name];
-    if (definition === void 0) {
-      return current;
-    }
-    current = definition.type;
-  }
-  return current;
-}
-function collectReferencedTypeConstraints(type, typeRegistry) {
-  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 = typeRegistry[current.name];
-    if (definition === void 0) {
-      break;
-    }
-    if (definition.constraints !== void 0) {
-      collected.push(...definition.constraints);
-    }
-    current = definition.type;
-  }
-  return collected;
-}
-function collectReferencedTypeAnnotations(type, typeRegistry) {
-  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 = typeRegistry[current.name];
-    if (definition === void 0) {
-      break;
-    }
-    if (definition.annotations !== void 0) {
-      collected.push(...definition.annotations);
-    }
-    current = definition.type;
-  }
-  return collected;
-}
-function resolveProperty(type, typeRegistry, segments) {
-  const effectiveType = dereferenceAnalysisType(type, typeRegistry);
-  if (segments.length === 0) {
-    return { kind: "resolved", property: null, rawType: type, type: effectiveType };
-  }
-  if (effectiveType.kind === "array") {
-    return resolveProperty(effectiveType.items, typeRegistry, segments);
-  }
-  if (effectiveType.kind !== "object") {
-    return { kind: "unresolvable", type: effectiveType };
-  }
-  const [segment, ...rest] = segments;
-  if (segment === void 0) {
-    throw new Error("Invariant violation: object traversal requires a segment");
-  }
-  const property = effectiveType.properties.find((candidate) => candidate.name === segment);
-  if (property === void 0) {
-    return { kind: "missing-property", segment };
-  }
-  if (rest.length === 0) {
-    return {
-      kind: "resolved",
-      property,
-      rawType: property.type,
-      type: dereferenceAnalysisType(property.type, typeRegistry)
-    };
-  }
-  return resolveProperty(property.type, typeRegistry, rest);
-}
-function resolveConstraintTargetState(fieldName, fieldType, path2, localConstraints, typeRegistry) {
-  if (path2 === null) {
-    const inheritedConstraints2 = collectReferencedTypeConstraints(fieldType, typeRegistry);
-    const inheritedAnnotations2 = collectReferencedTypeAnnotations(fieldType, typeRegistry);
-    const type = dereferenceAnalysisType(fieldType, typeRegistry);
-    return {
-      kind: "resolved",
-      fieldName,
-      path: path2,
-      targetName: fieldName,
-      type,
-      inheritedConstraints: inheritedConstraints2,
-      inheritedAnnotations: inheritedAnnotations2,
-      localConstraints,
-      effectiveConstraints: [...inheritedConstraints2, ...localConstraints]
-    };
-  }
-  const resolution = resolveProperty(fieldType, typeRegistry, path2.segments);
-  const targetName = formatConstraintTargetName(fieldName, path2);
-  if (resolution.kind === "missing-property") {
-    return {
-      kind: "missing-property",
-      fieldName,
-      path: path2,
-      targetName,
-      segment: resolution.segment,
-      localConstraints
-    };
-  }
-  if (resolution.kind === "unresolvable") {
-    return {
-      kind: "unresolvable",
-      fieldName,
-      path: path2,
-      targetName,
-      type: resolution.type,
-      localConstraints
-    };
-  }
-  const propertyConstraints = resolution.property?.constraints ?? [];
-  const propertyAnnotations = resolution.property?.annotations ?? [];
-  const referencedConstraints = collectReferencedTypeConstraints(resolution.rawType, typeRegistry);
-  const referencedAnnotations = collectReferencedTypeAnnotations(resolution.rawType, typeRegistry);
-  const inheritedConstraints = [...propertyConstraints, ...referencedConstraints];
-  const inheritedAnnotations = [...propertyAnnotations, ...referencedAnnotations];
-  return {
-    kind: "resolved",
-    fieldName,
-    path: path2,
-    targetName,
-    type: resolution.type,
-    inheritedConstraints,
-    inheritedAnnotations,
-    localConstraints,
-    effectiveConstraints: [...inheritedConstraints, ...localConstraints]
-  };
-}
-function cloneTargetPath(path2) {
-  if (path2 === void 0) {
-    return null;
-  }
-  return { segments: [...path2.segments] };
-}
-function buildConstraintTargetStates(fieldName, fieldType, constraints, typeRegistry) {
-  const grouped = /* @__PURE__ */ new Map([
-    ["", { path: null, constraints: [] }]
-  ]);
-  for (const constraint of constraints) {
-    const path2 = cloneTargetPath(constraint.path);
-    const key = pathKey(path2);
-    let bucket = grouped.get(key);
-    if (bucket === void 0) {
-      bucket = { path: path2, constraints: [] };
-      grouped.set(key, bucket);
-    }
-    bucket.constraints.push(constraint);
-  }
-  return [...grouped.values()].map(
-    (group) => resolveConstraintTargetState(fieldName, fieldType, group.path, group.constraints, typeRegistry)
-  );
-}
-function addContradiction(diagnostics, message, primary, related) {
-  diagnostics.push({
-    code: "CONTRADICTING_CONSTRAINTS",
-    message,
-    severity: "error",
-    primaryLocation: primary,
-    relatedLocations: [related]
-  });
-}
-function addTypeMismatch(diagnostics, message, primary) {
-  diagnostics.push({
-    code: "TYPE_MISMATCH",
-    message,
-    severity: "error",
-    primaryLocation: primary,
-    relatedLocations: []
-  });
-}
-function addUnknownExtension(diagnostics, message, primary) {
-  diagnostics.push({
-    code: "UNKNOWN_EXTENSION",
-    message,
-    severity: "warning",
-    primaryLocation: primary,
-    relatedLocations: []
-  });
-}
-function addUnknownPathTarget(diagnostics, message, primary) {
-  diagnostics.push({
-    code: "UNKNOWN_PATH_TARGET",
-    message,
-    severity: "error",
-    primaryLocation: primary,
-    relatedLocations: []
-  });
-}
-function addConstraintBroadening(diagnostics, message, primary, related) {
-  diagnostics.push({
-    code: "CONSTRAINT_BROADENING",
-    message,
-    severity: "error",
-    primaryLocation: primary,
-    relatedLocations: [related]
-  });
-}
-function getExtensionIdFromConstraintId(constraintId) {
-  const separator = constraintId.lastIndexOf("/");
-  if (separator <= 0) {
-    return null;
-  }
-  return constraintId.slice(0, separator);
-}
-function typeLabel(type) {
-  switch (type.kind) {
-    case "primitive":
-      return type.primitiveKind;
-    case "enum":
-      return "enum";
-    case "array":
-      return "array";
-    case "object":
-      return "object";
-    case "record":
-      return "record";
-    case "union":
-      return "union";
-    case "reference":
-      return `reference(${type.name})`;
-    case "dynamic":
-      return `dynamic(${type.dynamicKind})`;
-    case "custom":
-      return `custom(${type.typeId})`;
-    default: {
-      const exhaustive = type;
-      return String(exhaustive);
-    }
-  }
-}
-function isJsonObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isJsonArray(value) {
-  return Array.isArray(value);
-}
-function jsonValueEquals(left, right) {
-  if (left === right) {
-    return true;
-  }
-  if (isJsonArray(left) || isJsonArray(right)) {
-    if (!isJsonArray(left) || !isJsonArray(right) || left.length !== right.length) {
-      return false;
-    }
-    for (const [index, item] of left.entries()) {
-      const rightItem = right[index];
-      if (rightItem === void 0 || !jsonValueEquals(item, rightItem)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  if (isJsonObject(left) || isJsonObject(right)) {
-    if (!isJsonObject(left) || !isJsonObject(right)) {
-      return false;
-    }
-    const leftKeys = Object.keys(left).sort();
-    const rightKeys = Object.keys(right).sort();
-    if (leftKeys.length !== rightKeys.length) {
-      return false;
-    }
-    return leftKeys.every((key, index) => {
-      const rightKey = rightKeys[index];
-      if (rightKey !== key) {
-        return false;
-      }
-      const leftValue = left[key];
-      const rightValue = right[rightKey];
-      return leftValue !== void 0 && rightValue !== void 0 && jsonValueEquals(leftValue, rightValue);
-    });
-  }
-  return false;
-}
-function findNumeric(constraints, constraintKind) {
-  return constraints.find(
-    (constraint) => constraint.constraintKind === constraintKind
-  );
-}
-function findLength(constraints, constraintKind) {
-  return constraints.find(
-    (constraint) => constraint.constraintKind === constraintKind
-  );
-}
-function findAllowedMembers(constraints) {
-  return constraints.filter(
-    (constraint) => constraint.constraintKind === "allowedMembers"
-  );
-}
-function findConstConstraints(constraints) {
-  return constraints.filter(
-    (constraint) => constraint.constraintKind === "const"
-  );
-}
-function isOrderedBoundConstraint(constraint) {
-  return constraint.constraintKind === "minimum" || constraint.constraintKind === "exclusiveMinimum" || constraint.constraintKind === "minLength" || constraint.constraintKind === "minItems" || constraint.constraintKind === "maximum" || constraint.constraintKind === "exclusiveMaximum" || constraint.constraintKind === "maxLength" || constraint.constraintKind === "maxItems";
-}
-function constraintPathKey(constraint) {
-  return constraint.path?.segments.join(".") ?? "";
-}
-function orderedBoundFamily(kind) {
-  switch (kind) {
-    case "minimum":
-    case "exclusiveMinimum":
-      return "numeric-lower";
-    case "maximum":
-    case "exclusiveMaximum":
-      return "numeric-upper";
-    case "minLength":
-      return "minLength";
-    case "minItems":
-      return "minItems";
-    case "maxLength":
-      return "maxLength";
-    case "maxItems":
-      return "maxItems";
-    default: {
-      const exhaustive = kind;
-      return exhaustive;
-    }
-  }
-}
-function isNumericLowerKind(kind) {
-  return kind === "minimum" || kind === "exclusiveMinimum";
-}
-function isNumericUpperKind(kind) {
-  return kind === "maximum" || kind === "exclusiveMaximum";
-}
-function describeConstraintTag(constraint) {
-  return `@${constraint.constraintKind}`;
-}
-function compareConstraintStrength(current, previous) {
-  const family = orderedBoundFamily(current.constraintKind);
-  if (family === "numeric-lower") {
-    if (!isNumericLowerKind(current.constraintKind) || !isNumericLowerKind(previous.constraintKind)) {
-      throw new Error("numeric-lower family received non-numeric lower-bound constraint");
-    }
-    if (current.value !== previous.value) {
-      return current.value > previous.value ? 1 : -1;
-    }
-    if (current.constraintKind === "exclusiveMinimum" && previous.constraintKind === "minimum") {
-      return 1;
-    }
-    if (current.constraintKind === "minimum" && previous.constraintKind === "exclusiveMinimum") {
-      return -1;
-    }
-    return 0;
-  }
-  if (family === "numeric-upper") {
-    if (!isNumericUpperKind(current.constraintKind) || !isNumericUpperKind(previous.constraintKind)) {
-      throw new Error("numeric-upper family received non-numeric upper-bound constraint");
-    }
-    if (current.value !== previous.value) {
-      return current.value < previous.value ? 1 : -1;
-    }
-    if (current.constraintKind === "exclusiveMaximum" && previous.constraintKind === "maximum") {
-      return 1;
-    }
-    if (current.constraintKind === "maximum" && previous.constraintKind === "exclusiveMaximum") {
-      return -1;
-    }
-    return 0;
-  }
-  switch (family) {
-    case "minLength":
-    case "minItems":
-      if (current.value === previous.value) {
-        return 0;
-      }
-      return current.value > previous.value ? 1 : -1;
-    case "maxLength":
-    case "maxItems":
-      if (current.value === previous.value) {
-        return 0;
-      }
-      return current.value < previous.value ? 1 : -1;
-    default: {
-      const exhaustive = family;
-      return exhaustive;
-    }
-  }
-}
-function compareSemanticInclusivity(currentInclusive, previousInclusive) {
-  if (currentInclusive === previousInclusive) {
-    return 0;
-  }
-  return currentInclusive ? -1 : 1;
-}
-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 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 isNullType(type) {
-  return type.kind === "primitive" && type.primitiveKind === "null";
-}
-function collectCustomConstraintCandidateTypes(type, typeRegistry) {
-  const effectiveType = dereferenceAnalysisType(type, typeRegistry);
-  const candidates = [effectiveType];
-  if (effectiveType.kind === "array") {
-    candidates.push(...collectCustomConstraintCandidateTypes(effectiveType.items, typeRegistry));
-  }
-  if (effectiveType.kind === "union") {
-    const memberTypes = effectiveType.members.map(
-      (member) => dereferenceAnalysisType(member, typeRegistry)
-    );
-    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(nullableMember, typeRegistry));
-      }
-    }
-  }
-  return candidates;
-}
-function checkNumericContradictions(diagnostics, fieldName, constraints) {
-  const min = findNumeric(constraints, "minimum");
-  const max = findNumeric(constraints, "maximum");
-  const exMin = findNumeric(constraints, "exclusiveMinimum");
-  const exMax = findNumeric(constraints, "exclusiveMaximum");
-  if (min !== void 0 && max !== void 0 && min.value > max.value) {
-    addContradiction(
-      diagnostics,
-      `Field "${fieldName}": minimum (${String(min.value)}) is greater than maximum (${String(max.value)})`,
-      min.provenance,
-      max.provenance
-    );
-  }
-  if (exMin !== void 0 && max !== void 0 && exMin.value >= max.value) {
-    addContradiction(
-      diagnostics,
-      `Field "${fieldName}": exclusiveMinimum (${String(exMin.value)}) is greater than or equal to maximum (${String(max.value)})`,
-      exMin.provenance,
-      max.provenance
-    );
-  }
-  if (min !== void 0 && exMax !== void 0 && min.value >= exMax.value) {
-    addContradiction(
-      diagnostics,
-      `Field "${fieldName}": minimum (${String(min.value)}) is greater than or equal to exclusiveMaximum (${String(exMax.value)})`,
-      min.provenance,
-      exMax.provenance
-    );
-  }
-  if (exMin !== void 0 && exMax !== void 0 && exMin.value >= exMax.value) {
-    addContradiction(
-      diagnostics,
-      `Field "${fieldName}": exclusiveMinimum (${String(exMin.value)}) is greater than or equal to exclusiveMaximum (${String(exMax.value)})`,
-      exMin.provenance,
-      exMax.provenance
-    );
-  }
-}
-function checkLengthContradictions(diagnostics, fieldName, constraints) {
-  const minLen = findLength(constraints, "minLength");
-  const maxLen = findLength(constraints, "maxLength");
-  if (minLen !== void 0 && maxLen !== void 0 && minLen.value > maxLen.value) {
-    addContradiction(
-      diagnostics,
-      `Field "${fieldName}": minLength (${String(minLen.value)}) is greater than maxLength (${String(maxLen.value)})`,
-      minLen.provenance,
-      maxLen.provenance
-    );
-  }
-  const minItems = findLength(constraints, "minItems");
-  const maxItems = findLength(constraints, "maxItems");
-  if (minItems !== void 0 && maxItems !== void 0 && minItems.value > maxItems.value) {
-    addContradiction(
-      diagnostics,
-      `Field "${fieldName}": minItems (${String(minItems.value)}) is greater than maxItems (${String(maxItems.value)})`,
-      minItems.provenance,
-      maxItems.provenance
-    );
-  }
-}
-function checkAllowedMembersContradiction(diagnostics, fieldName, constraints) {
-  const members = findAllowedMembers(constraints);
-  if (members.length < 2) {
-    return;
-  }
-  const firstSet = new Set(members[0]?.members ?? []);
-  for (let index = 1; index < members.length; index += 1) {
-    const current = members[index];
-    if (current === void 0) {
-      continue;
-    }
-    for (const member of firstSet) {
-      if (!current.members.includes(member)) {
-        firstSet.delete(member);
-      }
-    }
-  }
-  if (firstSet.size === 0) {
-    const first = members[0];
-    const second = members[1];
-    if (first !== void 0 && second !== void 0) {
-      addContradiction(
-        diagnostics,
-        `Field "${fieldName}": allowedMembers constraints have an empty intersection (no valid values remain)`,
-        first.provenance,
-        second.provenance
-      );
-    }
-  }
-}
-function checkConstContradictions(diagnostics, fieldName, constraints) {
-  const constConstraints = findConstConstraints(constraints);
-  if (constConstraints.length < 2) {
-    return;
-  }
-  const first = constConstraints[0];
-  if (first === void 0) {
-    return;
-  }
-  for (let index = 1; index < constConstraints.length; index += 1) {
-    const current = constConstraints[index];
-    if (current === void 0 || jsonValueEquals(first.value, current.value)) {
-      continue;
-    }
-    addContradiction(
-      diagnostics,
-      `Field "${fieldName}": conflicting @const constraints require both ${JSON.stringify(first.value)} and ${JSON.stringify(current.value)}`,
-      first.provenance,
-      current.provenance
-    );
-  }
-}
-function checkConstraintBroadening(diagnostics, fieldName, constraints) {
-  const strongestByKey = /* @__PURE__ */ new Map();
-  for (const constraint of constraints) {
-    if (!isOrderedBoundConstraint(constraint)) {
-      continue;
-    }
-    const key = `${orderedBoundFamily(constraint.constraintKind)}:${constraintPathKey(constraint)}`;
-    const previous = strongestByKey.get(key);
-    if (previous === void 0) {
-      strongestByKey.set(key, constraint);
-      continue;
-    }
-    const strength = compareConstraintStrength(constraint, previous);
-    if (strength < 0) {
-      addConstraintBroadening(
-        diagnostics,
-        `Field "${fieldName}": ${describeConstraintTag(constraint)} (${String(constraint.value)}) is broader than earlier ${describeConstraintTag(previous)} (${String(previous.value)}). Constraints can only narrow.`,
-        constraint.provenance,
-        previous.provenance
-      );
-      continue;
-    }
-    if (strength > 0) {
-      strongestByKey.set(key, constraint);
-    }
-  }
-}
-function checkCustomConstraintSemantics(diagnostics, fieldName, constraints, extensionRegistry) {
-  if (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 = 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}:${constraintPathKey(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(
-          diagnostics,
-          `Field "${fieldName}": ${describeCustomConstraintTag(constraint)} conflicts with ${describeCustomConstraintTag(previous.constraint)}`,
-          constraint.provenance,
-          previous.constraint.provenance
-        );
-        continue;
-      }
-      if (strength < 0) {
-        addConstraintBroadening(
-          diagnostics,
-          `Field "${fieldName}": ${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 || !customConstraintsContradict(lower, upper)) {
-      continue;
-    }
-    addContradiction(
-      diagnostics,
-      `Field "${fieldName}": ${describeCustomConstraintTag(lower.constraint)} contradicts ${describeCustomConstraintTag(upper.constraint)}`,
-      lower.constraint.provenance,
-      upper.constraint.provenance
-    );
-  }
-}
-function checkCustomConstraint(diagnostics, fieldName, type, constraint, typeRegistry, extensionRegistry) {
-  if (extensionRegistry === void 0) {
-    return;
-  }
-  const registration = extensionRegistry.findConstraint(constraint.constraintId);
-  if (registration === void 0) {
-    addUnknownExtension(
-      diagnostics,
-      `Field "${fieldName}": custom constraint "${constraint.constraintId}" is not registered in the extension registry`,
-      constraint.provenance
-    );
-    return;
-  }
-  const candidateTypes = collectCustomConstraintCandidateTypes(type, typeRegistry);
-  const normalizedTagName = constraint.provenance.tagName === void 0 ? void 0 : (0, import_core3.normalizeConstraintTagName)(constraint.provenance.tagName.replace(/^@/, ""));
-  if (normalizedTagName !== void 0) {
-    const tagRegistration = 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(
-        diagnostics,
-        `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(
-        diagnostics,
-        `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(
-      diagnostics,
-      `Field "${fieldName}": custom constraint "${constraint.constraintId}" is not applicable to type "${typeLabel(type)}"`,
-      constraint.provenance
-    );
-  }
-}
-function checkConstraintOnType(diagnostics, fieldName, type, constraint, typeRegistry, extensionRegistry) {
-  const effectiveType = dereferenceAnalysisType(type, typeRegistry);
-  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";
-  const arrayItemType = effectiveType.kind === "array" ? dereferenceAnalysisType(effectiveType.items, typeRegistry) : void 0;
-  const isStringArray2 = arrayItemType?.kind === "primitive" && arrayItemType.primitiveKind === "string";
-  const label = typeLabel(effectiveType);
-  switch (constraint.constraintKind) {
-    case "minimum":
-    case "maximum":
-    case "exclusiveMinimum":
-    case "exclusiveMaximum":
-    case "multipleOf":
-      if (!isNumber) {
-        addTypeMismatch(
-          diagnostics,
-          `Field "${fieldName}": constraint "${constraint.constraintKind}" is only valid on number fields, but field type is "${label}"`,
-          constraint.provenance
-        );
-      }
-      break;
-    case "minLength":
-    case "maxLength":
-    case "pattern":
-      if (!isString && !isStringArray2) {
-        addTypeMismatch(
-          diagnostics,
-          `Field "${fieldName}": constraint "${constraint.constraintKind}" is only valid on string fields or string array items, but field type is "${label}"`,
-          constraint.provenance
-        );
-      }
-      break;
-    case "minItems":
-    case "maxItems":
-    case "uniqueItems":
-      if (!isArray) {
-        addTypeMismatch(
-          diagnostics,
-          `Field "${fieldName}": constraint "${constraint.constraintKind}" is only valid on array fields, but field type is "${label}"`,
-          constraint.provenance
-        );
-      }
-      break;
-    case "allowedMembers":
-      if (!isEnum) {
-        addTypeMismatch(
-          diagnostics,
-          `Field "${fieldName}": constraint "allowedMembers" is only valid on enum fields, but field type is "${label}"`,
-          constraint.provenance
-        );
-      }
-      break;
-    case "const": {
-      const isPrimitiveConstType = effectiveType.kind === "primitive" && ["string", "number", "integer", "bigint", "boolean", "null"].includes(
-        effectiveType.primitiveKind
-      ) || effectiveType.kind === "enum";
-      if (!isPrimitiveConstType) {
-        addTypeMismatch(
-          diagnostics,
-          `Field "${fieldName}": constraint "const" is only valid on primitive or enum fields, but field type is "${label}"`,
-          constraint.provenance
-        );
-        break;
-      }
-      if (effectiveType.kind === "primitive") {
-        const valueType = constraint.value === null ? "null" : Array.isArray(constraint.value) ? "array" : typeof constraint.value;
-        const expectedValueType = effectiveType.primitiveKind === "integer" || effectiveType.primitiveKind === "bigint" ? "number" : effectiveType.primitiveKind;
-        if (valueType !== expectedValueType) {
-          addTypeMismatch(
-            diagnostics,
-            `Field "${fieldName}": @const value type "${valueType}" is incompatible with field type "${effectiveType.primitiveKind}"`,
-            constraint.provenance
-          );
-        }
-        break;
-      }
-      const memberValues = effectiveType.members.map((member) => member.value);
-      if (!memberValues.some((member) => jsonValueEquals(member, constraint.value))) {
-        addTypeMismatch(
-          diagnostics,
-          `Field "${fieldName}": @const value ${JSON.stringify(constraint.value)} is not one of the enum members`,
-          constraint.provenance
-        );
-      }
-      break;
-    }
-    case "custom":
-      checkCustomConstraint(
-        diagnostics,
-        fieldName,
-        effectiveType,
-        constraint,
-        typeRegistry,
-        extensionRegistry
-      );
-      break;
-    default: {
-      const exhaustive = constraint;
-      throw new Error(`Unhandled constraint: ${JSON.stringify(exhaustive)}`);
-    }
-  }
-}
-function analyzeResolvedTargetState(diagnostics, state, typeRegistry, extensionRegistry) {
-  checkNumericContradictions(diagnostics, state.targetName, state.effectiveConstraints);
-  checkLengthContradictions(diagnostics, state.targetName, state.effectiveConstraints);
-  checkAllowedMembersContradiction(diagnostics, state.targetName, state.effectiveConstraints);
-  checkConstContradictions(diagnostics, state.targetName, state.effectiveConstraints);
-  checkConstraintBroadening(diagnostics, state.targetName, state.effectiveConstraints);
-  checkCustomConstraintSemantics(
-    diagnostics,
-    state.targetName,
-    state.effectiveConstraints,
-    extensionRegistry
-  );
-  for (const constraint of state.effectiveConstraints) {
-    checkConstraintOnType(
-      diagnostics,
-      state.targetName,
-      state.type,
-      constraint,
-      typeRegistry,
-      extensionRegistry
-    );
-  }
-}
-function analyzeConstraintTargets(fieldName, fieldType, constraints, typeRegistry, options) {
-  const diagnostics = [];
-  const targetStates = buildConstraintTargetStates(fieldName, fieldType, constraints, typeRegistry);
-  for (const targetState of targetStates) {
-    switch (targetState.kind) {
-      case "resolved":
-        analyzeResolvedTargetState(
-          diagnostics,
-          targetState,
-          typeRegistry,
-          options?.extensionRegistry
-        );
-        break;
-      case "missing-property":
-        for (const constraint of targetState.localConstraints) {
-          addUnknownPathTarget(
-            diagnostics,
-            `Field "${targetState.targetName}": path-targeted constraint "${constraint.constraintKind}" references unknown path segment "${targetState.segment}"`,
-            constraint.provenance
-          );
-        }
-        break;
-      case "unresolvable":
-        for (const constraint of targetState.localConstraints) {
-          addTypeMismatch(
-            diagnostics,
-            `Field "${targetState.targetName}": path-targeted constraint "${constraint.constraintKind}" is invalid because type "${typeLabel(targetState.type)}" cannot be traversed`,
-            constraint.provenance
-          );
-        }
-        break;
-      default: {
-        const exhaustive = targetState;
-        throw new Error(`Unhandled target state: ${String(exhaustive)}`);
-      }
-    }
-  }
-  return {
-    diagnostics,
-    targetStates
-  };
-}
-
-// src/file-snapshots.ts
-var ts4 = __toESM(require("typescript"), 1);
-
-// src/compiler-signatures.ts
-var ts2 = __toESM(require("typescript"), 1);
-var PRELUDE_LINES = [
-  "type FormSpecPlacement =",
-  '  | "class"',
-  '  | "class-field"',
-  '  | "class-method"',
-  '  | "interface"',
-  '  | "interface-field"',
-  '  | "type-alias"',
-  '  | "type-alias-field"',
-  '  | "variable"',
-  '  | "function"',
-  '  | "function-parameter"',
-  '  | "method-parameter";',
-  "",
-  "type FormSpecCapability =",
-  '  | "numeric-comparable"',
-  '  | "string-like"',
-  '  | "array-like"',
-  '  | "enum-member-addressable"',
-  '  | "json-like"',
-  '  | "condition-like"',
-  '  | "object-like";',
-  "",
-  "interface TagContext<P extends FormSpecPlacement, Host, Subject> {",
-  "  readonly placement: P;",
-  "  readonly hostType: Host;",
-  "  readonly subjectType: Subject;",
-  "}",
-  "",
-  "type NonNullish<T> = Exclude<T, null | undefined>;",
-  "",
-  "type ProvidesCapability<T, Capability extends FormSpecCapability> =",
-  '  Capability extends "numeric-comparable"',
-  "    ? NonNullish<T> extends number | bigint",
-  "      ? true",
-  "      : false",
-  '    : Capability extends "string-like"',
-  "      ? NonNullish<T> extends string",
-  "        ? true",
-  "        : false",
-  '      : Capability extends "array-like"',
-  "        ? NonNullish<T> extends readonly unknown[]",
-  "          ? true",
-  "          : false",
-  '        : Capability extends "enum-member-addressable"',
-  "          ? NonNullish<T> extends string",
-  "            ? true",
-  "            : false",
-  '          : Capability extends "json-like"',
-  "            ? true",
-  '            : Capability extends "condition-like"',
-  "              ? true",
-  '              : Capability extends "object-like"',
-  "                ? NonNullish<T> extends readonly unknown[]",
-  "                  ? false",
-  "                  : NonNullish<T> extends object",
-  "                    ? true",
-  "                    : false",
-  "                : false;",
-  "",
-  "type NestedPathOfCapability<Subject, Capability extends FormSpecCapability> =",
-  "  NonNullish<Subject> extends readonly (infer Item)[]",
-  "    ? NestedPathOfCapability<Item, Capability>",
-  "    : NonNullish<Subject> extends object",
-  "      ? {",
-  "          [Key in Extract<keyof NonNullish<Subject>, string>]:",
-  "            | (ProvidesCapability<NonNullish<Subject>[Key], Capability> extends true ? Key : never)",
-  "            | (NestedPathOfCapability<NonNullish<Subject>[Key], Capability> extends never",
-  "                ? never",
-  "                : `${Key}.${NestedPathOfCapability<NonNullish<Subject>[Key], Capability>}`);",
-  "        }[Extract<keyof NonNullish<Subject>, string>]",
-  "      : never;",
-  "",
-  "type PathOfCapability<Subject, Capability extends FormSpecCapability> =",
-  "  NestedPathOfCapability<Subject, Capability>;",
-  "",
-  "type MemberTarget<Subject> = Extract<keyof NonNullish<Subject>, string>;",
-  "",
-  'type VariantTarget<Subject> = "singular" | "plural";',
-  "",
-  "type FormSpecCondition = unknown;",
-  "type JsonValue = unknown;",
-  "",
-  "declare function __ctx<P extends FormSpecPlacement, Host, Subject>(): TagContext<P, Host, Subject>;",
-  "declare function __path<Subject, Capability extends FormSpecCapability>(",
-  "  path: PathOfCapability<Subject, Capability>",
-  "): PathOfCapability<Subject, Capability>;",
-  "declare function __member<Subject>(member: MemberTarget<Subject>): MemberTarget<Subject>;",
-  "declare function __variant<Subject>(variant: VariantTarget<Subject>): VariantTarget<Subject>;"
-];
-function placementUnion(placements) {
-  return placements.map((placement) => JSON.stringify(placement)).join(" | ");
-}
-function renderValueType(valueKind) {
-  switch (valueKind) {
-    case "number":
-    case "integer":
-    case "signedInteger":
-      return "number";
-    case "string":
-      return "string";
-    case "json":
-      return "JsonValue";
-    case "boolean":
-      return "boolean";
-    case "condition":
-      return "FormSpecCondition";
-    case void 0:
-      return "unknown";
-    default: {
-      const exhaustive = valueKind;
-      return exhaustive;
-    }
-  }
-}
-function renderTargetParameterType(parameter) {
-  switch (parameter.kind) {
-    case "target-path":
-      return parameter.capability === void 0 ? "PathOfCapability<Subject, FormSpecCapability>" : `PathOfCapability<Subject, ${JSON.stringify(parameter.capability)}>`;
-    case "target-member":
-      return "MemberTarget<Subject>";
-    case "target-variant":
-      return "VariantTarget<Subject>";
-    case "value":
-      return renderValueType(parameter.valueKind);
-    default: {
-      const exhaustive = parameter.kind;
-      return exhaustive;
-    }
-  }
-}
-function renderSignature(tagName, signature) {
-  const parameters = signature.parameters.map((parameter, index) => {
-    const name = parameter.kind === "value" ? "value" : `target${String(index)}`;
-    return `${name}: ${renderTargetParameterType(parameter)}`;
-  });
-  return [
-    `  function ${getSyntheticTagHelperName(tagName)}<Host, Subject>(`,
-    `    ctx: TagContext<${placementUnion(signature.placements)}, Host, Subject>${parameters.length > 0 ? "," : ""}`,
-    ...parameters.map(
-      (parameter, index) => `    ${parameter}${index === parameters.length - 1 ? "" : ","}`
-    ),
-    "  ): void;"
-  ].join("\n");
-}
-function getSyntheticTagHelperName(tagName) {
-  return `tag_${tagName}`;
-}
-function targetKindForParameter(parameter) {
-  switch (parameter.kind) {
-    case "target-path":
-      return "path";
-    case "target-member":
-      return "member";
-    case "target-variant":
-      return "variant";
-    case "value":
-      return null;
-    default: {
-      const exhaustive = parameter.kind;
-      return exhaustive;
-    }
-  }
-}
-function getSignatureTargetKind(signature) {
-  for (const parameter of signature.parameters) {
-    const targetKind = targetKindForParameter(parameter);
-    if (targetKind !== null) {
-      return targetKind;
-    }
-  }
-  return null;
-}
-function getTargetParameter(signature) {
-  return signature.parameters.find(
-    (parameter) => parameter.kind !== "value"
-  ) ?? null;
-}
-function getPathTargetCapability(signature) {
-  const parameter = getTargetParameter(signature);
-  if (parameter?.kind !== "target-path") {
-    throw new Error(`Invariant violation: expected a path-target synthetic signature`);
-  }
-  if (parameter.capability === void 0) {
-    throw new Error(
-      `Invariant violation: path-target synthetic signatures must declare a capability`
-    );
-  }
-  return JSON.stringify(parameter.capability);
-}
-function renderTargetArgument(target, signature, subjectType) {
-  switch (target.kind) {
-    case "path":
-      return `__path<${subjectType}, ${getPathTargetCapability(signature)}>(${JSON.stringify(
-        target.text
-      )})`;
-    case "member":
-      return `__member<${subjectType}>(${JSON.stringify(target.text)})`;
-    case "variant":
-      return `__variant<${subjectType}>(${JSON.stringify(target.text)})`;
-  }
-}
-function getMatchingTagSignatures(definition, placement, targetKind) {
-  return definition.signatures.filter(
-    (signature) => signature.placements.includes(placement) && getSignatureTargetKind(signature) === targetKind
-  );
-}
-function buildSyntheticHelperPrelude(extensions) {
-  const lines = [...PRELUDE_LINES, "", "declare namespace __formspec {"];
-  for (const definition of getAllTagDefinitions(extensions)) {
-    for (const signature of definition.signatures) {
-      lines.push(renderSignature(definition.canonicalName, signature));
-    }
-  }
-  lines.push("}");
-  return lines.join("\n");
-}
-function lowerTagApplicationToSyntheticCall(options) {
-  const definition = getTagDefinition(options.tagName, options.extensions);
-  if (definition === null) {
-    throw new Error(`Unknown FormSpec tag: ${options.tagName}`);
-  }
-  const targetKind = options.target?.kind ?? null;
-  const matchingSignatures = getMatchingTagSignatures(definition, options.placement, targetKind);
-  if (matchingSignatures.length === 0) {
-    throw new Error(
-      `No synthetic signature for @${definition.canonicalName} on placement "${options.placement}"` + (targetKind === null ? "" : ` with target kind "${targetKind}"`)
-    );
-  }
-  const args = [
-    `__ctx<${JSON.stringify(options.placement)}, ${options.hostType}, ${options.subjectType}>()`
-  ];
-  const signature = matchingSignatures[0];
-  if (signature === void 0) {
-    throw new Error(
-      `Invariant violation: missing synthetic signature for @${definition.canonicalName}`
-    );
-  }
-  if (options.target !== void 0 && options.target !== null) {
-    args.push(renderTargetArgument(options.target, signature, options.subjectType));
-  }
-  if (options.argumentExpression !== void 0 && options.argumentExpression !== null) {
-    args.push(options.argumentExpression);
-  }
-  return {
-    definition,
-    matchingSignatures,
-    callExpression: `__formspec.${getSyntheticTagHelperName(definition.canonicalName)}(${args.join(", ")});`
-  };
-}
-function createSyntheticCompilerHost(fileName, sourceText, compilerOptions) {
-  const host = ts2.createCompilerHost(compilerOptions, true);
-  const originalGetSourceFile = host.getSourceFile.bind(host);
-  host.getSourceFile = (requestedFileName, languageVersion, onError, shouldCreateNewSourceFile) => {
-    if (requestedFileName === fileName) {
-      return ts2.createSourceFile(requestedFileName, sourceText, languageVersion, true);
-    }
-    return originalGetSourceFile(
-      requestedFileName,
-      languageVersion,
-      onError,
-      shouldCreateNewSourceFile
-    );
-  };
-  host.readFile = (requestedFileName) => {
-    if (requestedFileName === fileName) {
-      return sourceText;
-    }
-    return ts2.sys.readFile(requestedFileName);
-  };
-  host.fileExists = (requestedFileName) => requestedFileName === fileName || ts2.sys.fileExists(requestedFileName);
-  host.writeFile = () => void 0;
-  return host;
-}
-function flattenDiagnosticMessage(message) {
-  return ts2.flattenDiagnosticMessageText(message, "\n");
-}
-var syntheticCheckCache = /* @__PURE__ */ new Map();
-function checkSyntheticTagApplication(options) {
-  const lowered = lowerTagApplicationToSyntheticCall(options);
-  const sourceText = [
-    buildSyntheticHelperPrelude(options.extensions),
-    "",
-    ...options.supportingDeclarations ?? [],
-    "",
-    lowered.callExpression
-  ].join("\n");
-  const cached = syntheticCheckCache.get(sourceText);
-  if (cached !== void 0) {
-    return cached;
-  }
-  const fileName = "/virtual/formspec-synthetic.ts";
-  const compilerOptions = {
-    strict: true,
-    noEmit: true,
-    target: ts2.ScriptTarget.ES2022,
-    module: ts2.ModuleKind.ESNext,
-    lib: ["lib.es2022.d.ts"]
-  };
-  const host = createSyntheticCompilerHost(fileName, sourceText, compilerOptions);
-  const program = ts2.createProgram([fileName], compilerOptions, host);
-  const diagnostics = ts2.getPreEmitDiagnostics(program).filter((diagnostic) => diagnostic.file === void 0 || diagnostic.file.fileName === fileName).map((diagnostic) => ({
-    code: diagnostic.code,
-    message: flattenDiagnosticMessage(diagnostic.messageText)
-  }));
-  const result = {
-    sourceText,
-    diagnostics
-  };
-  syntheticCheckCache.set(sourceText, result);
-  return result;
-}
-
-// src/source-bindings.ts
-var ts3 = __toESM(require("typescript"), 1);
-function getLastLeadingDocCommentRange(node, sourceFile) {
-  const ranges = ts3.getLeadingCommentRanges(sourceFile.text, node.getFullStart()) ?? [];
-  const docRanges = ranges.filter(
-    (range) => sourceFile.text.slice(range.pos, range.end).startsWith("/**")
-  );
-  return docRanges.length === 0 ? null : docRanges[docRanges.length - 1] ?? null;
-}
-function getSubjectType(node, checker) {
-  if (ts3.isClassDeclaration(node) || ts3.isInterfaceDeclaration(node) || ts3.isTypeAliasDeclaration(node) || ts3.isPropertyDeclaration(node) || ts3.isPropertySignature(node) || ts3.isMethodDeclaration(node) || ts3.isFunctionDeclaration(node) || ts3.isVariableDeclaration(node) || ts3.isParameter(node)) {
-    return checker.getTypeAtLocation(node);
-  }
-  return void 0;
-}
-function getHostType(node, checker) {
-  const parent = node.parent;
-  if (ts3.isClassDeclaration(parent) || ts3.isInterfaceDeclaration(parent) || ts3.isTypeLiteralNode(parent) || ts3.isTypeAliasDeclaration(parent)) {
-    return checker.getTypeAtLocation(parent);
-  }
-  return getSubjectType(node, checker);
-}
-function findDeclarationForCommentOffset(sourceFile, offset) {
-  let bestMatch = null;
-  const visit = (node) => {
-    if (resolveDeclarationPlacement(node) !== null) {
-      const range = getLastLeadingDocCommentRange(node, sourceFile);
-      if (range !== null && offset >= range.pos && offset <= range.end) {
-        if (bestMatch === null || node.getWidth(sourceFile) < bestMatch.getWidth(sourceFile)) {
-          bestMatch = node;
-        }
-      }
-    }
-    ts3.forEachChild(node, visit);
-  };
-  visit(sourceFile);
-  return bestMatch;
-}
-
-// src/semantic-protocol.ts
-var FORMSPEC_ANALYSIS_PROTOCOL_VERSION = 1;
-var FORMSPEC_ANALYSIS_SCHEMA_VERSION = 1;
-function isObjectRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isCommentSpan(value) {
-  if (!isObjectRecord(value)) {
-    return false;
-  }
-  const candidate = value;
-  return typeof candidate.start === "number" && typeof candidate.end === "number";
-}
-function isStringArray(value) {
-  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
-}
-function isPlacementArray(value) {
-  return isStringArray(value);
-}
-function isTargetKindArray(value) {
-  return isStringArray(value);
-}
-function isIpcEndpoint(value) {
-  if (!isObjectRecord(value)) {
-    return false;
-  }
-  const candidate = value;
-  return (candidate.kind === "unix-socket" || candidate.kind === "windows-pipe") && typeof candidate.address === "string";
-}
-function isSerializedTagDefinition(value) {
-  if (!isObjectRecord(value)) {
-    return false;
-  }
-  const candidate = value;
-  return typeof candidate.canonicalName === "string" && typeof candidate.completionDetail === "string" && typeof candidate.hoverMarkdown === "string";
-}
-function isSerializedTagSignature(value) {
-  if (!isObjectRecord(value)) {
-    return false;
-  }
-  const candidate = value;
-  return typeof candidate.label === "string" && isPlacementArray(candidate.placements);
-}
-function isSerializedCommentTargetSpecifier(value) {
-  if (!isObjectRecord(value)) {
-    return false;
-  }
-  const candidate = value;
-  return typeof candidate.rawText === "string" && typeof candidate.valid === "boolean" && typeof candidate.kind === "string" && isCommentSpan(candidate.fullSpan) && isCommentSpan(candidate.colonSpan) && isCommentSpan(candidate.span);
-}
-function isSerializedTagSemanticContext(value) {
-  if (!isObjectRecord(value)) {
-    return false;
-  }
-  const candidate = value;
-  return typeof candidate.tagName === "string" && (candidate.tagDefinition === null || isSerializedTagDefinition(candidate.tagDefinition)) && (candidate.placement === null || typeof candidate.placement === "string") && isTargetKindArray(candidate.supportedTargets) && isStringArray(candidate.targetCompletions) && isStringArray(candidate.compatiblePathTargets) && isStringArray(candidate.valueLabels) && Array.isArray(candidate.signatures) && candidate.signatures.every(isSerializedTagSignature) && (candidate.tagHoverMarkdown === null || typeof candidate.tagHoverMarkdown === "string") && (candidate.targetHoverMarkdown === null || typeof candidate.targetHoverMarkdown === "string") && (candidate.argumentHoverMarkdown === null || typeof candidate.argumentHoverMarkdown === "string");
-}
-function isSerializedCompletionContext(value) {
-  if (!isObjectRecord(value)) {
-    return false;
-  }
-  const candidate = value;
-  if (typeof candidate.kind !== "string") {
-    return false;
-  }
-  switch (candidate.kind) {
-    case "tag-name":
-      return typeof candidate.prefix === "string" && Array.isArray(candidate.availableTags) ? candidate.availableTags.every(isSerializedTagDefinition) : false;
-    case "target":
-      return isSerializedTagSemanticContext(candidate.semantic);
-    case "argument":
-      return isSerializedTagSemanticContext(candidate.semantic) && isStringArray(candidate.valueLabels);
-    case "none":
-      return true;
-    default:
-      return false;
-  }
-}
-function isSerializedHoverInfo(value) {
-  if (!isObjectRecord(value)) {
-    return false;
-  }
-  const candidate = value;
-  return (candidate.kind === "tag-name" || candidate.kind === "target" || candidate.kind === "argument") && typeof candidate.markdown === "string";
-}
-function hasCurrentProtocolVersion(value) {
-  return isObjectRecord(value) && value["protocolVersion"] === FORMSPEC_ANALYSIS_PROTOCOL_VERSION;
-}
-function isAnalysisDiagnostic(value) {
-  if (!isObjectRecord(value)) {
-    return false;
-  }
-  const candidate = value;
-  return typeof candidate.code === "string" && typeof candidate.message === "string" && isCommentSpan(candidate.range) && (candidate.severity === "error" || candidate.severity === "warning" || candidate.severity === "info");
-}
-function isAnalysisTagSnapshot(value) {
-  if (!isObjectRecord(value)) {
-    return false;
-  }
-  const candidate = value;
-  return typeof candidate.rawTagName === "string" && typeof candidate.normalizedTagName === "string" && typeof candidate.recognized === "boolean" && isCommentSpan(candidate.fullSpan) && isCommentSpan(candidate.tagNameSpan) && (candidate.payloadSpan === null || isCommentSpan(candidate.payloadSpan)) && (candidate.target === null || isSerializedCommentTargetSpecifier(candidate.target)) && (candidate.argumentSpan === null || isCommentSpan(candidate.argumentSpan)) && typeof candidate.argumentText === "string" && isSerializedTagSemanticContext(candidate.semantic);
-}
-function isAnalysisCommentSnapshot(value) {
-  if (!isObjectRecord(value)) {
-    return false;
-  }
-  const candidate = value;
-  return isCommentSpan(candidate.commentSpan) && isCommentSpan(candidate.declarationSpan) && (candidate.placement === null || typeof candidate.placement === "string") && (candidate.subjectType === null || typeof candidate.subjectType === "string") && (candidate.hostType === null || typeof candidate.hostType === "string") && Array.isArray(candidate.tags) && candidate.tags.every(isAnalysisTagSnapshot);
-}
-function isAnalysisFileSnapshot(value) {
-  if (!isObjectRecord(value)) {
-    return false;
-  }
-  const candidate = value;
-  return typeof candidate.filePath === "string" && typeof candidate.sourceHash === "string" && typeof candidate.generatedAt === "string" && Array.isArray(candidate.comments) && candidate.comments.every(isAnalysisCommentSnapshot) && Array.isArray(candidate.diagnostics) && candidate.diagnostics.every(isAnalysisDiagnostic);
-}
-function isFormSpecAnalysisManifest(value) {
-  if (!isObjectRecord(value)) {
-    return false;
-  }
-  const candidate = value;
-  return candidate.protocolVersion === FORMSPEC_ANALYSIS_PROTOCOL_VERSION && candidate.analysisSchemaVersion === FORMSPEC_ANALYSIS_SCHEMA_VERSION && typeof candidate.workspaceRoot === "string" && typeof candidate.workspaceId === "string" && isIpcEndpoint(candidate.endpoint) && typeof candidate.typescriptVersion === "string" && typeof candidate.extensionFingerprint === "string" && typeof candidate.generation === "number" && typeof candidate.updatedAt === "string";
-}
-function isFormSpecSemanticQuery(value) {
-  if (!hasCurrentProtocolVersion(value)) {
-    return false;
-  }
-  const candidate = value;
-  if (typeof candidate.kind !== "string") {
-    return false;
-  }
-  switch (candidate.kind) {
-    case "health":
-      return true;
-    case "completion":
-    case "hover":
-      return typeof candidate.filePath === "string" && typeof candidate.offset === "number";
-    case "diagnostics":
-    case "file-snapshot":
-      return typeof candidate.filePath === "string";
-    default:
-      return false;
-  }
-}
-function isFormSpecSemanticResponse(value) {
-  if (!hasCurrentProtocolVersion(value)) {
-    return false;
-  }
-  const candidate = value;
-  if (typeof candidate.kind !== "string") {
-    return false;
-  }
-  switch (candidate.kind) {
-    case "health":
-      return isFormSpecAnalysisManifest(candidate.manifest);
-    case "completion":
-      return typeof candidate.sourceHash === "string" && isSerializedCompletionContext(candidate.context);
-    case "hover":
-      return typeof candidate.sourceHash === "string" && (candidate.hover === null || isSerializedHoverInfo(candidate.hover));
-    case "diagnostics":
-      return typeof candidate.sourceHash === "string" && Array.isArray(candidate.diagnostics) && candidate.diagnostics.every(isAnalysisDiagnostic);
-    case "file-snapshot":
-      return candidate.snapshot === null || isAnalysisFileSnapshot(candidate.snapshot);
-    case "error":
-      return typeof candidate.error === "string";
-    default:
-      return false;
-  }
-}
-function computeFormSpecTextHash(text) {
-  let hash = 2166136261;
-  for (let index = 0; index < text.length; index += 1) {
-    hash ^= text.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}
-function serializeCommentTargetSpecifier(target) {
-  if (target === null) {
-    return null;
-  }
-  return {
-    rawText: target.rawText,
-    valid: target.valid,
-    kind: target.kind,
-    fullSpan: target.fullSpan,
-    colonSpan: target.colonSpan,
-    span: target.span
+    rawText: target.rawText,
+    valid: target.valid,
+    kind: target.kind,
+    fullSpan: target.fullSpan,
+    colonSpan: target.colonSpan,
+    span: target.span
   };
 }
 function serializeCommentTagSemanticContext(semantic) {
@@ -3283,233 +920,6 @@ function serializeParsedCommentTag(tag, semantic) {
   };
 }
 
-// src/file-snapshots.ts
-function spanFromPos(start, end) {
-  return { start, end };
-}
-function typeToString(type, checker) {
-  if (type === void 0) {
-    return null;
-  }
-  return checker.typeToString(type, void 0, ts4.TypeFormatFlags.NoTruncation);
-}
-function supportingDeclarationsForType(type) {
-  if (type === void 0) {
-    return [];
-  }
-  const symbol = type.aliasSymbol ?? type.getSymbol();
-  const declarations = symbol?.declarations ?? [];
-  return declarations.map(
-    (declaration) => declaration.getSourceFile().text.slice(declaration.getFullStart(), declaration.getEnd())
-  ).filter((declarationText) => declarationText.trim().length > 0);
-}
-function getSyntheticTargetForTag(tag) {
-  if (tag.target === null) {
-    return null;
-  }
-  switch (tag.target.kind) {
-    case "path":
-    case "member":
-    case "variant":
-      return {
-        kind: tag.target.kind,
-        text: tag.target.rawText
-      };
-    case "ambiguous":
-      return {
-        kind: "path",
-        text: tag.target.rawText
-      };
-    default: {
-      const exhaustive = tag.target.kind;
-      return exhaustive;
-    }
-  }
-}
-function getArgumentExpression(argumentText, valueLabels, capabilityTargets) {
-  const trimmed = argumentText.trim();
-  if (trimmed === "") {
-    return null;
-  }
-  if (valueLabels.some((label) => label.includes("number") || label.includes("integer"))) {
-    return trimmed;
-  }
-  if (valueLabels.some((label) => label.includes("boolean"))) {
-    return trimmed === "true" || trimmed === "false" ? trimmed : null;
-  }
-  if (valueLabels.some((label) => label.includes("json"))) {
-    try {
-      return JSON.stringify(JSON.parse(trimmed));
-    } catch {
-      return null;
-    }
-  }
-  if (valueLabels.some((label) => label.includes("condition"))) {
-    return "undefined as unknown as FormSpecCondition";
-  }
-  if (capabilityTargets.length > 0 || valueLabels.some((label) => label.includes("string"))) {
-    return JSON.stringify(trimmed);
-  }
-  return JSON.stringify(trimmed);
-}
-function diagnosticSeverity(code) {
-  switch (code) {
-    case "INVALID_TAG_ARGUMENT":
-    case "INVALID_TAG_PLACEMENT":
-    case "TYPE_MISMATCH":
-    case "UNKNOWN_PATH_TARGET":
-      return "error";
-    default:
-      return "warning";
-  }
-}
-function buildTagDiagnostics(sourceFile, checker, placement, hostType, subjectType, commentTags, semanticOptions) {
-  if (placement === null || subjectType === void 0) {
-    return [];
-  }
-  const diagnostics = [];
-  const hostTypeText = typeToString(hostType, checker) ?? "unknown";
-  const subjectTypeText = typeToString(subjectType, checker) ?? "unknown";
-  const supportingDeclarations = [
-    ...supportingDeclarationsForType(hostType),
-    ...supportingDeclarationsForType(subjectType)
-  ];
-  for (const tag of commentTags) {
-    const semantic = getCommentTagSemanticContext(tag, semanticOptions);
-    if (semantic.tagDefinition === null) {
-      continue;
-    }
-    const target = getSyntheticTargetForTag(tag);
-    const argumentExpression = getArgumentExpression(
-      tag.argumentText,
-      semantic.valueLabels,
-      semantic.compatiblePathTargets
-    );
-    try {
-      const result = checkSyntheticTagApplication({
-        tagName: tag.normalizedTagName,
-        placement,
-        hostType: hostTypeText,
-        subjectType: subjectTypeText,
-        supportingDeclarations,
-        ...target === null ? {} : { target },
-        ...argumentExpression === null ? {} : { argumentExpression },
-        ...semanticOptions.extensions === void 0 ? {} : { extensions: semanticOptions.extensions }
-      });
-      for (const diagnostic of result.diagnostics) {
-        const code = target !== null && diagnostic.message.includes("not assignable") ? target.kind === "path" ? "UNKNOWN_PATH_TARGET" : "TYPE_MISMATCH" : diagnostic.message.includes("Expected") ? "INVALID_TAG_ARGUMENT" : diagnostic.message.includes("No overload") ? "INVALID_TAG_PLACEMENT" : "TYPE_MISMATCH";
-        diagnostics.push({
-          code,
-          message: diagnostic.message,
-          range: tag.fullSpan,
-          severity: diagnosticSeverity(code)
-        });
-      }
-    } catch (error) {
-      diagnostics.push({
-        code: "INVALID_TAG_PLACEMENT",
-        message: error instanceof Error ? error.message : String(error),
-        range: tag.fullSpan,
-        severity: "error"
-      });
-    }
-  }
-  return diagnostics;
-}
-function buildCommentSnapshot(node, sourceFile, checker, extensions) {
-  const docComment = getLastLeadingDocCommentRange(node, sourceFile);
-  if (docComment === null) {
-    return null;
-  }
-  const commentText = sourceFile.text.slice(docComment.pos, docComment.end);
-  const parsed = parseCommentBlock(commentText, {
-    offset: docComment.pos,
-    ...extensions === void 0 ? {} : { extensions }
-  });
-  if (parsed.tags.length === 0) {
-    return null;
-  }
-  const placement = resolveDeclarationPlacement(node);
-  const subjectType = getSubjectType(node, checker);
-  const hostType = getHostType(node, checker);
-  const semanticOptions = {
-    checker,
-    ...subjectType === void 0 ? {} : { subjectType },
-    ...placement === null ? {} : { placement },
-    ...extensions === void 0 ? {} : { extensions }
-  };
-  const tags = parsed.tags.map(
-    (tag) => serializeParsedCommentTag(tag, getCommentTagSemanticContext(tag, semanticOptions))
-  );
-  return {
-    commentSpan: spanFromPos(docComment.pos, docComment.end),
-    declarationSpan: spanFromPos(node.getStart(sourceFile), node.getEnd()),
-    placement,
-    subjectType: typeToString(subjectType, checker),
-    hostType: typeToString(hostType, checker),
-    tags
-  };
-}
-function buildFormSpecAnalysisFileSnapshot(sourceFile, options) {
-  const comments = [];
-  const diagnostics = [];
-  const visit = (node) => {
-    const placement = resolveDeclarationPlacement(node);
-    if (placement !== null) {
-      const snapshot = buildCommentSnapshot(node, sourceFile, options.checker, options.extensions);
-      if (snapshot !== null) {
-        comments.push(snapshot);
-        const subjectType = getSubjectType(node, options.checker);
-        const hostType = getHostType(node, options.checker);
-        diagnostics.push(
-          ...buildTagDiagnostics(
-            sourceFile,
-            options.checker,
-            placement,
-            hostType,
-            subjectType,
-            snapshot.tags.map((tag) => ({
-              rawTagName: tag.rawTagName,
-              normalizedTagName: tag.normalizedTagName,
-              recognized: tag.recognized,
-              fullSpan: tag.fullSpan,
-              tagNameSpan: tag.tagNameSpan,
-              payloadSpan: tag.payloadSpan,
-              colonSpan: tag.target?.colonSpan ?? null,
-              target: tag.target === null ? null : {
-                rawText: tag.target.rawText,
-                valid: tag.target.valid,
-                kind: tag.target.kind,
-                fullSpan: tag.target.fullSpan,
-                colonSpan: tag.target.colonSpan,
-                span: tag.target.span,
-                path: null
-              },
-              argumentSpan: tag.argumentSpan,
-              argumentText: tag.argumentText
-            })),
-            {
-              checker: options.checker,
-              ...subjectType === void 0 ? {} : { subjectType },
-              placement,
-              ...options.extensions === void 0 ? {} : { extensions: options.extensions }
-            }
-          )
-        );
-      }
-    }
-    ts4.forEachChild(node, visit);
-  };
-  visit(sourceFile);
-  return {
-    filePath: sourceFile.fileName,
-    sourceHash: computeFormSpecTextHash(sourceFile.text),
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    comments,
-    diagnostics
-  };
-}
-
 // src/workspace-runtime.ts
 var import_node_path = __toESM(require("path"), 1);
 function getFormSpecWorkspaceId(workspaceRoot) {
@@ -3525,58 +935,17 @@ function getFormSpecManifestPath(workspaceRoot) {
 0 && (module.exports = {
   FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
   FORMSPEC_ANALYSIS_SCHEMA_VERSION,
-  analyzeConstraintTargets,
-  buildConstraintTargetStates,
-  buildFormSpecAnalysisFileSnapshot,
-  buildSyntheticHelperPrelude,
-  checkSyntheticTagApplication,
-  collectCompatiblePathTargets,
-  collectReferencedTypeAnnotations,
-  collectReferencedTypeConstraints,
   computeFormSpecTextHash,
-  dereferenceAnalysisType,
-  extractPathTarget,
-  findCommentTagAtOffset,
-  findDeclarationForCommentOffset,
-  findEnclosingDocComment,
-  formatConstraintTargetName,
-  formatPathTarget,
-  getAllTagDefinitions,
-  getCommentCompletionContextAtOffset,
-  getCommentCursorTargetAtOffset,
-  getCommentHoverInfoAtOffset,
-  getCommentTagSemanticContext,
-  getConstraintTagDefinitions,
   getFormSpecManifestPath,
   getFormSpecWorkspaceId,
   getFormSpecWorkspaceRuntimeDirectory,
-  getHostType,
-  getLastLeadingDocCommentRange,
-  getMatchingTagSignatures,
-  getSemanticCommentCompletionContextAtOffset,
-  getSubjectType,
-  getTagCompletionPrefixAtOffset,
-  getTagDefinition,
-  getTagHoverMarkdown,
-  getTypeSemanticCapabilities,
-  hasTypeSemanticCapability,
   isFormSpecAnalysisManifest,
   isFormSpecSemanticQuery,
   isFormSpecSemanticResponse,
-  lowerTagApplicationToSyntheticCall,
-  normalizeFormSpecTagName,
-  parseCommentBlock,
-  parseConstraintTagValue,
-  parseDefaultValueTagValue,
-  parseTagSyntax,
-  resolveConstraintTargetState,
-  resolveDeclarationPlacement,
-  resolvePathTargetType,
   serializeCommentTagSemanticContext,
   serializeCommentTargetSpecifier,
   serializeCompletionContext,
   serializeHoverInfo,
-  serializeParsedCommentTag,
-  sliceCommentSpan
+  serializeParsedCommentTag
 });
 //# sourceMappingURL=index.cjs.map