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

package/dist/internal.js

@@ -0,0 +1,3902 @@
+// 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
+import {
+  BUILTIN_CONSTRAINT_DEFINITIONS,
+  normalizeConstraintTagName
+} from "@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",
+  "type-alias-field",
+  "variable",
+  "function-parameter",
+  "method-parameter"
+];
+var TYPE_PLACEMENTS = [
+  "class",
+  "interface",
+  "type-alias"
+];
+var DECLARATION_PLACEMENTS = [
+  "class-method",
+  "function"
+];
+var ALL_PLACEMENTS = [
+  ...TYPE_PLACEMENTS,
+  ...FIELD_PLACEMENTS,
+  ...DECLARATION_PLACEMENTS
+];
+var INTEGER_VALUE_TAGS = /* @__PURE__ */ new Set(["minLength", "maxLength", "minItems", "maxItems"]);
+var SIGNED_INTEGER_VALUE_TAGS = /* @__PURE__ */ new Set(["order"]);
+var JSON_VALUE_TAGS = /* @__PURE__ */ new Set(["const", "enumOptions"]);
+var BOOLEAN_VALUE_TAGS = /* @__PURE__ */ new Set(["uniqueItems"]);
+var STRING_VALUE_TAGS = /* @__PURE__ */ new Set([
+  "pattern",
+  "displayName",
+  "description",
+  "format",
+  "placeholder",
+  "group",
+  "example",
+  "remarks",
+  "see",
+  "apiName"
+]);
+var CONDITION_VALUE_TAGS = /* @__PURE__ */ new Set(["showWhen", "hideWhen", "enableWhen", "disableWhen"]);
+var CONSTRAINT_COMPLETION_DETAIL = {
+  minimum: "Minimum numeric value (inclusive). Example: `@minimum 0`",
+  maximum: "Maximum numeric value (inclusive). Example: `@maximum 100`",
+  exclusiveMinimum: "Minimum numeric value (exclusive). Example: `@exclusiveMinimum 0`",
+  exclusiveMaximum: "Maximum numeric value (exclusive). Example: `@exclusiveMaximum 100`",
+  multipleOf: "Value must be a multiple of this number. Example: `@multipleOf 0.01`",
+  minLength: "Minimum string length. Example: `@minLength 1`",
+  maxLength: "Maximum string length. Example: `@maxLength 255`",
+  minItems: "Minimum number of array items. Example: `@minItems 1`",
+  maxItems: "Maximum number of array items. Example: `@maxItems 10`",
+  uniqueItems: "Require all array items to be distinct. Example: `@uniqueItems`",
+  pattern: "Regular expression pattern for string validation. Example: `@pattern ^[a-z]+$`",
+  enumOptions: 'Inline JSON array of allowed enum values. Example: `@enumOptions ["a","b","c"]`',
+  const: 'Require a constant JSON value. Example: `@const "USD"`'
+};
+var CONSTRAINT_HOVER_DOCS = {
+  minimum: [
+    "**@minimum** `<number>`",
+    "",
+    "Sets an inclusive lower bound on a numeric field.",
+    "",
+    "Maps to `minimum` in JSON Schema.",
+    "",
+    "**Signature:** `@minimum [:path] <number>`"
+  ].join("\n"),
+  maximum: [
+    "**@maximum** `<number>`",
+    "",
+    "Sets an inclusive upper bound on a numeric field.",
+    "",
+    "Maps to `maximum` in JSON Schema.",
+    "",
+    "**Signature:** `@maximum [:path] <number>`"
+  ].join("\n"),
+  exclusiveMinimum: [
+    "**@exclusiveMinimum** `<number>`",
+    "",
+    "Sets an exclusive lower bound on a numeric field.",
+    "",
+    "Maps to `exclusiveMinimum` in JSON Schema.",
+    "",
+    "**Signature:** `@exclusiveMinimum [:path] <number>`"
+  ].join("\n"),
+  exclusiveMaximum: [
+    "**@exclusiveMaximum** `<number>`",
+    "",
+    "Sets an exclusive upper bound on a numeric field.",
+    "",
+    "Maps to `exclusiveMaximum` in JSON Schema.",
+    "",
+    "**Signature:** `@exclusiveMaximum [:path] <number>`"
+  ].join("\n"),
+  multipleOf: [
+    "**@multipleOf** `<number>`",
+    "",
+    "Requires the numeric value to be a multiple of the given number.",
+    "",
+    "Maps to `multipleOf` in JSON Schema.",
+    "",
+    "**Signature:** `@multipleOf [:path] <number>`"
+  ].join("\n"),
+  minLength: [
+    "**@minLength** `<integer>`",
+    "",
+    "Sets a minimum character length on a string field.",
+    "",
+    "Maps to `minLength` in JSON Schema.",
+    "",
+    "**Signature:** `@minLength [:path] <integer>`"
+  ].join("\n"),
+  maxLength: [
+    "**@maxLength** `<integer>`",
+    "",
+    "Sets a maximum character length on a string field.",
+    "",
+    "Maps to `maxLength` in JSON Schema.",
+    "",
+    "**Signature:** `@maxLength [:path] <integer>`"
+  ].join("\n"),
+  minItems: [
+    "**@minItems** `<integer>`",
+    "",
+    "Sets a minimum number of items in an array field.",
+    "",
+    "Maps to `minItems` in JSON Schema.",
+    "",
+    "**Signature:** `@minItems [:path] <integer>`"
+  ].join("\n"),
+  maxItems: [
+    "**@maxItems** `<integer>`",
+    "",
+    "Sets a maximum number of items in an array field.",
+    "",
+    "Maps to `maxItems` in JSON Schema.",
+    "",
+    "**Signature:** `@maxItems [:path] <integer>`"
+  ].join("\n"),
+  uniqueItems: [
+    "**@uniqueItems**",
+    "",
+    "Requires all items in an array field to be distinct.",
+    "",
+    "Maps to `uniqueItems` in JSON Schema.",
+    "",
+    "**Signature:** `@uniqueItems [:path]`"
+  ].join("\n"),
+  pattern: [
+    "**@pattern** `<regex>`",
+    "",
+    "Sets a regular expression pattern that a string field must match.",
+    "",
+    "Maps to `pattern` in JSON Schema.",
+    "",
+    "**Signature:** `@pattern [:path] <regex>`"
+  ].join("\n"),
+  enumOptions: [
+    "**@enumOptions** `<json-array>`",
+    "",
+    "Specifies the allowed values for an enum field as an inline JSON array.",
+    "",
+    "Maps to `enum` in JSON Schema.",
+    "",
+    "**Signature:** `@enumOptions <json-array>`"
+  ].join("\n"),
+  const: [
+    "**@const** `<json-literal>`",
+    "",
+    "Requires the field value to equal a single constant JSON value.",
+    "",
+    "Maps to `const` in JSON Schema.",
+    "",
+    "**Signature:** `@const [:path] <json-literal>`"
+  ].join("\n")
+};
+function inferValueKind(name) {
+  if (INTEGER_VALUE_TAGS.has(name)) return "integer";
+  if (SIGNED_INTEGER_VALUE_TAGS.has(name)) return "signedInteger";
+  if (JSON_VALUE_TAGS.has(name)) return "json";
+  if (BOOLEAN_VALUE_TAGS.has(name)) return "boolean";
+  if (STRING_VALUE_TAGS.has(name)) return "string";
+  if (CONDITION_VALUE_TAGS.has(name)) return "condition";
+  return null;
+}
+function getBuiltinValueKind(name) {
+  return inferValueKind(name) ?? "number";
+}
+function getBuiltinConstraintCapability(name) {
+  switch (name) {
+    case "minimum":
+    case "maximum":
+    case "exclusiveMinimum":
+    case "exclusiveMaximum":
+    case "multipleOf":
+      return "numeric-comparable";
+    case "minLength":
+    case "maxLength":
+    case "pattern":
+      return "string-like";
+    case "minItems":
+    case "maxItems":
+    case "uniqueItems":
+      return "array-like";
+    case "enumOptions":
+      return "enum-member-addressable";
+    case "const":
+      return "json-like";
+    default: {
+      const exhaustive = name;
+      return exhaustive;
+    }
+  }
+}
+function capabilitiesForValueKind(valueKind) {
+  switch (valueKind) {
+    case "number":
+    case "integer":
+    case "signedInteger":
+      return ["numeric-comparable"];
+    case "string":
+      return ["string-like"];
+    case "json":
+      return ["json-like"];
+    case "condition":
+      return ["condition-like"];
+    case "boolean":
+    case null:
+      return [];
+    default: {
+      const exhaustive = valueKind;
+      return exhaustive;
+    }
+  }
+}
+function valueLabelForKind(valueKind, fallback = "<value>") {
+  switch (valueKind) {
+    case "number":
+      return "<number>";
+    case "integer":
+    case "signedInteger":
+      return "<integer>";
+    case "string":
+      return "<text>";
+    case "json":
+      return "<json>";
+    case "condition":
+      return "<condition>";
+    case "boolean":
+    case null:
+      return "";
+    default: {
+      const exhaustive = valueKind;
+      void exhaustive;
+      return fallback;
+    }
+  }
+}
+function targetLabelForKind(kind) {
+  switch (kind) {
+    case "path":
+      return "[:path]";
+    case "member":
+      return ":member";
+    case "variant":
+      return ":variant";
+    default: {
+      const exhaustive = kind;
+      return exhaustive;
+    }
+  }
+}
+function parameterKindForTarget(targetKind) {
+  switch (targetKind) {
+    case "path":
+      return "target-path";
+    case "member":
+      return "target-member";
+    case "variant":
+      return "target-variant";
+    default: {
+      const exhaustive = targetKind;
+      return exhaustive;
+    }
+  }
+}
+function createTargetParameter(targetKind, valueKind, pathCapability) {
+  const base = {
+    kind: parameterKindForTarget(targetKind),
+    label: targetLabelForKind(targetKind),
+    optional: targetKind === "path"
+  };
+  if (targetKind === "path") {
+    const capability = pathCapability ?? capabilitiesForValueKind(valueKind)[0];
+    return capability === void 0 ? base : { ...base, capability };
+  }
+  if (targetKind === "member") {
+    return { ...base, capability: "enum-member-addressable" };
+  }
+  return base;
+}
+function createSignature(name, placements, targetKind, valueKind, valueLabel, pathCapability) {
+  const parameters = [];
+  if (targetKind !== null) {
+    parameters.push(createTargetParameter(targetKind, valueKind, pathCapability));
+  }
+  if (valueLabel !== "") {
+    parameters.push(
+      valueKind === null ? {
+        kind: "value",
+        label: valueLabel
+      } : {
+        kind: "value",
+        label: valueLabel,
+        valueKind
+      }
+    );
+  }
+  const targetLabel = targetKind === null ? "" : ` ${targetLabelForKind(targetKind)}`;
+  const valueLabelSuffix = valueLabel === "" ? "" : ` ${valueLabel}`;
+  return {
+    label: `@${name}${targetLabel}${valueLabelSuffix}`,
+    placements,
+    parameters
+  };
+}
+function buildHoverMarkdown(name, hoverSummary, signatures, valueLabel) {
+  const header = valueLabel === "" ? `**@${name}**` : `**@${name}** \`${valueLabel}\``;
+  const signatureLines = signatures.length === 1 ? [`**Signature:** \`${signatures[0]?.label ?? `@${name}`}\``] : ["**Signatures:**", ...signatures.map((signature) => `- \`${signature.label}\``)];
+  return [header, "", hoverSummary, "", ...signatureLines].join("\n");
+}
+function makeConstraintSignatures(name) {
+  const valueKind = getBuiltinValueKind(name);
+  const subjectCapability = getBuiltinConstraintCapability(name);
+  const valueLabel = name === "pattern" ? "<regex>" : name === "enumOptions" ? "<json-array>" : name === "const" ? "<json-literal>" : valueLabelForKind(valueKind);
+  return [
+    createSignature(name, FIELD_PLACEMENTS, null, valueKind, valueLabel),
+    createSignature(name, FIELD_PLACEMENTS, "path", valueKind, valueLabel, subjectCapability)
+  ];
+}
+var BUILTIN_TAG_DEFINITIONS = Object.fromEntries(
+  Object.keys(BUILTIN_CONSTRAINT_DEFINITIONS).map((name) => {
+    const valueKind = getBuiltinValueKind(name);
+    const subjectCapability = getBuiltinConstraintCapability(name);
+    return [
+      name,
+      {
+        canonicalName: name,
+        valueKind,
+        requiresArgument: valueKind !== "boolean",
+        supportedTargets: ["none", "path"],
+        allowDuplicates: false,
+        category: "constraint",
+        placements: FIELD_PLACEMENTS,
+        capabilities: [subjectCapability],
+        completionDetail: CONSTRAINT_COMPLETION_DETAIL[name] ?? `@${name}`,
+        hoverMarkdown: CONSTRAINT_HOVER_DOCS[name] ?? `**@${name}**`,
+        signatures: makeConstraintSignatures(name)
+      }
+    ];
+  })
+);
+var EXTRA_TAG_SPECS = {
+  displayName: {
+    requiresArgument: true,
+    supportedTargets: ["none", "member", "variant"],
+    allowDuplicates: false,
+    category: "annotation",
+    placements: [...TYPE_PLACEMENTS, ...FIELD_PLACEMENTS],
+    completionDetail: "Display label for a type, field, or enum member.",
+    hoverSummary: "Provides a user-facing display label.",
+    valueLabel: "<label>",
+    targetPlacements: {
+      member: FIELD_PLACEMENTS,
+      variant: TYPE_PLACEMENTS
+    }
+  },
+  description: {
+    requiresArgument: true,
+    supportedTargets: ["none"],
+    allowDuplicates: false,
+    category: "annotation",
+    placements: [...TYPE_PLACEMENTS, ...FIELD_PLACEMENTS],
+    completionDetail: "Description text for a type or field.",
+    hoverSummary: "Provides descriptive documentation for a type or field."
+  },
+  format: {
+    requiresArgument: true,
+    supportedTargets: ["none"],
+    allowDuplicates: false,
+    category: "annotation",
+    placements: FIELD_PLACEMENTS,
+    completionDetail: "Format hint for a field.",
+    hoverSummary: "Provides a format hint for a field.",
+    valueLabel: "<format>"
+  },
+  placeholder: {
+    requiresArgument: true,
+    supportedTargets: ["none"],
+    allowDuplicates: false,
+    category: "annotation",
+    placements: FIELD_PLACEMENTS,
+    completionDetail: "Placeholder text for a field.",
+    hoverSummary: "Provides placeholder text for a field."
+  },
+  order: {
+    requiresArgument: true,
+    supportedTargets: ["none"],
+    allowDuplicates: false,
+    category: "annotation",
+    placements: FIELD_PLACEMENTS,
+    completionDetail: "Field display order hint.",
+    hoverSummary: "Provides an integer ordering hint for UI layout."
+  },
+  apiName: {
+    requiresArgument: true,
+    supportedTargets: ["none", "member", "variant"],
+    allowDuplicates: false,
+    category: "annotation",
+    placements: [...TYPE_PLACEMENTS, ...FIELD_PLACEMENTS],
+    completionDetail: "API-facing serialized name for a type, field, or variant.",
+    hoverSummary: "Overrides the serialized API name used in generated schema output.",
+    valueLabel: "<identifier>",
+    targetPlacements: {
+      member: FIELD_PLACEMENTS,
+      variant: TYPE_PLACEMENTS
+    }
+  },
+  group: {
+    requiresArgument: true,
+    supportedTargets: ["none"],
+    allowDuplicates: false,
+    category: "structure",
+    placements: FIELD_PLACEMENTS,
+    completionDetail: "Assigns a field to a UI group.",
+    hoverSummary: "Assigns the field to a named grouping container.",
+    valueLabel: "<group>"
+  },
+  showWhen: {
+    requiresArgument: true,
+    supportedTargets: ["none"],
+    allowDuplicates: true,
+    category: "structure",
+    placements: FIELD_PLACEMENTS,
+    completionDetail: "Conditional visibility rule.",
+    hoverSummary: "Shows the field only when the condition is satisfied."
+  },
+  hideWhen: {
+    requiresArgument: true,
+    supportedTargets: ["none"],
+    allowDuplicates: true,
+    category: "structure",
+    placements: FIELD_PLACEMENTS,
+    completionDetail: "Conditional visibility suppression rule.",
+    hoverSummary: "Hides the field when the condition is satisfied."
+  },
+  enableWhen: {
+    requiresArgument: true,
+    supportedTargets: ["none"],
+    allowDuplicates: true,
+    category: "structure",
+    placements: FIELD_PLACEMENTS,
+    completionDetail: "Conditional interactivity rule.",
+    hoverSummary: "Enables the field only when the condition is satisfied."
+  },
+  disableWhen: {
+    requiresArgument: true,
+    supportedTargets: ["none"],
+    allowDuplicates: true,
+    category: "structure",
+    placements: FIELD_PLACEMENTS,
+    completionDetail: "Conditional disablement rule.",
+    hoverSummary: "Disables the field when the condition is satisfied."
+  },
+  defaultValue: {
+    requiresArgument: true,
+    supportedTargets: ["none"],
+    allowDuplicates: false,
+    category: "ecosystem",
+    placements: FIELD_PLACEMENTS,
+    completionDetail: "Default JSON value for a field.",
+    hoverSummary: "Provides a default JSON value for ecosystem integrations.",
+    valueLabel: "<value>"
+  },
+  deprecated: {
+    requiresArgument: false,
+    supportedTargets: ["none"],
+    allowDuplicates: false,
+    category: "ecosystem",
+    placements: ALL_PLACEMENTS,
+    completionDetail: "Marks a declaration as deprecated.",
+    hoverSummary: "Marks the declaration as deprecated."
+  },
+  example: {
+    requiresArgument: true,
+    supportedTargets: ["none"],
+    allowDuplicates: true,
+    category: "ecosystem",
+    placements: [...TYPE_PLACEMENTS, ...FIELD_PLACEMENTS],
+    completionDetail: "Example serialized value.",
+    hoverSummary: "Provides an example value for documentation and tooling."
+  },
+  remarks: {
+    requiresArgument: true,
+    supportedTargets: ["none"],
+    allowDuplicates: false,
+    category: "ecosystem",
+    placements: ALL_PLACEMENTS,
+    completionDetail: "Additional remarks text.",
+    hoverSummary: "Provides additional remarks for the declaration."
+  },
+  see: {
+    requiresArgument: true,
+    supportedTargets: ["none"],
+    allowDuplicates: true,
+    category: "ecosystem",
+    placements: ALL_PLACEMENTS,
+    completionDetail: "Reference to related documentation.",
+    hoverSummary: "References related documentation or declarations.",
+    valueLabel: "<reference>"
+  }
+};
+function buildExtraTagDefinition(canonicalName, spec) {
+  const valueKind = spec.valueKind ?? inferValueKind(canonicalName);
+  const valueLabel = spec.requiresArgument ? spec.valueLabel ?? valueLabelForKind(valueKind) : "";
+  const signatures = [];
+  if (spec.supportedTargets.includes("none")) {
+    signatures.push(createSignature(canonicalName, spec.placements, null, valueKind, valueLabel));
+  }
+  if (spec.supportedTargets.includes("path")) {
+    signatures.push(
+      createSignature(
+        canonicalName,
+        spec.targetPlacements?.path ?? spec.placements,
+        "path",
+        valueKind,
+        valueLabel
+      )
+    );
+  }
+  if (spec.supportedTargets.includes("member")) {
+    signatures.push(
+      createSignature(
+        canonicalName,
+        spec.targetPlacements?.member ?? spec.placements,
+        "member",
+        valueKind,
+        valueLabel
+      )
+    );
+  }
+  if (spec.supportedTargets.includes("variant")) {
+    signatures.push(
+      createSignature(
+        canonicalName,
+        spec.targetPlacements?.variant ?? spec.placements,
+        "variant",
+        valueKind,
+        valueLabel
+      )
+    );
+  }
+  return {
+    canonicalName,
+    valueKind,
+    requiresArgument: spec.requiresArgument,
+    supportedTargets: spec.supportedTargets,
+    allowDuplicates: spec.allowDuplicates,
+    category: spec.category,
+    placements: spec.placements,
+    capabilities: capabilitiesForValueKind(valueKind),
+    completionDetail: spec.completionDetail,
+    hoverMarkdown: buildHoverMarkdown(canonicalName, spec.hoverSummary, signatures, valueLabel),
+    signatures
+  };
+}
+var EXTRA_TAG_DEFINITIONS = Object.fromEntries(
+  Object.entries(EXTRA_TAG_SPECS).map(([canonicalName, spec]) => [
+    canonicalName,
+    buildExtraTagDefinition(canonicalName, spec)
+  ])
+);
+function normalizeFormSpecTagName(rawName) {
+  return 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";
+}
+function isTagStart(lineText, index) {
+  if (lineText[index] !== "@") {
+    return false;
+  }
+  const nextChar = lineText[index + 1];
+  if (nextChar === void 0 || !/[A-Za-z]/u.test(nextChar)) {
+    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;
+}
+function trimTrailingWhitespace(lineText, end) {
+  let cursor = end;
+  while (cursor > 0 && isWhitespace(lineText[cursor - 1])) {
+    cursor -= 1;
+  }
+  return cursor;
+}
+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
+  };
+}
+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 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 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 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)
+      });
+    }
+  }
+  return {
+    commentText,
+    offset: baseOffset,
+    tags
+  };
+}
+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}`);
+  }
+  return tag;
+}
+function sliceCommentSpan(commentText, span, options) {
+  const baseOffset = options?.offset ?? 0;
+  return commentText.slice(span.start - baseOffset, span.end - baseOffset);
+}
+
+// src/ts-binding.ts
+import * as ts from "typescript";
+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];
+  }
+  return type;
+}
+function isIntersectionWithBase(type, predicate) {
+  return type.isIntersection() && type.types.some((member) => predicate(member));
+}
+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));
+  }
+  return isIntersectionWithBase(stripped, isNumberLike);
+}
+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));
+  }
+  return isIntersectionWithBase(stripped, isStringLike);
+}
+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));
+  }
+  return isIntersectionWithBase(stripped, isBooleanLike);
+}
+function isNullLike(type) {
+  const stripped = stripNullishUnion(type);
+  if (stripped.flags & ts.TypeFlags.Null) {
+    return true;
+  }
+  if (stripped.isUnion()) {
+    return stripped.types.every((member) => isNullLike(member));
+  }
+  return isIntersectionWithBase(stripped, isNullLike);
+}
+function isArrayLike(type, checker) {
+  const stripped = stripNullishUnion(type);
+  if (checker.isArrayType(stripped)) {
+    return true;
+  }
+  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);
+}
+function isObjectLike(type, checker) {
+  const stripped = stripNullishUnion(type);
+  return !isArrayLike(stripped, checker) && (stripped.flags & ts.TypeFlags.Object) !== 0;
+}
+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;
+  }
+  return isIntersectionWithBase(stripped, (member) => isJsonLike(member, checker));
+}
+function getArrayElementType(type, checker) {
+  const stripped = stripNullishUnion(type);
+  if (!checker.isArrayType(stripped)) {
+    return null;
+  }
+  return checker.getTypeArguments(stripped)[0] ?? null;
+}
+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";
+  }
+  return null;
+}
+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");
+  }
+  return [...capabilities];
+}
+function hasTypeSemanticCapability(type, checker, capability) {
+  return getTypeSemanticCapabilities(type, checker).includes(capability);
+}
+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
+    };
+  }
+  return resolvePathTargetType(
+    checker.getTypeOfSymbolAtLocation(property, declaration),
+    checker,
+    rest
+  );
+}
+function collectPropertyPaths(type, checker, capability, prefix, visited) {
+  const stripped = stripNullishUnion(type);
+  if (visited.has(stripped)) {
+    return [];
+  }
+  visited.add(stripped);
+  const suggestions = [];
+  if (hasTypeSemanticCapability(stripped, checker, capability) && prefix.length > 0) {
+    suggestions.push(prefix.join("."));
+  }
+  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)
+    );
+  }
+  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;
+  }
+  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 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);
+      }
+    }
+  }
+  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;
+      }
+    }
+  }
+  return [...supportedTargets];
+}
+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;
+      }
+    }
+  }
+  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
+import {
+  BUILTIN_CONSTRAINT_DEFINITIONS as BUILTIN_CONSTRAINT_DEFINITIONS2,
+  isBuiltinConstraintName
+} from "@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 (!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 = BUILTIN_CONSTRAINT_DEFINITIONS2[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 (!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
+import { normalizeConstraintTagName as normalizeConstraintTagName2 } from "@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 : normalizeConstraintTagName2(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/constants.ts
+var FORM_SPEC_SYNTHETIC_BATCH_CACHE_ENTRIES = 64;
+
+// src/file-snapshots.ts
+import * as ts4 from "typescript";
+
+// src/compiler-signatures.ts
+import * as ts2 from "typescript";
+
+// src/perf-tracing.ts
+var EMPTY_PERFORMANCE_EVENTS = Object.freeze([]);
+function getHighResolutionTime() {
+  return performance.now();
+}
+var FormSpecPerformanceRecorderImpl = class {
+  mutableEvents = [];
+  get events() {
+    return this.mutableEvents;
+  }
+  measure(name, detail, callback) {
+    const startedAt = getHighResolutionTime();
+    try {
+      return callback();
+    } finally {
+      this.record({
+        name,
+        durationMs: getHighResolutionTime() - startedAt,
+        ...detail === void 0 ? {} : { detail }
+      });
+    }
+  }
+  record(event) {
+    this.mutableEvents.push(event);
+  }
+};
+var NoopFormSpecPerformanceRecorderImpl = class {
+  get events() {
+    return EMPTY_PERFORMANCE_EVENTS;
+  }
+  measure(_name, _detail, callback) {
+    return callback();
+  }
+  record(_event) {
+  }
+};
+var NOOP_FORMSPEC_PERFORMANCE_RECORDER = new NoopFormSpecPerformanceRecorderImpl();
+function createFormSpecPerformanceRecorder() {
+  return new FormSpecPerformanceRecorderImpl();
+}
+function getFormSpecPerformanceNow() {
+  return getHighResolutionTime();
+}
+function optionalMeasure(recorder, name, detail, callback) {
+  return (recorder ?? NOOP_FORMSPEC_PERFORMANCE_RECORDER).measure(name, detail, callback);
+}
+
+// src/compiler-signatures.ts
+var SYNTHETIC_CHECK_EVENT = {
+  batch: "analysis.syntheticCheckBatch",
+  narrowBatch: "analysis.narrowSyntheticCheckBatch"
+};
+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 SYNTHETIC_COMPILER_OPTIONS = {
+  strict: true,
+  noEmit: true,
+  target: ts2.ScriptTarget.ES2022,
+  module: ts2.ModuleKind.ESNext,
+  lib: ["lib.es2022.d.ts"],
+  types: []
+};
+var LruCache = class {
+  constructor(maxEntries) {
+    this.maxEntries = maxEntries;
+  }
+  map = /* @__PURE__ */ new Map();
+  get(key) {
+    const cached = this.map.get(key);
+    if (cached === void 0) {
+      return void 0;
+    }
+    this.map.delete(key);
+    this.map.set(key, cached);
+    return cached;
+  }
+  set(key, value) {
+    if (this.map.has(key)) {
+      this.map.delete(key);
+    }
+    this.map.set(key, value);
+    if (this.map.size <= this.maxEntries) {
+      return;
+    }
+    const oldestKey = this.map.keys().next().value;
+    if (oldestKey !== void 0) {
+      this.map.delete(oldestKey);
+    }
+  }
+};
+var syntheticBatchResultCache = new LruCache(
+  FORM_SPEC_SYNTHETIC_BATCH_CACHE_ENTRIES
+);
+function pushChunkLines(target, chunk) {
+  target.push(...chunk.split("\n"));
+}
+function buildSyntheticBatchSource(applications) {
+  const lines = [];
+  pushChunkLines(lines, buildSyntheticHelperPrelude(collectBatchExtensions(applications)));
+  lines.push("");
+  const applicationLineRanges = [];
+  for (const [index, application] of applications.entries()) {
+    const namespaceName = `__formspec_app_${String(index)}`;
+    const startLine = lines.length;
+    lines.push(`namespace ${namespaceName} {`);
+    for (const declaration of application.options.supportingDeclarations ?? []) {
+      pushChunkLines(lines, declaration);
+    }
+    lines.push(`type __Host = ${application.options.hostType};`);
+    lines.push(`type __Subject = ${application.options.subjectType};`);
+    lines.push(application.lowered.callExpression);
+    lines.push("}");
+    applicationLineRanges.push({
+      startLine,
+      endLine: lines.length - 1
+    });
+  }
+  return {
+    sourceText: lines.join("\n"),
+    applicationLineRanges
+  };
+}
+function collectBatchExtensions(applications) {
+  const extensions = applications.flatMap((application) => application.options.extensions ?? []);
+  return extensions.length === 0 ? void 0 : extensions;
+}
+function mapBatchDiagnostics(diagnostics, sourceFile, applicationLineRanges) {
+  const diagnosticsByApplication = applicationLineRanges.map(
+    () => []
+  );
+  const defaultResult = diagnosticsByApplication[0];
+  for (const diagnostic of diagnostics) {
+    const serialized = {
+      code: diagnostic.code,
+      message: flattenDiagnosticMessage(diagnostic.messageText)
+    };
+    if (diagnostic.file === void 0 || diagnostic.start === void 0) {
+      if (defaultResult !== void 0) {
+        defaultResult.push(serialized);
+      }
+      continue;
+    }
+    const line = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start).line;
+    const applicationIndex = applicationLineRanges.findIndex(
+      (range) => line >= range.startLine && line <= range.endLine
+    );
+    if (applicationIndex < 0) {
+      if (defaultResult !== void 0) {
+        defaultResult.push(serialized);
+      }
+      continue;
+    }
+    const targetResult = diagnosticsByApplication[applicationIndex];
+    if (targetResult !== void 0) {
+      targetResult.push(serialized);
+    }
+  }
+  return diagnosticsByApplication.map((diagnosticsForApplication) => ({
+    sourceText: sourceFile.text,
+    diagnostics: diagnosticsForApplication
+  }));
+}
+function runSyntheticProgram(fileName, sourceText, performance2, eventPrefix, missingSourceFileMessage) {
+  const host = optionalMeasure(
+    performance2,
+    `${eventPrefix}.createCompilerHost`,
+    void 0,
+    () => createSyntheticCompilerHost(fileName, sourceText, SYNTHETIC_COMPILER_OPTIONS)
+  );
+  const program = optionalMeasure(
+    performance2,
+    `${eventPrefix}.createProgram`,
+    void 0,
+    () => ts2.createProgram([fileName], SYNTHETIC_COMPILER_OPTIONS, host)
+  );
+  const diagnostics = optionalMeasure(
+    performance2,
+    `${eventPrefix}.getPreEmitDiagnostics`,
+    void 0,
+    () => ts2.getPreEmitDiagnostics(program).filter(
+      (diagnostic) => diagnostic.file === void 0 || diagnostic.file.fileName === fileName
+    )
+  );
+  const sourceFile = program.getSourceFile(fileName);
+  if (sourceFile === void 0) {
+    throw new Error(missingSourceFileMessage);
+  }
+  return {
+    sourceFile,
+    diagnostics
+  };
+}
+function runBatchSyntheticCheck(options) {
+  if (options.applications.length === 0) {
+    return [];
+  }
+  const resolvedApplications = options.lowerApplications(options.applications, options.performance);
+  const batchSource = options.buildBatchSource(resolvedApplications, options.performance);
+  const cached = options.cache.get(batchSource.sourceText);
+  if (cached !== void 0) {
+    options.performance?.record({
+      name: `${options.eventPrefix}.cacheHit`,
+      durationMs: 0,
+      detail: {
+        applicationCount: options.applications.length
+      }
+    });
+    return cached;
+  }
+  const { sourceFile, diagnostics } = runSyntheticProgram(
+    options.fileName,
+    batchSource.sourceText,
+    options.performance,
+    options.eventPrefix,
+    options.missingSourceFileMessage
+  );
+  const results = optionalMeasure(
+    options.performance,
+    `${options.eventPrefix}.mapDiagnostics`,
+    void 0,
+    () => mapBatchDiagnostics(diagnostics, sourceFile, batchSource.applicationLineRanges)
+  );
+  options.cache.set(batchSource.sourceText, results);
+  return results;
+}
+function checkSyntheticTagApplications(options) {
+  return runBatchSyntheticCheck({
+    applications: options.applications,
+    performance: options.performance,
+    cache: syntheticBatchResultCache,
+    eventPrefix: SYNTHETIC_CHECK_EVENT.batch,
+    missingSourceFileMessage: "Invariant violation: missing synthetic batch source file",
+    fileName: "/virtual/formspec-synthetic-batch.ts",
+    lowerApplications: (applications, performance2) => optionalMeasure(
+      performance2,
+      `${SYNTHETIC_CHECK_EVENT.batch}.lower`,
+      void 0,
+      () => applications.map((application) => ({
+        options: application,
+        lowered: lowerTagApplicationToSyntheticCall({
+          ...application,
+          hostType: "__Host",
+          subjectType: "__Subject"
+        })
+      }))
+    ),
+    buildBatchSource: (applications, performance2) => optionalMeasure(
+      performance2,
+      `${SYNTHETIC_CHECK_EVENT.batch}.buildSource`,
+      void 0,
+      () => buildSyntheticBatchSource(applications)
+    )
+  });
+}
+function checkSyntheticTagApplication(options) {
+  const result = checkSyntheticTagApplications({
+    applications: [options],
+    ...options.performance === void 0 ? {} : { performance: options.performance }
+  })[0];
+  if (result === void 0) {
+    throw new Error("Invariant violation: missing synthetic batch result for singular check");
+  }
+  return result;
+}
+
+// src/source-bindings.ts
+import * as ts3 from "typescript";
+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");
+}
+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 isTargetKindValue(value) {
+  return typeof value === "string" && FORM_SPEC_TARGET_KIND_VALUES.has(value);
+}
+function isPlacementArray(value) {
+  return Array.isArray(value) && value.every(isPlacementValue);
+}
+function isTargetKindArray(value) {
+  return Array.isArray(value) && value.every(isTargetKindValue);
+}
+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 || 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 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 || 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 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
+  };
+}
+function serializeCommentTagSemanticContext(semantic) {
+  return {
+    tagName: semantic.tag.normalizedTagName,
+    tagDefinition: semantic.tagDefinition === null ? null : {
+      canonicalName: semantic.tagDefinition.canonicalName,
+      completionDetail: semantic.tagDefinition.completionDetail,
+      hoverMarkdown: semantic.tagDefinition.hoverMarkdown
+    },
+    placement: semantic.placement,
+    supportedTargets: semantic.supportedTargets,
+    targetCompletions: semantic.targetCompletions,
+    compatiblePathTargets: semantic.compatiblePathTargets,
+    valueLabels: semantic.valueLabels,
+    signatures: semantic.signatures.map((signature) => ({
+      label: signature.label,
+      placements: signature.placements
+    })),
+    tagHoverMarkdown: semantic.tagHoverMarkdown,
+    targetHoverMarkdown: semantic.targetHoverMarkdown,
+    argumentHoverMarkdown: semantic.argumentHoverMarkdown
+  };
+}
+function serializeCompletionContext(context) {
+  switch (context.kind) {
+    case "tag-name":
+      return {
+        kind: "tag-name",
+        prefix: context.prefix,
+        availableTags: context.availableTags.map((tag) => ({
+          canonicalName: tag.canonicalName,
+          completionDetail: tag.completionDetail,
+          hoverMarkdown: tag.hoverMarkdown
+        }))
+      };
+    case "target":
+      return {
+        kind: "target",
+        semantic: serializeCommentTagSemanticContext(context.semantic)
+      };
+    case "argument":
+      return {
+        kind: "argument",
+        semantic: serializeCommentTagSemanticContext(context.semantic),
+        valueLabels: context.valueLabels
+      };
+    case "none":
+      return { kind: "none" };
+    default: {
+      const exhaustive = context;
+      return exhaustive;
+    }
+  }
+}
+function serializeHoverInfo(hover) {
+  return hover === null ? null : {
+    kind: hover.kind,
+    markdown: hover.markdown
+  };
+}
+function serializeParsedCommentTag(tag, semantic) {
+  return {
+    rawTagName: tag.rawTagName,
+    normalizedTagName: tag.normalizedTagName,
+    recognized: tag.recognized,
+    fullSpan: tag.fullSpan,
+    tagNameSpan: tag.tagNameSpan,
+    payloadSpan: tag.payloadSpan,
+    target: serializeCommentTargetSpecifier(tag.target),
+    argumentSpan: tag.argumentSpan,
+    argumentText: tag.argumentText,
+    semantic: serializeCommentTagSemanticContext(semantic)
+  };
+}
+
+// src/file-snapshots.ts
+var SYNTHETIC_TYPE_NODE_BUILDER_FLAGS = ts4.NodeBuilderFlags.NoTruncation | ts4.NodeBuilderFlags.UseStructuralFallback | ts4.NodeBuilderFlags.IgnoreErrors | ts4.NodeBuilderFlags.InTypeAlias;
+var SYNTHETIC_TYPE_PRINT_SOURCE_FILE = ts4.createSourceFile(
+  "/virtual/formspec-standalone-type.ts",
+  "",
+  ts4.ScriptTarget.ES2022,
+  false,
+  ts4.ScriptKind.TS
+);
+var SYNTHETIC_TYPE_PRINTER = ts4.createPrinter({ removeComments: true });
+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 renderStandaloneTypeSyntax(type, checker) {
+  if (type === void 0) {
+    return null;
+  }
+  const typeNode = checker.typeToTypeNode(type, void 0, SYNTHETIC_TYPE_NODE_BUILDER_FLAGS);
+  if (typeNode === void 0) {
+    return null;
+  }
+  const rendered = SYNTHETIC_TYPE_PRINTER.printNode(
+    ts4.EmitHint.Unspecified,
+    typeNode,
+    SYNTHETIC_TYPE_PRINT_SOURCE_FILE
+  ).trim();
+  return rendered === "" ? null : rendered;
+}
+function requiresSupportingDeclarationsForStandaloneTypeSyntax(typeText) {
+  if (typeText === null) {
+    return true;
+  }
+  const sourceFile = ts4.createSourceFile(
+    "/virtual/formspec-standalone-type-analysis.ts",
+    `type __FormSpecStandalone = ${typeText};`,
+    ts4.ScriptTarget.ES2022,
+    false,
+    ts4.ScriptKind.TS
+  );
+  const statement = sourceFile.statements[0];
+  if (statement === void 0 || !ts4.isTypeAliasDeclaration(statement)) {
+    return true;
+  }
+  let requiresDeclarations = false;
+  const visit = (node) => {
+    if (ts4.isTypeReferenceNode(node) || ts4.isExpressionWithTypeArguments(node) || ts4.isImportTypeNode(node) || ts4.isTypeQueryNode(node)) {
+      requiresDeclarations = true;
+      return;
+    }
+    ts4.forEachChild(node, visit);
+  };
+  visit(statement.type);
+  return requiresDeclarations;
+}
+function dedupeSupportingDeclarations(declarations) {
+  return [...new Set(declarations)];
+}
+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 getDeclaredSubjectType(node, checker, subjectType) {
+  if ((ts4.isPropertyDeclaration(node) || ts4.isPropertySignature(node) || ts4.isParameter(node) || ts4.isVariableDeclaration(node) || ts4.isTypeAliasDeclaration(node)) && node.type !== void 0) {
+    return checker.getTypeFromTypeNode(node.type);
+  }
+  return subjectType;
+}
+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(node, sourceFile, checker, placement, hostType, subjectType, commentTags, semanticOptions, performance2) {
+  if (placement === null || subjectType === void 0) {
+    return [];
+  }
+  const declaredSubjectType = getDeclaredSubjectType(node, checker, subjectType);
+  const diagnostics = [];
+  const standaloneHostTypeText = optionalMeasure(
+    performance2,
+    "analysis.renderStandaloneHostType",
+    void 0,
+    () => renderStandaloneTypeSyntax(hostType, checker)
+  );
+  const standaloneSubjectTypeText = optionalMeasure(
+    performance2,
+    "analysis.renderStandaloneSubjectType",
+    void 0,
+    () => renderStandaloneTypeSyntax(subjectType, checker)
+  );
+  const hostTypeNeedsDeclarations = requiresSupportingDeclarationsForStandaloneTypeSyntax(standaloneHostTypeText);
+  const subjectTypeNeedsDeclarations = requiresSupportingDeclarationsForStandaloneTypeSyntax(standaloneSubjectTypeText);
+  const hostTypeText = standaloneHostTypeText ?? typeToString(hostType, checker) ?? "unknown";
+  const subjectTypeText = standaloneSubjectTypeText ?? typeToString(subjectType, checker) ?? "unknown";
+  const supportingDeclarations = dedupeSupportingDeclarations([
+    ...hostTypeNeedsDeclarations ? supportingDeclarationsForType(hostType) : [],
+    ...subjectTypeNeedsDeclarations ? supportingDeclarationsForType(subjectType) : []
+  ]);
+  const syntheticApplications = [];
+  for (const tag of commentTags) {
+    const semantic = getCommentTagSemanticContext(tag, semanticOptions);
+    if (semantic.tagDefinition === null) {
+      continue;
+    }
+    const target = getSyntheticTargetForTag(tag);
+    const pathTargetResolution = tag.target?.kind === "path" || tag.target?.kind === "ambiguous" ? tag.target.path === null ? null : resolvePathTargetType(declaredSubjectType, checker, tag.target.path.segments) : null;
+    const argumentExpression = getArgumentExpression(
+      tag.argumentText,
+      semantic.valueLabels,
+      semantic.compatiblePathTargets
+    );
+    try {
+      const syntheticOptions = {
+        tagName: tag.normalizedTagName,
+        placement,
+        hostType: hostTypeText,
+        subjectType: subjectTypeText,
+        supportingDeclarations,
+        ...target === null ? {} : { target },
+        ...argumentExpression === null ? {} : { argumentExpression },
+        ...semanticOptions.extensions === void 0 ? {} : { extensions: semanticOptions.extensions }
+      };
+      lowerTagApplicationToSyntheticCall(syntheticOptions);
+      syntheticApplications.push({
+        tag,
+        target,
+        pathTargetResolution,
+        options: syntheticOptions
+      });
+    } catch (error) {
+      diagnostics.push({
+        code: "INVALID_TAG_PLACEMENT",
+        message: error instanceof Error ? error.message : String(error),
+        range: tag.fullSpan,
+        severity: "error"
+      });
+    }
+  }
+  const batchResults = optionalMeasure(
+    performance2,
+    "analysis.syntheticCheckBatch",
+    {
+      tagCount: syntheticApplications.length
+    },
+    () => checkSyntheticTagApplications({
+      applications: syntheticApplications.map((application) => application.options),
+      ...performance2 === void 0 ? {} : { performance: performance2 }
+    })
+  );
+  for (const [index, result] of batchResults.entries()) {
+    const application = syntheticApplications[index];
+    if (application === void 0) {
+      continue;
+    }
+    for (const diagnostic of result.diagnostics) {
+      const code = application.target !== null && diagnostic.message.includes("not assignable") ? application.target.kind === "path" && application.pathTargetResolution?.kind === "missing-property" ? "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: application.tag.fullSpan,
+        severity: diagnosticSeverity(code)
+      });
+    }
+  }
+  return diagnostics;
+}
+function deserializeSnapshotTagsForDiagnostics(snapshot) {
+  return 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: extractPathTarget(`:${tag.target.rawText}`)?.path ?? null
+    },
+    argumentSpan: tag.argumentSpan,
+    argumentText: tag.argumentText
+  }));
+}
+function buildCommentSnapshot(node, sourceFile, checker, extensions, performance2) {
+  return optionalMeasure(
+    performance2,
+    "analysis.buildCommentSnapshot",
+    {
+      nodeKind: ts4.SyntaxKind[node.kind]
+    },
+    () => {
+      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 startedAt = getFormSpecPerformanceNow();
+  const comments = [];
+  const diagnostics = [];
+  const visit = (node) => {
+    const placement = resolveDeclarationPlacement(node);
+    if (placement !== null) {
+      const snapshot2 = buildCommentSnapshot(
+        node,
+        sourceFile,
+        options.checker,
+        options.extensions,
+        options.performance
+      );
+      if (snapshot2 !== null) {
+        comments.push(snapshot2);
+        const subjectType = getSubjectType(node, options.checker);
+        const hostType = getHostType(node, options.checker);
+        diagnostics.push(
+          ...optionalMeasure(
+            options.performance,
+            "analysis.buildTagDiagnostics",
+            {
+              placement,
+              tagCount: snapshot2.tags.length
+            },
+            () => buildTagDiagnostics(
+              node,
+              sourceFile,
+              options.checker,
+              placement,
+              hostType,
+              subjectType,
+              deserializeSnapshotTagsForDiagnostics(snapshot2),
+              {
+                checker: options.checker,
+                ...subjectType === void 0 ? {} : { subjectType },
+                placement,
+                ...options.extensions === void 0 ? {} : { extensions: options.extensions }
+              },
+              options.performance
+            )
+          )
+        );
+      }
+    }
+    ts4.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  const snapshot = {
+    filePath: sourceFile.fileName,
+    sourceHash: computeFormSpecTextHash(sourceFile.text),
+    generatedAt: (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
+    comments,
+    diagnostics
+  };
+  options.performance?.record({
+    name: "analysis.buildFileSnapshot",
+    durationMs: getFormSpecPerformanceNow() - startedAt,
+    detail: {
+      filePath: sourceFile.fileName,
+      commentCount: comments.length,
+      diagnosticCount: diagnostics.length
+    }
+  });
+  return snapshot;
+}
+
+// src/workspace-runtime.ts
+import path from "path";
+function getFormSpecWorkspaceId(workspaceRoot) {
+  return computeFormSpecTextHash(workspaceRoot);
+}
+function getFormSpecWorkspaceRuntimeDirectory(workspaceRoot) {
+  return path.join(workspaceRoot, ".cache", "formspec", "tooling");
+}
+function getFormSpecManifestPath(workspaceRoot) {
+  return path.join(getFormSpecWorkspaceRuntimeDirectory(workspaceRoot), "manifest.json");
+}
+export {
+  FORMSPEC_ANALYSIS_PROTOCOL_VERSION,
+  FORMSPEC_ANALYSIS_SCHEMA_VERSION,
+  FORM_SPEC_PLACEMENTS,
+  FORM_SPEC_SYNTHETIC_BATCH_CACHE_ENTRIES,
+  FORM_SPEC_TARGET_KINDS,
+  NOOP_FORMSPEC_PERFORMANCE_RECORDER,
+  analyzeConstraintTargets,
+  buildConstraintTargetStates,
+  buildFormSpecAnalysisFileSnapshot,
+  buildSyntheticHelperPrelude,
+  checkSyntheticTagApplication,
+  checkSyntheticTagApplications,
+  collectCompatiblePathTargets,
+  collectReferencedTypeAnnotations,
+  collectReferencedTypeConstraints,
+  computeFormSpecTextHash,
+  createFormSpecPerformanceRecorder,
+  dereferenceAnalysisType,
+  extractPathTarget,
+  findCommentTagAtOffset,
+  findDeclarationForCommentOffset,
+  findEnclosingDocComment,
+  formatConstraintTargetName,
+  formatPathTarget,
+  getAllTagDefinitions,
+  getCommentCompletionContextAtOffset,
+  getCommentCursorTargetAtOffset,
+  getCommentHoverInfoAtOffset,
+  getCommentTagSemanticContext,
+  getConstraintTagDefinitions,
+  getFormSpecManifestPath,
+  getFormSpecPerformanceNow,
+  getFormSpecWorkspaceId,
+  getFormSpecWorkspaceRuntimeDirectory,
+  getHostType,
+  getLastLeadingDocCommentRange,
+  getMatchingTagSignatures,
+  getSemanticCommentCompletionContextAtOffset,
+  getSubjectType,
+  getTagCompletionPrefixAtOffset,
+  getTagDefinition,
+  getTagHoverMarkdown,
+  getTypeSemanticCapabilities,
+  hasTypeSemanticCapability,
+  isFormSpecAnalysisManifest,
+  isFormSpecSemanticQuery,
+  isFormSpecSemanticResponse,
+  lowerTagApplicationToSyntheticCall,
+  normalizeFormSpecTagName,
+  optionalMeasure,
+  parseCommentBlock,
+  parseConstraintTagValue,
+  parseDefaultValueTagValue,
+  parseTagSyntax,
+  resolveConstraintTargetState,
+  resolveDeclarationPlacement,
+  resolvePathTargetType,
+  serializeCommentTagSemanticContext,
+  serializeCommentTargetSpecifier,
+  serializeCompletionContext,
+  serializeHoverInfo,
+  serializeParsedCommentTag,
+  sliceCommentSpan
+};
+//# sourceMappingURL=internal.js.map