@termwright/protocol 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,12 +1,78 @@
+import {
+  ARTIFACT_VALUE_POLICIES,
+  DEFAULT_ARTIFACT_VALUE_POLICY,
+  executableText,
+  projectActionReceiptForArtifact,
+  projectSemanticSnapshotForArtifact,
+  publicValue,
+  recordActionPlan,
+  recordDeviceOperation,
+  recordValue,
+  sensitive,
+  valueSensitivity
+} from "./chunk-PUXRCPGY.js";
+import {
+  PROBE_DEGRADED_CAPABILITIES,
+  PROBE_INJECTION_TIERS,
+  PROBE_SEMANTIC_CLASSES,
+  PROBE_UNOBSERVABLE_FIELDS,
+  PROVENANCE_SOURCES,
+  evidence
+} from "./chunk-B4VUTTUE.js";
+import {
+  ADAPTER_CAPABILITIES,
+  CAPABILITY_CONFORMANCE_CLAIMS,
+  CAPABILITY_EDGE_KINDS,
+  CAPABILITY_GRAPH,
+  CAPABILITY_GRAPH_VERSION,
+  CAPABILITY_NODE_CATEGORIES,
+  CAPABILITY_NODE_LAYERS,
+  CONDITION_KINDS,
+  EVIDENCE_PROVIDER_CAPABILITIES,
+  EVIDENCE_PROVIDER_TYPES,
+  PROBE_CAPABILITIES,
+  PUBLIC_CAPABILITY_CONSUMERS,
+  RUNTIME_PREREQUISITES,
+  SESSION_CAPABILITIES,
+  capabilityNode,
+  capabilityRemediation,
+  resolveCapability,
+  sessionCapabilitiesFromProducers,
+  validateCapabilityGraph
+} from "./chunk-VBLS6E6U.js";
+import {
+  DEFAULT_RUN_EVENT_JOURNAL_LIMITS,
+  RunEventJournal
+} from "./chunk-ZZIYHDJ4.js";
+import {
+  DEFAULT_RUN_EVENT_LIMITS,
+  RUN_EVENT_CLASSES,
+  RUN_EVENT_VERSION,
+  RUN_ID_KINDS,
+  RunEventProducer,
+  RunEventStreamValidator,
+  RunIdFactory,
+  createRunEvent,
+  createRunId,
+  parseRunId,
+  validateRunEvent
+} from "./chunk-CZK6NNP3.js";
+import {
+  RUN_STATES,
+  RUN_STATE_TRANSITIONS,
+  TERMINAL_RUN_STATES,
+  canTransitionRunState,
+  isRunState,
+  isTerminalRunState,
+  validateRunStateTransition
+} from "./chunk-ODOJRXL6.js";
+
 // src/env.ts
 import { randomBytes } from "crypto";
 var ENV_ENDPOINT = "TERMWRIGHT_ENDPOINT";
 var ENV_TOKEN = "TERMWRIGHT_TOKEN";
-var ENV_PROTOCOL = "TERMWRIGHT_PROTOCOL";
-var PROTOCOL_VERSION = 1;
-var PROTOCOL_ID = "termwright/1";
-var PROTOCOL_V2_ID = "termwright/2";
-var SUPPORTED_PROTOCOL_IDS = [PROTOCOL_V2_ID, PROTOCOL_ID];
+var PROTOCOL_VERSION = 2;
+var PROTOCOL_ID = "termwright/2";
 var TOKEN_BYTES = 32;
 function generateToken() {
   return randomBytes(TOKEN_BYTES).toString("base64url");
@@ -58,6 +124,7 @@ var SEMANTIC_ACTIONS = [
   "select",
   "expand"
 ];
+var PHYSICAL_INPUT_RECIPE_ACTIONS = ["focus", "activate", "toggle", "setValue"];
 
 // src/limits.ts
 var DEFAULT_LIMITS = Object.freeze({
@@ -86,7 +153,7 @@ var ABSOLUTE_LIMITS = Object.freeze({
   maxLogRecordBytes: 256 * 1024,
   maxLogQueue: 1e4
 });
-var DEFAULT_NEGOTIATION_MS = 250;
+var DEFAULT_NEGOTIATION_MS = 2e3;
 
 // src/observation.ts
 function intersectRects(a, b) {
@@ -147,97 +214,9 @@ function spatialRelation(a, relation, b) {
   }
 }
 
-// src/geometry-capabilities.ts
-var FRAMEWORK_OBSERVATION_CAPABILITIES = Object.freeze([
-  { framework: "generic", identity: "none", attached: "supported", displayed: "supported", intendedRect: "supported", visibleRect: "supported", hitTest: "conditional", reason: "Grid matches are physical cells; pointer delivery still requires terminal mouse mode." },
-  { framework: "textual", identity: "stable", attached: "supported", displayed: "supported", intendedRect: "supported", visibleRect: "supported", hitTest: "supported", reason: "The compositor exposes intended/clipped regions and Screen.get_widget_at(), the same fresh-pointer routing lookup." },
-  { framework: "opentui", identity: "stable", attached: "supported", displayed: "supported", intendedRect: "supported", visibleRect: "unsupported", hitTest: "supported", reason: "The committed native hit grid proves fresh-pointer ownership; the renderer exposes no per-node visual clip rectangle." },
-  { framework: "ink", identity: "stable", attached: "supported", displayed: "supported", intendedRect: "conditional", visibleRect: "unsupported", hitTest: "unsupported", reason: "Intended bounds are conditional on a viewport-stable live region; Ink exposes neither clipping nor pointer ownership." },
-  { framework: "tview", identity: "stable", attached: "supported", displayed: "supported", intendedRect: "supported", visibleRect: "conditional", hitTest: "unsupported", reason: "Primitive rectangles do not identify the recipient after overlap." },
-  { framework: "ratatui", identity: "frame-local", attached: "supported", displayed: "conditional", intendedRect: "supported", visibleRect: "conditional", hitTest: "unsupported", reason: "Render areas are frame-local and buffer writes do not preserve widget ownership." },
-  { framework: "charm", identity: "frame-local", attached: "supported", displayed: "conditional", intendedRect: "unsupported", visibleRect: "unsupported", hitTest: "unsupported", reason: "Bubble Tea hands over a rendered string without attributable widget geometry." }
-]);
-function frameworkObservationCapabilities(framework) {
-  return FRAMEWORK_OBSERVATION_CAPABILITIES.find((entry) => entry.framework === framework);
-}
-var weakest = (...values) => values.includes("unsupported") ? "unsupported" : values.includes("conditional") ? "conditional" : "supported";
-var FRAMEWORK_OPERATION_CAPABILITIES = Object.freeze(
-  FRAMEWORK_OBSERVATION_CAPABILITIES.flatMap((row) => {
-    const visibility = weakest(row.displayed, row.visibleRect);
-    const viewport = weakest(row.intendedRect, row.visibleRect);
-    const reason = row.reason;
-    return [
-      { framework: row.framework, operation: "keyboard-actions", availability: "supported", reason: "Keyboard input is sent through the PTY and does not require geometry." },
-      {
-        framework: row.framework,
-        operation: "pointer-actions",
-        availability: row.hitTest === "unsupported" ? "unsupported" : "conditional",
-        reason: row.hitTest === "unsupported" ? reason : "Requires an exact hit recipient and terminal mouse reporting enabled by the application."
-      },
-      { framework: row.framework, operation: "toBeAttached", availability: "supported", reason: "Tree membership is observed directly." },
-      { framework: row.framework, operation: "toBeDetached", availability: "supported", reason: "Tree absence is observed directly without coercing missing layout facts." },
-      { framework: row.framework, operation: "toBeDisplayed", availability: row.displayed, reason },
-      { framework: row.framework, operation: "toBeHidden", availability: row.displayed, reason },
-      { framework: row.framework, operation: "toBeVisible", availability: visibility, reason },
-      { framework: row.framework, operation: "toBeOffscreen", availability: viewport, reason },
-      { framework: row.framework, operation: "toBeInViewport", availability: viewport, reason },
-      { framework: row.framework, operation: "toReceivePointerEvents", availability: row.hitTest, reason },
-      { framework: row.framework, operation: "toHaveBounds", availability: row.intendedRect, reason },
-      { framework: row.framework, operation: "toHaveSpatialRelation", availability: row.intendedRect, reason },
-      { framework: row.framework, operation: "cellSnapshot", availability: row.visibleRect, reason }
-    ];
-  })
-);
-
 // src/node-schema.ts
 import { Buffer } from "buffer";
 import { z } from "zod";
-
-// src/probe/ir.ts
-var PROBE_UNOBSERVABLE_FIELDS = [
-  "focused",
-  "disabled",
-  "checked",
-  "expanded",
-  "readonly",
-  "selected",
-  "busy",
-  "multiline",
-  "displayed",
-  "value",
-  "selectedIndex",
-  "textSelection",
-  "scroll",
-  "scrollExtent",
-  "intendedRect",
-  "visibleRect",
-  "paintOrder",
-  "text",
-  "parent"
-];
-var PROBE_CAPABILITIES = [
-  /** Identities survive across frames and may be correlated. */
-  "stable-identity",
-  /** `visibleRect` is computed, not guessed. */
-  "visible-rect",
-  /** A render/layout call stream is reported. */
-  "operations",
-  /** Author annotations are readable. */
-  "annotations",
-  /** A frame-start signal is emitted. Absent for most frameworks — see below. */
-  "frame-begin",
-  /** `paintOrder` is reported, so occlusion can be reasoned about. */
-  "paint-order"
-];
-var PROVENANCE_SOURCES = [
-  "annotation",
-  "recognizer",
-  "framework",
-  "correlation",
-  "heuristic"
-];
-
-// src/node-schema.ts
 function safeInt() {
   return z.number().refine(Number.isSafeInteger, "expected a safe integer");
 }
@@ -263,11 +242,70 @@ function build(limits) {
     width: nonNegativeInt(),
     height: nonNegativeInt()
   });
+  const evidence2 = z.strictObject({
+    source: z.enum(["framework", "application", "terminal", "recognizer", "driver"]),
+    method: z.enum([
+      "native",
+      "instrumented",
+      "declared",
+      "correlated",
+      "measured",
+      "derived",
+      "heuristic"
+    ]),
+    strength: z.enum(["authoritative", "diagnostic"]),
+    providerId: z.string().min(1).max(256)
+  });
+  const authoritativeEvidence = evidence2.extend({
+    strength: z.literal("authoritative")
+  });
   const observation = (value) => z.discriminatedUnion("status", [
-    z.strictObject({ status: z.literal("known"), value, evidence: z.enum(["adapter", "probe", "terminal-grid", "viewport-clip", "paint-order", "hit-grid", "legacy-v1"]) }),
-    z.strictObject({ status: z.literal("absent"), reason: z.enum(["detached", "not-displayed", "not-laid-out"]) }),
-    z.strictObject({ status: z.literal("unknown"), reason: z.enum(["not-reported", "temporary", "clip-unobservable", "legacy-unqualified"]) }),
-    z.strictObject({ status: z.literal("unsupported"), capability: text, reason: z.enum(["capability", "framework-unobservable", "not-negotiated"]) })
+    z.strictObject({
+      status: z.literal("known"),
+      value,
+      evidence: evidence2
+    }),
+    z.strictObject({
+      status: z.literal("absent"),
+      reason: z.enum(["detached", "not-displayed", "not-laid-out"]),
+      evidence: authoritativeEvidence
+    }),
+    z.strictObject({
+      status: z.literal("unknown"),
+      reason: z.enum(["awaiting-revision-pair", "provider-refresh", "stale-revision"])
+    }),
+    z.strictObject({
+      status: z.literal("unsupported"),
+      capability: text,
+      reason: z.enum(["capability", "framework-unobservable", "not-negotiated"])
+    })
+  ]);
+  const semanticValue = z.discriminatedUnion("status", [
+    z.strictObject({
+      status: z.literal("known"),
+      value: text,
+      sensitivity: z.enum(["public", "sensitive"]),
+      evidence: evidence2
+    }),
+    z.strictObject({
+      status: z.literal("absent"),
+      reason: z.enum(["detached", "not-displayed", "not-laid-out", "no-value"]),
+      evidence: authoritativeEvidence
+    }),
+    z.strictObject({
+      status: z.literal("unknown"),
+      reason: z.enum(["awaiting-revision-pair", "provider-refresh", "stale-revision"])
+    }),
+    z.strictObject({
+      status: z.literal("unsupported"),
+      capability: z.literal("semantic-value"),
+      reason: z.enum(["capability", "framework-unobservable", "not-negotiated"])
+    }),
+    z.strictObject({
+      status: z.literal("withheld"),
+      reason: z.enum(["sensitive", "artifact-policy", "provider-policy"]),
+      sensitivity: z.enum(["public", "sensitive"])
+    })
   ]);
   const state = z.strictObject({
     disabled: z.boolean().optional(),
@@ -281,12 +319,12 @@ function build(limits) {
     offscreen: z.boolean().optional(),
     readonly: z.boolean().optional(),
     multiline: z.boolean().optional(),
+    required: z.boolean().optional(),
+    multiselectable: z.boolean().optional(),
     orientation: z.union([z.literal("horizontal"), z.literal("vertical")]).optional(),
     level: positiveInt().optional(),
     positionInSet: positiveInt().optional(),
-    setSize: nonNegativeInt().optional(),
-    scrollOffset: nonNegativeInt().optional(),
-    scrollExtent: nonNegativeInt().optional()
+    setSize: nonNegativeInt().optional()
   });
   const textRange = z.strictObject({
     startOffset: nonNegativeInt(),
@@ -313,27 +351,81 @@ function build(limits) {
     (value) => Object.keys(value).length <= limits.maxRelationTargets,
     `expected at most ${limits.maxRelationTargets} properties`
   );
+  const inputRecipe = z.strictObject({
+    action: z.enum(PHYSICAL_INPUT_RECIPE_ACTIONS),
+    requiresFocus: z.boolean(),
+    steps: z.array(
+      z.union([
+        z.strictObject({
+          kind: z.literal("press"),
+          key: text.refine((s) => s.length > 0, "key must not be empty")
+        }),
+        z.strictObject({ kind: z.literal("insert-action-value") })
+      ])
+    ).min(1).max(limits.maxRelationTargets)
+  }).superRefine((recipe, context) => {
+    const inserts = recipe.steps.filter(({ kind }) => kind === "insert-action-value").length;
+    if (recipe.action === "setValue" && inserts !== 1 || recipe.action !== "setValue" && inserts !== 0) {
+      context.addIssue({
+        code: "custom",
+        message: "setValue requires exactly one insert-action-value step"
+      });
+    }
+    if (recipe.action === "focus" && recipe.requiresFocus) {
+      context.addIssue({
+        code: "custom",
+        message: "focus recipe cannot require focus"
+      });
+    }
+  });
+  const inputRecipes = z.array(inputRecipe).max(PHYSICAL_INPUT_RECIPE_ACTIONS.length).superRefine((recipes, context) => {
+    if (new Set(recipes.map(({ action }) => action)).size !== recipes.length) {
+      context.addIssue({
+        code: "custom",
+        message: "input recipe actions must be unique"
+      });
+    }
+  });
+  const regionSpan = z.strictObject({
+    row: nonNegativeInt(),
+    from: nonNegativeInt(),
+    to: positiveInt()
+  }).refine((span) => span.to > span.from, "region span must be non-empty");
+  const regionSpans = z.array(regionSpan).max(limits.maxNodes).superRefine((spans, ctx) => {
+    let previous;
+    for (let index = 0; index < spans.length; index += 1) {
+      const current = spans[index];
+      if (previous !== void 0 && (current.row < previous.row || current.row === previous.row && current.from < previous.to)) {
+        ctx.addIssue({
+          code: "custom",
+          path: [index],
+          message: "region spans must be non-overlapping row-major runs"
+        });
+        return;
+      }
+      previous = current;
+    }
+  });
   const nodeFields = {
     id: text.refine((s) => s.length > 0, "node id must not be empty"),
     parentId: text.optional(),
     role: z.enum(SEMANTIC_ROLES),
     name: text,
     description: text.optional(),
-    value: text.optional(),
-    bounds: rect.optional(),
+    value: semanticValue.optional(),
     state: state.optional(),
     extended: extended.optional(),
     actions: z.array(z.enum(SEMANTIC_ACTIONS)).max(SEMANTIC_ACTIONS.length).optional(),
+    inputRecipes: inputRecipes.optional(),
     labelledBy: relations.optional(),
     describedBy: relations.optional(),
     textRanges: z.array(textRange).max(limits.maxRelationTargets).optional(),
     testId: text.optional(),
     frameworkType: text.optional(),
-    occlusion: z.enum(["known", "unknown"]).optional(),
+    opaqueChildren: z.boolean().optional(),
     p: z.enum(PROVENANCE_SOURCES).optional(),
     px: z.record(text, z.enum(PROVENANCE_SOURCES)).optional()
   };
-  const node = z.strictObject(nodeFields);
   const geometry = z.strictObject({
     displayed: observation(z.boolean()),
     intendedRect: observation(rect),
@@ -341,9 +433,32 @@ function build(limits) {
   });
   const nodeV2 = z.strictObject({
     ...nodeFields,
-    bounds: z.never().optional(),
-    occlusion: z.never().optional(),
-    geometry
+    geometry,
+    scroll: observation(
+      z.strictObject({
+        axis: z.enum(["vertical", "horizontal"]),
+        offset: nonNegativeInt(),
+        viewport: nonNegativeInt(),
+        extent: nonNegativeInt()
+      })
+    ).optional(),
+    paintedRegion: observation(
+      z.strictObject({
+        regionBounds: rect,
+        spans: regionSpans
+      })
+    ).optional()
+  }).superRefine((node, context) => {
+    const intents = new Set(node.actions ?? []);
+    for (const [index, recipe] of (node.inputRecipes ?? []).entries()) {
+      if (!intents.has(recipe.action)) {
+        context.addIssue({
+          code: "custom",
+          path: ["inputRecipes", index, "action"],
+          message: `input recipe '${recipe.action}' requires the matching semantic action intent`
+        });
+      }
+    }
   });
   const cursor = z.strictObject({
     row: nonNegativeInt(),
@@ -351,16 +466,6 @@ function build(limits) {
     visible: z.boolean(),
     shape: z.union([z.literal("block"), z.literal("underline"), z.literal("bar")]).optional()
   });
-  const snapshotV1 = z.strictObject({
-    v: z.literal(1),
-    sessionId: text.refine((s) => s.length > 0, "sessionId must not be empty"),
-    revision: positiveInt(),
-    columns: positiveInt(),
-    rows: positiveInt(),
-    cursor: cursor.optional(),
-    rootIds: z.array(text).max(limits.maxNodes),
-    nodes: z.array(node).max(limits.maxNodes)
-  });
   const hitRun = z.strictObject({
     rect: z.strictObject({
       row: nonNegativeInt(),
@@ -389,6 +494,107 @@ function build(limits) {
       }
     })
   });
+  const providerPointerRegion = z.strictObject({
+    recipientId: text.refine((value) => value.length > 0, "recipient id must not be empty"),
+    regionBounds: rect,
+    spans: regionSpans
+  });
+  const providerActionRecipes = z.strictObject({
+    recipientId: text.refine((value) => value.length > 0, "recipient id must not be empty"),
+    recipes: inputRecipes
+  });
+  const providerScrollState = z.strictObject({
+    recipientId: text.refine((value) => value.length > 0, "recipient id must not be empty"),
+    axis: z.enum(["vertical", "horizontal"]),
+    offset: nonNegativeInt(),
+    viewport: nonNegativeInt(),
+    extent: nonNegativeInt()
+  }).superRefine((state2, context) => {
+    if (state2.offset > state2.extent || state2.viewport > state2.extent || state2.offset + state2.viewport > state2.extent) {
+      context.addIssue({
+        code: "custom",
+        message: "scroll state must fit inside its extent"
+      });
+    }
+  });
+  const providerEvidence = z.discriminatedUnion("status", [
+    z.strictObject({
+      providerId: text.refine((value) => value.length > 0, "provider id must not be empty"),
+      sessionId: text.refine((value) => value.length > 0, "provider session id must not be empty"),
+      revision: positiveInt(),
+      status: z.literal("available"),
+      evidence: z.strictObject({
+        source: z.literal("application"),
+        method: z.enum(["native", "instrumented", "declared"]),
+        strength: z.literal("authoritative"),
+        providerId: text.refine(
+          (value) => value.length > 0,
+          "evidence provider id must not be empty"
+        )
+      }),
+      pointerRegions: z.array(providerPointerRegion).max(limits.maxNodes),
+      paintedRegions: z.array(providerPointerRegion).max(limits.maxNodes).optional(),
+      inputModes: z.strictObject({
+        mouseTracking: z.enum(["none", "x10", "vt200", "drag", "any"]),
+        mouseEncoding: z.enum(["default", "sgr", "urxvt", "utf8"]),
+        focusReporting: z.enum(["on", "off"])
+      }).optional(),
+      focusState: z.discriminatedUnion("status", [
+        z.strictObject({
+          status: z.literal("focused"),
+          recipientId: text.refine(
+            (value) => value.length > 0,
+            "focused recipient id must not be empty"
+          )
+        }),
+        z.strictObject({ status: z.literal("none") })
+      ]).optional(),
+      actionRecipes: z.array(providerActionRecipes).max(limits.maxNodes).superRefine((entries, context) => {
+        const seen = /* @__PURE__ */ new Set();
+        for (const [index, entry] of entries.entries()) {
+          if (seen.has(entry.recipientId)) {
+            context.addIssue({
+              code: "custom",
+              path: [index, "recipientId"],
+              message: "provider action recipe recipients must be unique"
+            });
+          }
+          seen.add(entry.recipientId);
+        }
+      }).optional(),
+      scrollStates: z.array(providerScrollState).max(limits.maxNodes).superRefine((entries, context) => {
+        const seen = /* @__PURE__ */ new Set();
+        for (const [index, entry] of entries.entries()) {
+          if (seen.has(entry.recipientId)) {
+            context.addIssue({
+              code: "custom",
+              path: [index, "recipientId"],
+              message: "provider scroll recipients must be unique"
+            });
+          }
+          seen.add(entry.recipientId);
+        }
+      }).optional(),
+      hitGrid: hitGrid.optional()
+    }),
+    z.strictObject({
+      providerId: text.refine((value) => value.length > 0, "provider id must not be empty"),
+      sessionId: text.refine((value) => value.length > 0, "provider session id must not be empty"),
+      revision: positiveInt(),
+      status: z.literal("lost"),
+      reason: text.refine((value) => value.length > 0, "provider loss reason must not be empty")
+    }),
+    z.strictObject({
+      providerId: text.refine((value) => value.length > 0, "provider id must not be empty"),
+      sessionId: text.refine((value) => value.length > 0, "provider session id must not be empty"),
+      revision: positiveInt(),
+      status: z.literal("violation"),
+      reason: text.refine(
+        (value) => value.length > 0,
+        "provider violation reason must not be empty"
+      )
+    })
+  ]);
   const snapshotV2 = z.strictObject({
     v: z.literal(2),
     sessionId: text.refine((s) => s.length > 0, "sessionId must not be empty"),
@@ -399,17 +605,16 @@ function build(limits) {
     rootIds: z.array(text).max(limits.maxNodes),
     nodes: z.array(nodeV2).max(limits.maxNodes),
     coordinateSpace: observation(z.enum(["viewport-cells", "framework-local-cells"])),
-    hitGrid: observation(hitGrid)
+    hitGrid: observation(hitGrid),
+    providerEvidence: z.array(providerEvidence).max(64).optional()
   });
-  const snapshot = z.discriminatedUnion("v", [snapshotV1, snapshotV2]);
+  const snapshot = snapshotV2;
   return {
     text,
-    node,
+    node: nodeV2,
     cursor,
     snapshot,
-    snapshotV1,
-    snapshotV2,
-    nodeKeys: Object.freeze(Object.keys(node.shape)),
+    nodeKeys: Object.freeze(Object.keys(nodeV2.shape)),
     stateKeys: Object.freeze(Object.keys(state.shape))
   };
 }
@@ -443,10 +648,7 @@ var encoder = new TextEncoder();
 var decoder = new TextDecoder("utf-8", { fatal: true });
 function assertPositiveByteCeiling(maxFrameBytes) {
   if (!Number.isSafeInteger(maxFrameBytes) || maxFrameBytes <= 0) {
-    throw new ProtocolViolation(
-      "frame-malformed",
-      "maxFrameBytes must be a positive safe integer"
-    );
+    throw new ProtocolViolation("frame-malformed", "maxFrameBytes must be a positive safe integer");
   }
 }
 var BufferedFrameDecoder = class {
@@ -785,433 +987,96 @@ function validateLogRecord(value, limits) {
   return { ok: true, record: projected };
 }
 
-// src/delta.ts
-import { Buffer as Buffer4 } from "buffer";
-import { z as z3 } from "zod";
-
-// src/validate.ts
-import { Buffer as Buffer3 } from "buffer";
-import "zod";
-function fail2(code, detail) {
-  return { ok: false, code, detail };
-}
-function codeForIssue(issue) {
-  const path = issue.path.map(String);
-  if (path.includes("role")) return "unknown-role";
-  if (path.includes("revision")) return "revision";
-  if (path.includes("bounds") || path.includes("rect")) return "bad-rect";
-  if (issue.code === "custom" && issue.message?.includes("hit regions")) return "bad-rect";
-  if (issue.code === "too_big" && (path.includes("nodes") || path.includes("rootIds"))) {
-    return "count";
-  }
-  if (issue.code === "custom" && typeof issue.message === "string" && issue.message.includes("UTF-8 bytes")) {
-    return "string-bytes";
-  }
-  return "schema";
+// src/accesskit.ts
+import { createHash } from "crypto";
+var ACCESSKIT_ROOT_TREE_ID = "00000000-0000-0000-0000-000000000000";
+var ACCESSKIT_ROLE_BY_SEMANTIC_ROLE = Object.freeze({
+  application: "application",
+  region: "region",
+  dialog: "dialog",
+  alert: "alert",
+  status: "status",
+  list: "list",
+  listitem: "listItem",
+  menu: "menu",
+  menuitem: "menuItem",
+  button: "button",
+  checkbox: "checkBox",
+  radio: "radioButton",
+  tab: "tab",
+  textbox: "textInput",
+  heading: "heading",
+  text: "label",
+  progressbar: "progressIndicator",
+  separator: "splitter",
+  scrollbar: "scrollBar",
+  table: "table",
+  row: "row",
+  cell: "cell",
+  generic: "genericContainer"
+});
+var ACCESSKIT_ACTION_BY_SEMANTIC_ACTION = Object.freeze({
+  focus: "focus",
+  activate: "click",
+  toggle: "click",
+  setValue: "setValue",
+  expand: "expand",
+  scroll: "scrollIntoView"
+});
+var NODE_ID_BITS = 53n;
+var NODE_ID_MASK = (1n << NODE_ID_BITS) - 1n;
+function accessKitNodeId(id) {
+  const digest = createHash("sha256").update(id, "utf8").digest();
+  const value = digest.readBigUInt64BE(0) & NODE_ID_MASK;
+  return value === 0n ? 1 : Number(value);
 }
-function describeIssue(issue) {
-  const where = issue.path.length > 0 ? issue.path.map(String).join(".") : "<root>";
-  return `${where}: ${issue.message}`;
+function toggledFor(checked) {
+  if (checked === void 0) return void 0;
+  if (checked === "mixed") return "mixed";
+  return checked ? "true" : "false";
 }
-function rectIntersectsViewport(rect, columns, rows) {
-  if (rect.width === 0 || rect.height === 0) return false;
-  return rect.column < columns && rect.row < rows && rect.column + rect.width > 0 && rect.row + rect.height > 0;
+function accessKitRoleFor(node) {
+  if (node.role === "textbox" && node.state?.multiline === true) return "multilineTextInput";
+  return ACCESSKIT_ROLE_BY_SEMANTIC_ROLE[node.role];
 }
-function checkNodeShape(node, snapshot, ids, limits) {
-  if (node.role === "generic" && (node.frameworkType === void 0 || node.frameworkType === "")) {
-    return fail2(
-      "schema",
-      `node ${node.id} has role 'generic' without a frameworkType; an unrecognised widget must name what the framework called it`
-    );
-  }
-  if (node.state?.offscreen === true && node.state.hidden !== true) {
-    return fail2(
-      "schema",
-      `node ${node.id}: state.offscreen implies state.hidden \u2014 every cell is outside the visible area, so the node cannot also be visible`
-    );
-  }
-  if (node.bounds !== void 0) {
-    const { width, height, row, column } = node.bounds;
-    if (!Number.isSafeInteger(row + height) || !Number.isSafeInteger(column + width)) {
-      return fail2("bad-rect", `node ${node.id}: bounds overflow the safe-integer range`);
-    }
-    if (node.state?.hidden !== true && !rectIntersectsViewport(node.bounds, snapshot.columns, snapshot.rows)) {
-      return fail2(
-        "bad-rect",
-        `node ${node.id}: bounds do not intersect the ${snapshot.columns}x${snapshot.rows} viewport and the node is not hidden`
-      );
-    }
-  }
-  for (const range of node.textRanges ?? []) {
-    if (range.endOffset < range.startOffset) {
-      return fail2("bad-rect", `node ${node.id}: text range ends before it starts`);
-    }
-    if (!Number.isSafeInteger(range.rect.row + range.rect.height)) {
-      return fail2("bad-rect", `node ${node.id}: text range rect overflows the safe-integer range`);
-    }
-  }
-  for (const [field, targets] of [
-    ["labelledBy", node.labelledBy],
-    ["describedBy", node.describedBy]
-  ]) {
-    if (targets === void 0) continue;
-    if (targets.length > limits.maxRelationTargets) {
-      return fail2("count", `node ${node.id}: ${field} exceeds ${limits.maxRelationTargets} targets`);
-    }
-    for (const target of targets) {
-      if (!ids.has(target)) {
-        return fail2("missing-parent", `node ${node.id}: ${field} references unknown node ${target}`);
-      }
-    }
+function actionsFor(actions) {
+  if (actions === void 0 || actions.length === 0) return void 0;
+  const mapped = /* @__PURE__ */ new Set();
+  for (const action of actions) {
+    const target = ACCESSKIT_ACTION_BY_SEMANTIC_ACTION[action];
+    if (target !== void 0) mapped.add(target);
   }
-  return null;
+  return mapped.size === 0 ? void 0 : [...mapped];
 }
-function computeDepths(nodes, byId) {
-  const depths = /* @__PURE__ */ new Map();
-  for (const start of nodes) {
-    if (depths.has(start.id)) continue;
-    const chain = [];
-    const onChain = /* @__PURE__ */ new Set();
-    let current = start;
-    while (current !== void 0 && !depths.has(current.id)) {
-      if (onChain.has(current.id)) return { cycleAt: current.id };
-      onChain.add(current.id);
-      chain.push(current.id);
-      current = current.parentId === void 0 ? void 0 : byId.get(current.parentId);
-    }
-    let depth = current === void 0 ? 0 : depths.get(current.id);
-    for (let i = chain.length - 1; i >= 0; i -= 1) {
-      depth += 1;
-      depths.set(chain[i], depth);
-    }
-  }
-  return { depths };
+function boundsFor(rect, cellSize) {
+  return {
+    x0: rect.column * cellSize.width,
+    y0: rect.row * cellSize.height,
+    x1: (rect.column + rect.width) * cellSize.width,
+    y1: (rect.row + rect.height) * cellSize.height
+  };
 }
-function validateSnapshot(value, limits) {
-  let projected;
-  try {
-    projected = projectDto(value, limits.maxDepth);
-  } catch (error) {
-    if (error instanceof ProtocolViolation) {
-      return fail2(error.code === "dto-depth" ? "depth" : "schema", error.message);
+function toAccessKitTreeUpdate(snapshot, options = {}) {
+  const idOf = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Map();
+  for (const node of snapshot.nodes) {
+    const mapped = accessKitNodeId(node.id);
+    const previous = seen.get(mapped);
+    if (previous !== void 0) {
+      throw new ProtocolViolation(
+        "dto-key",
+        `node ids "${previous}" and "${node.id}" collide in the AccessKit id space`
+      );
     }
-    return fail2("schema", "value could not be projected into a plain DTO");
-  }
-  const serialised = JSON.stringify(projected);
-  if (serialised === void 0) {
-    return fail2("schema", "snapshot is not a JSON object");
-  }
-  const bytes = Buffer3.byteLength(serialised, "utf8");
-  if (bytes > limits.maxSnapshotBytes) {
-    return fail2("bytes", `snapshot is ${bytes} bytes, ceiling is ${limits.maxSnapshotBytes}`);
-  }
-  const parsed = treeSchemas(limits).snapshot.safeParse(projected);
-  if (!parsed.success) {
-    const issue = parsed.error.issues[0];
-    return fail2(codeForIssue(issue), describeIssue(issue));
-  }
-  const snapshot = projected;
-  if (snapshot.nodes.length > limits.maxNodes) {
-    return fail2("count", `snapshot carries ${snapshot.nodes.length} nodes, ceiling is ${limits.maxNodes}`);
+    seen.set(mapped, node.id);
+    idOf.set(node.id, mapped);
   }
-  const byId = /* @__PURE__ */ new Map();
+  const childrenOf = /* @__PURE__ */ new Map();
   for (const node of snapshot.nodes) {
-    if (byId.has(node.id)) {
-      return fail2("duplicate-id", `node id ${node.id} appears more than once`);
-    }
-    byId.set(node.id, node);
-  }
-  const rootIds = /* @__PURE__ */ new Set();
-  for (const id of snapshot.rootIds) {
-    if (rootIds.has(id)) {
-      return fail2("duplicate-id", `root id ${id} appears more than once`);
-    }
-    rootIds.add(id);
-    const node = byId.get(id);
-    if (node === void 0) {
-      return fail2("missing-parent", `rootIds references unknown node ${id}`);
-    }
-    if (node.parentId !== void 0) {
-      return fail2("schema", `root node ${id} declares a parent`);
-    }
-  }
-  const ids = new Set(byId.keys());
-  if (snapshot.v === 2) {
-    if (snapshot.coordinateSpace?.status === "known" && snapshot.coordinateSpace.value !== "viewport-cells") {
-    }
-    if (snapshot.hitGrid?.status === "known") {
-      for (const region of snapshot.hitGrid.value.regions) {
-        if (!ids.has(region.recipientId)) {
-          return fail2("missing-parent", `hitGrid references unknown recipient ${region.recipientId}`);
-        }
-        if (!rectIntersectsViewport(region.rect, snapshot.columns, snapshot.rows)) {
-          return fail2("bad-rect", `hitGrid region for ${region.recipientId} does not intersect the viewport`);
-        }
-      }
-    }
-  }
-  for (const node of snapshot.nodes) {
-    if (node.parentId === void 0) {
-      if (!rootIds.has(node.id)) {
-        return fail2("schema", `parentless node ${node.id} is missing from rootIds`);
-      }
-    } else if (!byId.has(node.parentId)) {
-      return fail2("missing-parent", `node ${node.id} references unknown parent ${node.parentId}`);
-    } else if (node.parentId === node.id) {
-      return fail2("cycle", `node ${node.id} is its own parent`);
-    }
-    const problem = checkNodeShape(node, snapshot, ids, limits);
-    if (problem !== null) return problem;
-  }
-  const depthResult = computeDepths(snapshot.nodes, byId);
-  if ("cycleAt" in depthResult) {
-    return fail2("cycle", `parent chain through node ${depthResult.cycleAt} is cyclic`);
-  }
-  for (const [id, depth] of depthResult.depths) {
-    if (depth > limits.maxDepth) {
-      return fail2("depth", `node ${id} sits at depth ${depth}, ceiling is ${limits.maxDepth}`);
-    }
-  }
-  if (snapshot.cursor !== void 0) {
-    const { row, column } = snapshot.cursor;
-    if (row >= snapshot.rows || column >= snapshot.columns) {
-      return fail2("bad-rect", `cursor (${row}, ${column}) lies outside the viewport`);
-    }
-  }
-  return { ok: true, snapshot };
-}
-
-// src/delta.ts
-function fail3(code, detail) {
-  return { ok: false, code, detail };
-}
-var DELTA_KEYS = ["baseRevision", "revision", "changed", "removed", "rootIds", "cursor"];
-function validateTreeDelta(value, limits) {
-  let projected;
-  try {
-    projected = projectDto(value, limits.maxDepth);
-  } catch (error) {
-    if (error instanceof ProtocolViolation) {
-      return fail3(error.code === "dto-depth" ? "depth" : "schema", error.message);
-    }
-    return fail3("schema", "value could not be projected into a plain DTO");
-  }
-  const serialised = JSON.stringify(projected);
-  if (serialised === void 0) {
-    return fail3("schema", "delta is not a JSON object");
-  }
-  const bytes = Buffer4.byteLength(serialised, "utf8");
-  if (bytes > limits.maxSnapshotBytes) {
-    return fail3("bytes", `delta is ${bytes} bytes, ceiling is ${limits.maxSnapshotBytes}`);
-  }
-  if (typeof projected !== "object" || projected === null || Array.isArray(projected)) {
-    return fail3("schema", "delta must be an object");
-  }
-  const delta = projected;
-  for (const key of Object.keys(delta)) {
-    if (!DELTA_KEYS.includes(key)) return fail3("schema", `unknown delta property "${key}"`);
-  }
-  const { text, node, cursor } = treeSchemas(limits);
-  const parsed = deltaSchema(text, node, cursor, limits).safeParse(delta);
-  if (!parsed.success) {
-    const issue = parsed.error.issues[0];
-    const path = issue.path.map(String);
-    const where = path.length > 0 ? path.join(".") : "<root>";
-    const code = path.includes("role") ? "unknown-role" : path.includes("revision") || path.includes("baseRevision") ? "revision" : path.includes("bounds") || path.includes("rect") ? "bad-rect" : issue.code === "too_big" ? "count" : "schema";
-    return fail3(code, `${where}: ${issue.message}`);
-  }
-  const typed = delta;
-  if (typed.revision <= typed.baseRevision) {
-    return fail3(
-      "revision",
-      `revision ${typed.revision} must be greater than baseRevision ${typed.baseRevision}`
-    );
-  }
-  const total = typed.changed.length + typed.removed.length;
-  if (total > limits.maxNodes) {
-    return fail3("count", `delta touches ${total} nodes, ceiling is ${limits.maxNodes}`);
-  }
-  const changedIds = /* @__PURE__ */ new Set();
-  for (const entry of typed.changed) {
-    if (changedIds.has(entry.id)) {
-      return fail3("duplicate-id", `node id ${entry.id} appears twice in changed`);
-    }
-    changedIds.add(entry.id);
-    if (entry.parentId === entry.id) {
-      return fail3("cycle", `node ${entry.id} is its own parent`);
-    }
-  }
-  const removedIds = /* @__PURE__ */ new Set();
-  for (const id of typed.removed) {
-    if (removedIds.has(id)) return fail3("duplicate-id", `node id ${id} appears twice in removed`);
-    removedIds.add(id);
-    if (changedIds.has(id)) {
-      return fail3("schema", `node id ${id} is both changed and removed`);
-    }
-  }
-  if (typed.rootIds !== void 0) {
-    const seen = /* @__PURE__ */ new Set();
-    for (const id of typed.rootIds) {
-      if (seen.has(id)) return fail3("duplicate-id", `root id ${id} appears twice`);
-      seen.add(id);
-    }
-  }
-  return { ok: true, delta: typed };
-}
-var deltaCache = /* @__PURE__ */ new WeakMap();
-function deltaSchema(text, node, cursor, limits) {
-  const cached = deltaCache.get(limits);
-  if (cached !== void 0) return cached;
-  const built = z3.strictObject({
-    baseRevision: z3.number().refine((n) => Number.isSafeInteger(n) && n > 0, "expected a positive safe integer"),
-    revision: z3.number().refine((n) => Number.isSafeInteger(n) && n > 0, "expected a positive safe integer"),
-    changed: z3.array(node).max(limits.maxNodes),
-    removed: z3.array(text).max(limits.maxNodes),
-    rootIds: z3.array(text).max(limits.maxNodes).optional(),
-    cursor: cursor.optional()
-  });
-  deltaCache.set(limits, built);
-  return built;
-}
-function applyTreeDelta(base, delta, limits) {
-  if (delta.baseRevision !== base.revision) {
-    return {
-      ok: false,
-      code: "revision",
-      detail: `delta is based on revision ${delta.baseRevision} but the held snapshot is revision ${base.revision}; request a full snapshot instead of patching`
-    };
-  }
-  const byId = /* @__PURE__ */ new Map();
-  for (const node of base.nodes) byId.set(node.id, node);
-  const childrenOf = /* @__PURE__ */ new Map();
-  for (const node of base.nodes) {
-    if (node.parentId === void 0) continue;
-    const siblings = childrenOf.get(node.parentId);
-    if (siblings === void 0) childrenOf.set(node.parentId, [node.id]);
-    else siblings.push(node.id);
-  }
-  for (const id of delta.removed) {
-    if (!byId.has(id)) {
-      return {
-        ok: false,
-        code: "missing-parent",
-        detail: `delta removes unknown node ${id}; the producer's base disagrees with ours, so the tree must be resynchronised rather than patched`
-      };
-    }
-    const pending = [id];
-    while (pending.length > 0) {
-      const current = pending.pop();
-      if (!byId.delete(current)) continue;
-      const children = childrenOf.get(current);
-      if (children !== void 0) pending.push(...children);
-    }
-  }
-  for (const node of delta.changed) byId.set(node.id, node);
-  const rootIds = delta.rootIds ?? base.rootIds.filter((id) => byId.has(id));
-  const composed = {
-    v: 1,
-    sessionId: base.sessionId,
-    revision: delta.revision,
-    columns: base.columns,
-    rows: base.rows,
-    // Absent cursor means unchanged, so the base's carries over.
-    ...(delta.cursor ?? base.cursor) === void 0 ? {} : { cursor: delta.cursor ?? base.cursor },
-    rootIds,
-    nodes: [...byId.values()]
-  };
-  return validateSnapshot(composed, limits);
-}
-
-// src/accesskit.ts
-import { createHash } from "crypto";
-var ACCESSKIT_ROOT_TREE_ID = "00000000-0000-0000-0000-000000000000";
-var ACCESSKIT_ROLE_BY_SEMANTIC_ROLE = Object.freeze({
-  application: "application",
-  region: "region",
-  dialog: "dialog",
-  alert: "alert",
-  status: "status",
-  list: "list",
-  listitem: "listItem",
-  menu: "menu",
-  menuitem: "menuItem",
-  button: "button",
-  checkbox: "checkBox",
-  radio: "radioButton",
-  tab: "tab",
-  textbox: "textInput",
-  heading: "heading",
-  text: "label",
-  progressbar: "progressIndicator",
-  separator: "splitter",
-  scrollbar: "scrollBar",
-  table: "table",
-  row: "row",
-  cell: "cell",
-  generic: "genericContainer"
-});
-var ACCESSKIT_ACTION_BY_SEMANTIC_ACTION = Object.freeze({
-  focus: "focus",
-  activate: "click",
-  toggle: "click",
-  setValue: "setValue",
-  expand: "expand",
-  scroll: "scrollIntoView"
-});
-var NODE_ID_BITS = 53n;
-var NODE_ID_MASK = (1n << NODE_ID_BITS) - 1n;
-function accessKitNodeId(id) {
-  const digest = createHash("sha256").update(id, "utf8").digest();
-  const value = digest.readBigUInt64BE(0) & NODE_ID_MASK;
-  return value === 0n ? 1 : Number(value);
-}
-function toggledFor(checked) {
-  if (checked === void 0) return void 0;
-  if (checked === "mixed") return "mixed";
-  return checked ? "true" : "false";
-}
-function accessKitRoleFor(node) {
-  if (node.role === "textbox" && node.state?.multiline === true) return "multilineTextInput";
-  return ACCESSKIT_ROLE_BY_SEMANTIC_ROLE[node.role];
-}
-function actionsFor(actions) {
-  if (actions === void 0 || actions.length === 0) return void 0;
-  const mapped = /* @__PURE__ */ new Set();
-  for (const action of actions) {
-    const target = ACCESSKIT_ACTION_BY_SEMANTIC_ACTION[action];
-    if (target !== void 0) mapped.add(target);
-  }
-  return mapped.size === 0 ? void 0 : [...mapped];
-}
-function boundsFor(rect, cellSize) {
-  return {
-    x0: rect.column * cellSize.width,
-    y0: rect.row * cellSize.height,
-    x1: (rect.column + rect.width) * cellSize.width,
-    y1: (rect.row + rect.height) * cellSize.height
-  };
-}
-function toAccessKitTreeUpdate(snapshot, options = {}) {
-  const idOf = /* @__PURE__ */ new Map();
-  const seen = /* @__PURE__ */ new Map();
-  for (const node of snapshot.nodes) {
-    const mapped = accessKitNodeId(node.id);
-    const previous = seen.get(mapped);
-    if (previous !== void 0) {
-      throw new ProtocolViolation(
-        "dto-key",
-        `node ids "${previous}" and "${node.id}" collide in the AccessKit id space`
-      );
-    }
-    seen.set(mapped, node.id);
-    idOf.set(node.id, mapped);
-  }
-  const childrenOf = /* @__PURE__ */ new Map();
-  for (const node of snapshot.nodes) {
-    if (node.parentId === void 0) continue;
-    const siblings = childrenOf.get(node.parentId);
-    if (siblings === void 0) childrenOf.set(node.parentId, [idOf.get(node.id)]);
-    else siblings.push(idOf.get(node.id));
+    if (node.parentId === void 0) continue;
+    const siblings = childrenOf.get(node.parentId);
+    if (siblings === void 0) childrenOf.set(node.parentId, [idOf.get(node.id)]);
+    else siblings.push(idOf.get(node.id));
   }
   const relation = (ids) => {
     if (ids === void 0 || ids.length === 0) return void 0;
@@ -1225,14 +1090,15 @@ function toAccessKitTreeUpdate(snapshot, options = {}) {
     const id = idOf.get(node.id);
     const state = node.state;
     if (state?.focused === true && focus === void 0) focus = id;
-    if (node.bounds !== void 0) cellBounds[String(id)] = node.bounds;
+    const visibleRect = node.geometry.visibleRect.status === "known" ? node.geometry.visibleRect.value : void 0;
+    if (visibleRect !== void 0) cellBounds[String(id)] = visibleRect;
     const accessKitNode = {
       role: accessKitRoleFor(node),
       ...node.name === "" ? {} : { label: node.name },
       ...node.description === void 0 ? {} : { description: node.description },
-      ...node.value === void 0 ? {} : { value: node.value },
+      ...node.value?.status === "known" && node.value.sensitivity === "public" ? { value: node.value.value } : {},
       ...childrenOf.has(node.id) ? { children: childrenOf.get(node.id) } : {},
-      ...node.bounds !== void 0 && options.cellSize !== void 0 ? { bounds: boundsFor(node.bounds, options.cellSize) } : {},
+      ...visibleRect !== void 0 && options.cellSize !== void 0 ? { bounds: boundsFor(visibleRect, options.cellSize) } : {},
       ...actionsFor(node.actions) === void 0 ? {} : { actions: actionsFor(node.actions) },
       ...relation(node.labelledBy) === void 0 ? {} : { labelledBy: relation(node.labelledBy) },
       ...relation(node.describedBy) === void 0 ? {} : { describedBy: relation(node.describedBy) },
@@ -1243,6 +1109,8 @@ function toAccessKitTreeUpdate(snapshot, options = {}) {
       ...state?.modal === void 0 ? {} : { modal: state.modal },
       ...state?.hidden === void 0 ? {} : { hidden: state.hidden },
       ...state?.readonly === void 0 ? {} : { readOnly: state.readonly },
+      ...state?.required === void 0 ? {} : { required: state.required },
+      ...state?.multiselectable === void 0 ? {} : { multiselectable: state.multiselectable },
       ...toggledFor(state?.checked) === void 0 ? {} : { toggled: toggledFor(state?.checked) }
     };
     nodes.push(Object.freeze([id, Object.freeze(accessKitNode)]));
@@ -1264,135 +1132,154 @@ function toAccessKitTreeUpdate(snapshot, options = {}) {
   return Object.freeze({ update: Object.freeze(update), cellBounds: Object.freeze(cellBounds) });
 }
 
-// src/probe/bounds.ts
-function intersect(a, b) {
-  const row = Math.max(a.row, b.row);
-  const column = Math.max(a.column, b.column);
-  const bottom = Math.min(a.row + a.height, b.row + b.height);
-  const right = Math.min(a.column + a.width, b.column + b.width);
-  const height = Math.max(0, bottom - row);
-  const width = Math.max(0, right - column);
-  return { rect: { row, column, width, height }, empty: width === 0 || height === 0 };
-}
-function resolveNodeBounds(geometry, options = {}) {
-  const occlusion = options.paintOrderKnown === true ? "known" : "unknown";
-  if (geometry?.visibleRect !== void 0) {
-    const rect = geometry.visibleRect;
-    return {
-      rect,
-      occlusion,
-      source: "visible",
-      clippedAway: rect.width === 0 || rect.height === 0
-    };
-  }
-  if (geometry?.intendedRect === void 0) return void 0;
-  if (options.clip !== void 0) {
-    const { rect, empty } = intersect(geometry.intendedRect, options.clip);
-    const occupiedCells = geometry.intendedRect.width > 0 && geometry.intendedRect.height > 0;
-    return { rect, occlusion, source: "clipped", clippedAway: empty && occupiedCells };
-  }
-  return {
-    rect: geometry.intendedRect,
-    occlusion,
-    source: "intended",
-    clippedAway: false
-  };
-}
-
 // src/probe/validate.ts
-import { Buffer as Buffer5 } from "buffer";
-import { z as z4 } from "zod";
-function fail4(code, detail) {
+import { Buffer as Buffer3 } from "buffer";
+import { z as z2 } from "zod";
+function fail2(code, detail) {
   return { ok: false, code, detail };
 }
-var safeInt2 = z4.number().refine(Number.isSafeInteger, "expected a safe integer");
-var nonNegative = z4.number().refine((n) => Number.isSafeInteger(n) && n >= 0, "expected a non-negative safe integer");
-var positive = z4.number().refine((n) => Number.isSafeInteger(n) && n > 0, "expected a positive safe integer");
+var safeInt2 = z2.number().refine(Number.isSafeInteger, "expected a safe integer");
+var nonNegative = z2.number().refine((n) => Number.isSafeInteger(n) && n >= 0, "expected a non-negative safe integer");
+var positive = z2.number().refine((n) => Number.isSafeInteger(n) && n > 0, "expected a positive safe integer");
 var cache2 = /* @__PURE__ */ new WeakMap();
 function buildFrameSchema(limits) {
-  const text = z4.string().refine(
-    (s) => Buffer5.byteLength(s, "utf8") <= limits.maxStringBytes,
+  const text = z2.string().refine(
+    (s) => Buffer3.byteLength(s, "utf8") <= limits.maxStringBytes,
     `expected at most ${limits.maxStringBytes} UTF-8 bytes`
   );
-  const rect = z4.strictObject({
+  const rect = z2.strictObject({
     row: safeInt2,
     column: safeInt2,
     width: nonNegative,
     height: nonNegative
   });
-  const identity = z4.strictObject({
-    kind: z4.enum(["stable", "frame-local"]),
+  const identity = z2.strictObject({
+    kind: z2.enum(["stable", "frame-local"]),
     value: text.min(1)
   });
-  const extendedValue = z4.lazy(
-    () => z4.union([
-      z4.null(),
-      z4.boolean(),
-      z4.number().finite().refine(
+  const extendedValue = z2.lazy(
+    () => z2.union([
+      z2.null(),
+      z2.boolean(),
+      z2.number().finite().refine(
         (value) => Math.abs(value) <= Number.MAX_SAFE_INTEGER,
         "expected a finite JSON number in the safe range"
       ),
       text,
-      z4.array(extendedValue).max(limits.maxRelationTargets),
-      z4.record(text, extendedValue).refine(
+      z2.array(extendedValue).max(limits.maxRelationTargets),
+      z2.record(text, extendedValue).refine(
         (value) => Object.keys(value).length <= limits.maxRelationTargets,
         `expected at most ${limits.maxRelationTargets} properties`
       )
     ])
   );
-  const extended = z4.record(text, extendedValue).refine(
+  const extended = z2.record(text, extendedValue).refine(
     (value) => Object.keys(value).length <= limits.maxRelationTargets,
     `expected at most ${limits.maxRelationTargets} properties`
   );
-  const relations = z4.array(text.min(1)).max(limits.maxRelationTargets);
-  const state = z4.strictObject({
-    focused: z4.boolean().optional(),
-    disabled: z4.boolean().optional(),
-    checked: z4.union([z4.boolean(), z4.literal("mixed")]).optional(),
-    expanded: z4.boolean().optional(),
-    readonly: z4.boolean().optional(),
-    selected: z4.boolean().optional(),
-    busy: z4.boolean().optional(),
-    multiline: z4.boolean().optional(),
-    displayed: z4.boolean().optional(),
+  const relations = z2.array(text.min(1)).max(limits.maxRelationTargets);
+  const inputRecipe = z2.strictObject({
+    action: z2.enum(PHYSICAL_INPUT_RECIPE_ACTIONS),
+    requiresFocus: z2.boolean(),
+    steps: z2.array(
+      z2.union([
+        z2.strictObject({ kind: z2.literal("press"), key: text.min(1) }),
+        z2.strictObject({ kind: z2.literal("insert-action-value") })
+      ])
+    ).min(1).max(limits.maxRelationTargets)
+  }).superRefine((recipe, context) => {
+    const inserts = recipe.steps.filter(({ kind }) => kind === "insert-action-value").length;
+    if (recipe.action === "setValue" && inserts !== 1 || recipe.action !== "setValue" && inserts !== 0) {
+      context.addIssue({
+        code: "custom",
+        message: "setValue requires exactly one insert-action-value step"
+      });
+    }
+    if (recipe.action === "focus" && recipe.requiresFocus) {
+      context.addIssue({
+        code: "custom",
+        message: "focus recipe cannot require focus"
+      });
+    }
+  });
+  const inputRecipes = z2.array(inputRecipe).max(PHYSICAL_INPUT_RECIPE_ACTIONS.length).superRefine((recipes, context) => {
+    if (new Set(recipes.map(({ action }) => action)).size !== recipes.length) {
+      context.addIssue({
+        code: "custom",
+        message: "input recipe actions must be unique"
+      });
+    }
+  });
+  const state = z2.strictObject({
+    focused: z2.boolean().optional(),
+    disabled: z2.boolean().optional(),
+    checked: z2.union([z2.boolean(), z2.literal("mixed")]).optional(),
+    expanded: z2.boolean().optional(),
+    readonly: z2.boolean().optional(),
+    selected: z2.boolean().optional(),
+    busy: z2.boolean().optional(),
+    multiline: z2.boolean().optional(),
+    required: z2.boolean().optional(),
+    multiselectable: z2.boolean().optional(),
+    displayed: z2.boolean().optional(),
     value: text.optional(),
+    valueSensitivity: z2.enum(["public", "sensitive"]).optional(),
     selectedIndex: nonNegative.optional(),
-    textSelection: z4.strictObject({ start: nonNegative, end: nonNegative }).optional(),
-    scroll: z4.strictObject({ row: nonNegative, column: nonNegative }).optional(),
-    scrollExtent: z4.strictObject({ rows: nonNegative, columns: nonNegative }).optional()
+    textSelection: z2.strictObject({ start: nonNegative, end: nonNegative }).optional(),
+    scroll: z2.strictObject({ row: nonNegative, column: nonNegative }).optional(),
+    scrollExtent: z2.strictObject({ rows: nonNegative, columns: nonNegative }).optional()
   });
-  const object = z4.strictObject({
+  const object = z2.strictObject({
     identity,
     frameworkType: text.min(1),
     parent: text.optional(),
-    geometry: z4.strictObject({ intendedRect: rect.optional(), visibleRect: rect.optional() }).optional(),
+    geometry: z2.strictObject({
+      intendedRect: rect.optional(),
+      visibleRect: rect.optional()
+    }).optional(),
     state: state.optional(),
     text: text.optional(),
-    accessibility: z4.strictObject({ role: text.optional(), name: text.optional(), description: text.optional() }).optional(),
-    annotations: z4.strictObject({
+    accessibility: z2.strictObject({
+      role: text.optional(),
+      name: text.optional(),
+      description: text.optional()
+    }).optional(),
+    annotations: z2.strictObject({
       role: text.optional(),
       name: text.optional(),
       testId: text.optional(),
       description: text.optional(),
       extended: extended.optional(),
-      actions: z4.array(z4.enum(SEMANTIC_ACTIONS)).max(SEMANTIC_ACTIONS.length).optional(),
+      actions: z2.array(z2.enum(SEMANTIC_ACTIONS)).max(SEMANTIC_ACTIONS.length).optional(),
+      inputRecipes: inputRecipes.optional(),
       labelledBy: relations.optional(),
       describedBy: relations.optional()
+    }).superRefine((annotations, context) => {
+      const intents = new Set(annotations.actions ?? []);
+      for (const [index, recipe] of (annotations.inputRecipes ?? []).entries()) {
+        if (!intents.has(recipe.action)) {
+          context.addIssue({
+            code: "custom",
+            path: ["inputRecipes", index, "action"],
+            message: `input recipe '${recipe.action}' requires the matching semantic action intent`
+          });
+        }
+      }
     }).optional(),
     paintOrder: safeInt2.optional(),
-    unobservable: z4.array(z4.enum(PROBE_UNOBSERVABLE_FIELDS)).max(PROBE_UNOBSERVABLE_FIELDS.length).optional()
+    unobservable: z2.array(z2.enum(PROBE_UNOBSERVABLE_FIELDS)).max(PROBE_UNOBSERVABLE_FIELDS.length).optional()
   });
-  const operation = z4.strictObject({
-    kind: z4.enum(["render", "layout"]),
+  const operation = z2.strictObject({
+    kind: z2.enum(["render", "layout"]),
     ordinal: nonNegative,
     target: identity.optional(),
     frameworkType: text.optional(),
     intendedRect: rect.optional()
   });
-  return z4.strictObject({
+  return z2.strictObject({
     frame: positive,
-    objects: z4.array(object).max(limits.maxNodes),
-    operations: z4.array(operation).max(limits.maxNodes).optional()
+    objects: z2.array(object).max(limits.maxNodes),
+    operations: z2.array(operation).max(limits.maxNodes).optional()
   });
 }
 function frameSchema(limits) {
@@ -1402,12 +1289,17 @@ function frameSchema(limits) {
   cache2.set(limits, built);
   return built;
 }
-var probeInfoSchema = z4.strictObject({
-  framework: z4.string().min(1).max(128),
-  frameworkVersion: z4.string().max(128).optional(),
-  probeVersion: z4.string().min(1).max(128),
-  identityKind: z4.enum(["stable", "frame-local"]),
-  capabilities: z4.array(z4.enum(PROBE_CAPABILITIES)).max(PROBE_CAPABILITIES.length)
+var probeInfoSchema = z2.strictObject({
+  framework: z2.string().min(1).max(128),
+  frameworkVersion: z2.string().max(128).optional(),
+  probeVersion: z2.string().min(1).max(128),
+  identityKind: z2.enum(["stable", "frame-local"]),
+  capabilities: z2.array(z2.enum(PROBE_CAPABILITIES)).max(PROBE_CAPABILITIES.length),
+  instrumentation: z2.strictObject({
+    highestTier: z2.enum(PROBE_INJECTION_TIERS),
+    semanticClass: z2.enum(PROBE_SEMANTIC_CLASSES),
+    degradedCapabilities: z2.array(z2.enum(PROBE_DEGRADED_CAPABILITIES)).max(PROBE_DEGRADED_CAPABILITIES.length)
+  }).optional()
 });
 function validateProbeInfo(value) {
   const parsed = probeInfoSchema.safeParse(value);
@@ -1417,13 +1309,35 @@ function validateProbeInfo(value) {
     return { ok: false, detail: `${where}: ${issue.message}` };
   }
   const info = parsed.data;
+  const degraded = info.instrumentation?.degradedCapabilities;
+  if (degraded !== void 0 && new Set(degraded).size !== degraded.length) {
+    return { ok: false, detail: "instrumentation.degradedCapabilities: duplicate capability" };
+  }
+  if (info.instrumentation?.semanticClass === "B" && (!degraded?.includes("intended-geometry") || !degraded.includes("clipped-geometry"))) {
+    return {
+      ok: false,
+      detail: "semantic class B must declare both 'intended-geometry' and 'clipped-geometry' as degraded"
+    };
+  }
   if (info.identityKind === "frame-local" && info.capabilities.includes("stable-identity")) {
     return {
       ok: false,
       detail: "a probe declaring identityKind 'frame-local' must not claim the 'stable-identity' capability: nothing in an immediate-mode frame survives to be correlated"
     };
   }
-  return { ok: true, info: Object.freeze(info) };
+  return {
+    ok: true,
+    info: Object.freeze({
+      ...info,
+      capabilities: Object.freeze([...info.capabilities]),
+      ...info.instrumentation === void 0 ? {} : {
+        instrumentation: Object.freeze({
+          ...info.instrumentation,
+          degradedCapabilities: Object.freeze([...info.instrumentation.degradedCapabilities])
+        })
+      }
+    })
+  };
 }
 function validateProbeFrame(value, limits) {
   let projected;
@@ -1431,15 +1345,15 @@ function validateProbeFrame(value, limits) {
     projected = projectDto(value, limits.maxDepth);
   } catch (error) {
     if (error instanceof ProtocolViolation) {
-      return fail4(error.code === "dto-depth" ? "depth" : "schema", error.message);
+      return fail2(error.code === "dto-depth" ? "depth" : "schema", error.message);
     }
-    return fail4("schema", "value could not be projected into a plain DTO");
+    return fail2("schema", "value could not be projected into a plain DTO");
   }
   const serialised = JSON.stringify(projected);
-  if (serialised === void 0) return fail4("schema", "probe frame is not a JSON object");
-  const bytes = Buffer5.byteLength(serialised, "utf8");
+  if (serialised === void 0) return fail2("schema", "probe frame is not a JSON object");
+  const bytes = Buffer3.byteLength(serialised, "utf8");
   if (bytes > limits.maxSnapshotBytes) {
-    return fail4("bytes", `probe frame is ${bytes} bytes, ceiling is ${limits.maxSnapshotBytes}`);
+    return fail2("bytes", `probe frame is ${bytes} bytes, ceiling is ${limits.maxSnapshotBytes}`);
   }
   const parsed = frameSchema(limits).safeParse(projected);
   if (!parsed.success) {
@@ -1447,31 +1361,37 @@ function validateProbeFrame(value, limits) {
     const path = issue.path.map(String);
     const where = path.length > 0 ? path.join(".") : "<root>";
     const code = path.includes("intendedRect") || path.includes("visibleRect") ? "bad-rect" : path.includes("frame") ? "revision" : issue.code === "too_big" ? "count" : "schema";
-    return fail4(code, `${where}: ${issue.message}`);
+    return fail2(code, `${where}: ${issue.message}`);
   }
   const frame = projected;
   const seen = /* @__PURE__ */ new Set();
   for (const object of frame.objects) {
     if (seen.has(object.identity.value)) {
-      return fail4("duplicate-id", `identity ${object.identity.value} appears twice in the frame`);
+      return fail2("duplicate-id", `identity ${object.identity.value} appears twice in the frame`);
     }
     seen.add(object.identity.value);
   }
   for (const object of frame.objects) {
     if (object.parent !== void 0 && !seen.has(object.parent)) {
-      return fail4(
+      return fail2(
         "missing-parent",
         `object ${object.identity.value} names parent ${object.parent}, which is not in the frame`
       );
     }
     if (object.parent === object.identity.value) {
-      return fail4("cycle", `object ${object.identity.value} is its own parent`);
+      return fail2("cycle", `object ${object.identity.value} is its own parent`);
+    }
+    if (object.state?.valueSensitivity !== void 0 && object.state.value === void 0) {
+      return fail2(
+        "schema",
+        `object ${object.identity.value} classifies a semantic value it did not report`
+      );
     }
     const unobservable = object.unobservable;
     if (unobservable === void 0) continue;
     const declared = new Set(unobservable);
     if (declared.size !== unobservable.length) {
-      return fail4("duplicate-id", `object ${object.identity.value} repeats an unobservable field`);
+      return fail2("duplicate-id", `object ${object.identity.value} repeats an unobservable field`);
     }
     for (const [field, present] of [
       ["text", object.text !== void 0],
@@ -1481,7 +1401,7 @@ function validateProbeFrame(value, limits) {
       ["paintOrder", object.paintOrder !== void 0]
     ]) {
       if (declared.has(field) && present) {
-        return fail4(
+        return fail2(
           "schema",
           `object ${object.identity.value} reports ${field} and also declares it unobservable`
         );
@@ -1489,7 +1409,7 @@ function validateProbeFrame(value, limits) {
     }
     for (const [field, value_] of Object.entries(object.state ?? {})) {
       if (declared.has(field) && value_ !== void 0) {
-        return fail4(
+        return fail2(
           "schema",
           `object ${object.identity.value} reports state.${field} and also declares it unobservable`
         );
@@ -1534,26 +1454,350 @@ function validateProbeAnnotations(value, limits) {
 }
 
 // src/messages.ts
-import { z as z5 } from "zod";
-var ADAPTER_CAPABILITIES = [
-  "tree",
-  "bounds",
-  "absolute-bounds",
-  "states",
-  "actions",
-  "text-ranges",
-  "render-revisions",
-  "tree-diffs",
-  "logs",
-  "qualified-observations",
-  "pointer-hit-grid"
-];
+import { z as z4 } from "zod";
+
+// src/validate.ts
+import { Buffer as Buffer4 } from "buffer";
+import "zod";
+function fail3(code, detail) {
+  return { ok: false, code, detail };
+}
+function codeForIssue(issue) {
+  const path = issue.path.map(String);
+  if (path.includes("role")) return "unknown-role";
+  if (path.includes("revision")) return "revision";
+  if (path.includes("bounds") || ["row", "column", "width", "height"].includes(path.at(-1) ?? ""))
+    return "bad-rect";
+  if (issue.code === "custom" && issue.message?.includes("hit regions")) return "bad-rect";
+  if (issue.code === "too_big" && (path.includes("nodes") || path.includes("rootIds"))) {
+    return "count";
+  }
+  if (issue.code === "custom" && typeof issue.message === "string" && issue.message.includes("UTF-8 bytes")) {
+    return "string-bytes";
+  }
+  return "schema";
+}
+function describeIssue(issue) {
+  const where = issue.path.length > 0 ? issue.path.map(String).join(".") : "<root>";
+  return `${where}: ${issue.message}`;
+}
+function rectIntersectsViewport(rect, columns, rows) {
+  if (rect.width === 0 || rect.height === 0) return false;
+  return rect.column < columns && rect.row < rows && rect.column + rect.width > 0 && rect.row + rect.height > 0;
+}
+function rectContains(outer, inner) {
+  return inner.row >= outer.row && inner.column >= outer.column && inner.row + inner.height <= outer.row + outer.height && inner.column + inner.width <= outer.column + outer.width;
+}
+function regionProblem(owner, region, columns, rows) {
+  for (const span of region.spans) {
+    if (span.row >= rows || span.from >= columns || span.to > columns) {
+      return fail3("bad-rect", `${owner} span lies outside the viewport`);
+    }
+    if (span.row < region.regionBounds.row || span.row >= region.regionBounds.row + region.regionBounds.height || span.from < region.regionBounds.column || span.to > region.regionBounds.column + region.regionBounds.width) {
+      return fail3("bad-rect", `${owner} span lies outside regionBounds`);
+    }
+  }
+  return null;
+}
+function checkNodeShape(node, snapshot, ids, limits) {
+  if (node.role === "generic" && (node.frameworkType === void 0 || node.frameworkType === "")) {
+    return fail3(
+      "schema",
+      `node ${node.id} has role 'generic' without a frameworkType; an unrecognised widget must name what the framework called it`
+    );
+  }
+  if (node.state?.offscreen === true && node.state.hidden !== true) {
+    return fail3(
+      "schema",
+      `node ${node.id}: state.offscreen implies state.hidden \u2014 every cell is outside the visible area, so the node cannot also be visible`
+    );
+  }
+  for (const [name, observation] of [
+    ["intendedRect", node.geometry.intendedRect],
+    ["visibleRect", node.geometry.visibleRect]
+  ]) {
+    if (observation.status !== "known") continue;
+    const { row, column, width, height } = observation.value;
+    if (!Number.isSafeInteger(row + height) || !Number.isSafeInteger(column + width)) {
+      return fail3("bad-rect", `node ${node.id}: ${name} overflows the safe-integer range`);
+    }
+  }
+  if (node.paintedRegion?.status === "known") {
+    const problem = regionProblem(
+      `node ${node.id} painted region`,
+      node.paintedRegion.value,
+      snapshot.columns,
+      snapshot.rows
+    );
+    if (problem !== null) return problem;
+  }
+  const intended = node.geometry.intendedRect;
+  const visible = node.geometry.visibleRect;
+  if (visible.status === "known" && visible.value.width > 0 && visible.value.height > 0) {
+    if (snapshot.coordinateSpace.status === "known" && snapshot.coordinateSpace.value === "viewport-cells" && !rectIntersectsViewport(visible.value, snapshot.columns, snapshot.rows)) {
+      return fail3("bad-rect", `node ${node.id}: visibleRect does not intersect the viewport`);
+    }
+    if (intended.status === "known" && !rectContains(intended.value, visible.value)) {
+      return fail3("bad-rect", `node ${node.id}: visibleRect extends outside intendedRect`);
+    }
+  }
+  for (const range of node.textRanges ?? []) {
+    if (range.endOffset < range.startOffset) {
+      return fail3("bad-rect", `node ${node.id}: text range ends before it starts`);
+    }
+    if (!Number.isSafeInteger(range.rect.row + range.rect.height)) {
+      return fail3("bad-rect", `node ${node.id}: text range rect overflows the safe-integer range`);
+    }
+  }
+  for (const [field, targets] of [
+    ["labelledBy", node.labelledBy],
+    ["describedBy", node.describedBy]
+  ]) {
+    if (targets === void 0) continue;
+    if (targets.length > limits.maxRelationTargets) {
+      return fail3(
+        "count",
+        `node ${node.id}: ${field} exceeds ${limits.maxRelationTargets} targets`
+      );
+    }
+    for (const target of targets) {
+      if (!ids.has(target)) {
+        return fail3(
+          "missing-parent",
+          `node ${node.id}: ${field} references unknown node ${target}`
+        );
+      }
+    }
+  }
+  return null;
+}
+function computeDepths(nodes, byId) {
+  const depths = /* @__PURE__ */ new Map();
+  for (const start of nodes) {
+    if (depths.has(start.id)) continue;
+    const chain = [];
+    const onChain = /* @__PURE__ */ new Set();
+    let current = start;
+    while (current !== void 0 && !depths.has(current.id)) {
+      if (onChain.has(current.id)) return { cycleAt: current.id };
+      onChain.add(current.id);
+      chain.push(current.id);
+      current = current.parentId === void 0 ? void 0 : byId.get(current.parentId);
+    }
+    let depth = current === void 0 ? 0 : depths.get(current.id);
+    for (let i = chain.length - 1; i >= 0; i -= 1) {
+      depth += 1;
+      depths.set(chain[i], depth);
+    }
+  }
+  return { depths };
+}
+function validateSnapshot(value, limits) {
+  let projected;
+  try {
+    projected = projectDto(value, limits.maxDepth);
+  } catch (error) {
+    if (error instanceof ProtocolViolation) {
+      return fail3(error.code === "dto-depth" ? "depth" : "schema", error.message);
+    }
+    return fail3("schema", "value could not be projected into a plain DTO");
+  }
+  const serialised = JSON.stringify(projected);
+  if (serialised === void 0) {
+    return fail3("schema", "snapshot is not a JSON object");
+  }
+  const bytes = Buffer4.byteLength(serialised, "utf8");
+  if (bytes > limits.maxSnapshotBytes) {
+    return fail3("bytes", `snapshot is ${bytes} bytes, ceiling is ${limits.maxSnapshotBytes}`);
+  }
+  const parsed = treeSchemas(limits).snapshot.safeParse(projected);
+  if (!parsed.success) {
+    const issue = parsed.error.issues[0];
+    return fail3(codeForIssue(issue), describeIssue(issue));
+  }
+  const snapshot = projected;
+  if (snapshot.nodes.length > limits.maxNodes) {
+    return fail3(
+      "count",
+      `snapshot carries ${snapshot.nodes.length} nodes, ceiling is ${limits.maxNodes}`
+    );
+  }
+  const byId = /* @__PURE__ */ new Map();
+  for (const node of snapshot.nodes) {
+    if (byId.has(node.id)) {
+      return fail3("duplicate-id", `node id ${node.id} appears more than once`);
+    }
+    byId.set(node.id, node);
+  }
+  const rootIds = /* @__PURE__ */ new Set();
+  for (const id of snapshot.rootIds) {
+    if (rootIds.has(id)) {
+      return fail3("duplicate-id", `root id ${id} appears more than once`);
+    }
+    rootIds.add(id);
+    const node = byId.get(id);
+    if (node === void 0) {
+      return fail3("missing-parent", `rootIds references unknown node ${id}`);
+    }
+    if (node.parentId !== void 0) {
+      return fail3("schema", `root node ${id} declares a parent`);
+    }
+  }
+  const ids = new Set(byId.keys());
+  if (snapshot.coordinateSpace.status === "known" && snapshot.coordinateSpace.value !== "viewport-cells") {
+  }
+  if (snapshot.hitGrid.status === "known") {
+    for (const region of snapshot.hitGrid.value.regions) {
+      if (!ids.has(region.recipientId)) {
+        return fail3("missing-parent", `hitGrid references unknown recipient ${region.recipientId}`);
+      }
+      if (!rectIntersectsViewport(region.rect, snapshot.columns, snapshot.rows)) {
+        return fail3(
+          "bad-rect",
+          `hitGrid region for ${region.recipientId} does not intersect the viewport`
+        );
+      }
+    }
+  }
+  const providerIds = /* @__PURE__ */ new Set();
+  for (const provider of snapshot.providerEvidence ?? []) {
+    if (providerIds.has(provider.providerId)) {
+      return fail3("provider", `provider evidence id ${provider.providerId} appears more than once`);
+    }
+    providerIds.add(provider.providerId);
+    if (provider.sessionId !== snapshot.sessionId) {
+      return fail3(
+        "provider",
+        `provider ${provider.providerId} evidence session ${provider.sessionId} does not match snapshot session ${snapshot.sessionId}`
+      );
+    }
+    if (provider.revision !== snapshot.revision) {
+      return fail3(
+        "provider",
+        `provider ${provider.providerId} evidence revision ${provider.revision} does not match snapshot revision ${snapshot.revision}`
+      );
+    }
+    if (provider.status !== "available") continue;
+    if (provider.evidence.providerId !== provider.providerId) {
+      return fail3(
+        "schema",
+        `provider ${provider.providerId} evidence provenance names ${provider.evidence.providerId}`
+      );
+    }
+    if (provider.focusState?.status === "focused" && !ids.has(provider.focusState.recipientId)) {
+      return fail3(
+        "missing-parent",
+        `provider ${provider.providerId} focus references unknown recipient ${provider.focusState.recipientId}`
+      );
+    }
+    for (const region of provider.pointerRegions) {
+      if (!ids.has(region.recipientId)) {
+        return fail3(
+          "missing-parent",
+          `provider ${provider.providerId} references unknown recipient ${region.recipientId}`
+        );
+      }
+      const problem = regionProblem(
+        `provider ${provider.providerId} span for ${region.recipientId}`,
+        region,
+        snapshot.columns,
+        snapshot.rows
+      );
+      if (problem !== null) return problem;
+    }
+    for (const region of provider.paintedRegions ?? []) {
+      if (!ids.has(region.recipientId)) {
+        return fail3(
+          "missing-parent",
+          `provider ${provider.providerId} painted region references unknown recipient ${region.recipientId}`
+        );
+      }
+      const problem = regionProblem(
+        `provider ${provider.providerId} painted region for ${region.recipientId}`,
+        region,
+        snapshot.columns,
+        snapshot.rows
+      );
+      if (problem !== null) return problem;
+    }
+    for (const hit of provider.hitGrid?.regions ?? []) {
+      if (!ids.has(hit.recipientId)) {
+        return fail3(
+          "missing-parent",
+          `provider ${provider.providerId} hitGrid references unknown recipient ${hit.recipientId}`
+        );
+      }
+      if (!rectIntersectsViewport(hit.rect, snapshot.columns, snapshot.rows)) {
+        return fail3(
+          "bad-rect",
+          `provider ${provider.providerId} hitGrid region for ${hit.recipientId} does not intersect the viewport`
+        );
+      }
+    }
+    for (const entry of provider.actionRecipes ?? []) {
+      if (!ids.has(entry.recipientId)) {
+        return fail3(
+          "missing-parent",
+          `provider ${provider.providerId} action recipes reference unknown recipient ${entry.recipientId}`
+        );
+      }
+      const node = snapshot.nodes.find(({ id }) => id === entry.recipientId);
+      const intents = new Set(node.actions ?? []);
+      const missingIntent = entry.recipes.find(({ action }) => !intents.has(action));
+      if (missingIntent !== void 0) {
+        return fail3(
+          "provider",
+          `provider ${provider.providerId} ${missingIntent.action} recipe has no matching semantic action intent on ${entry.recipientId}`
+        );
+      }
+    }
+    for (const state of provider.scrollStates ?? []) {
+      if (!ids.has(state.recipientId)) {
+        return fail3(
+          "missing-parent",
+          `provider ${provider.providerId} scroll state references unknown recipient ${state.recipientId}`
+        );
+      }
+    }
+  }
+  for (const node of snapshot.nodes) {
+    if (node.parentId === void 0) {
+      if (!rootIds.has(node.id)) {
+        return fail3("schema", `parentless node ${node.id} is missing from rootIds`);
+      }
+    } else if (!byId.has(node.parentId)) {
+      return fail3("missing-parent", `node ${node.id} references unknown parent ${node.parentId}`);
+    } else if (node.parentId === node.id) {
+      return fail3("cycle", `node ${node.id} is its own parent`);
+    }
+    const problem = checkNodeShape(node, snapshot, ids, limits);
+    if (problem !== null) return problem;
+  }
+  const depthResult = computeDepths(snapshot.nodes, byId);
+  if ("cycleAt" in depthResult) {
+    return fail3("cycle", `parent chain through node ${depthResult.cycleAt} is cyclic`);
+  }
+  for (const [id, depth] of depthResult.depths) {
+    if (depth > limits.maxDepth) {
+      return fail3("depth", `node ${id} sits at depth ${depth}, ceiling is ${limits.maxDepth}`);
+    }
+  }
+  if (snapshot.cursor !== void 0) {
+    const { row, column } = snapshot.cursor;
+    if (row >= snapshot.rows || column >= snapshot.columns) {
+      return fail3("bad-rect", `cursor (${row}, ${column}) lies outside the viewport`);
+    }
+  }
+  return { ok: true, snapshot };
+}
+
+// src/messages.ts
 var MAX_IDENTIFIER_LENGTH = 1024;
-var identifier = z5.string().max(MAX_IDENTIFIER_LENGTH);
+var identifier = z4.string().max(MAX_IDENTIFIER_LENGTH);
 var nonEmptyIdentifier = identifier.min(1);
-var safeIndex = z5.number().refine((n) => Number.isSafeInteger(n) && n >= 0, "expected a non-negative safe integer");
-var revisionNumber = z5.number().refine((n) => Number.isSafeInteger(n) && n > 0, "expected a positive safe integer");
-var limitsSchema = z5.object({
+var safeIndex = z4.number().refine((n) => Number.isSafeInteger(n) && n >= 0, "expected a non-negative safe integer");
+var revisionNumber = z4.number().refine((n) => Number.isSafeInteger(n) && n > 0, "expected a positive safe integer");
+var limitsSchema = z4.object({
   maxFrameBytes: revisionNumber,
   maxSnapshotBytes: revisionNumber,
   maxNodes: revisionNumber,
@@ -1567,64 +1811,87 @@ var limitsSchema = z5.object({
   maxLogQueue: revisionNumber
 });
 var errorFields = {
-  type: z5.literal("error"),
-  code: z5.enum(["bad-token", "bad-version", "malformed", "limit-exceeded", "internal"]),
-  message: z5.string().max(MAX_IDENTIFIER_LENGTH)
+  type: z4.literal("error"),
+  code: z4.enum([
+    "bad-token",
+    "bad-version",
+    "malformed",
+    "limit-exceeded",
+    "duplicate-semantic-key",
+    "adapter-guarantee-violation",
+    "capability-provider-violation",
+    "internal"
+  ]),
+  message: z4.string().max(MAX_IDENTIFIER_LENGTH)
 };
-var errorSchema = z5.strictObject(errorFields);
-var errorFromDriverSchema = z5.object(errorFields);
-var helloSchema = z5.strictObject({
-  type: z5.literal("hello"),
-  protocol: z5.union([z5.literal(PROTOCOL_ID), z5.literal(PROTOCOL_V2_ID)]),
+var errorSchema = z4.strictObject(errorFields);
+var errorFromDriverSchema = z4.object(errorFields);
+var helloSchema = z4.strictObject({
+  type: z4.literal("hello"),
+  protocol: z4.literal(PROTOCOL_ID),
   token: nonEmptyIdentifier,
-  adapter: z5.strictObject({ name: nonEmptyIdentifier, version: nonEmptyIdentifier }),
-  capabilities: z5.array(z5.enum(ADAPTER_CAPABILITIES)).max(ADAPTER_CAPABILITIES.length),
-  probe: probeInfoSchema.optional()
+  adapter: z4.strictObject({
+    name: nonEmptyIdentifier,
+    version: nonEmptyIdentifier
+  }),
+  capabilities: z4.array(z4.enum(ADAPTER_CAPABILITIES)).max(ADAPTER_CAPABILITIES.length),
+  probe: probeInfoSchema.optional(),
+  providers: z4.array(
+    z4.strictObject({
+      id: nonEmptyIdentifier,
+      version: nonEmptyIdentifier,
+      method: z4.enum(["native", "declared"]),
+      capabilities: z4.array(z4.enum(EVIDENCE_PROVIDER_CAPABILITIES)).min(1).max(EVIDENCE_PROVIDER_CAPABILITIES.length).refine(
+        (values) => new Set(values).size === values.length,
+        "provider capabilities must be unique"
+      )
+    })
+  ).max(64).superRefine((providers, ctx) => {
+    const ids = /* @__PURE__ */ new Set();
+    for (let index = 0; index < providers.length; index += 1) {
+      const provider = providers[index];
+      const id = provider.id;
+      if (ids.has(id)) {
+        ctx.addIssue({
+          code: "custom",
+          path: [index, "id"],
+          message: `duplicate provider id ${id}`
+        });
+        return;
+      }
+      ids.add(id);
+    }
+  }).optional()
 });
-var frameBeginSchema = z5.strictObject({
-  type: z5.literal("frame-begin"),
+var frameBeginSchema = z4.strictObject({
+  type: z4.literal("frame-begin"),
   revision: revisionNumber
 });
-var revisionCommitSchema = z5.strictObject({
-  type: z5.literal("revision-commit"),
+var revisionCommitSchema = z4.strictObject({
+  type: z4.literal("revision-commit"),
   revision: revisionNumber
 });
-var snapshotEnvelopeSchema = z5.strictObject({
-  type: z5.literal("snapshot"),
-  snapshot: z5.unknown()
+var snapshotEnvelopeSchema = z4.strictObject({
+  type: z4.literal("snapshot"),
+  snapshot: z4.unknown()
 });
-var treeDeltaTypeSchema = z5.object({ type: z5.literal("tree-delta") });
-var logEnvelopeSchema = z5.strictObject({
-  type: z5.literal("log"),
-  record: z5.unknown()
+var logEnvelopeSchema = z4.strictObject({
+  type: z4.literal("log"),
+  record: z4.unknown()
 });
-var getTreeResultSchema = z5.strictObject({
-  type: z5.literal("get-tree-result"),
-  requestId: safeIndex,
-  snapshot: z5.unknown().optional(),
-  error: z5.string().max(MAX_IDENTIFIER_LENGTH).optional()
-}).refine(
-  (m) => m.snapshot === void 0 !== (m.error === void 0),
-  "exactly one of snapshot or error must be present"
-);
-var helloAckSchema = z5.object({
-  type: z5.literal("hello-ack"),
-  protocol: z5.union([z5.literal(PROTOCOL_ID), z5.literal(PROTOCOL_V2_ID)]),
+var helloAckSchema = z4.object({
+  type: z4.literal("hello-ack"),
+  protocol: z4.literal(PROTOCOL_ID),
   sessionId: nonEmptyIdentifier,
   limits: limitsSchema,
-  subscribe: z5.enum(["snapshots", "revisions", "diffs"]),
-  marker: z5.object({ enabled: z5.boolean() }),
-  logs: z5.object({
-    enabled: z5.boolean(),
+  subscribe: z4.enum(["snapshots", "revisions"]),
+  marker: z4.object({ enabled: z4.boolean() }),
+  logs: z4.object({
+    enabled: z4.boolean(),
     maxRecordsPerSecond: revisionNumber,
     burst: safeIndex
   }).optional()
 });
-var getTreeRequestSchema = z5.object({
-  type: z5.literal("get-tree"),
-  requestId: safeIndex,
-  revision: revisionNumber.optional()
-});
 function malformed(detail) {
   return { ok: false, code: "malformed", detail };
 }
@@ -1654,7 +1921,7 @@ function checkSnapshot(value, limits) {
   const overCapacity = result.code === "bytes" || result.code === "count" || result.code === "depth" || result.code === "string-bytes";
   return {
     ok: false,
-    code: overCapacity ? "limit-exceeded" : "malformed",
+    code: overCapacity ? "limit-exceeded" : result.code === "provider" ? "capability-provider-violation" : "malformed",
     detail: `snapshot ${result.code}: ${result.detail}`
   };
 }
@@ -1668,16 +1935,6 @@ function checkLogRecord(value, limits) {
     detail: `log record ${result.code}: ${result.detail}`
   };
 }
-function checkTreeDelta(value, limits) {
-  const result = validateTreeDelta(value, limits);
-  if (result.ok) return null;
-  const overCapacity = result.code === "bytes" || result.code === "count" || result.code === "depth" || result.code === "string-bytes";
-  return {
-    ok: false,
-    code: overCapacity ? "limit-exceeded" : "malformed",
-    detail: `tree delta ${result.code}: ${result.detail}`
-  };
-}
 function parseAdapterMessage(value, limits) {
   const projected = project(value, limits);
   if (!projected.ok) return projected;
@@ -1685,21 +1942,15 @@ function parseAdapterMessage(value, limits) {
   switch (messageType(dto)) {
     case "hello": {
       const protocol = dto.protocol;
-      if (typeof protocol === "string" && protocol !== PROTOCOL_ID && protocol !== PROTOCOL_V2_ID) {
-        return { ok: false, code: "bad-version", detail: `unsupported protocol ${protocol}` };
+      if (typeof protocol === "string" && protocol !== PROTOCOL_ID) {
+        return {
+          ok: false,
+          code: "bad-version",
+          detail: `unsupported protocol ${protocol}`
+        };
       }
       const issue = check(helloSchema, dto);
       if (issue !== null) return malformed(issue);
-      const candidate = dto;
-      const qualified = candidate.capabilities.includes("qualified-observations");
-      if (candidate.protocol === PROTOCOL_V2_ID !== qualified) {
-        return malformed(
-          candidate.protocol === PROTOCOL_V2_ID ? "termwright/2 requires the 'qualified-observations' capability" : "'qualified-observations' requires termwright/2"
-        );
-      }
-      if (candidate.capabilities.includes("pointer-hit-grid") && !qualified) {
-        return malformed("'pointer-hit-grid' requires qualified observations");
-      }
       const probe = dto.probe;
       if (probe !== void 0) {
         const checked = validateProbeInfo(probe);
@@ -1717,27 +1968,10 @@ function parseAdapterMessage(value, limits) {
       const bad = checkSnapshot(dto.snapshot, limits);
       return bad ?? { ok: true, message: dto };
     }
-    case "get-tree-result": {
-      const issue = check(getTreeResultSchema, dto);
-      if (issue !== null) return malformed(issue);
-      const envelope = dto;
-      if (envelope.snapshot !== void 0) {
-        const bad = checkSnapshot(envelope.snapshot, limits);
-        if (bad !== null) return bad;
-      }
-      return { ok: true, message: dto };
-    }
     case "frame-begin": {
       const issue = check(frameBeginSchema, dto);
       return issue === null ? { ok: true, message: dto } : malformed(issue);
     }
-    case "tree-delta": {
-      const issue = check(treeDeltaTypeSchema, dto);
-      if (issue !== null) return malformed(issue);
-      const { type: _type, ...body } = dto;
-      const bad = checkTreeDelta(body, limits);
-      return bad ?? { ok: true, message: dto };
-    }
     case "log": {
       const issue = check(logEnvelopeSchema, dto);
       if (issue !== null) return malformed(issue);
@@ -1759,16 +1993,16 @@ function parseDriverMessage(value, limits) {
   switch (messageType(dto)) {
     case "hello-ack": {
       const protocol = dto.protocol;
-      if (typeof protocol === "string" && protocol !== PROTOCOL_ID && protocol !== PROTOCOL_V2_ID) {
-        return { ok: false, code: "bad-version", detail: `unsupported protocol ${protocol}` };
+      if (typeof protocol === "string" && protocol !== PROTOCOL_ID) {
+        return {
+          ok: false,
+          code: "bad-version",
+          detail: `unsupported protocol ${protocol}`
+        };
       }
       const issue = check(helloAckSchema, dto);
       return issue === null ? { ok: true, message: dto } : malformed(issue);
     }
-    case "get-tree": {
-      const issue = check(getTreeRequestSchema, dto);
-      return issue === null ? { ok: true, message: dto } : malformed(issue);
-    }
     case "error": {
       const issue = check(errorFromDriverSchema, dto);
       return issue === null ? { ok: true, message: dto } : malformed(issue);
@@ -1779,7 +2013,7 @@ function parseDriverMessage(value, limits) {
 }
 
 // src/marker.ts
-import { Buffer as Buffer6 } from "buffer";
+import { Buffer as Buffer5 } from "buffer";
 import { createHmac, timingSafeEqual } from "crypto";
 var MARKER_OSC_CODE = 8487;
 var MARKER_OSC_PREFIX = "twm;";
@@ -1820,24 +2054,74 @@ function verifyMarkerPayload(payload, token, sessionId) {
   if (!MAC_TEXT.test(mac)) return null;
   const revision = Number(revisionText);
   if (!Number.isSafeInteger(revision) || revision <= 0) return null;
-  const expected = Buffer6.from(computeMac(token, sessionId, revision), "utf8");
-  const actual = Buffer6.from(mac, "utf8");
+  const expected = Buffer5.from(computeMac(token, sessionId, revision), "utf8");
+  const actual = Buffer5.from(mac, "utf8");
   if (expected.length !== actual.length) return null;
   if (!timingSafeEqual(expected, actual)) return null;
   return Object.freeze({ revision, mac });
 }
+
+// src/conpty-host-rpc.ts
+var CONPTY_HOST_CURSOR_OSC_CODE = 8488;
+var CONPTY_HOST_CURSOR_PREFIX = "twh-cpr-v1";
+var TOKEN = "[0-9a-f]{32}";
+var REQUEST = new RegExp(`^${CONPTY_HOST_CURSOR_PREFIX}:q:(${TOKEN})$`, "u");
+var RESPONSE = new RegExp(
+  `^\\x1b\\]${CONPTY_HOST_CURSOR_OSC_CODE};${CONPTY_HOST_CURSOR_PREFIX}:r:(${TOKEN}):([1-9][0-9]{0,4}):([1-9][0-9]{0,4})\\x07$`,
+  "u"
+);
+var MAX_COORDINATE = 32768;
+function parseConPtyHostCursorRequest(payload) {
+  const match = REQUEST.exec(payload);
+  return match?.[1] === void 0 ? null : { token: match[1] };
+}
+function encodeConPtyHostCursorResponse(request, row, column) {
+  if (!new RegExp(`^${TOKEN}$`, "u").test(request.token)) {
+    throw new TypeError("ConPTY host cursor token must be 128-bit lowercase hexadecimal");
+  }
+  for (const [name, value] of [
+    ["row", row],
+    ["column", column]
+  ]) {
+    if (!Number.isSafeInteger(value) || value < 1 || value > MAX_COORDINATE) {
+      throw new RangeError(`ConPTY host cursor ${name} must be an integer from 1 to 32768`);
+    }
+  }
+  return `\x1B]${CONPTY_HOST_CURSOR_OSC_CODE};${CONPTY_HOST_CURSOR_PREFIX}:r:${request.token}:${row}:${column}\x07`;
+}
+function parseConPtyHostCursorResponse(value) {
+  const text = typeof value === "string" ? value : new TextDecoder("ascii", { fatal: true }).decode(value);
+  const match = RESPONSE.exec(text);
+  if (match?.[1] === void 0 || match[2] === void 0 || match[3] === void 0) return null;
+  const row = Number(match[2]);
+  const column = Number(match[3]);
+  if (row > MAX_COORDINATE || column > MAX_COORDINATE) return null;
+  return { token: match[1], row, column };
+}
 export {
   ABSOLUTE_LIMITS,
   ACCESSKIT_ROLE_BY_SEMANTIC_ROLE,
   ACCESSKIT_ROOT_TREE_ID,
   ADAPTER_CAPABILITIES,
+  ARTIFACT_VALUE_POLICIES,
+  CAPABILITY_CONFORMANCE_CLAIMS,
+  CAPABILITY_EDGE_KINDS,
+  CAPABILITY_GRAPH,
+  CAPABILITY_GRAPH_VERSION,
+  CAPABILITY_NODE_CATEGORIES,
+  CAPABILITY_NODE_LAYERS,
+  CONDITION_KINDS,
+  CONPTY_HOST_CURSOR_OSC_CODE,
+  CONPTY_HOST_CURSOR_PREFIX,
+  DEFAULT_ARTIFACT_VALUE_POLICY,
   DEFAULT_LIMITS,
   DEFAULT_NEGOTIATION_MS,
+  DEFAULT_RUN_EVENT_JOURNAL_LIMITS,
+  DEFAULT_RUN_EVENT_LIMITS,
   ENV_ENDPOINT,
-  ENV_PROTOCOL,
   ENV_TOKEN,
-  FRAMEWORK_OBSERVATION_CAPABILITIES,
-  FRAMEWORK_OPERATION_CAPABILITIES,
+  EVIDENCE_PROVIDER_CAPABILITIES,
+  EVIDENCE_PROVIDER_TYPES,
   FRAME_HEADER_BYTES,
   LOG_LEVELS,
   LOG_LEVEL_SEVERITY,
@@ -1845,41 +2129,78 @@ export {
   MARKER_OSC_CODE,
   MARKER_OSC_PREFIX,
   MAX_LOG_ATTRS,
+  PHYSICAL_INPUT_RECIPE_ACTIONS,
   PROBE_CAPABILITIES,
+  PROBE_DEGRADED_CAPABILITIES,
+  PROBE_INJECTION_TIERS,
+  PROBE_SEMANTIC_CLASSES,
   PROBE_UNOBSERVABLE_FIELDS,
   PROTOCOL_ID,
-  PROTOCOL_V2_ID,
   PROTOCOL_VERSION,
   PROVENANCE_SOURCES,
+  PUBLIC_CAPABILITY_CONSUMERS,
   ProtocolViolation,
+  RUNTIME_PREREQUISITES,
+  RUN_EVENT_CLASSES,
+  RUN_EVENT_VERSION,
+  RUN_ID_KINDS,
+  RUN_STATES,
+  RUN_STATE_TRANSITIONS,
+  RunEventJournal,
+  RunEventProducer,
+  RunEventStreamValidator,
+  RunIdFactory,
   SEMANTIC_ACTIONS,
   SEMANTIC_NODE_KEYS,
   SEMANTIC_ROLES,
   SEMANTIC_STATE_KEYS,
-  SUPPORTED_PROTOCOL_IDS,
+  SESSION_CAPABILITIES,
+  TERMINAL_RUN_STATES,
   TOKEN_BYTES,
   accessKitNodeId,
-  applyTreeDelta,
+  canTransitionRunState,
+  capabilityNode,
+  capabilityRemediation,
   createFrameDecoder,
+  createRunEvent,
+  createRunId,
+  encodeConPtyHostCursorResponse,
   encodeFrame,
   encodeMarker,
-  frameworkObservationCapabilities,
+  evidence,
+  executableText,
   generateToken,
   intersectRects,
+  isRunState,
+  isTerminalRunState,
   parseAdapterMessage,
+  parseConPtyHostCursorRequest,
+  parseConPtyHostCursorResponse,
   parseDriverMessage,
+  parseRunId,
   probeInfoSchema,
+  projectActionReceiptForArtifact,
   projectDto,
+  projectSemanticSnapshotForArtifact,
+  publicValue,
+  recordActionPlan,
+  recordDeviceOperation,
+  recordValue,
   rectArea,
-  resolveNodeBounds,
+  resolveCapability,
+  sensitive,
+  sessionCapabilitiesFromProducers,
   spatialRelation,
   toAccessKitTreeUpdate,
+  validateCapabilityGraph,
   validateLogRecord,
   validateProbeAnnotations,
   validateProbeFrame,
   validateProbeInfo,
+  validateRunEvent,
+  validateRunStateTransition,
   validateSnapshot,
-  validateTreeDelta,
+  valueSensitivity,
   verifyMarkerPayload,
   viewportIntersection
 };