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

package/dist/protocol.js

@@ -0,0 +1,904 @@
+// 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)
+  ])
+);
+
+// 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/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,
+  computeFormSpecTextHash,
+  getFormSpecManifestPath,
+  getFormSpecWorkspaceId,
+  getFormSpecWorkspaceRuntimeDirectory,
+  isFormSpecAnalysisManifest,
+  isFormSpecSemanticQuery,
+  isFormSpecSemanticResponse,
+  serializeCommentTagSemanticContext,
+  serializeCommentTargetSpecifier,
+  serializeCompletionContext,
+  serializeHoverInfo,
+  serializeParsedCommentTag
+};
+//# sourceMappingURL=protocol.js.map