@termwright/protocol 0.2.0

package/dist/index.js

@@ -0,0 +1,1886 @@
+// 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 TOKEN_BYTES = 32;
+function generateToken() {
+  return randomBytes(TOKEN_BYTES).toString("base64url");
+}
+
+// src/errors.ts
+var ProtocolViolation = class extends Error {
+  /** Machine-readable reason. */
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "ProtocolViolation";
+    this.code = code;
+  }
+};
+
+// src/roles.ts
+var SEMANTIC_ROLES = [
+  "application",
+  "region",
+  "dialog",
+  "alert",
+  "status",
+  "list",
+  "listitem",
+  "menu",
+  "menuitem",
+  "button",
+  "checkbox",
+  "radio",
+  "tab",
+  "textbox",
+  "heading",
+  "text",
+  "progressbar",
+  "separator",
+  "scrollbar",
+  "table",
+  "row",
+  "cell",
+  "generic"
+];
+var SEMANTIC_ACTIONS = [
+  "focus",
+  "activate",
+  "toggle",
+  "setValue",
+  "scroll",
+  "select",
+  "expand"
+];
+
+// src/limits.ts
+var DEFAULT_LIMITS = Object.freeze({
+  maxFrameBytes: 1 * 1024 * 1024,
+  maxSnapshotBytes: 2 * 1024 * 1024,
+  maxNodes: 5e3,
+  maxDepth: 64,
+  maxStringBytes: 16 * 1024,
+  maxRelationTargets: 64,
+  maxQueuedFrames: 32,
+  maxPendingWaiters: 256,
+  maxSessions: 16,
+  maxLogRecordBytes: 32 * 1024,
+  maxLogQueue: 1e3
+});
+var ABSOLUTE_LIMITS = Object.freeze({
+  maxFrameBytes: 8 * 1024 * 1024,
+  maxSnapshotBytes: 8 * 1024 * 1024,
+  maxNodes: 5e4,
+  maxDepth: 256,
+  maxStringBytes: 256 * 1024,
+  maxRelationTargets: 1024,
+  maxQueuedFrames: 256,
+  maxPendingWaiters: 4096,
+  maxSessions: 128,
+  maxLogRecordBytes: 256 * 1024,
+  maxLogQueue: 1e4
+});
+var DEFAULT_NEGOTIATION_MS = 250;
+
+// src/observation.ts
+function intersectRects(a, b) {
+  const row = Math.max(a.row, b.row);
+  const column = Math.max(a.column, b.column);
+  return {
+    row,
+    column,
+    width: Math.max(0, Math.min(a.column + a.width, b.column + b.width) - column),
+    height: Math.max(0, Math.min(a.row + a.height, b.row + b.height) - row)
+  };
+}
+function rectArea(rect) {
+  return Math.max(0, rect.width) * Math.max(0, rect.height);
+}
+function viewportIntersection(rect, columns, rows) {
+  const intersection = intersectRects(rect, { row: 0, column: 0, width: columns, height: rows });
+  const area = rectArea(rect);
+  const visible = rectArea(intersection);
+  return Object.freeze({
+    rect: Object.freeze(intersection),
+    ratio: area === 0 ? 0 : visible / area,
+    fullyInside: area > 0 && visible === area
+  });
+}
+function spatialRelation(a, relation, b) {
+  const aBottom = a.row + a.height;
+  const bBottom = b.row + b.height;
+  const aRight = a.column + a.width;
+  const bRight = b.column + b.width;
+  switch (relation) {
+    case "contains":
+      return a.row <= b.row && a.column <= b.column && aBottom >= bBottom && aRight >= bRight;
+    case "inside":
+      return spatialRelation(b, "contains", a);
+    case "overlaps":
+      return rectArea(intersectRects(a, b)) > 0;
+    case "left-of":
+      return aRight <= b.column;
+    case "right-of":
+      return bRight <= a.column;
+    case "above":
+      return aBottom <= b.row;
+    case "below":
+      return bBottom <= a.row;
+    case "aligned-left":
+      return a.column === b.column;
+    case "aligned-right":
+      return aRight === bRight;
+    case "aligned-top":
+      return a.row === b.row;
+    case "aligned-bottom":
+      return aBottom === bBottom;
+    case "adjacent-horizontal":
+      return (aRight === b.column || bRight === a.column) && Math.max(a.row, b.row) < Math.min(aBottom, bBottom);
+    case "adjacent-vertical":
+      return (aBottom === b.row || bBottom === a.row) && Math.max(a.column, b.column) < Math.min(aRight, bRight);
+  }
+}
+
+// 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");
+}
+function nonNegativeInt() {
+  return z.number().refine((n) => Number.isSafeInteger(n) && n >= 0, "expected a non-negative safe integer");
+}
+function positiveInt() {
+  return z.number().refine((n) => Number.isSafeInteger(n) && n > 0, "expected a positive safe integer");
+}
+function boundedString(maxStringBytes) {
+  return z.string().refine(
+    (s) => Buffer.byteLength(s, "utf8") <= maxStringBytes,
+    `expected at most ${maxStringBytes} UTF-8 bytes`
+  );
+}
+var cache = /* @__PURE__ */ new WeakMap();
+function build(limits) {
+  const text = boundedString(limits.maxStringBytes);
+  const relations = z.array(text).max(limits.maxRelationTargets);
+  const rect = z.strictObject({
+    row: safeInt(),
+    column: safeInt(),
+    width: nonNegativeInt(),
+    height: nonNegativeInt()
+  });
+  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"]) })
+  ]);
+  const state = z.strictObject({
+    disabled: z.boolean().optional(),
+    focused: z.boolean().optional(),
+    selected: z.boolean().optional(),
+    checked: z.union([z.boolean(), z.literal("mixed")]).optional(),
+    expanded: z.boolean().optional(),
+    modal: z.boolean().optional(),
+    busy: z.boolean().optional(),
+    hidden: z.boolean().optional(),
+    offscreen: z.boolean().optional(),
+    readonly: z.boolean().optional(),
+    multiline: 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()
+  });
+  const textRange = z.strictObject({
+    startOffset: nonNegativeInt(),
+    endOffset: nonNegativeInt(),
+    rect
+  });
+  const extendedValue = z.lazy(
+    () => z.union([
+      z.null(),
+      z.boolean(),
+      z.number().finite().refine(
+        (value) => Math.abs(value) <= Number.MAX_SAFE_INTEGER,
+        "expected a finite JSON number in the safe range"
+      ),
+      text,
+      z.array(extendedValue).max(limits.maxRelationTargets),
+      z.record(text, extendedValue).refine(
+        (value) => Object.keys(value).length <= limits.maxRelationTargets,
+        `expected at most ${limits.maxRelationTargets} properties`
+      )
+    ])
+  );
+  const extended = z.record(text, extendedValue).refine(
+    (value) => Object.keys(value).length <= limits.maxRelationTargets,
+    `expected at most ${limits.maxRelationTargets} properties`
+  );
+  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(),
+    state: state.optional(),
+    extended: extended.optional(),
+    actions: z.array(z.enum(SEMANTIC_ACTIONS)).max(SEMANTIC_ACTIONS.length).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(),
+    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),
+    visibleRect: observation(rect)
+  });
+  const nodeV2 = z.strictObject({
+    ...nodeFields,
+    bounds: z.never().optional(),
+    occlusion: z.never().optional(),
+    geometry
+  });
+  const cursor = z.strictObject({
+    row: nonNegativeInt(),
+    column: nonNegativeInt(),
+    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(),
+      column: nonNegativeInt(),
+      width: positiveInt(),
+      height: z.literal(1)
+    }),
+    recipientId: text
+  });
+  const hitGrid = z.strictObject({
+    // Canonical row runs make ambiguity validation linear and keep hostile
+    // snapshots from forcing an O(n²) rectangle-overlap check.
+    regions: z.array(hitRun).max(limits.maxNodes).superRefine((regions, ctx) => {
+      let previous;
+      for (let index = 0; index < regions.length; index += 1) {
+        const current = regions[index];
+        if (previous !== void 0 && (current.rect.row < previous.rect.row || current.rect.row === previous.rect.row && current.rect.column < previous.rect.column + previous.rect.width)) {
+          ctx.addIssue({
+            code: "custom",
+            path: [index, "rect"],
+            message: "hit regions must be non-overlapping row-major runs"
+          });
+          return;
+        }
+        previous = current;
+      }
+    })
+  });
+  const snapshotV2 = z.strictObject({
+    v: z.literal(2),
+    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(nodeV2).max(limits.maxNodes),
+    coordinateSpace: observation(z.enum(["viewport-cells", "framework-local-cells"])),
+    hitGrid: observation(hitGrid)
+  });
+  const snapshot = z.discriminatedUnion("v", [snapshotV1, snapshotV2]);
+  return {
+    text,
+    node,
+    cursor,
+    snapshot,
+    snapshotV1,
+    snapshotV2,
+    nodeKeys: Object.freeze(Object.keys(node.shape)),
+    stateKeys: Object.freeze(Object.keys(state.shape))
+  };
+}
+function treeSchemas(limits) {
+  const cached = cache.get(limits);
+  if (cached !== void 0) return cached;
+  const built = build(limits);
+  cache.set(limits, built);
+  return built;
+}
+
+// src/node-keys.ts
+var schemas = treeSchemas(DEFAULT_LIMITS);
+var SEMANTIC_NODE_KEYS = Object.freeze(
+  schemas.nodeKeys
+);
+var SEMANTIC_STATE_KEYS = Object.freeze(
+  schemas.stateKeys
+);
+
+// src/logs.ts
+import { Buffer as Buffer2 } from "buffer";
+
+// src/framing.ts
+import { types } from "util";
+var FRAME_HEADER_BYTES = 4;
+var FRAME_PROJECTION_DEPTH = DEFAULT_LIMITS.maxDepth;
+var RESERVED_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var LONE_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
+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"
+    );
+  }
+}
+var BufferedFrameDecoder = class {
+  #maxFrameBytes;
+  #buffer;
+  /** Offset of the first unconsumed byte in `#buffer`. */
+  #start = 0;
+  /** Offset just past the last buffered byte in `#buffer`. */
+  #end = 0;
+  #failure = null;
+  constructor(maxFrameBytes) {
+    assertPositiveByteCeiling(maxFrameBytes);
+    this.#maxFrameBytes = maxFrameBytes;
+    this.#buffer = new Uint8Array(0);
+  }
+  get buffered() {
+    return this.#end - this.#start;
+  }
+  push(chunk) {
+    if (this.#failure !== null) {
+      throw new ProtocolViolation(
+        "decoder-poisoned",
+        `decoder failed earlier (${this.#failure.code}) and accepts no further input`
+      );
+    }
+    try {
+      return this.#pushOrThrow(chunk);
+    } catch (error) {
+      this.#failure = error instanceof ProtocolViolation ? error : new ProtocolViolation("frame-malformed", "frame decoding failed");
+      this.#buffer = new Uint8Array(0);
+      this.#start = 0;
+      this.#end = 0;
+      throw this.#failure;
+    }
+  }
+  #pushOrThrow(chunk) {
+    this.#append(chunk);
+    const messages = [];
+    for (; ; ) {
+      const available = this.#end - this.#start;
+      if (available < FRAME_HEADER_BYTES) break;
+      const length = this.#readLength();
+      if (length === 0) {
+        throw new ProtocolViolation("frame-malformed", "frame length must be non-zero");
+      }
+      if (length > this.#maxFrameBytes) {
+        throw new ProtocolViolation(
+          "frame-oversized",
+          `frame declares ${length} bytes, ceiling is ${this.#maxFrameBytes}`
+        );
+      }
+      if (available < FRAME_HEADER_BYTES + length) break;
+      const bodyStart = this.#start + FRAME_HEADER_BYTES;
+      const body = this.#buffer.subarray(bodyStart, bodyStart + length);
+      messages.push(decodeBody(body));
+      this.#start = bodyStart + length;
+    }
+    this.#compact();
+    if (this.buffered > this.#maxFrameBytes + FRAME_HEADER_BYTES) {
+      throw new ProtocolViolation(
+        "frame-oversized",
+        `buffered ${this.buffered} bytes without a complete frame`
+      );
+    }
+    return messages;
+  }
+  #readLength() {
+    const b = this.#buffer;
+    const i = this.#start;
+    return b[i] * 16777216 + (b[i + 1] << 16 | b[i + 2] << 8 | b[i + 3]) >>> 0;
+  }
+  #append(chunk) {
+    const kept = this.#end - this.#start;
+    const needed = kept + chunk.length;
+    if (needed > this.#buffer.length - this.#start) {
+      const next = new Uint8Array(needed);
+      next.set(this.#buffer.subarray(this.#start, this.#end), 0);
+      this.#buffer = next;
+      this.#start = 0;
+      this.#end = kept;
+    }
+    this.#buffer.set(chunk, this.#end);
+    this.#end += chunk.length;
+  }
+  #compact() {
+    if (this.#start === 0) return;
+    const kept = this.#end - this.#start;
+    if (kept === 0) {
+      this.#buffer = new Uint8Array(0);
+    } else {
+      const next = new Uint8Array(kept);
+      next.set(this.#buffer.subarray(this.#start, this.#end), 0);
+      this.#buffer = next;
+    }
+    this.#start = 0;
+    this.#end = kept;
+  }
+};
+function decodeBody(body) {
+  let text;
+  try {
+    text = decoder.decode(body);
+  } catch {
+    throw new ProtocolViolation("frame-encoding", "frame body is not valid UTF-8");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new ProtocolViolation("frame-malformed", "frame body is not valid JSON");
+  }
+  return projectDto(parsed, FRAME_PROJECTION_DEPTH);
+}
+function createFrameDecoder(maxFrameBytes) {
+  return new BufferedFrameDecoder(maxFrameBytes);
+}
+function encodeFrame(message, maxFrameBytes) {
+  assertPositiveByteCeiling(maxFrameBytes);
+  let text;
+  try {
+    text = JSON.stringify(message);
+  } catch {
+    throw new ProtocolViolation("frame-malformed", "message is not JSON-serialisable");
+  }
+  if (text === void 0) {
+    throw new ProtocolViolation("dto-scalar", "message serialises to undefined");
+  }
+  const body = encoder.encode(text);
+  if (body.length > maxFrameBytes) {
+    throw new ProtocolViolation(
+      "frame-oversized",
+      `encoded frame is ${body.length} bytes, ceiling is ${maxFrameBytes}`
+    );
+  }
+  const frame = new Uint8Array(FRAME_HEADER_BYTES + body.length);
+  const n = body.length;
+  frame[0] = n >>> 24 & 255;
+  frame[1] = n >>> 16 & 255;
+  frame[2] = n >>> 8 & 255;
+  frame[3] = n & 255;
+  frame.set(body, FRAME_HEADER_BYTES);
+  return frame;
+}
+function projectScalar(value, path) {
+  if (value === null) return null;
+  switch (typeof value) {
+    case "boolean":
+      return value;
+    case "number":
+      if (!Number.isFinite(value)) {
+        throw new ProtocolViolation("dto-scalar", `non-finite number at ${path}`);
+      }
+      return value;
+    case "string":
+      if (LONE_SURROGATE.test(value)) {
+        throw new ProtocolViolation("dto-string", `unpaired surrogate at ${path}`);
+      }
+      return value;
+    default:
+      throw new ProtocolViolation(
+        "dto-scalar",
+        `value of type ${typeof value} is not JSON-representable at ${path}`
+      );
+  }
+}
+function projectNode(value, depth, maxDepth, seen, path) {
+  if (value === null || typeof value !== "object") {
+    return projectScalar(value, path);
+  }
+  if (depth > maxDepth) {
+    throw new ProtocolViolation("dto-depth", `nesting exceeds ${maxDepth} at ${path}`);
+  }
+  if (types.isProxy(value)) {
+    throw new ProtocolViolation("dto-prototype", `proxy at ${path}`);
+  }
+  if (seen.has(value)) {
+    throw new ProtocolViolation("dto-alias", `value is reachable more than once at ${path}`);
+  }
+  seen.add(value);
+  if (Object.getOwnPropertySymbols(value).length > 0) {
+    throw new ProtocolViolation("dto-symbol", `symbol-keyed property at ${path}`);
+  }
+  const proto = Object.getPrototypeOf(value);
+  const result = Array.isArray(value) ? projectArray(value, proto, depth, maxDepth, seen, path) : projectObject(value, proto, depth, maxDepth, seen, path);
+  return Object.freeze(result);
+}
+function projectArray(value, proto, depth, maxDepth, seen, path) {
+  if (proto !== Array.prototype) {
+    throw new ProtocolViolation("dto-prototype", `array with exotic prototype at ${path}`);
+  }
+  const length = value.length;
+  const out = new Array(length);
+  for (let i = 0; i < length; i += 1) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, i);
+    if (descriptor === void 0) {
+      throw new ProtocolViolation("dto-sparse", `hole at ${path}[${i}]`);
+    }
+    if (!("value" in descriptor)) {
+      throw new ProtocolViolation("dto-accessor", `accessor at ${path}[${i}]`);
+    }
+    out[i] = projectNode(descriptor.value, depth + 1, maxDepth, seen, `${path}[${i}]`);
+  }
+  if (Object.getOwnPropertyNames(value).length !== length + 1) {
+    throw new ProtocolViolation("dto-sparse", `array carries extra own properties at ${path}`);
+  }
+  return out;
+}
+function projectObject(value, proto, depth, maxDepth, seen, path) {
+  if (proto !== Object.prototype && proto !== null) {
+    throw new ProtocolViolation("dto-prototype", `non-plain object at ${path}`);
+  }
+  const out = {};
+  for (const key of Object.getOwnPropertyNames(value)) {
+    if (RESERVED_KEYS.has(key)) {
+      throw new ProtocolViolation("dto-key", `reserved property name "${key}" at ${path}`);
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!("value" in descriptor)) {
+      throw new ProtocolViolation("dto-accessor", `accessor property "${key}" at ${path}`);
+    }
+    if (!descriptor.enumerable) {
+      throw new ProtocolViolation("dto-key", `non-enumerable property "${key}" at ${path}`);
+    }
+    if (LONE_SURROGATE.test(key)) {
+      throw new ProtocolViolation("dto-string", `unpaired surrogate in key at ${path}`);
+    }
+    out[key] = projectNode(descriptor.value, depth + 1, maxDepth, seen, `${path}.${key}`);
+  }
+  return out;
+}
+function projectDto(value, maxDepth) {
+  if (!Number.isSafeInteger(maxDepth) || maxDepth < 0) {
+    throw new ProtocolViolation("dto-depth", "maxDepth must be a non-negative safe integer");
+  }
+  return projectNode(value, 0, maxDepth, /* @__PURE__ */ new Set(), "$");
+}
+
+// src/logs.ts
+var LOG_LEVELS = ["trace", "debug", "info", "warn", "error", "fatal"];
+var LOG_LEVEL_SEVERITY = Object.freeze({
+  trace: 10,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  fatal: 60
+});
+var MAX_LOG_ATTRS = 64;
+function fail(code, detail) {
+  return { ok: false, code, detail };
+}
+var LEVELS = new Set(LOG_LEVELS);
+function isSafeNonNegative(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function validateLogRecord(value, limits) {
+  let projected;
+  try {
+    projected = projectDto(value, limits.maxDepth);
+  } catch (error) {
+    if (error instanceof ProtocolViolation) {
+      return fail(error.code === "dto-depth" ? "depth" : "schema", error.message);
+    }
+    return fail("schema", "value could not be projected into a plain DTO");
+  }
+  const serialised = JSON.stringify(projected);
+  if (serialised === void 0) {
+    return fail("schema", "log record is not a JSON object");
+  }
+  const bytes = Buffer2.byteLength(serialised, "utf8");
+  if (bytes > limits.maxLogRecordBytes) {
+    return fail("bytes", `log record is ${bytes} bytes, ceiling is ${limits.maxLogRecordBytes}`);
+  }
+  if (typeof projected !== "object" || projected === null || Array.isArray(projected)) {
+    return fail("schema", "log record must be an object");
+  }
+  const record = projected;
+  for (const key of Object.keys(record)) {
+    if (!["ts", "level", "message", "attrs", "logger", "seq", "revision"].includes(key)) {
+      return fail("schema", `unknown log record property "${key}"`);
+    }
+  }
+  if (!isSafeNonNegative(record["ts"]) || record["ts"] === 0) {
+    return fail("schema", "ts must be a positive safe integer (epoch milliseconds)");
+  }
+  if (typeof record["level"] !== "string" || !LEVELS.has(record["level"])) {
+    return fail("schema", `level must be one of ${LOG_LEVELS.join(", ")}`);
+  }
+  if (typeof record["message"] !== "string") {
+    return fail("schema", "message must be a string");
+  }
+  if (Buffer2.byteLength(record["message"], "utf8") > limits.maxStringBytes) {
+    return fail("string-bytes", `message exceeds ${limits.maxStringBytes} UTF-8 bytes`);
+  }
+  if (!isSafeNonNegative(record["seq"])) {
+    return fail("schema", "seq must be a non-negative safe integer");
+  }
+  if (record["logger"] !== void 0) {
+    if (typeof record["logger"] !== "string") {
+      return fail("schema", "logger must be a string");
+    }
+    if (Buffer2.byteLength(record["logger"], "utf8") > limits.maxStringBytes) {
+      return fail("string-bytes", `logger exceeds ${limits.maxStringBytes} UTF-8 bytes`);
+    }
+  }
+  if (record["revision"] !== void 0) {
+    if (!isSafeNonNegative(record["revision"]) || record["revision"] === 0) {
+      return fail("revision", "revision must be a positive safe integer");
+    }
+  }
+  const attrs = record["attrs"];
+  if (attrs !== void 0) {
+    if (typeof attrs !== "object" || attrs === null || Array.isArray(attrs)) {
+      return fail("schema", "attrs must be a flat object");
+    }
+    const entries = Object.entries(attrs);
+    if (entries.length > MAX_LOG_ATTRS) {
+      return fail("count", `attrs carries ${entries.length} keys, ceiling is ${MAX_LOG_ATTRS}`);
+    }
+    for (const [key, attrValue] of entries) {
+      if (Buffer2.byteLength(key, "utf8") > limits.maxStringBytes) {
+        return fail("string-bytes", `attribute key "${key}" exceeds the string ceiling`);
+      }
+      const type = typeof attrValue;
+      if (attrValue !== null && type !== "string" && type !== "number" && type !== "boolean") {
+        return fail("schema", `attribute "${key}" must be a string, number, boolean or null`);
+      }
+      if (type === "number" && !Number.isFinite(attrValue)) {
+        return fail("schema", `attribute "${key}" must be a finite number`);
+      }
+      if (type === "string" && Buffer2.byteLength(attrValue, "utf8") > limits.maxStringBytes) {
+        return fail("string-bytes", `attribute "${key}" exceeds the string ceiling`);
+      }
+    }
+  }
+  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";
+}
+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 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}`);
+      }
+    }
+  }
+  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 fail2(error.code === "dto-depth" ? "depth" : "schema", error.message);
+    }
+    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}`);
+  }
+  const byId = /* @__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));
+  }
+  const relation = (ids) => {
+    if (ids === void 0 || ids.length === 0) return void 0;
+    const mapped = ids.map((id) => idOf.get(id)).filter((id) => id !== void 0);
+    return mapped.length === 0 ? void 0 : mapped;
+  };
+  const cellBounds = {};
+  const nodes = [];
+  let focus;
+  for (const node of snapshot.nodes) {
+    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 accessKitNode = {
+      role: accessKitRoleFor(node),
+      ...node.name === "" ? {} : { label: node.name },
+      ...node.description === void 0 ? {} : { description: node.description },
+      ...node.value === void 0 ? {} : { value: node.value },
+      ...childrenOf.has(node.id) ? { children: childrenOf.get(node.id) } : {},
+      ...node.bounds !== void 0 && options.cellSize !== void 0 ? { bounds: boundsFor(node.bounds, 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) },
+      ...state?.disabled === void 0 ? {} : { disabled: state.disabled },
+      ...state?.selected === void 0 ? {} : { selected: state.selected },
+      ...state?.expanded === void 0 ? {} : { expanded: state.expanded },
+      ...state?.busy === void 0 ? {} : { busy: state.busy },
+      ...state?.modal === void 0 ? {} : { modal: state.modal },
+      ...state?.hidden === void 0 ? {} : { hidden: state.hidden },
+      ...state?.readonly === void 0 ? {} : { readOnly: state.readonly },
+      ...toggledFor(state?.checked) === void 0 ? {} : { toggled: toggledFor(state?.checked) }
+    };
+    nodes.push(Object.freeze([id, Object.freeze(accessKitNode)]));
+  }
+  const rootId = snapshot.rootIds[0];
+  const root = rootId === void 0 ? void 0 : idOf.get(rootId);
+  const update = {
+    nodes: Object.freeze(nodes),
+    ...root === void 0 ? {} : {
+      tree: Object.freeze({
+        root,
+        ...options.toolkitName === void 0 ? {} : { toolkitName: options.toolkitName },
+        ...options.toolkitVersion === void 0 ? {} : { toolkitVersion: options.toolkitVersion }
+      })
+    },
+    treeId: options.treeId ?? ACCESSKIT_ROOT_TREE_ID,
+    focus: focus ?? root ?? 0
+  };
+  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) {
+  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 cache2 = /* @__PURE__ */ new WeakMap();
+function buildFrameSchema(limits) {
+  const text = z4.string().refine(
+    (s) => Buffer5.byteLength(s, "utf8") <= limits.maxStringBytes,
+    `expected at most ${limits.maxStringBytes} UTF-8 bytes`
+  );
+  const rect = z4.strictObject({
+    row: safeInt2,
+    column: safeInt2,
+    width: nonNegative,
+    height: nonNegative
+  });
+  const identity = z4.strictObject({
+    kind: z4.enum(["stable", "frame-local"]),
+    value: text.min(1)
+  });
+  const extendedValue = z4.lazy(
+    () => z4.union([
+      z4.null(),
+      z4.boolean(),
+      z4.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(
+        (value) => Object.keys(value).length <= limits.maxRelationTargets,
+        `expected at most ${limits.maxRelationTargets} properties`
+      )
+    ])
+  );
+  const extended = z4.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(),
+    value: text.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()
+  });
+  const object = z4.strictObject({
+    identity,
+    frameworkType: text.min(1),
+    parent: text.optional(),
+    geometry: z4.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({
+      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(),
+      labelledBy: relations.optional(),
+      describedBy: relations.optional()
+    }).optional(),
+    paintOrder: safeInt2.optional(),
+    unobservable: z4.array(z4.enum(PROBE_UNOBSERVABLE_FIELDS)).max(PROBE_UNOBSERVABLE_FIELDS.length).optional()
+  });
+  const operation = z4.strictObject({
+    kind: z4.enum(["render", "layout"]),
+    ordinal: nonNegative,
+    target: identity.optional(),
+    frameworkType: text.optional(),
+    intendedRect: rect.optional()
+  });
+  return z4.strictObject({
+    frame: positive,
+    objects: z4.array(object).max(limits.maxNodes),
+    operations: z4.array(operation).max(limits.maxNodes).optional()
+  });
+}
+function frameSchema(limits) {
+  const cached = cache2.get(limits);
+  if (cached !== void 0) return cached;
+  const built = buildFrameSchema(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)
+});
+function validateProbeInfo(value) {
+  const parsed = probeInfoSchema.safeParse(value);
+  if (!parsed.success) {
+    const issue = parsed.error.issues[0];
+    const where = issue.path.length > 0 ? issue.path.map(String).join(".") : "<root>";
+    return { ok: false, detail: `${where}: ${issue.message}` };
+  }
+  const info = parsed.data;
+  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) };
+}
+function validateProbeFrame(value, limits) {
+  let projected;
+  try {
+    projected = projectDto(value, limits.maxDepth);
+  } catch (error) {
+    if (error instanceof ProtocolViolation) {
+      return fail4(error.code === "dto-depth" ? "depth" : "schema", error.message);
+    }
+    return fail4("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 (bytes > limits.maxSnapshotBytes) {
+    return fail4("bytes", `probe frame is ${bytes} bytes, ceiling is ${limits.maxSnapshotBytes}`);
+  }
+  const parsed = frameSchema(limits).safeParse(projected);
+  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("intendedRect") || path.includes("visibleRect") ? "bad-rect" : path.includes("frame") ? "revision" : issue.code === "too_big" ? "count" : "schema";
+    return fail4(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`);
+    }
+    seen.add(object.identity.value);
+  }
+  for (const object of frame.objects) {
+    if (object.parent !== void 0 && !seen.has(object.parent)) {
+      return fail4(
+        "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`);
+    }
+    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`);
+    }
+    for (const [field, present] of [
+      ["text", object.text !== void 0],
+      ["parent", object.parent !== void 0],
+      ["intendedRect", object.geometry?.intendedRect !== void 0],
+      ["visibleRect", object.geometry?.visibleRect !== void 0],
+      ["paintOrder", object.paintOrder !== void 0]
+    ]) {
+      if (declared.has(field) && present) {
+        return fail4(
+          "schema",
+          `object ${object.identity.value} reports ${field} and also declares it unobservable`
+        );
+      }
+    }
+    for (const [field, value_] of Object.entries(object.state ?? {})) {
+      if (declared.has(field) && value_ !== void 0) {
+        return fail4(
+          "schema",
+          `object ${object.identity.value} reports state.${field} and also declares it unobservable`
+        );
+      }
+    }
+  }
+  return { ok: true, frame };
+}
+function validateProbeAnnotations(value, limits) {
+  const result = validateProbeFrame(
+    {
+      frame: 1,
+      objects: [
+        {
+          identity: { kind: "stable", value: "a" },
+          frameworkType: "A",
+          annotations: value
+        }
+      ]
+    },
+    limits
+  );
+  if (!result.ok) return { ok: false, code: result.code, detail: result.detail };
+  const annotations = result.frame.objects[0]?.annotations;
+  if (annotations === void 0) {
+    return {
+      ok: false,
+      code: "schema",
+      detail: "annotations: expected an annotation object"
+    };
+  }
+  try {
+    encodeFrame({ annotations }, limits.maxFrameBytes);
+  } catch (error) {
+    return {
+      ok: false,
+      code: error instanceof ProtocolViolation && error.code === "frame-oversized" ? "bytes" : "schema",
+      detail: error instanceof Error ? error.message : "annotations could not be framed"
+    };
+  }
+  return { ok: true, annotations };
+}
+
+// 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"
+];
+var MAX_IDENTIFIER_LENGTH = 1024;
+var identifier = z5.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({
+  maxFrameBytes: revisionNumber,
+  maxSnapshotBytes: revisionNumber,
+  maxNodes: revisionNumber,
+  maxDepth: revisionNumber,
+  maxStringBytes: revisionNumber,
+  maxRelationTargets: revisionNumber,
+  maxQueuedFrames: revisionNumber,
+  maxPendingWaiters: revisionNumber,
+  maxSessions: revisionNumber,
+  maxLogRecordBytes: revisionNumber,
+  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)
+};
+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)]),
+  token: nonEmptyIdentifier,
+  adapter: z5.strictObject({ name: nonEmptyIdentifier, version: nonEmptyIdentifier }),
+  capabilities: z5.array(z5.enum(ADAPTER_CAPABILITIES)).max(ADAPTER_CAPABILITIES.length),
+  probe: probeInfoSchema.optional()
+});
+var frameBeginSchema = z5.strictObject({
+  type: z5.literal("frame-begin"),
+  revision: revisionNumber
+});
+var revisionCommitSchema = z5.strictObject({
+  type: z5.literal("revision-commit"),
+  revision: revisionNumber
+});
+var snapshotEnvelopeSchema = z5.strictObject({
+  type: z5.literal("snapshot"),
+  snapshot: z5.unknown()
+});
+var treeDeltaTypeSchema = z5.object({ type: z5.literal("tree-delta") });
+var logEnvelopeSchema = z5.strictObject({
+  type: z5.literal("log"),
+  record: z5.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)]),
+  sessionId: nonEmptyIdentifier,
+  limits: limitsSchema,
+  subscribe: z5.enum(["snapshots", "revisions", "diffs"]),
+  marker: z5.object({ enabled: z5.boolean() }),
+  logs: z5.object({
+    enabled: z5.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 };
+}
+function project(value, limits) {
+  try {
+    return { ok: true, message: projectDto(value, limits.maxDepth) };
+  } catch (error) {
+    const detail = error instanceof ProtocolViolation ? error.message : "value is not a plain JSON DTO";
+    return error instanceof ProtocolViolation && error.code === "dto-depth" ? { ok: false, code: "limit-exceeded", detail } : malformed(detail);
+  }
+}
+function messageType(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const type = value.type;
+  return typeof type === "string" ? type : null;
+}
+function check(schema, value) {
+  const result = schema.safeParse(value);
+  if (result.success) return null;
+  const issue = result.error.issues[0];
+  const where = issue.path.length > 0 ? issue.path.map(String).join(".") : "<root>";
+  return `${where}: ${issue.message}`;
+}
+function checkSnapshot(value, limits) {
+  const result = validateSnapshot(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: `snapshot ${result.code}: ${result.detail}`
+  };
+}
+function checkLogRecord(value, limits) {
+  const result = validateLogRecord(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: `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;
+  const dto = projected.message;
+  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}` };
+      }
+      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);
+        if (!checked.ok) return malformed(`probe: ${checked.detail}`);
+      }
+      return { ok: true, message: dto };
+    }
+    case "revision-commit": {
+      const issue = check(revisionCommitSchema, dto);
+      return issue === null ? { ok: true, message: dto } : malformed(issue);
+    }
+    case "snapshot": {
+      const issue = check(snapshotEnvelopeSchema, dto);
+      if (issue !== null) return malformed(issue);
+      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);
+      const bad = checkLogRecord(dto.record, limits);
+      return bad ?? { ok: true, message: dto };
+    }
+    case "error": {
+      const issue = check(errorSchema, dto);
+      return issue === null ? { ok: true, message: dto } : malformed(issue);
+    }
+    default:
+      return malformed("unknown or missing message type");
+  }
+}
+function parseDriverMessage(value, limits) {
+  const projected = project(value, limits);
+  if (!projected.ok) return projected;
+  const dto = projected.message;
+  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}` };
+      }
+      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);
+    }
+    default:
+      return malformed("unknown or missing message type");
+  }
+}
+
+// src/marker.ts
+import { Buffer as Buffer6 } from "buffer";
+import { createHmac, timingSafeEqual } from "crypto";
+var MARKER_OSC_CODE = 8487;
+var MARKER_OSC_PREFIX = "twm;";
+var MARKER_MAC_BYTES = 16;
+var MARKER_MAC_CHARS = 22;
+var REVISION_TEXT = /^[1-9][0-9]{0,15}$/;
+var MAC_TEXT = new RegExp(`^[A-Za-z0-9_-]{${MARKER_MAC_CHARS}}$`);
+var BEL = "\x07";
+var ST = "\x1B\\";
+function computeMac(token, sessionId, revision) {
+  return createHmac("sha256", token).update(`${sessionId}:${revision}`, "utf8").digest().subarray(0, MARKER_MAC_BYTES).toString("base64url");
+}
+function encodeMarker(token, sessionId, revision) {
+  if (token.length === 0) {
+    throw new ProtocolViolation("marker-argument", "token must not be empty");
+  }
+  if (sessionId.length === 0) {
+    throw new ProtocolViolation("marker-argument", "sessionId must not be empty");
+  }
+  if (!Number.isSafeInteger(revision) || revision <= 0) {
+    throw new ProtocolViolation("marker-argument", "revision must be a positive safe integer");
+  }
+  const mac = computeMac(token, sessionId, revision);
+  return `\x1B]${MARKER_OSC_CODE};${MARKER_OSC_PREFIX}${revision};${mac}${BEL}`;
+}
+function verifyMarkerPayload(payload, token, sessionId) {
+  if (token.length === 0 || sessionId.length === 0) return null;
+  let text = payload;
+  if (text.endsWith(BEL)) text = text.slice(0, -BEL.length);
+  else if (text.endsWith(ST)) text = text.slice(0, -ST.length);
+  if (!text.startsWith(MARKER_OSC_PREFIX)) return null;
+  const body = text.slice(MARKER_OSC_PREFIX.length);
+  const separator = body.indexOf(";");
+  if (separator < 0) return null;
+  const revisionText = body.slice(0, separator);
+  const mac = body.slice(separator + 1);
+  if (!REVISION_TEXT.test(revisionText)) return null;
+  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");
+  if (expected.length !== actual.length) return null;
+  if (!timingSafeEqual(expected, actual)) return null;
+  return Object.freeze({ revision, mac });
+}
+export {
+  ABSOLUTE_LIMITS,
+  ACCESSKIT_ROLE_BY_SEMANTIC_ROLE,
+  ACCESSKIT_ROOT_TREE_ID,
+  ADAPTER_CAPABILITIES,
+  DEFAULT_LIMITS,
+  DEFAULT_NEGOTIATION_MS,
+  ENV_ENDPOINT,
+  ENV_PROTOCOL,
+  ENV_TOKEN,
+  FRAMEWORK_OBSERVATION_CAPABILITIES,
+  FRAMEWORK_OPERATION_CAPABILITIES,
+  FRAME_HEADER_BYTES,
+  LOG_LEVELS,
+  LOG_LEVEL_SEVERITY,
+  MARKER_MAC_BYTES,
+  MARKER_OSC_CODE,
+  MARKER_OSC_PREFIX,
+  MAX_LOG_ATTRS,
+  PROBE_CAPABILITIES,
+  PROBE_UNOBSERVABLE_FIELDS,
+  PROTOCOL_ID,
+  PROTOCOL_V2_ID,
+  PROTOCOL_VERSION,
+  PROVENANCE_SOURCES,
+  ProtocolViolation,
+  SEMANTIC_ACTIONS,
+  SEMANTIC_NODE_KEYS,
+  SEMANTIC_ROLES,
+  SEMANTIC_STATE_KEYS,
+  SUPPORTED_PROTOCOL_IDS,
+  TOKEN_BYTES,
+  accessKitNodeId,
+  applyTreeDelta,
+  createFrameDecoder,
+  encodeFrame,
+  encodeMarker,
+  frameworkObservationCapabilities,
+  generateToken,
+  intersectRects,
+  parseAdapterMessage,
+  parseDriverMessage,
+  probeInfoSchema,
+  projectDto,
+  rectArea,
+  resolveNodeBounds,
+  spatialRelation,
+  toAccessKitTreeUpdate,
+  validateLogRecord,
+  validateProbeAnnotations,
+  validateProbeFrame,
+  validateProbeInfo,
+  validateSnapshot,
+  validateTreeDelta,
+  verifyMarkerPayload,
+  viewportIntersection
+};
+//# sourceMappingURL=index.js.map