@syrin/iris 0.4.0

package/dist/index.js

@@ -0,0 +1,3984 @@
+// ../protocol/dist/constants.js
+var IRIS_DEFAULT_PORT = 4400;
+var IRIS_WS_PATH = "/iris";
+var IRIS_PROTOCOL_VERSION = 1;
+var RunKind = {
+  FLOW_REPLAY: "flow_replay",
+  // auto-recorded by iris_flow_replay
+  MANUAL: "manual"
+  // explicitly recorded via iris_run_record
+};
+var RunStatus = {
+  PASS: "pass",
+  DRIFT: "drift",
+  ERROR: "error",
+  FAIL: "fail"
+};
+var FLOW_FILE_VERSION = 1;
+var AnchorKind = {
+  TESTID: "testid",
+  // { kind:'testid', value }
+  ROLE: "role",
+  // { kind:'role', role, name? } — best-effort fallback
+  SIGNAL: "signal"
+  // { kind:'signal', name } — wait/assert anchors
+};
+var DEGRADED_ANCHOR_ROLE = "unresolved";
+var AnnotationKind = {
+  ASSERT_SIGNAL: "assert-signal",
+  // → step.expect.signal  (invariant)
+  ASSERT_VISIBLE: "assert-visible",
+  // → step.expect.element (invariant)
+  MARK_DYNAMIC: "mark-dynamic",
+  // → flow.dynamic[]      (don't assert words/content)
+  SUCCESS_STATE: "success-state"
+  // → flow.success        (golden end condition)
+};
+var RecorderPhase = {
+  IDLE: "idle",
+  // listeners inert, no steps captured
+  RECORDING: "recording",
+  // capture-phase listeners live
+  ANNOTATING: "annotating"
+  // recording paused, awaiting an annotation target/kind
+};
+var EventType = {
+  DOM_ADDED: "dom.added",
+  DOM_REMOVED: "dom.removed",
+  DOM_ATTR: "dom.attr",
+  DOM_TEXT: "dom.text",
+  NET_REQUEST: "net.request",
+  NET_PENDING: "net.pending",
+  ROUTE_CHANGE: "route.change",
+  CONSOLE_LOG: "console.log",
+  CONSOLE_WARN: "console.warn",
+  CONSOLE_ERROR: "console.error",
+  ERROR_UNCAUGHT: "error.uncaught",
+  VISIBLE_SHOWN: "visible.shown",
+  VISIBLE_HIDDEN: "visible.hidden",
+  ANIM_START: "anim.start",
+  ANIM_END: "anim.end",
+  SCROLL_POSITION: "scroll.position",
+  REVEAL_SHOWN: "reveal.shown",
+  SIGNAL: "signal",
+  STATE_CHANGE: "state.change",
+  /** page-level visibility/focus health (distinct from element-level VISIBLE_*). */
+  PAGE_HEALTH: "page.health",
+  /** browser → bridge: a human recording compiled in-page. */
+  FLOW_RECORDED: "flow.recorded",
+  /** synthetic: browser transport queue overflowed; events were dropped. `data: { dropped: number }`. */
+  TRANSPORT_OVERFLOW: "transport.overflow",
+  /**
+   * Live-control: browser → bridge. A human acted on the presenter panel.
+   * `data: { kind: HumanControlKind; text?: string }`. Rides the existing EventMessage.
+   */
+  HUMAN_CONTROL: "human.control"
+};
+var SessionState = {
+  ACTIVE: "active",
+  PAUSED: "paused",
+  ENDED: "ended"
+};
+var SESSION_AUTO = "auto";
+var HumanControlKind = {
+  PAUSE: "pause",
+  RESUME: "resume",
+  END: "end",
+  MESSAGE: "message"
+};
+var SESSION_HEALTH = {
+  HEARTBEAT_MS: 5e3,
+  /** lastSeenMs beyond this ⇒ throttled (≈ 2 missed heartbeats). */
+  STALE_THRESHOLD_MS: 12e3
+};
+var SESSION_LIFECYCLE = {
+  /** Default agent-idle window before the server reaps a session. Agent-tunable via iris_session. */
+  IDLE_END_MS: 3e5,
+  /** Floor for a tuned idle window (so an agent can't disable the safety net). */
+  IDLE_END_MIN_MS: 5e3,
+  /** How often the server reaper sweeps sessions for idle/disconnected ones. */
+  REAP_INTERVAL_MS: 5e3,
+  /** Browser fallback: continuous failure to reach the bridge for this long ⇒ self-end the session. */
+  BRIDGE_LOST_MS: 15e3
+};
+var HealthReason = {
+  VISIBILITY: "visibilitychange",
+  FOCUS: "focus",
+  BLUR: "blur",
+  HEARTBEAT: "heartbeat",
+  INITIAL: "initial"
+};
+var ActionWarning = {
+  HOVER_NATIVE_ENTER_LEAVE: "target has enter/leave handlers; synthetic hover may not trigger them \u2014 expect no state change",
+  /** real-input provider was available but failed; the action fell back to synthetic dispatch. */
+  REAL_INPUT_FELL_BACK: "real-input provider was available but failed; fell back to synthetic dispatch",
+  /**
+   * The click point was covered by another element. Synthetic dispatch still delivered the event to
+   * your target, but a real user could NOT click it — treat the target as visually blocked, not
+   * actionable. Scroll it into a clear area or dismiss the overlay on top.
+   */
+  CLICK_OCCLUDED: "target is visually occluded by another element; a real user could not click it (synthetic dispatch still delivered the event) \u2014 dismiss the overlay or scroll the target clear"
+};
+var ActionType = {
+  CLICK: "click",
+  DBLCLICK: "dblclick",
+  HOVER: "hover",
+  FOCUS: "focus",
+  BLUR: "blur",
+  FILL: "fill",
+  TYPE: "type",
+  CLEAR: "clear",
+  SELECT: "select",
+  CHECK: "check",
+  UNCHECK: "uncheck",
+  SUBMIT: "submit",
+  PRESS: "press",
+  UPLOAD: "upload",
+  SCROLL_INTO_VIEW: "scrollIntoView",
+  DRAG: "drag",
+  WEBMCP: "webmcp"
+};
+var SettleReason = {
+  TIMEOUT: "timeout",
+  THROTTLED: "throttled"
+};
+var ComponentStateReason = {
+  UNAVAILABLE: "component-state-unavailable"
+};
+var ElementState = {
+  VISIBLE: "visible",
+  HIDDEN: "hidden",
+  ENABLED: "enabled",
+  DISABLED: "disabled",
+  CHECKED: "checked",
+  EXPANDED: "expanded",
+  FOCUSED: "focused",
+  PRESENT: "present"
+};
+var QueryBy = {
+  ROLE: "role",
+  TEXT: "text",
+  LABEL: "label",
+  PLACEHOLDER: "placeholder",
+  TESTID: "testid",
+  ALT: "alt"
+};
+var IrisCommand = {
+  SNAPSHOT: "snapshot",
+  QUERY: "query",
+  MATCH: "match",
+  INSPECT: "inspect",
+  ACT: "act",
+  ACT_SEQUENCE: "act_sequence",
+  ANIMATIONS: "animations",
+  NARRATE: "narrate",
+  CLOCK: "clock",
+  CAPABILITIES: "capabilities",
+  STATE_READ: "state_read",
+  /** scroll a ref's nearest scrollable container by ~a viewport (virtualized lists). */
+  SCROLL: "scroll",
+  /** Session lifecycle: agent tunes the presenter session (e.g. idle-end timeout) for the app's needs. */
+  SESSION_CONFIG: "session_config",
+  /**
+   * Live-control: bridge → browser. Pushes the current session state to the panel so an
+   * AGENT-driven pause/end keeps the presenter in sync. `args: { state, text? }`.
+   */
+  PRESENTER: "presenter",
+  /** Navigate the page to a new URL. `args: { url: string }`. */
+  NAVIGATE: "navigate",
+  /** Reload the page. `args: { hard?: boolean }` — hard clears the cache via location replace trick. */
+  REFRESH: "refresh"
+};
+var PresenterMode = {
+  IDLE: "idle",
+  READING: "reading",
+  ACTING: "acting"
+};
+var SnapshotMode = {
+  FULL: "full",
+  INTERACTIVE: "interactive",
+  STATUS: "status"
+};
+var MessageKind = {
+  HELLO: "hello",
+  COMMAND: "command",
+  COMMAND_RESULT: "command_result",
+  EVENT: "event"
+};
+
+// ../protocol/dist/types.js
+import { z } from "zod";
+var ElementQuerySchema = z.object({
+  by: z.nativeEnum(QueryBy).optional(),
+  value: z.string().optional(),
+  role: z.string().optional(),
+  name: z.string().optional(),
+  text: z.string().optional(),
+  label: z.string().optional(),
+  placeholder: z.string().optional(),
+  testid: z.string().optional(),
+  alt: z.string().optional(),
+  /** CSS selector or ref to scope the search. */
+  scope: z.string().optional()
+});
+var CapabilityFlowSchema = z.object({
+  name: z.string(),
+  steps: z.array(z.string())
+});
+var CapabilitiesSchema = z.object({
+  testids: z.array(z.string()),
+  signals: z.array(z.string()),
+  stores: z.array(z.string()),
+  flows: z.array(CapabilityFlowSchema)
+});
+var ContractFileSchema = z.object({
+  version: z.number(),
+  generatedAt: z.number(),
+  capabilities: CapabilitiesSchema
+});
+var RunEvidenceSchema = z.object({
+  consoleErrors: z.number().optional(),
+  networkErrors: z.number().optional(),
+  driftSteps: z.number().optional()
+});
+var RunRecordSchema = z.object({
+  kind: z.nativeEnum(RunKind),
+  name: z.string(),
+  status: z.nativeEnum(RunStatus),
+  at: z.number(),
+  summary: z.string().optional(),
+  evidence: RunEvidenceSchema.optional(),
+  durationMs: z.number().optional()
+});
+var ProjectLearnedSchema = z.object({
+  flows: z.array(z.string()).optional(),
+  routes: z.array(z.string()).optional()
+});
+var ProjectFileSchema = z.object({
+  version: z.number(),
+  learned: ProjectLearnedSchema.optional(),
+  runs: z.array(RunRecordSchema)
+});
+var FlowAnchorSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal(AnchorKind.TESTID), value: z.string().min(1) }),
+  z.object({
+    kind: z.literal(AnchorKind.ROLE),
+    role: z.string().min(1),
+    name: z.string().optional()
+  }),
+  z.object({ kind: z.literal(AnchorKind.SIGNAL), name: z.string().min(1) })
+]);
+var FlowExpectSchema = z.object({
+  signal: z.string().optional(),
+  /**
+   * Optional payload shape an `assert-signal` annotation requires the signal
+   * to match (the predicate DSL's signal.dataMatches). Additive/optional — a flow file with a
+   * bare `signal` still parses, and the on-disk version stays FLOW_FILE_VERSION 1.
+   */
+  signalData: z.record(z.unknown()).optional(),
+  net: z.object({
+    method: z.string().optional(),
+    urlContains: z.string().optional(),
+    status: z.number().optional()
+  }).optional(),
+  element: z.object({
+    testid: z.string().optional(),
+    role: z.string().optional(),
+    name: z.string().optional()
+  }).optional()
+});
+var baseFlowStep = z.object({
+  tool: z.string(),
+  anchor: FlowAnchorSchema,
+  action: z.nativeEnum(ActionType).optional(),
+  args: z.record(z.unknown()).optional(),
+  expect: FlowExpectSchema.optional(),
+  degraded: z.boolean().optional()
+});
+var FlowStepSchema = baseFlowStep.extend({
+  steps: z.lazy(() => z.array(FlowStepSchema).optional())
+});
+var FlowFileSchema = z.object({
+  version: z.literal(FLOW_FILE_VERSION),
+  name: z.string(),
+  // FUTURE: fixtures/preconditions — schema slot reserved, unpopulated this cut. The recorder
+  // never writes it and no fixture runner exists.
+  fixture: z.string().optional(),
+  /** From the injected clock (ms) — deterministic in tests, byte-stable on disk. */
+  createdAt: z.number(),
+  steps: z.array(FlowStepSchema),
+  success: FlowExpectSchema.optional(),
+  /**
+   * Anchors whose CONTENT must not be asserted (e.g. LLM output). Replay asserts
+   * presence, not words. Compiled from a `mark-dynamic` annotation.
+   */
+  dynamic: z.array(FlowAnchorSchema).optional()
+});
+var RecordedFlowSchema = z.object({
+  name: z.string(),
+  flow: FlowFileSchema
+});
+var AnnotationSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal(AnnotationKind.ASSERT_SIGNAL),
+    name: z.string().min(1),
+    dataMatches: z.record(z.unknown()).optional()
+  }),
+  z.object({
+    kind: z.literal(AnnotationKind.ASSERT_VISIBLE),
+    testid: z.string().min(1)
+  }),
+  z.object({
+    kind: z.literal(AnnotationKind.MARK_DYNAMIC),
+    testid: z.string().min(1)
+  }),
+  z.object({
+    kind: z.literal(AnnotationKind.SUCCESS_STATE),
+    signal: z.string().min(1).optional(),
+    testid: z.string().min(1).optional()
+  })
+]);
+
+// ../browser/dist/dom/refs.js
+var RefRegistry = class {
+  #toRef = /* @__PURE__ */ new WeakMap();
+  #fromRef = /* @__PURE__ */ new Map();
+  #seq = 0;
+  /** Get the existing ref for an element, or mint a new one. */
+  refFor(el) {
+    const existing = this.#toRef.get(el);
+    if (existing !== void 0)
+      return existing;
+    this.#seq += 1;
+    const ref = `e${String(this.#seq)}`;
+    this.#toRef.set(el, ref);
+    this.#fromRef.set(ref, new WeakRef(el));
+    return ref;
+  }
+  /** Resolve a ref back to its element, or null if it's gone/detached. */
+  resolve(ref) {
+    const weak = this.#fromRef.get(ref);
+    if (weak === void 0)
+      return null;
+    const el = weak.deref();
+    if (el === void 0 || !el.isConnected) {
+      this.#fromRef.delete(ref);
+      return null;
+    }
+    return el;
+  }
+};
+var refs = new RefRegistry();
+
+// ../browser/dist/dom/a11y.js
+var NAME_FROM_CONTENT = /* @__PURE__ */ new Set([
+  "button",
+  "link",
+  "heading",
+  "option",
+  "listitem",
+  "cell",
+  "columnheader",
+  "rowheader",
+  "tab",
+  "menuitem",
+  "menuitemcheckbox",
+  "menuitemradio",
+  "treeitem",
+  "gridcell",
+  "switch",
+  "status",
+  "alert"
+]);
+var INPUT_TEXT_TYPES = /* @__PURE__ */ new Set(["text", "email", "tel", "url", "search", "password", ""]);
+function inputRole(input) {
+  const type = input.type.toLowerCase();
+  if (INPUT_TEXT_TYPES.has(type))
+    return "textbox";
+  if (type === "checkbox")
+    return "checkbox";
+  if (type === "radio")
+    return "radio";
+  if (type === "range")
+    return "slider";
+  if (type === "number")
+    return "spinbutton";
+  if (type === "submit" || type === "button" || type === "reset")
+    return "button";
+  return "textbox";
+}
+function getRole(el) {
+  const explicit = el.getAttribute("role");
+  if (explicit !== null && explicit.trim().length > 0)
+    return explicit.trim();
+  const tag = el.tagName.toLowerCase();
+  switch (tag) {
+    case "a":
+      return el.hasAttribute("href") ? "link" : "generic";
+    case "button":
+      return "button";
+    case "input":
+      return inputRole(el);
+    case "textarea":
+      return "textbox";
+    case "select":
+      return el.multiple ? "listbox" : "combobox";
+    case "h1":
+    case "h2":
+    case "h3":
+    case "h4":
+    case "h5":
+    case "h6":
+      return "heading";
+    case "ul":
+    case "ol":
+      return "list";
+    case "li":
+      return "listitem";
+    case "nav":
+      return "navigation";
+    case "main":
+      return "main";
+    case "aside":
+      return "complementary";
+    case "dialog":
+      return "dialog";
+    case "img":
+      return "img";
+    case "table":
+      return "table";
+    case "form":
+      return "form";
+    case "p":
+      return "paragraph";
+    case "header":
+      return "banner";
+    case "footer":
+      return "contentinfo";
+    default:
+      return "generic";
+  }
+}
+function collapse(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function labelledByText(el) {
+  const ids = el.getAttribute("aria-labelledby");
+  if (ids === null)
+    return null;
+  const parts = [];
+  for (const id of ids.split(/\s+/)) {
+    const ref = el.ownerDocument.getElementById(id);
+    if (ref !== null)
+      parts.push(collapse(ref.textContent ?? ""));
+  }
+  const joined = parts.join(" ").trim();
+  return joined.length > 0 ? joined : null;
+}
+function getAccessibleName(el) {
+  const labelled = labelledByText(el);
+  if (labelled !== null)
+    return labelled;
+  const ariaLabel = el.getAttribute("aria-label");
+  if (ariaLabel !== null && ariaLabel.trim().length > 0)
+    return ariaLabel.trim();
+  if (el instanceof HTMLImageElement) {
+    const alt = el.getAttribute("alt");
+    if (alt !== null)
+      return alt.trim();
+  }
+  if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement) {
+    const labels = el.labels;
+    if (labels !== null && labels.length > 0) {
+      const text = [...labels].map((l) => collapse(l.textContent ?? "")).join(" ").trim();
+      if (text.length > 0)
+        return text;
+    }
+    if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) {
+      const placeholder = el.getAttribute("placeholder");
+      if (placeholder !== null && placeholder.trim().length > 0)
+        return placeholder.trim();
+    }
+  }
+  if (NAME_FROM_CONTENT.has(getRole(el))) {
+    const text = collapse(el.textContent ?? "");
+    if (text.length > 0)
+      return text;
+  }
+  const title = el.getAttribute("title");
+  if (title !== null && title.trim().length > 0)
+    return title.trim();
+  return "";
+}
+function ariaBool(el, attr) {
+  const value = el.getAttribute(attr);
+  if (value === null)
+    return void 0;
+  return value === "true";
+}
+function getStates(el) {
+  const states = [ElementState.PRESENT];
+  if (isVisible(el))
+    states.push(ElementState.VISIBLE);
+  else
+    states.push(ElementState.HIDDEN);
+  const disabledProp = (el instanceof HTMLButtonElement || el instanceof HTMLInputElement || el instanceof HTMLSelectElement || el instanceof HTMLTextAreaElement) && el.disabled;
+  const disabled = disabledProp || ariaBool(el, "aria-disabled") === true;
+  states.push(disabled ? ElementState.DISABLED : ElementState.ENABLED);
+  const checkedProp = el instanceof HTMLInputElement && (el.type === "checkbox" || el.type === "radio") && el.checked;
+  if (checkedProp || ariaBool(el, "aria-checked") === true)
+    states.push(ElementState.CHECKED);
+  if (ariaBool(el, "aria-expanded") === true)
+    states.push(ElementState.EXPANDED);
+  if (el.ownerDocument.activeElement === el)
+    states.push(ElementState.FOCUSED);
+  return states;
+}
+function getValue(el) {
+  if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement) {
+    return el.value;
+  }
+  const valueNow = el.getAttribute("aria-valuenow");
+  return valueNow ?? void 0;
+}
+function isVisible(el) {
+  if (!el.isConnected)
+    return false;
+  let node = el;
+  while (node !== null) {
+    if (node.getAttribute("aria-hidden") === "true")
+      return false;
+    if (node instanceof HTMLElement && node.hidden)
+      return false;
+    const view = node.ownerDocument.defaultView;
+    if (view !== null) {
+      const style = view.getComputedStyle(node);
+      if (style.display === "none" || style.visibility === "hidden" || style.visibility === "collapse") {
+        return false;
+      }
+      if (Number.parseFloat(style.opacity || "1") === 0)
+        return false;
+    }
+    node = node.parentElement;
+  }
+  return true;
+}
+var MAX_TEXT = 80;
+function getVisibleText(el) {
+  const text = collapse(el.textContent ?? "");
+  return text.length > MAX_TEXT ? `${text.slice(0, MAX_TEXT)}\u2026` : text;
+}
+function describe(el) {
+  const value = getValue(el);
+  const text = getVisibleText(el);
+  const name = getAccessibleName(el);
+  const base = {
+    ref: refs.refFor(el),
+    role: getRole(el),
+    name,
+    states: getStates(el),
+    visible: isVisible(el)
+  };
+  if (value !== void 0 && value.length > 0)
+    base.value = value;
+  if (text.length > 0 && text !== name)
+    base.text = text;
+  return base;
+}
+
+// ../browser/dist/dom/dom-ignore.js
+var IRIS_OVERLAY = "[data-iris-overlay],[data-iris-cursor],[data-iris-hud],[data-iris-glow]";
+var DEV_OVERLAYS = "[data-agentation],#__next-build-watcher,nextjs-portal,[data-nextjs-dialog],[data-nextjs-toast]";
+var extraIgnore = "";
+function setIgnoreSelectors(selectors) {
+  extraIgnore = selectors.join(",");
+}
+function isIrisOverlay(el) {
+  return el.closest(IRIS_OVERLAY) !== null;
+}
+function isIgnored(el) {
+  const sel = extraIgnore.length > 0 ? `${IRIS_OVERLAY},${DEV_OVERLAYS},${extraIgnore}` : `${IRIS_OVERLAY},${DEV_OVERLAYS}`;
+  return el.closest(sel) !== null;
+}
+
+// ../browser/dist/dom/snapshot.js
+var INTERACTIVE = /* @__PURE__ */ new Set([
+  "button",
+  "link",
+  "textbox",
+  "checkbox",
+  "radio",
+  "combobox",
+  "listbox",
+  "slider",
+  "spinbutton",
+  "switch",
+  "tab",
+  "menuitem",
+  "option"
+]);
+var SKIP_TAGS = /* @__PURE__ */ new Set(["script", "style", "noscript", "template", "head", "meta", "link"]);
+function skip(el) {
+  if (SKIP_TAGS.has(el.tagName.toLowerCase()))
+    return true;
+  if (isIgnored(el))
+    return true;
+  if (el.getAttribute("aria-hidden") === "true")
+    return true;
+  if (el instanceof HTMLElement && el.hidden)
+    return true;
+  const view = el.ownerDocument.defaultView;
+  if (view !== null) {
+    const style = view.getComputedStyle(el);
+    if (style.display === "none")
+      return true;
+  }
+  return false;
+}
+function stateSuffix(el) {
+  const states = getStates(el).filter((s) => s === ElementState.DISABLED || s === ElementState.CHECKED || s === ElementState.EXPANDED || s === ElementState.FOCUSED);
+  return states.length > 0 ? ` [${states.join(",")}]` : "";
+}
+function formatLine(el, depth, role, name) {
+  const indent = "  ".repeat(depth);
+  const value = getValue(el);
+  const namePart = name.length > 0 ? ` "${name}"` : "";
+  const refPart = INTERACTIVE.has(role) || name.length > 0 ? ` (ref=${refs.refFor(el)})` : "";
+  const valuePart = value !== void 0 && value.length > 0 ? ` [value="${value}"]` : "";
+  return `${indent}- ${role}${namePart}${refPart}${valuePart}${stateSuffix(el)}`;
+}
+function walk(parent, depth, ctx) {
+  if (depth > ctx.maxDepth)
+    return;
+  for (const child of parent.children) {
+    if (ctx.nodes >= ctx.maxNodes) {
+      ctx.truncated = true;
+      return;
+    }
+    if (skip(child))
+      continue;
+    const role = getRole(child);
+    const name = getAccessibleName(child);
+    const interactive = INTERACTIVE.has(role);
+    const meaningful = interactive || role !== "generic" || name.length > 0;
+    const include = ctx.mode === SnapshotMode.INTERACTIVE ? interactive : meaningful;
+    if (include) {
+      ctx.nodes += 1;
+      ctx.lines.push(formatLine(child, depth, role, name));
+      walk(child, depth + 1, ctx);
+    } else {
+      walk(child, depth, ctx);
+    }
+  }
+}
+function collectDialogs(root) {
+  const nodes = root.querySelectorAll('[role="dialog"], dialog[open], [aria-modal="true"]');
+  const names = [];
+  for (const node of nodes) {
+    if (isVisible(node))
+      names.push(getAccessibleName(node) || "(unnamed dialog)");
+  }
+  return names;
+}
+function buildStatus(root) {
+  return {
+    route: `${location.pathname}${location.search}${location.hash}`,
+    title: document.title,
+    visibleDialogs: collectDialogs(root)
+  };
+}
+function buildSnapshot(options = {}) {
+  const mode = options.mode ?? SnapshotMode.FULL;
+  const scopeEl = options.scope !== void 0 ? refs.resolve(options.scope) ?? document.querySelector(options.scope) : document.body;
+  const root = scopeEl ?? document.body;
+  const status = buildStatus(root);
+  if (mode === SnapshotMode.STATUS) {
+    return { tree: "", status, nodes: 0, truncated: false };
+  }
+  const ctx = {
+    lines: [],
+    nodes: 0,
+    truncated: false,
+    mode,
+    maxNodes: options.maxNodes ?? 400,
+    maxDepth: options.maxDepth ?? 20
+  };
+  walk(root, 0, ctx);
+  return {
+    tree: ctx.lines.join("\n"),
+    status,
+    nodes: ctx.nodes,
+    truncated: ctx.truncated
+  };
+}
+
+// ../browser/dist/dom/query.js
+import { queryAllByRole, queryAllByText, queryAllByLabelText, queryAllByPlaceholderText, queryAllByTestId, queryAllByAltText } from "@testing-library/dom";
+
+// ../browser/dist/registry/capabilities.js
+var globalStore = globalThis;
+function empty() {
+  return { testids: [], signals: [], stores: [], flows: [] };
+}
+var capabilities = globalStore.__irisCapabilities ??= empty();
+function mergeUnique(into, add) {
+  if (add === void 0)
+    return;
+  for (const v of add)
+    if (!into.includes(v))
+      into.push(v);
+}
+function registerCapabilities(input) {
+  mergeUnique(capabilities.testids, input.testids);
+  mergeUnique(capabilities.signals, input.signals);
+  mergeUnique(capabilities.stores, input.stores);
+  if (input.flows !== void 0) {
+    for (const flow of input.flows) {
+      const existing = capabilities.flows.find((f) => f.name === flow.name);
+      if (existing === void 0) {
+        capabilities.flows.push({ name: flow.name, steps: [...flow.steps] });
+      } else {
+        existing.steps = [...flow.steps];
+      }
+    }
+  }
+}
+function getCapabilities() {
+  return {
+    testids: [...capabilities.testids],
+    signals: [...capabilities.signals],
+    stores: [...capabilities.stores],
+    flows: capabilities.flows.map((f) => ({ name: f.name, steps: [...f.steps] }))
+  };
+}
+function hasCapabilities() {
+  return capabilities.testids.length > 0 || capabilities.signals.length > 0 || capabilities.stores.length > 0 || capabilities.flows.length > 0;
+}
+
+// ../browser/dist/dom/query.js
+var TESTID_ATTR = "data-testid";
+var MAX_PRESENT_TESTIDS = 12;
+function resolveContainer(scope) {
+  const body = document.body;
+  if (scope === void 0)
+    return body;
+  const byRef = refs.resolve(scope);
+  if (byRef instanceof HTMLElement)
+    return byRef;
+  try {
+    const found = document.querySelector(scope);
+    if (found instanceof HTMLElement)
+      return found;
+  } catch {
+  }
+  return body;
+}
+function findCandidates(query) {
+  const container = resolveContainer(query.scope);
+  const by = query.by;
+  const value = query.value;
+  if (by !== void 0 && value !== void 0) {
+    switch (by) {
+      case QueryBy.ROLE:
+        return queryAllByRole(container, value, query.name !== void 0 ? { hidden: true, name: query.name } : { hidden: true });
+      case QueryBy.TEXT:
+        return queryAllByText(container, value, { exact: false });
+      case QueryBy.LABEL:
+        return queryAllByLabelText(container, value, { exact: false });
+      case QueryBy.PLACEHOLDER:
+        return queryAllByPlaceholderText(container, value, { exact: false });
+      case QueryBy.TESTID:
+        return queryAllByTestId(container, value, { exact: true });
+      case QueryBy.ALT:
+        return queryAllByAltText(container, value, { exact: false });
+      default:
+        return [];
+    }
+  }
+  if (query.role !== void 0) {
+    const options = query.name !== void 0 ? { hidden: true, name: query.name } : { hidden: true };
+    return queryAllByRole(container, query.role, options);
+  }
+  if (query.text !== void 0)
+    return queryAllByText(container, query.text, { exact: false });
+  if (query.label !== void 0) {
+    return queryAllByLabelText(container, query.label, { exact: false });
+  }
+  if (query.placeholder !== void 0) {
+    return queryAllByPlaceholderText(container, query.placeholder, { exact: false });
+  }
+  if (query.testid !== void 0)
+    return queryAllByTestId(container, query.testid, { exact: true });
+  if (query.alt !== void 0)
+    return queryAllByAltText(container, query.alt, { exact: false });
+  return [];
+}
+function inState(el, state) {
+  return getStates(el).includes(state);
+}
+function matchQuery(query, state) {
+  let elements;
+  try {
+    elements = findCandidates(query);
+  } catch {
+    elements = [];
+  }
+  const filtered = state === void 0 ? elements : elements.filter((el) => inState(el, state));
+  const descriptors = filtered.map((el) => describe(el));
+  return { matched: descriptors.length > 0, count: descriptors.length, elements: descriptors };
+}
+function buildPresentRegions(query) {
+  const container = resolveContainer(query.scope);
+  const regions = [];
+  const CONTAINER_ROLES = [
+    "list",
+    "listbox",
+    "grid",
+    "table",
+    "tree",
+    "treegrid",
+    "dialog",
+    "alertdialog",
+    "navigation",
+    "main",
+    "banner",
+    "form",
+    "search",
+    "menu",
+    "menubar",
+    "tablist"
+  ];
+  for (const role of CONTAINER_ROLES) {
+    let containers;
+    try {
+      containers = queryAllByRole(container, role, { hidden: true });
+    } catch {
+      continue;
+    }
+    for (const el of containers) {
+      const name = el.getAttribute("aria-label") ?? el.getAttribute("aria-labelledby") ?? el.getAttribute("data-testid") ?? void 0;
+      const children = el.querySelectorAll("[role]");
+      const sample = [];
+      for (const child of Array.from(children)) {
+        if (sample.length >= 3)
+          break;
+        const childRole = child.getAttribute("role");
+        const childName = child.getAttribute("aria-label") ?? child.getAttribute("data-testid") ?? child.textContent?.trim().slice(0, 40) ?? "";
+        if (childRole !== null && childName.length > 0) {
+          sample.push(`${childRole}[${childName}]`);
+        }
+      }
+      const region = { role, childCount: children.length, sample };
+      if (name !== void 0 && name.length > 0)
+        region.name = name;
+      regions.push(region);
+      if (regions.length >= 10)
+        return regions;
+    }
+  }
+  return regions;
+}
+function buildEmptyHint(query) {
+  const container = resolveContainer(query.scope);
+  const all = container.querySelectorAll(`[${TESTID_ATTR}]`);
+  const present = [];
+  for (const el of Array.from(all)) {
+    const id = el.getAttribute(TESTID_ATTR);
+    if (id !== null && id.length > 0 && !present.includes(id)) {
+      present.push(id);
+      if (present.length >= MAX_PRESENT_TESTIDS)
+        break;
+    }
+  }
+  const registered = getCapabilities().testids;
+  const knownEmptyState = present.some((id) => registered.includes(id));
+  const route = `${location.pathname}${location.search}`;
+  return {
+    route,
+    presentTestids: present,
+    presentRegions: buildPresentRegions(query),
+    knownEmptyState
+  };
+}
+function runQuery(query) {
+  const result2 = matchQuery(query);
+  if (result2.elements.length === 0) {
+    return { elements: result2.elements, hint: buildEmptyHint(query) };
+  }
+  return { elements: result2.elements };
+}
+
+// ../browser/dist/registry/adapters.js
+var globalStore2 = globalThis;
+var adapters = globalStore2.__irisAdapters ??= [];
+function registerAdapter(adapter) {
+  if (!adapters.some((a) => a.name === adapter.name))
+    adapters.push(adapter);
+}
+function identifyComponent(el) {
+  for (const adapter of adapters) {
+    const info = adapter.identify(el);
+    if (info !== null)
+      return info;
+  }
+  return null;
+}
+function readComponentState(el) {
+  for (const adapter of adapters) {
+    if (adapter.readState === void 0)
+      continue;
+    const state = adapter.readState(el);
+    if (state !== void 0)
+      return state;
+  }
+  return void 0;
+}
+function elementHasHoverHandlers(el) {
+  for (const adapter of adapters) {
+    if (adapter.hasHoverHandlers === void 0)
+      continue;
+    if (adapter.hasHoverHandlers(el))
+      return true;
+  }
+  return false;
+}
+function adapterNames() {
+  return adapters.map((a) => a.name);
+}
+
+// ../browser/dist/timers/native-timers.js
+var g = globalThis;
+var realSetTimeout = typeof g.setTimeout === "function" ? g.setTimeout.bind(g) : null;
+var realClearTimeout = typeof g.clearTimeout === "function" ? g.clearTimeout.bind(g) : null;
+var realRaf = typeof g.requestAnimationFrame === "function" ? g.requestAnimationFrame.bind(g) : null;
+var realPerfNow = typeof g.performance?.now === "function" ? g.performance.now.bind(g.performance) : null;
+var nativeNow = () => realPerfNow ? realPerfNow() : 0;
+var nativeSetTimeout = (cb, ms = 0) => realSetTimeout ? realSetTimeout(cb, ms) : 0;
+var nativeClearTimeout = (id) => {
+  realClearTimeout?.(id);
+};
+var nativeSetInterval = (cb, ms) => {
+  let stopped = false;
+  let id = 0;
+  const tick = () => {
+    if (stopped)
+      return;
+    cb();
+    if (stopped)
+      return;
+    id = nativeSetTimeout(tick, ms);
+  };
+  id = nativeSetTimeout(tick, ms);
+  return () => {
+    stopped = true;
+    nativeClearTimeout(id);
+  };
+};
+var FRAME_BUDGET_MS = 200;
+var boundedFrame = (budgetMs = FRAME_BUDGET_MS) => new Promise((resolve) => {
+  let done = false;
+  const finish = (settled) => {
+    if (done)
+      return;
+    done = true;
+    nativeClearTimeout(timer);
+    resolve({ settled });
+  };
+  const timer = nativeSetTimeout(() => finish(false), budgetMs);
+  if (realRaf)
+    realRaf(() => finish(true));
+  else
+    nativeSetTimeout(() => finish(true), 0);
+});
+var nativeFrame = () => boundedFrame().then(() => void 0);
+var settle = async (budgetMs = FRAME_BUDGET_MS) => {
+  await Promise.resolve();
+  return boundedFrame(budgetMs);
+};
+
+// ../browser/dist/actions/actions.js
+function setNativeValue(el, value) {
+  const proto = el instanceof HTMLTextAreaElement ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype;
+  const setter = Object.getOwnPropertyDescriptor(proto, "value")?.set;
+  if (setter !== void 0) {
+    setter.call(el, value);
+  } else {
+    el.value = value;
+  }
+  const notPrevented = el.dispatchEvent(new Event("input", { bubbles: true, cancelable: true }));
+  el.dispatchEvent(new Event("change", { bubbles: true }));
+  return !notPrevented;
+}
+function asString(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function requireElement(ref) {
+  const el = refs.resolve(ref);
+  if (el === null)
+    throw new Error(`ref '${ref}' no longer resolves to an element`);
+  if (!(el instanceof HTMLElement))
+    throw new Error(`ref '${ref}' is not an HTMLElement`);
+  return el;
+}
+var result = (ref, action, effect, settled, settleReason, warning) => {
+  const testid = refs.resolve(ref)?.getAttribute("data-testid") ?? void 0;
+  const base = {
+    ok: true,
+    ref,
+    action,
+    dispatched: true,
+    settled,
+    settleReason,
+    effect
+  };
+  if (testid !== void 0)
+    base.testid = testid;
+  if (warning !== void 0)
+    base.warning = warning;
+  return base;
+};
+var FILL_LIKE = /* @__PURE__ */ new Set([ActionType.FILL, ActionType.TYPE, ActionType.CLEAR]);
+var isFillLike = (action) => FILL_LIKE.has(action);
+var CLICK_LIKE = /* @__PURE__ */ new Set([ActionType.CLICK, ActionType.DBLCLICK]);
+var NO_GEOMETRY = { occluded: false, occludedBy: null, scrolledIntoView: false };
+function fireClickSequence(el) {
+  const doc = el.ownerDocument;
+  const from = doc.activeElement ?? doc.body;
+  firePointer(el, "pointerdown", from);
+  el.dispatchEvent(new MouseEvent("mousedown", { bubbles: true, cancelable: true }));
+  if (el.tabIndex >= 0 && typeof el.focus === "function")
+    el.focus();
+  firePointer(el, "pointerup", from);
+  el.dispatchEvent(new MouseEvent("mouseup", { bubbles: true, cancelable: true }));
+  const notPrevented = el.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
+  return !notPrevented;
+}
+function isMeasurable(rect) {
+  return rect.width > 0 || rect.height > 0;
+}
+function isOffViewport(el, rect) {
+  const win = el.ownerDocument.defaultView;
+  if (win === null)
+    return false;
+  const cx = rect.left + rect.width / 2;
+  const cy = rect.top + rect.height / 2;
+  return cx < 0 || cy < 0 || cx > win.innerWidth || cy > win.innerHeight;
+}
+function hitTest(el, rect) {
+  const doc = el.ownerDocument;
+  if (typeof doc.elementFromPoint !== "function")
+    return { occluded: false, occludedBy: null };
+  const top = doc.elementFromPoint(rect.left + rect.width / 2, rect.top + rect.height / 2);
+  if (top === null)
+    return { occluded: false, occludedBy: null };
+  const lands = top === el || el.contains(top) || top.contains(el);
+  return lands ? { occluded: false, occludedBy: null } : { occluded: true, occludedBy: refs.refFor(top) };
+}
+function clickGeometry(el) {
+  if (typeof el.getBoundingClientRect !== "function")
+    return NO_GEOMETRY;
+  let rect = el.getBoundingClientRect();
+  if (!isMeasurable(rect))
+    return NO_GEOMETRY;
+  let scrolledIntoView = false;
+  if (isOffViewport(el, rect) && typeof el.scrollIntoView === "function") {
+    el.scrollIntoView({ block: "center", inline: "center" });
+    scrolledIntoView = true;
+    rect = el.getBoundingClientRect();
+  }
+  return { ...hitTest(el, rect), scrolledIntoView };
+}
+function enabledOf(el) {
+  return !getStates(el).includes(ElementState.DISABLED);
+}
+function valueOf(el) {
+  if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement || el instanceof HTMLSelectElement) {
+    return el.value;
+  }
+  return void 0;
+}
+function activeRef(el) {
+  const active = el.ownerDocument.activeElement;
+  if (active === null || active === el.ownerDocument.body)
+    return null;
+  return refs.refFor(active);
+}
+async function dispatchFor(el, action, args) {
+  switch (action) {
+    case ActionType.CLICK:
+      return fireClickSequence(el);
+    case ActionType.DBLCLICK:
+      return !el.dispatchEvent(new MouseEvent("dblclick", { bubbles: true, cancelable: true }));
+    case ActionType.HOVER: {
+      const doc = el.ownerDocument;
+      const from = doc.activeElement ?? doc.body;
+      firePointer(el, "pointerover", from);
+      el.dispatchEvent(new MouseEvent("mouseover", { bubbles: true, relatedTarget: from }));
+      firePointerNonBubbling(el, "pointerenter", from);
+      el.dispatchEvent(new MouseEvent("mouseenter", { relatedTarget: from }));
+      firePointer(el, "pointermove", from);
+      const moved = el.dispatchEvent(new MouseEvent("mousemove", { bubbles: true, cancelable: true }));
+      const holdMs = typeof args["holdMs"] === "number" ? args["holdMs"] : 0;
+      if (holdMs > 0)
+        await sleep(holdMs);
+      return !moved;
+    }
+    case ActionType.FOCUS:
+      el.focus();
+      el.dispatchEvent(new FocusEvent("focusin", { bubbles: true }));
+      return false;
+    // FocusEvents are not cancelable.
+    case ActionType.BLUR:
+      el.blur();
+      el.dispatchEvent(new FocusEvent("blur"));
+      el.dispatchEvent(new FocusEvent("focusout", { bubbles: true }));
+      return false;
+    case ActionType.FILL:
+      if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) {
+        el.focus();
+        return setNativeValue(el, asString(args["value"]));
+      }
+      throw new Error(`cannot fill a <${el.tagName.toLowerCase()}>`);
+    case ActionType.TYPE:
+      if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) {
+        el.focus();
+        return setNativeValue(el, el.value + asString(args["text"]));
+      }
+      throw new Error(`cannot type into a <${el.tagName.toLowerCase()}>`);
+    case ActionType.CLEAR:
+      if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) {
+        return setNativeValue(el, "");
+      }
+      return false;
+    case ActionType.SELECT:
+      if (el instanceof HTMLSelectElement) {
+        el.value = asString(args["value"]);
+        el.dispatchEvent(new Event("change", { bubbles: true }));
+        return false;
+      }
+      throw new Error(`cannot select on a <${el.tagName.toLowerCase()}>`);
+    case ActionType.CHECK:
+    case ActionType.UNCHECK:
+      if (el instanceof HTMLInputElement) {
+        el.checked = action === ActionType.CHECK;
+        el.dispatchEvent(new Event("change", { bubbles: true }));
+        return false;
+      }
+      throw new Error(`cannot (un)check a <${el.tagName.toLowerCase()}>`);
+    case ActionType.SUBMIT: {
+      const form = el instanceof HTMLFormElement ? el : el.closest("form");
+      if (form === null)
+        throw new Error("no form to submit");
+      form.requestSubmit();
+      return false;
+    }
+    case ActionType.PRESS: {
+      const key = asString(args["key"], "Enter");
+      const down = el.dispatchEvent(new KeyboardEvent("keydown", { key, bubbles: true, cancelable: true }));
+      el.dispatchEvent(new KeyboardEvent("keyup", { key, bubbles: true }));
+      return !down;
+    }
+    case ActionType.SCROLL_INTO_VIEW:
+      el.scrollIntoView();
+      return false;
+    case ActionType.UPLOAD: {
+      if (!(el instanceof HTMLInputElement) || el.type !== "file") {
+        throw new Error('upload target must be a <input type="file">');
+      }
+      const file = new File([asString(args["content"], "iris test file")], asString(args["name"], "file.txt"), {
+        type: asString(args["type"], "text/plain")
+      });
+      const dt = new DataTransfer();
+      dt.items.add(file);
+      el.files = dt.files;
+      const inputOk = el.dispatchEvent(new Event("input", { bubbles: true, cancelable: true }));
+      el.dispatchEvent(new Event("change", { bubbles: true }));
+      return !inputOk;
+    }
+    case ActionType.DRAG: {
+      const toRef = asString(args["toRef"]);
+      const resolved = toRef !== void 0 ? refs.resolve(toRef) : null;
+      return await dragElement(el, resolved instanceof HTMLElement ? resolved : null, args["data"]);
+    }
+    default:
+      throw new Error(`unknown action '${action}'`);
+  }
+}
+async function executeAction(ref, action, args = {}) {
+  const el = requireElement(ref);
+  const visible = isVisible(el);
+  const enabled = enabledOf(el);
+  const prevFocus = activeRef(el);
+  const valueBefore = valueOf(el);
+  const geometry = CLICK_LIKE.has(action) ? clickGeometry(el) : NO_GEOMETRY;
+  let mutated = 0;
+  const obs = new MutationObserver((records) => {
+    mutated += records.length;
+  });
+  obs.observe(el.ownerDocument.documentElement, {
+    subtree: true,
+    childList: true,
+    attributes: true,
+    characterData: true
+  });
+  let defaultPrevented = false;
+  let settled = false;
+  let settleReason = null;
+  try {
+    defaultPrevented = await dispatchFor(el, action, args);
+  } finally {
+    const outcome = await settle();
+    settled = outcome.settled;
+    settleReason = outcome.settled ? null : SettleReason.TIMEOUT;
+    obs.disconnect();
+  }
+  const valueAfter = valueOf(el);
+  const nextFocus = activeRef(el);
+  const effect = {
+    dispatched: true,
+    targetMatched: el.isConnected,
+    visible,
+    enabled,
+    defaultPrevented,
+    focusMoved: prevFocus !== nextFocus ? `${prevFocus ?? "null"}->${nextFocus ?? "null"}` : null,
+    valueChanged: isFillLike(action) ? valueBefore !== valueAfter : false,
+    domMutatedWithin: mutated,
+    occluded: geometry.occluded,
+    occludedBy: geometry.occludedBy,
+    scrolledIntoView: geometry.scrolledIntoView
+  };
+  const warning = geometry.occluded ? ActionWarning.CLICK_OCCLUDED : action === ActionType.HOVER && elementHasHoverHandlers(el) ? ActionWarning.HOVER_NATIVE_ENTER_LEAVE : void 0;
+  return result(ref, action, effect, settled, settleReason, warning);
+}
+var sleep = (ms) => new Promise((r) => nativeSetTimeout(r, ms));
+function firePointer(el, type, relatedTarget = null) {
+  if (typeof PointerEvent === "function") {
+    el.dispatchEvent(new PointerEvent(type, { bubbles: true, cancelable: true, relatedTarget }));
+  } else {
+    el.dispatchEvent(new MouseEvent(type, { bubbles: true, cancelable: true, relatedTarget }));
+  }
+}
+function firePointerNonBubbling(el, type, relatedTarget = null) {
+  if (typeof PointerEvent === "function") {
+    el.dispatchEvent(new PointerEvent(type, { bubbles: false, cancelable: true, relatedTarget }));
+  } else {
+    el.dispatchEvent(new MouseEvent(type, { bubbles: false, cancelable: true, relatedTarget }));
+  }
+}
+function makeDataTransfer(data) {
+  if (typeof DataTransfer !== "function")
+    return null;
+  const dt = new DataTransfer();
+  const entries = Array.isArray(data) ? data : data !== void 0 ? [data] : [];
+  for (const entry of entries) {
+    if (typeof entry === "object" && entry !== null) {
+      const e = entry;
+      if (typeof e.mime === "string" && typeof e.value === "string")
+        dt.setData(e.mime, e.value);
+    }
+  }
+  return dt;
+}
+async function dragElement(source, target, data) {
+  const dest = target ?? source;
+  const fire = (el, type) => {
+    if (typeof PointerEvent === "function" && type.startsWith("pointer")) {
+      el.dispatchEvent(new PointerEvent(type, { bubbles: true, cancelable: true }));
+    } else {
+      el.dispatchEvent(new MouseEvent(type, { bubbles: true, cancelable: true }));
+    }
+  };
+  fire(source, "pointerdown");
+  fire(source, "mousedown");
+  await nativeFrame();
+  fire(dest, "pointermove");
+  fire(dest, "mousemove");
+  await nativeFrame();
+  fire(dest, "pointerup");
+  fire(dest, "mouseup");
+  let dropPrevented = false;
+  if (typeof DragEvent === "function") {
+    const dataTransfer = makeDataTransfer(data);
+    const init = { bubbles: true, cancelable: true };
+    if (dataTransfer !== null)
+      init.dataTransfer = dataTransfer;
+    source.dispatchEvent(new DragEvent("dragstart", init));
+    await nativeFrame();
+    dest.dispatchEvent(new DragEvent("dragenter", init));
+    dest.dispatchEvent(new DragEvent("dragover", init));
+    await nativeFrame();
+    dropPrevented = !dest.dispatchEvent(new DragEvent("drop", init));
+    source.dispatchEvent(new DragEvent("dragend", init));
+  }
+  return dropPrevented;
+}
+async function dispatchWebMcp(tool, params) {
+  const mc = navigator.modelContext;
+  if (mc === void 0 || typeof mc.callTool !== "function") {
+    throw new Error("WebMCP (navigator.modelContext) not available on this page");
+  }
+  return await mc.callTool(tool, params);
+}
+async function executeSequence(steps) {
+  const effects = [];
+  const stepResults = [];
+  for (const step of steps) {
+    const res = await executeAction(step.ref, step.action, step.args ?? {});
+    effects.push(res.effect);
+    const stepBase = {
+      ref: res.ref,
+      action: res.action,
+      dispatched: res.dispatched,
+      settled: res.settled,
+      settleReason: res.settleReason
+    };
+    if (res.testid !== void 0)
+      stepBase.testid = res.testid;
+    if (res.warning !== void 0)
+      stepBase.warning = res.warning;
+    stepResults.push(stepBase);
+  }
+  return { ok: true, count: steps.length, effects, steps: stepResults };
+}
+
+// ../browser/dist/registry/stores.js
+var globalStore3 = globalThis;
+var stores = globalStore3.__irisStores ??= /* @__PURE__ */ new Map();
+function registerStore(name, getter) {
+  stores.set(name, getter);
+}
+function unregisterStore(name) {
+  stores.delete(name);
+}
+function storeNames() {
+  return [...stores.keys()];
+}
+function readStores(only) {
+  const out = {};
+  for (const [name, getter] of stores) {
+    if (only !== void 0 && name !== only)
+      continue;
+    try {
+      out[name] = getter();
+    } catch (error) {
+      out[name] = { __error: error instanceof Error ? error.message : String(error) };
+    }
+  }
+  return out;
+}
+
+// ../browser/dist/timers/clock.js
+var installed = false;
+var virtualNow = 0;
+var realBase = 0;
+var seq = 1;
+var tasks = [];
+var originals = null;
+function isClockFrozen() {
+  return installed;
+}
+function freezeClock() {
+  if (installed || typeof window === "undefined")
+    return;
+  installed = true;
+  virtualNow = 0;
+  realBase = Date.now();
+  originals = {
+    setTimeout: window.setTimeout,
+    clearTimeout: window.clearTimeout,
+    setInterval: window.setInterval,
+    clearInterval: window.clearInterval,
+    dateNow: Date.now
+  };
+  const schedule = (cb, delay, interval) => {
+    const id = seq;
+    seq += 1;
+    tasks.push({ id, time: virtualNow + Math.max(0, delay), cb, interval });
+    return id;
+  };
+  const cancel = (id) => {
+    tasks = tasks.filter((t) => t.id !== id);
+  };
+  window.setTimeout = ((cb, delay = 0) => schedule(cb, delay));
+  window.clearTimeout = ((id) => cancel(id));
+  window.setInterval = ((cb, delay = 0) => schedule(cb, delay, Math.max(1, delay)));
+  window.clearInterval = ((id) => cancel(id));
+  Date.now = () => realBase + virtualNow;
+}
+function advanceClock(ms) {
+  if (!installed)
+    return;
+  const target = virtualNow + Math.max(0, ms);
+  let guard = 0;
+  for (; ; ) {
+    guard += 1;
+    if (guard > 1e5)
+      break;
+    const due = tasks.filter((t) => t.time <= target).sort((a, b) => a.time - b.time);
+    const next = due[0];
+    if (next === void 0)
+      break;
+    tasks = tasks.filter((t) => t !== next);
+    virtualNow = next.time;
+    next.cb();
+    if (next.interval !== void 0) {
+      tasks.push({ ...next, id: seq++, time: virtualNow + next.interval });
+    }
+  }
+  virtualNow = target;
+}
+function resetClock() {
+  if (!installed || originals === null)
+    return;
+  window.setTimeout = originals.setTimeout;
+  window.clearTimeout = originals.clearTimeout;
+  window.setInterval = originals.setInterval;
+  window.clearInterval = originals.clearInterval;
+  Date.now = originals.dateNow;
+  originals = null;
+  tasks = [];
+  installed = false;
+  virtualNow = 0;
+}
+
+// ../browser/dist/actions/scroll.js
+var FALLBACK_STEP_PX = 400;
+var VIEWPORT_FRACTION = 0.8;
+function nearestScrollable(el) {
+  let cur = el;
+  while (cur !== null && cur !== document.body) {
+    const oy = getComputedStyle(cur).overflowY;
+    if ((oy === "auto" || oy === "scroll") && cur.scrollHeight > cur.clientHeight)
+      return cur;
+    cur = cur.parentElement;
+  }
+  return document.scrollingElement ?? document.documentElement;
+}
+function scrollContainer(ref, dy, fraction) {
+  const base = ref !== void 0 ? refs.resolve(ref) : null;
+  const target = base instanceof Element ? nearestScrollable(base) : document.scrollingElement ?? document.documentElement;
+  const before = target.scrollTop;
+  if (fraction !== void 0 && fraction >= 0 && fraction <= 1) {
+    target.scrollTop = Math.round(target.scrollHeight * fraction);
+  } else {
+    const step = dy ?? (Math.round(target.clientHeight * VIEWPORT_FRACTION) || FALLBACK_STEP_PX);
+    target.scrollTop = before + step;
+  }
+  target.dispatchEvent(new Event("scroll", { bubbles: false }));
+  const after = target.scrollTop;
+  return {
+    scrolled: after !== before,
+    scrollTop: after,
+    scrollHeight: target.scrollHeight,
+    clientHeight: target.clientHeight,
+    atEnd: after + target.clientHeight >= target.scrollHeight - 1
+  };
+}
+
+// ../browser/dist/commands/commands.js
+function str(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function record(value) {
+  return typeof value === "object" && value !== null ? value : {};
+}
+function queryFromArgs(args) {
+  return {
+    by: str(args["by"]),
+    value: str(args["value"]),
+    role: str(args["role"]),
+    name: str(args["name"]),
+    text: str(args["text"]),
+    label: str(args["label"]),
+    placeholder: str(args["placeholder"]),
+    testid: str(args["testid"]),
+    alt: str(args["alt"]),
+    scope: str(args["scope"])
+  };
+}
+function inspect(ref) {
+  const el = refs.resolve(ref);
+  if (el === null)
+    return { error: `ref '${ref}' no longer resolves` };
+  const rect = el.getBoundingClientRect();
+  const component = identifyComponent(el);
+  const view = el.ownerDocument.defaultView;
+  const cs = view !== null ? view.getComputedStyle(el) : null;
+  const styles = cs !== null ? { color: cs.color, backgroundColor: cs.backgroundColor, opacity: cs.opacity } : null;
+  return {
+    ...describe(el),
+    tag: el.tagName.toLowerCase(),
+    box: { x: rect.x, y: rect.y, width: rect.width, height: rect.height },
+    styles,
+    component
+  };
+}
+function isComponentStateResult(value) {
+  return typeof value === "object" && value !== null && "ok" in value && typeof value.ok === "boolean";
+}
+var COMPONENT_UNAVAILABLE = {
+  ok: false,
+  reason: ComponentStateReason.UNAVAILABLE
+};
+function readState(ref, store) {
+  const stores2 = readStores(store);
+  const result2 = {
+    stores: stores2,
+    storeNames: storeNames()
+  };
+  if (ref !== void 0 && ref.length > 0) {
+    const el = refs.resolve(ref);
+    if (el === null) {
+      result2.component = COMPONENT_UNAVAILABLE;
+    } else {
+      const state = readComponentState(el);
+      result2.component = isComponentStateResult(state) ? state : COMPONENT_UNAVAILABLE;
+    }
+  }
+  return result2;
+}
+function listAnimations() {
+  const doc = document;
+  if (typeof doc.getAnimations !== "function")
+    return { animations: [] };
+  const animations = doc.getAnimations().map((a) => {
+    const effect = a.effect;
+    const timing = effect?.getTiming();
+    return {
+      playState: a.playState,
+      currentTime: a.currentTime,
+      duration: timing?.duration
+    };
+  });
+  return { animations };
+}
+function createCommandRegistry() {
+  const reg = /* @__PURE__ */ new Map();
+  reg.set(IrisCommand.SNAPSHOT, (args) => buildSnapshot({
+    scope: str(args["scope"]),
+    mode: str(args["mode"]) ?? SnapshotMode.FULL
+  }));
+  reg.set(IrisCommand.QUERY, (args) => runQuery(queryFromArgs(args)));
+  reg.set(IrisCommand.MATCH, (args) => matchQuery(ElementQuerySchema.parse(record(args["query"])), str(args["state"])));
+  reg.set(IrisCommand.ACT, (args) => {
+    const action = str(args["action"]) ?? "";
+    if (action === ActionType.WEBMCP) {
+      const inner = record(args["args"]);
+      return dispatchWebMcp(str(inner["tool"]) ?? "", record(inner["params"]));
+    }
+    return executeAction(str(args["ref"]) ?? "", action, record(args["args"]));
+  });
+  reg.set(IrisCommand.ACT_SEQUENCE, (args) => executeSequence(Array.isArray(args["steps"]) ? args["steps"] : []));
+  reg.set(IrisCommand.INSPECT, (args) => inspect(str(args["ref"]) ?? ""));
+  reg.set(IrisCommand.ANIMATIONS, () => listAnimations());
+  reg.set(IrisCommand.CLOCK, (args) => {
+    if (args["reset"] === true) {
+      resetClock();
+    } else {
+      if (args["freeze"] === true)
+        freezeClock();
+      const adv = args["advanceMs"];
+      if (typeof adv === "number")
+        advanceClock(adv);
+    }
+    return { frozen: isClockFrozen() };
+  });
+  reg.set(IrisCommand.STATE_READ, (args) => readState(str(args["ref"]), str(args["store"])));
+  reg.set(IrisCommand.CAPABILITIES, () => getCapabilities());
+  reg.set(IrisCommand.SCROLL, (args) => {
+    const dy = args["dy"];
+    const fraction = args["fraction"];
+    return scrollContainer(str(args["ref"]), typeof dy === "number" ? dy : void 0, typeof fraction === "number" ? fraction : void 0);
+  });
+  reg.set(IrisCommand.NAVIGATE, (args) => {
+    const url = str(args["url"]);
+    if (url === void 0 || url.length === 0)
+      return { ok: false, reason: "url required" };
+    window.location.assign(url);
+    return { ok: true, url };
+  });
+  reg.set(IrisCommand.REFRESH, (args) => {
+    if (args["hard"] === true) {
+      const url = new URL(window.location.href);
+      url.searchParams.set("_iris_reload", String(Date.now()));
+      window.location.replace(url.toString());
+    } else {
+      window.location.reload();
+    }
+    return { ok: true };
+  });
+  return reg;
+}
+
+// ../browser/dist/transport/transport.js
+var RECONNECT_DELAY_MS = 1e3;
+var MAX_QUEUE = 500;
+var Transport = class {
+  #ws;
+  #queue = [];
+  #closed = false;
+  /** When the current continuous outage began (nativeNow), or undefined while connected. */
+  #disconnectedSince;
+  /** Whether onConnectionLost has already fired for the current outage (fire-once). */
+  #lost = false;
+  #overflowCount = 0;
+  #deps;
+  #now;
+  constructor(deps) {
+    this.#deps = deps;
+    this.#now = deps.now ?? nativeNow;
+  }
+  connect() {
+    if (typeof WebSocket === "undefined")
+      return;
+    this.#closed = false;
+    this.#open();
+  }
+  #open() {
+    const ws = new WebSocket(this.#deps.url);
+    this.#ws = ws;
+    ws.onopen = () => {
+      this.#disconnectedSince = void 0;
+      this.#lost = false;
+      ws.send(JSON.stringify(this.#deps.hello()));
+      for (const msg of this.#queue)
+        ws.send(msg);
+      this.#queue = [];
+    };
+    ws.onmessage = (event) => {
+      const data = event.data;
+      void this.#onMessage(typeof data === "string" ? data : String(data));
+    };
+    ws.onclose = () => {
+      this.#ws = void 0;
+      this.#noteOutage();
+      if (!this.#closed)
+        nativeSetTimeout(() => this.#reopen(), RECONNECT_DELAY_MS);
+    };
+    ws.onerror = () => {
+      ws.close();
+    };
+  }
+  /** A scheduled reconnect — skipped if the SDK has since been torn down. */
+  #reopen() {
+    if (this.#closed)
+      return;
+    this.#open();
+  }
+  /**
+   * Track how long the bridge has been unreachable. Once the outage exceeds BRIDGE_LOST_MS, fire
+   * onConnectionLost exactly once so the SDK can end the session (the server/agent is gone and can
+   * no longer push an end itself).
+   */
+  #noteOutage() {
+    const at = this.#now();
+    this.#disconnectedSince ??= at;
+    if (!this.#lost && at - this.#disconnectedSince >= SESSION_LIFECYCLE.BRIDGE_LOST_MS) {
+      this.#lost = true;
+      this.#deps.onConnectionLost?.();
+    }
+  }
+  async #onMessage(text) {
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      return;
+    }
+    const msg = parsed;
+    if (msg.kind !== MessageKind.COMMAND)
+      return;
+    const command = parsed;
+    const outcome = await this.#deps.handleCommand(command);
+    this.#sendRaw(JSON.stringify({
+      kind: MessageKind.COMMAND_RESULT,
+      id: command.id,
+      ok: outcome.ok,
+      result: outcome.result,
+      error: outcome.error
+    }));
+  }
+  sendEvent(event) {
+    this.#sendRaw(JSON.stringify({ kind: MessageKind.EVENT, event }));
+  }
+  #sendRaw(text) {
+    if (this.#ws !== void 0 && this.#ws.readyState === WebSocket.OPEN) {
+      this.#ws.send(text);
+    } else if (this.#queue.length < MAX_QUEUE) {
+      this.#queue.push(text);
+    } else {
+      this.#overflowCount += 1;
+      this.#deps.onOverflow?.(this.#overflowCount);
+    }
+  }
+  close() {
+    this.#closed = true;
+    this.#ws?.close();
+    this.#ws = void 0;
+  }
+};
+
+// ../browser/dist/observers/dom.js
+var WATCHED_ATTRS = [
+  "class",
+  "hidden",
+  "disabled",
+  "open",
+  "aria-hidden",
+  "aria-expanded",
+  "aria-selected",
+  "aria-checked",
+  "data-state"
+];
+var DIALOG_ROLES = /* @__PURE__ */ new Set(["dialog", "alertdialog"]);
+var LIVE_ROLES = /* @__PURE__ */ new Set(["alert", "status"]);
+var MAX_PER_BATCH = 40;
+function isMeaningful(role, name) {
+  return role !== "generic" || name.length > 0;
+}
+function installDom(emit) {
+  const observer = new MutationObserver((records) => {
+    let added = 0;
+    let removed = 0;
+    let changed = 0;
+    for (const record2 of records) {
+      if (record2.type === "attributes") {
+        const target = record2.target;
+        if (target instanceof Element && record2.attributeName !== null && changed < MAX_PER_BATCH && !isIrisOverlay(target)) {
+          changed += 1;
+          emit(EventType.DOM_ATTR, { attr: record2.attributeName, value: target.getAttribute(record2.attributeName) }, refs.refFor(target));
+        }
+        continue;
+      }
+      if (record2.type === "characterData") {
+        const parent = record2.target.parentElement;
+        if (parent !== null && changed < MAX_PER_BATCH && !isIrisOverlay(parent)) {
+          changed += 1;
+          const text = (record2.target.textContent ?? "").trim().slice(0, 80);
+          emit(EventType.DOM_TEXT, { text }, refs.refFor(parent));
+        }
+        continue;
+      }
+      for (const node of record2.addedNodes) {
+        if (!(node instanceof Element) || added >= MAX_PER_BATCH)
+          continue;
+        if (isIrisOverlay(node))
+          continue;
+        const role = getRole(node);
+        const name = getAccessibleName(node);
+        if (!isMeaningful(role, name))
+          continue;
+        added += 1;
+        const ref = refs.refFor(node);
+        emit(EventType.DOM_ADDED, { role, name }, ref);
+        if (DIALOG_ROLES.has(role) || LIVE_ROLES.has(role) || node.getAttribute("aria-modal") === "true") {
+          if (isVisible(node))
+            emit(EventType.VISIBLE_SHOWN, { role, name }, ref);
+        }
+      }
+      for (const node of record2.removedNodes) {
+        if (!(node instanceof Element) || removed >= MAX_PER_BATCH)
+          continue;
+        if (isIrisOverlay(node))
+          continue;
+        const role = getRole(node);
+        const name = getAccessibleName(node);
+        if (!isMeaningful(role, name))
+          continue;
+        removed += 1;
+        emit(EventType.DOM_REMOVED, { role, name });
+      }
+    }
+  });
+  observer.observe(document.documentElement, {
+    subtree: true,
+    childList: true,
+    attributes: true,
+    attributeFilter: WATCHED_ATTRS,
+    characterData: true
+  });
+  return () => {
+    observer.disconnect();
+  };
+}
+
+// ../browser/dist/observers/network.js
+function urlOf(input) {
+  if (typeof input === "string")
+    return input;
+  if (input instanceof URL)
+    return input.href;
+  return input.url;
+}
+function methodOf(input, init) {
+  if (init?.method !== void 0)
+    return init.method.toUpperCase();
+  if (input instanceof Request)
+    return input.method.toUpperCase();
+  return "GET";
+}
+function installNetwork(emit) {
+  const origFetch = window.fetch.bind(window);
+  window.fetch = async (input, init) => {
+    const start = performance.now();
+    const method = methodOf(input, init);
+    const url = urlOf(input);
+    try {
+      const res = await origFetch(input, init);
+      emit(EventType.NET_REQUEST, {
+        method,
+        url,
+        status: res.status,
+        ok: res.ok,
+        durationMs: Math.round(performance.now() - start),
+        initiator: "fetch"
+      });
+      return res;
+    } catch (error) {
+      emit(EventType.NET_REQUEST, {
+        method,
+        url,
+        status: 0,
+        ok: false,
+        error: error instanceof Error ? error.message : String(error),
+        durationMs: Math.round(performance.now() - start),
+        initiator: "fetch"
+      });
+      throw error;
+    }
+  };
+  const meta = /* @__PURE__ */ new WeakMap();
+  const proto = XMLHttpRequest.prototype;
+  const origOpen = proto.open;
+  const origSend = proto.send;
+  const callOpen = origOpen;
+  proto.open = function(method, url, ...rest) {
+    meta.set(this, { method: method.toUpperCase(), url: String(url), start: 0 });
+    callOpen.call(this, method, url, ...rest);
+  };
+  proto.send = function(body) {
+    const m = meta.get(this);
+    if (m !== void 0) {
+      m.start = performance.now();
+      this.addEventListener("loadend", () => {
+        emit(EventType.NET_REQUEST, {
+          method: m.method,
+          url: m.url,
+          status: this.status,
+          ok: this.status >= 200 && this.status < 400,
+          durationMs: Math.round(performance.now() - m.start),
+          initiator: "xhr"
+        });
+      });
+    }
+    origSend.call(this, body ?? null);
+  };
+  return () => {
+    window.fetch = origFetch;
+    proto.open = origOpen;
+    proto.send = origSend;
+  };
+}
+
+// ../browser/dist/observers/route.js
+function snapshotLocation() {
+  return {
+    pathname: location.pathname,
+    search: location.search,
+    hash: location.hash,
+    href: location.href
+  };
+}
+function installRoute(emit) {
+  const origPush = history.pushState.bind(history);
+  const origReplace = history.replaceState.bind(history);
+  const fire = (from) => {
+    const to = snapshotLocation();
+    if (to.href === from)
+      return;
+    emit(EventType.ROUTE_CHANGE, {
+      from,
+      to: to.href,
+      pathname: to.pathname,
+      search: to.search,
+      hash: to.hash
+    });
+  };
+  history.pushState = (data, unused, url) => {
+    const from = location.href;
+    origPush(data, unused, url ?? null);
+    fire(from);
+  };
+  history.replaceState = (data, unused, url) => {
+    const from = location.href;
+    origReplace(data, unused, url ?? null);
+    fire(from);
+  };
+  let lastHref = location.href;
+  const onNav = () => {
+    fire(lastHref);
+    lastHref = location.href;
+  };
+  window.addEventListener("popstate", onNav);
+  window.addEventListener("hashchange", onNav);
+  return () => {
+    history.pushState = origPush;
+    history.replaceState = origReplace;
+    window.removeEventListener("popstate", onNav);
+    window.removeEventListener("hashchange", onNav);
+  };
+}
+
+// ../browser/dist/observers/console.js
+var METHOD_EVENT = {
+  log: EventType.CONSOLE_LOG,
+  warn: EventType.CONSOLE_WARN,
+  error: EventType.CONSOLE_ERROR
+};
+function stringifyArgs(args) {
+  return args.map((a) => {
+    if (typeof a === "string")
+      return a;
+    if (a instanceof Error)
+      return a.message;
+    try {
+      return JSON.stringify(a);
+    } catch {
+      return String(a);
+    }
+  }).join(" ");
+}
+function installConsole(emit) {
+  const methods = ["log", "warn", "error"];
+  const originals2 = /* @__PURE__ */ new Map();
+  for (const method of methods) {
+    const original = console[method].bind(console);
+    originals2.set(method, original);
+    console[method] = (...args) => {
+      emit(METHOD_EVENT[method], { message: stringifyArgs(args) });
+      original(...args);
+    };
+  }
+  const onError = (event) => {
+    emit(EventType.ERROR_UNCAUGHT, {
+      message: event.message,
+      source: event.filename,
+      line: event.lineno
+    });
+  };
+  const onRejection = (event) => {
+    const reason = event.reason;
+    emit(EventType.ERROR_UNCAUGHT, {
+      message: reason instanceof Error ? reason.message : String(reason),
+      kind: "unhandledrejection"
+    });
+  };
+  window.addEventListener("error", onError);
+  window.addEventListener("unhandledrejection", onRejection);
+  return () => {
+    for (const [method, original] of originals2) {
+      console[method] = original;
+    }
+    window.removeEventListener("error", onError);
+    window.removeEventListener("unhandledrejection", onRejection);
+  };
+}
+
+// ../browser/dist/observers/animation.js
+function installAnimation(emit) {
+  const onStart = (event) => {
+    const target = event.target;
+    if (target instanceof Element && !isIrisOverlay(target)) {
+      emit(EventType.ANIM_START, { name: event.animationName }, refs.refFor(target));
+    }
+  };
+  const onEnd = (event) => {
+    const target = event.target;
+    if (target instanceof Element && !isIrisOverlay(target)) {
+      emit(EventType.ANIM_END, { name: event.animationName }, refs.refFor(target));
+    }
+  };
+  const onTransitionEnd = (event) => {
+    const target = event.target;
+    if (target instanceof Element && !isIrisOverlay(target)) {
+      emit(EventType.ANIM_END, { name: event.propertyName, kind: "transition" }, refs.refFor(target));
+    }
+  };
+  document.addEventListener("animationstart", onStart, true);
+  document.addEventListener("animationend", onEnd, true);
+  document.addEventListener("transitionend", onTransitionEnd, true);
+  return () => {
+    document.removeEventListener("animationstart", onStart, true);
+    document.removeEventListener("animationend", onEnd, true);
+    document.removeEventListener("transitionend", onTransitionEnd, true);
+  };
+}
+
+// ../browser/dist/observers/scroll.js
+var THROTTLE_MS = 100;
+var REVEAL_SELECTOR = "[data-iris-reveal], [data-reveal], section";
+function installScroll(emit) {
+  let lastEmit = 0;
+  let lastY = 0;
+  const onScroll = () => {
+    const now = performance.now();
+    if (now - lastEmit < THROTTLE_MS)
+      return;
+    lastEmit = now;
+    const y = window.scrollY;
+    const max = Math.max(1, document.documentElement.scrollHeight - window.innerHeight);
+    emit(EventType.SCROLL_POSITION, {
+      x: window.scrollX,
+      y,
+      percent: Math.round(y / max * 100),
+      direction: y >= lastY ? "down" : "up"
+    });
+    lastY = y;
+  };
+  window.addEventListener("scroll", onScroll, { passive: true });
+  let io;
+  if (typeof IntersectionObserver === "function") {
+    io = new IntersectionObserver((entries) => {
+      for (const entry of entries) {
+        if (entry.isIntersecting) {
+          emit(EventType.REVEAL_SHOWN, { ratio: entry.intersectionRatio }, refs.refFor(entry.target));
+        }
+      }
+    }, { threshold: 0.25 });
+    for (const el of document.querySelectorAll(REVEAL_SELECTOR))
+      io.observe(el);
+  }
+  return () => {
+    window.removeEventListener("scroll", onScroll);
+    io?.disconnect();
+  };
+}
+
+// ../browser/dist/observers/health.js
+function snapshotHealth() {
+  return {
+    hidden: document.visibilityState === "hidden",
+    focused: document.hasFocus()
+  };
+}
+function installHealth(emit) {
+  const report = (reason) => {
+    emit(EventType.PAGE_HEALTH, { ...snapshotHealth(), reason });
+  };
+  const onVisibility = () => report(HealthReason.VISIBILITY);
+  const onFocus = () => report(HealthReason.FOCUS);
+  const onBlur = () => report(HealthReason.BLUR);
+  document.addEventListener("visibilitychange", onVisibility);
+  window.addEventListener("focus", onFocus);
+  window.addEventListener("blur", onBlur);
+  report(HealthReason.INITIAL);
+  const stopHeartbeat = nativeSetInterval(() => report(HealthReason.HEARTBEAT), SESSION_HEALTH.HEARTBEAT_MS);
+  return () => {
+    stopHeartbeat();
+    document.removeEventListener("visibilitychange", onVisibility);
+    window.removeEventListener("focus", onFocus);
+    window.removeEventListener("blur", onBlur);
+  };
+}
+
+// ../browser/dist/presenter/overlay.js
+var STYLE = [
+  "position:fixed",
+  "bottom:8px",
+  "right:8px",
+  "z-index:2147483647",
+  "font:11px ui-monospace,SFMono-Regular,Menlo,monospace",
+  "background:#151823",
+  "color:#e6e9f0",
+  "border:1px solid #2a2f3d",
+  "border-radius:8px",
+  "padding:6px 10px",
+  "pointer-events:none",
+  "opacity:0.85"
+].join(";");
+function installOverlay() {
+  const el = document.createElement("div");
+  el.setAttribute("data-iris-overlay", "");
+  el.style.cssText = STYLE;
+  el.textContent = "iris: connecting\u2026";
+  document.body.appendChild(el);
+  return {
+    update: (stats) => {
+      el.textContent = `iris ${stats.connected ? "\u25CF" : "\u25CB"} ${String(stats.events)} events`;
+    },
+    destroy: () => {
+      el.remove();
+    }
+  };
+}
+
+// ../browser/dist/presenter/presenter-verbs.js
+function actionVerb(action) {
+  switch (action) {
+    case "click":
+    case "dblclick":
+      return "Clicking";
+    case "fill":
+    case "type":
+      return "Typing into";
+    case "hover":
+      return "Hovering";
+    case "select":
+      return "Selecting";
+    case "submit":
+      return "Submitting";
+    case "check":
+    case "uncheck":
+      return "Toggling";
+    case "upload":
+      return "Uploading to";
+    case "drag":
+      return "Dragging";
+    default:
+      return action;
+  }
+}
+
+// ../browser/dist/presenter/presenter-log.js
+var DEFAULT_LOG_MAX = 50;
+var LOG_KIND = {
+  READ: "read",
+  ACT: "act",
+  NARRATION: "narration",
+  HUMAN: "human"
+};
+var HUMAN_ROW_PREFIX = "\u{1F9D1} you: ";
+var LOG_RESULT = { PASS: "pass", FAIL: "fail" };
+var LOG_CHIP = { read: "READ", act: "ACT", narration: "", human: "" };
+var CHIP_LABEL = {
+  [PresenterMode.IDLE]: "",
+  [PresenterMode.READING]: "READING",
+  [PresenterMode.ACTING]: "ACTING"
+};
+var LOG_CHIP_MODE = {
+  read: PresenterMode.READING,
+  act: PresenterMode.ACTING,
+  narration: PresenterMode.IDLE,
+  human: PresenterMode.IDLE
+};
+var RESULT_GLYPH = { pass: "\u2713", fail: "\u2717" };
+var RESULT_CLASS = { pass: "iris-pass", fail: "iris-fail" };
+var DATA_IRIS_LOG = "data-iris-log";
+var DATA_IRIS_LOG_ROW = "data-iris-log-row";
+var DATA_IRIS_LOG_TS = "data-iris-log-ts";
+var DATA_KIND = "data-kind";
+var LOG_TEXT_CLASS = "iris-log-text";
+var LOG_RES_CLASS = "iris-res";
+var LOG_CHIP_CLASS = "iris-chip";
+var LOG_CSS = `
+[data-iris-log]{flex:1;min-height:0;overflow-y:auto;overscroll-behavior:contain;display:flex;flex-direction:column;
+  gap:7px;padding:12px 14px;scrollbar-width:thin;scrollbar-color:rgba(255,255,255,.16) transparent;}
+[data-iris-log]::-webkit-scrollbar{width:9px;}
+[data-iris-log]::-webkit-scrollbar-thumb{background:rgba(255,255,255,.14);border-radius:9px;border:2px solid transparent;background-clip:content-box;}
+[data-iris-log]::-webkit-scrollbar-thumb:hover{background:rgba(255,255,255,.26);background-clip:content-box;}
+[data-iris-log-row]{display:flex;align-items:baseline;gap:8px;font-size:12px;line-height:1.45;
+  animation:iris-row-in .26s cubic-bezier(.16,1,.3,1);}
+@keyframes iris-row-in{from{opacity:0;transform:translateY(5px);}to{opacity:1;transform:none;}}
+[data-iris-log-ts]{flex:none;color:var(--iris-faint);font-size:10px;font-variant-numeric:tabular-nums;padding-top:1px;}
+[data-iris-log] .iris-log-text{flex:1;min-width:0;color:#d6dae4;overflow-wrap:anywhere;word-break:break-word;}
+[data-iris-log] .iris-res{flex:none;font-weight:700;}
+[data-iris-log-row][data-kind="human"]{align-self:flex-end;max-width:88%;
+  background:var(--iris-accent-soft);border:1px solid var(--iris-accent);border-radius:13px 13px 4px 13px;padding:6px 11px;}
+[data-iris-log-row][data-kind="human"] [data-iris-log-ts]{display:none;}
+[data-iris-log-row][data-kind="human"] .iris-log-text{color:var(--iris-fg);}
+`;
+function clampLogMax(n) {
+  if (n === void 0 || !Number.isFinite(n) || n <= 0)
+    return DEFAULT_LOG_MAX;
+  return Math.floor(n);
+}
+function humanDuration(ms) {
+  const s = Math.max(0, Math.floor(ms / 1e3));
+  if (s < 60)
+    return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60)
+    return s % 60 === 0 ? `${m}m` : `${m}m ${s % 60}s`;
+  const h = Math.floor(m / 60);
+  return m % 60 === 0 ? `${h}h` : `${h}h ${m % 60}m`;
+}
+function formatElapsed(ms) {
+  return humanDuration(ms);
+}
+function appendLogRow(container, kind, text, ts, logMax) {
+  const row = document.createElement("div");
+  row.setAttribute(DATA_IRIS_LOG_ROW, "");
+  row.setAttribute(DATA_KIND, kind);
+  const tsEl = document.createElement("span");
+  tsEl.setAttribute(DATA_IRIS_LOG_TS, "");
+  tsEl.textContent = ts;
+  const chip = document.createElement("span");
+  chip.className = LOG_CHIP_CLASS;
+  chip.setAttribute("data-mode", LOG_CHIP_MODE[kind]);
+  chip.textContent = LOG_CHIP[kind];
+  const textEl = document.createElement("span");
+  textEl.className = LOG_TEXT_CLASS;
+  textEl.textContent = text;
+  const resEl = document.createElement("span");
+  resEl.className = LOG_RES_CLASS;
+  row.append(tsEl, chip, textEl, resEl);
+  container.appendChild(row);
+  while (container.childElementCount > logMax)
+    container.firstElementChild?.remove();
+  container.scrollTop = container.scrollHeight;
+  return {
+    result: (r) => {
+      resEl.textContent = ` ${RESULT_GLYPH[r]}`;
+      resEl.className = `${LOG_RES_CLASS} ${RESULT_CLASS[r]}`;
+    }
+  };
+}
+
+// ../browser/dist/presenter/presenter-controls.js
+var DATA_IRIS_STATE = "data-iris-state";
+var DATA_ON = "data-on";
+var GLOW_OFF = "0";
+var CONTROL_LABEL = {
+  PAUSE: "Pause",
+  RESUME: "Resume",
+  END: "End",
+  SEND: "Send"
+};
+var INPUT_PLACEHOLDER = "Tell the agent something\u2026";
+var PAUSED_BADGE_TEXT = "PAUSED";
+var ENDED_BANNER_TEXT = "Session ended";
+var COPY_LABEL = "Copy run";
+var EXPORT_LABEL = "Export";
+var COPIED_TEXT = "Copied \u2713";
+var RUN_FILENAME = "iris-run.json";
+var ENDED_FADE_MS = 4e3;
+var CONTROLS_CSS = `
+[data-iris-hud] .iris-ctl{pointer-events:auto;cursor:pointer;flex:none;display:inline-flex;align-items:center;justify-content:center;
+  height:26px;padding:0 11px;border-radius:8px;border:1px solid var(--iris-line);background:rgba(255,255,255,.04);
+  color:var(--iris-muted);font-family:var(--iris-font);font-size:11px;font-weight:500;letter-spacing:.01em;line-height:1;
+  transition:background .15s,color .15s,border-color .15s,transform .1s;}
+[data-iris-hud] .iris-ctl:hover{color:var(--iris-fg);background:rgba(255,255,255,.09);}
+[data-iris-hud] .iris-ctl:active{transform:scale(.95);}
+[data-iris-hud] .iris-ctl:disabled{opacity:.35;cursor:default;}
+[data-iris-hud] [data-iris-end]{color:#ff9aa2;border-color:rgba(255,107,107,.22);}
+[data-iris-hud] [data-iris-end]:hover{color:#ff7a7a;border-color:rgba(255,107,107,.5);background:rgba(255,107,107,.1);}
+[data-iris-hud] .iris-badge{display:none;align-items:center;flex:none;font-weight:600;letter-spacing:.1em;font-size:9px;
+  color:var(--iris-accent);border:1px solid var(--iris-accent);background:var(--iris-accent-soft);padding:2px 8px;border-radius:999px;}
+[data-iris-overlay][data-iris-state="paused"] [data-iris-badge]{display:inline-flex;}
+[data-iris-hud] [data-iris-foot]{flex:none;padding:10px 12px 12px;border-top:1px solid var(--iris-line2);background:rgba(0,0,0,.16);}
+[data-iris-hud] .iris-composer{display:flex;align-items:center;gap:6px;background:rgba(255,255,255,.05);
+  border:1px solid var(--iris-line);border-radius:14px;padding:5px 6px 5px 14px;transition:border-color .15s,box-shadow .15s;}
+[data-iris-hud] .iris-composer:focus-within{border-color:var(--iris-accent);box-shadow:0 0 0 3px var(--iris-accent-soft);}
+[data-iris-hud] .iris-msg{flex:1;min-width:0;pointer-events:auto;background:transparent;border:none;outline:none;
+  color:var(--iris-fg);font-family:var(--iris-font);font-size:13px;height:28px;padding:0;}
+[data-iris-hud] .iris-msg::placeholder{color:var(--iris-faint);}
+[data-iris-hud] .iris-msg:disabled{opacity:.5;}
+[data-iris-hud] .iris-send{flex:none;width:30px;height:30px;padding:0;border-radius:10px;border:none;cursor:pointer;pointer-events:auto;
+  background:var(--iris-accent);color:#0b0d14;display:inline-flex;align-items:center;justify-content:center;transition:filter .15s,transform .1s;}
+[data-iris-hud] .iris-send svg{display:block;}
+[data-iris-hud] .iris-send:hover{filter:brightness(1.12);}
+[data-iris-hud] .iris-send:active{transform:scale(.9);}
+[data-iris-hud] .iris-send:disabled{opacity:.4;cursor:default;}
+[data-iris-hud] .iris-banner{display:none;flex:none;padding:8px 15px;color:var(--iris-accent);
+  font-size:11.5px;font-weight:500;border-bottom:1px solid var(--iris-line2);background:var(--iris-accent-soft);}
+[data-iris-overlay][data-iris-state="ended"] [data-iris-banner]{display:block;}
+/* Export row: hidden during a live session; revealed when ended so the run can be copied/saved. */
+[data-iris-hud] .iris-export{display:none;align-items:center;gap:8px;margin-top:9px;}
+[data-iris-overlay][data-iris-state="ended"] [data-iris-hud] .iris-export{display:flex;}
+[data-iris-hud] .iris-export-msg{color:var(--iris-ok);font-size:11px;opacity:0;transition:opacity .15s;}
+[data-iris-hud] .iris-export-msg[data-show="1"]{opacity:1;}
+[data-iris-overlay][data-iris-state="paused"] [data-iris-glow][data-on="1"]{animation:none;
+  box-shadow:inset 0 0 0 3px rgba(246,180,76,.9),inset 0 0 30px 6px rgba(246,180,76,.4);}
+[data-iris-overlay][data-iris-state="ended"] [data-iris-glow][data-on="1"]{animation:none;
+  box-shadow:inset 0 0 0 2px rgba(61,215,166,.55);}
+`;
+var CONTROLS_HEAD_HTML = `<button type="button" data-iris-pause class="iris-ctl">${CONTROL_LABEL.PAUSE}</button><button type="button" data-iris-end class="iris-ctl">${CONTROL_LABEL.END}</button><span data-iris-badge class="iris-badge">${PAUSED_BADGE_TEXT}</span>`;
+var CONTROLS_BANNER_HTML = `<div data-iris-banner class="iris-banner">${ENDED_BANNER_TEXT}</div>`;
+var SEND_ICON = `<svg viewBox="0 0 24 24" width="15" height="15" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><line x1="22" y1="2" x2="11" y2="13"></line><polygon points="22 2 15 22 11 13 2 9 22 2"></polygon></svg>`;
+var CONTROLS_FOOT_HTML = `<div data-iris-foot><div class="iris-composer"><input data-iris-input class="iris-msg" type="text" placeholder="${INPUT_PLACEHOLDER}" /><button type="button" data-iris-send class="iris-send" aria-label="${CONTROL_LABEL.SEND}">${SEND_ICON}</button></div><div class="iris-export"><button type="button" data-iris-copy class="iris-ctl">${COPY_LABEL}</button><button type="button" data-iris-export class="iris-ctl">${EXPORT_LABEL}</button><span data-iris-export-msg class="iris-export-msg"></span></div></div>`;
+function queryControlRefs(root) {
+  return {
+    pauseBtn: root.querySelector("[data-iris-pause]") ?? void 0,
+    endBtn: root.querySelector("[data-iris-end]") ?? void 0,
+    input: root.querySelector("[data-iris-input]") ?? void 0,
+    sendBtn: root.querySelector("[data-iris-send]") ?? void 0,
+    banner: root.querySelector("[data-iris-banner]") ?? void 0,
+    copyBtn: root.querySelector("[data-iris-copy]") ?? void 0,
+    exportBtn: root.querySelector("[data-iris-export]") ?? void 0,
+    exportMsg: root.querySelector("[data-iris-export-msg]") ?? void 0
+  };
+}
+var ControlPanel = class {
+  #refs = {
+    pauseBtn: void 0,
+    endBtn: void 0,
+    input: void 0,
+    sendBtn: void 0,
+    banner: void 0,
+    copyBtn: void 0,
+    exportBtn: void 0,
+    exportMsg: void 0
+  };
+  #state = SessionState.ACTIVE;
+  #fadeTimer;
+  #root;
+  #glow;
+  #host;
+  constructor(host) {
+    this.#host = host;
+  }
+  get state() {
+    return this.#state;
+  }
+  /** Query control refs out of the mounted root and bind the DOM listeners, then paint active. */
+  mount(root, glow) {
+    this.#root = root;
+    this.#glow = glow;
+    this.#refs = queryControlRefs(root);
+    this.#refs.pauseBtn?.addEventListener("click", () => this.#onPauseToggle());
+    this.#refs.endBtn?.addEventListener("click", () => this.#onEnd());
+    this.#refs.sendBtn?.addEventListener("click", () => this.#onSend());
+    this.#refs.input?.addEventListener("keydown", (e) => {
+      if (e instanceof KeyboardEvent && e.key === "Enter")
+        this.#onSend();
+    });
+    this.#refs.copyBtn?.addEventListener("click", () => this.#onCopy());
+    this.#refs.exportBtn?.addEventListener("click", () => this.#onExport());
+    this.setState(SessionState.ACTIVE);
+  }
+  /** Serialize the run state to pretty JSON for Copy/Export. */
+  #runJson() {
+    return JSON.stringify(this.#host.runState(), null, 2);
+  }
+  /** Copy the run state to the clipboard (with a brief "Copied ✓" flash). */
+  #onCopy() {
+    void navigator.clipboard?.writeText(this.#runJson());
+    const msg = this.#refs.exportMsg;
+    if (msg !== void 0) {
+      msg.textContent = COPIED_TEXT;
+      msg.setAttribute("data-show", "1");
+      nativeSetTimeout(() => msg.setAttribute("data-show", "0"), 1600);
+    }
+  }
+  /** Download the run state as iris-run.json. */
+  #onExport() {
+    const blob = new Blob([this.#runJson()], { type: "application/json" });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = RUN_FILENAME;
+    a.click();
+    URL.revokeObjectURL(url);
+  }
+  /** Clear any pending ended-fade timer (called from Presenter.destroy). */
+  teardown() {
+    if (this.#fadeTimer !== void 0)
+      nativeClearTimeout(this.#fadeTimer);
+    this.#fadeTimer = void 0;
+  }
+  #onPauseToggle() {
+    if (this.#state === SessionState.PAUSED) {
+      this.#host.emit(HumanControlKind.RESUME);
+      this.setState(SessionState.ACTIVE);
+    } else if (this.#state === SessionState.ACTIVE) {
+      this.#host.emit(HumanControlKind.PAUSE);
+      this.setState(SessionState.PAUSED);
+    }
+  }
+  #onEnd() {
+    if (this.#state === SessionState.ENDED)
+      return;
+    this.#host.emit(HumanControlKind.END);
+    this.setState(SessionState.ENDED);
+  }
+  #onSend() {
+    if (this.#state === SessionState.ENDED)
+      return;
+    const text = (this.#refs.input?.value ?? "").trim();
+    if (text.length === 0)
+      return;
+    this.#host.emit(HumanControlKind.MESSAGE, text);
+    this.#host.logHuman(text);
+    if (this.#refs.input !== void 0)
+      this.#refs.input.value = "";
+  }
+  /**
+   * Drive the panel's visual state. Idempotent; NEVER emits a control — the shared path for both the
+   * optimistic local click and the authoritative server PRESENTER echo. Only the ended-border fade
+   * touches a clock, via the injected native timer.
+   */
+  setState(state, text) {
+    this.#state = state;
+    this.#root?.setAttribute(DATA_IRIS_STATE, state);
+    if (this.#fadeTimer !== void 0) {
+      nativeClearTimeout(this.#fadeTimer);
+      this.#fadeTimer = void 0;
+    }
+    const refs2 = this.#refs;
+    const ended = state === SessionState.ENDED;
+    if (refs2.pauseBtn !== void 0) {
+      refs2.pauseBtn.textContent = state === SessionState.PAUSED ? CONTROL_LABEL.RESUME : CONTROL_LABEL.PAUSE;
+      refs2.pauseBtn.disabled = ended;
+    }
+    if (refs2.endBtn !== void 0)
+      refs2.endBtn.disabled = ended;
+    if (refs2.sendBtn !== void 0)
+      refs2.sendBtn.disabled = ended;
+    if (refs2.input !== void 0)
+      refs2.input.disabled = ended;
+    if (refs2.banner !== void 0) {
+      const summary = text !== void 0 && text.trim().length > 0 ? ` \xB7 ${text.trim()}` : "";
+      refs2.banner.textContent = `${ENDED_BANNER_TEXT}${summary}`;
+    }
+    if (ended) {
+      const glow = this.#glow;
+      this.#fadeTimer = nativeSetTimeout(() => {
+        glow?.setAttribute(DATA_ON, GLOW_OFF);
+      }, this.#host.endedFadeMs);
+    }
+  }
+};
+
+// ../browser/dist/presenter/presenter.js
+var CSS = `
+@import url("https://fonts.googleapis.com/css2?family=IBM+Plex+Serif:wght@400;500&family=Inter:wght@400;450;500;600&display=swap");
+[data-iris-glow]{position:fixed;inset:0;pointer-events:none;z-index:2147483600;opacity:0;
+  transition:opacity .25s ease;box-shadow:inset 0 0 0 3px rgba(99,102,241,.9),inset 0 0 28px 6px rgba(99,102,241,.45);}
+[data-iris-glow][data-on="1"]{opacity:1;animation:iris-pulse 1.6s ease-in-out infinite;}
+[data-iris-glow][data-on="1"][data-busy="1"]{animation:iris-shimmer 1.1s ease-in-out infinite;}
+@keyframes iris-pulse{0%,100%{box-shadow:inset 0 0 0 3px rgba(99,102,241,.9),inset 0 0 22px 4px rgba(99,102,241,.35)}
+  50%{box-shadow:inset 0 0 0 3px rgba(124,127,242,1),inset 0 0 40px 10px rgba(99,102,241,.6)}}
+@keyframes iris-shimmer{0%,100%{box-shadow:inset 0 0 0 3px rgba(124,127,242,1),inset 0 0 34px 8px rgba(99,102,241,.55)}
+  50%{box-shadow:inset 0 0 0 3px rgba(140,142,255,1),inset 0 0 48px 12px rgba(99,102,241,.7)}}
+[data-iris-cursor]{position:fixed;top:0;left:0;width:22px;height:22px;margin:-11px 0 0 -11px;
+  border:2px solid #6366f1;border-radius:50%;background:rgba(99,102,241,.25);pointer-events:none;
+  z-index:2147483646;opacity:0;transition:transform .32s cubic-bezier(.22,1,.36,1),opacity .2s ease;}
+[data-iris-cursor][data-on="1"]{opacity:1;}
+[data-iris-cursor]::after{content:"";position:absolute;inset:7px;border-radius:50%;background:#6366f1;}
+[data-iris-ripple]{position:fixed;width:14px;height:14px;margin:-7px 0 0 -7px;border-radius:50%;
+  background:rgba(99,102,241,.5);pointer-events:none;z-index:2147483645;animation:iris-ripple .5s ease-out forwards;}
+@keyframes iris-ripple{from{transform:scale(.4);opacity:.8}to{transform:scale(5);opacity:0}}
+[data-iris-ring]{position:fixed;pointer-events:none;z-index:2147483644;border:2px solid #22c55e;border-radius:8px;
+  box-shadow:0 0 0 3px rgba(34,197,94,.25);opacity:0;transition:opacity .15s ease;}
+[data-iris-ring][data-on="1"]{opacity:1;}
+[data-iris-hud]{
+  --iris-accent:#7c83ff;--iris-accent-soft:rgba(124,131,255,.16);
+  --iris-bg:rgba(13,15,22,.80);--iris-bg2:rgba(19,22,32,.74);
+  --iris-fg:#e9ebf2;--iris-muted:#9aa0b2;--iris-faint:#6a7186;
+  --iris-line:rgba(255,255,255,.09);--iris-line2:rgba(255,255,255,.05);
+  --iris-read:#54d2e6;--iris-ok:#3dd7a6;--iris-bad:#ff7a7a;
+  --iris-font:"Inter",system-ui,-apple-system,"Segoe UI",Roboto,"Helvetica Neue",Arial,sans-serif;
+  --iris-serif:"IBM Plex Serif",Georgia,"Times New Roman",serif;
+  position:fixed;left:50%;right:auto;bottom:20px;box-sizing:border-box;
+  width:384px;height:468px;max-width:calc(100vw - 32px);max-height:calc(100vh - 32px);
+  display:flex;flex-direction:column;overflow:hidden;text-align:left;z-index:2147483647;pointer-events:none;
+  font-family:var(--iris-font);font-size:13px;line-height:1.5;color:var(--iris-fg);-webkit-font-smoothing:antialiased;
+  background:linear-gradient(180deg,var(--iris-bg),var(--iris-bg2));
+  -webkit-backdrop-filter:blur(24px) saturate(1.5);backdrop-filter:blur(24px) saturate(1.5);
+  border:1px solid var(--iris-line);border-radius:20px;
+  box-shadow:0 28px 70px -18px rgba(0,0,0,.66),0 0 0 1px rgba(0,0,0,.35),inset 0 1px 0 rgba(255,255,255,.07),0 0 54px -22px var(--iris-accent);
+  opacity:0;transform:translateX(-50%) translateY(14px) scale(.985);
+  transition:opacity .3s ease,transform .42s cubic-bezier(.16,1,.3,1),height .42s cubic-bezier(.16,1,.3,1),border-radius .42s ease,box-shadow .35s ease;}
+[data-iris-overlay][data-iris-state="paused"] [data-iris-hud]{--iris-accent:#f6b44c;--iris-accent-soft:rgba(246,180,76,.16);}
+[data-iris-overlay][data-iris-state="ended"] [data-iris-hud]{--iris-accent:#3dd7a6;--iris-accent-soft:rgba(61,215,166,.14);}
+[data-iris-hud]::before{content:"";position:absolute;inset:0;border-radius:inherit;pointer-events:none;
+  background:radial-gradient(130% 90% at 50% 0%,var(--iris-accent-soft),transparent 60%);}
+[data-iris-hud]>*{position:relative;}
+[data-iris-hud][data-on="1"]{opacity:1;transform:translateX(-50%) translateY(0) scale(1);}
+/* Click-through: the glassy panel itself never blocks the app \u2014 only its interactive controls
+   capture clicks (buttons / inputs), so a human can click straight through the HUD to the page.
+   The log auto-scrolls, so it stays click-through too (drag-scroll is traded for click-through). */
+[data-iris-hud] button,[data-iris-hud] input,[data-iris-hud] textarea,
+[data-iris-hud] select,[data-iris-hud] [contenteditable]{pointer-events:auto;}
+/* When minimised to a pill, the whole bar is the (single) click target to restore. */
+[data-iris-overlay][data-iris-min="1"] [data-iris-hud][data-on="1"]{pointer-events:auto;}
+[data-iris-hud] .iris-hud-head{display:flex;align-items:center;gap:8px;flex:none;
+  padding:12px 12px 12px 15px;border-bottom:1px solid var(--iris-line2);}
+[data-iris-hud] .iris-dot{width:9px;height:9px;border-radius:50%;flex:none;background:var(--iris-accent);
+  animation:iris-breathe 2.6s ease-in-out infinite;}
+@keyframes iris-breathe{0%,100%{box-shadow:0 0 0 0 var(--iris-accent),0 0 7px 1px var(--iris-accent);opacity:.85}
+  50%{box-shadow:0 0 0 4px var(--iris-accent-soft),0 0 15px 3px var(--iris-accent);opacity:1}}
+[data-iris-hud] .iris-brand{font-family:var(--iris-serif);font-weight:500;font-size:15px;letter-spacing:.01em;color:var(--iris-fg);}
+[data-iris-hud] .iris-head-sp{flex:1;}
+[data-iris-hud] .iris-live{display:none;flex:1;min-width:0;color:var(--iris-muted);font-size:12.5px;
+  white-space:nowrap;overflow:hidden;text-overflow:ellipsis;}
+[data-iris-hud] .iris-maxhint{display:none;flex:none;color:var(--iris-faint);font-size:13px;line-height:1;}
+[data-iris-hud] .iris-act-strip{flex:none;padding:7px 15px;border-bottom:1px solid var(--iris-line2);background:rgba(0,0,0,.14);}
+[data-iris-hud] .iris-act{display:block;color:var(--iris-muted);font-size:11.5px;
+  white-space:nowrap;overflow:hidden;text-overflow:ellipsis;}
+[data-iris-hud] [data-iris-min-btn]{flex:none;cursor:pointer;display:inline-flex;align-items:center;justify-content:center;
+  width:26px;height:26px;border-radius:8px;border:1px solid var(--iris-line);background:rgba(255,255,255,.04);
+  color:var(--iris-muted);font-size:15px;line-height:1;transition:background .15s,color .15s,transform .1s;}
+[data-iris-hud] [data-iris-min-btn]:hover{color:var(--iris-fg);background:rgba(255,255,255,.08);}
+[data-iris-hud] [data-iris-min-btn]:active{transform:scale(.94);}
+[data-iris-hud] .iris-pass{color:var(--iris-ok);}[data-iris-hud] .iris-fail{color:var(--iris-bad);}
+[data-iris-hud] .iris-chip{display:none;flex:none;font-size:9px;font-weight:600;letter-spacing:.08em;
+  padding:2px 7px;border-radius:6px;vertical-align:middle;}
+[data-iris-hud] .iris-chip[data-mode="reading"]{display:inline-block;color:var(--iris-read);
+  background:rgba(84,210,230,.12);border:1px solid rgba(84,210,230,.32);}
+[data-iris-hud] .iris-chip[data-mode="acting"]{display:inline-block;color:var(--iris-accent);
+  background:var(--iris-accent-soft);border:1px solid var(--iris-accent);}
+[data-iris-hud] .iris-chip[data-mode="idle"]{display:none;}
+[data-iris-overlay][data-iris-min="1"] [data-iris-hud]{height:50px;border-radius:25px;cursor:pointer;}
+[data-iris-overlay][data-iris-min="1"] [data-iris-hud] .iris-hud-head{border-bottom:none;height:50px;padding:0 12px 0 16px;}
+[data-iris-overlay][data-iris-min="1"] [data-iris-hud] .iris-brand,
+[data-iris-overlay][data-iris-min="1"] [data-iris-hud] .iris-chip,
+[data-iris-overlay][data-iris-min="1"] [data-iris-hud] .iris-head-sp,
+[data-iris-overlay][data-iris-min="1"] [data-iris-hud] [data-iris-min-btn],
+[data-iris-overlay][data-iris-min="1"] [data-iris-hud] .iris-ctl,
+[data-iris-overlay][data-iris-min="1"] [data-iris-hud] .iris-badge,
+[data-iris-overlay][data-iris-min="1"] [data-iris-hud] .iris-act-strip,
+[data-iris-overlay][data-iris-min="1"] [data-iris-hud] [data-iris-log],
+[data-iris-overlay][data-iris-min="1"] [data-iris-hud] [data-iris-foot],
+[data-iris-overlay][data-iris-min="1"] [data-iris-hud] .iris-banner{display:none;}
+[data-iris-overlay][data-iris-min="1"] [data-iris-hud] .iris-live{display:block;}
+[data-iris-overlay][data-iris-min="1"] [data-iris-hud] .iris-maxhint{display:inline-flex;}
+[data-iris-mode="reading"] [data-iris-glow][data-on="1"]{
+  box-shadow:inset 0 0 0 3px rgba(34,211,238,.9),inset 0 0 28px 6px rgba(34,211,238,.4);}
+[data-iris-mode="reading"] [data-iris-ring]{border-color:#22d3ee;
+  box-shadow:0 0 0 3px rgba(34,211,238,.25);}
+[data-iris-overlay][data-iris-throttled="1"] [data-iris-glow][data-on="1"]{
+  box-shadow:inset 0 0 0 3px rgba(251,191,36,.9),inset 0 0 28px 6px rgba(251,191,36,.45);}
+[data-iris-overlay][data-iris-throttled="1"] [data-iris-hud]{--iris-accent:#fbbf24;--iris-accent-soft:rgba(251,191,36,.16);}
+${LOG_CSS}
+${CONTROLS_CSS}`;
+var BorderMode = { SESSION: "session", BUSY: "busy" };
+var DEFAULT_BORDER_MODE = BorderMode.SESSION;
+var DATA_BUSY = "data-busy";
+var BUSY_ON = "1";
+var BUSY_OFF = "0";
+var DEFAULT_PACE = 450;
+var GlowPhase = {
+  IDLE: "idle",
+  BUSY: "busy",
+  FADING: "fading"
+};
+var IDLE_AFTER_MS = 700;
+var HEARTBEAT_MS = 1e3;
+var IDLE_NOTICE_MS = 4e3;
+var IDLE_END_MS = 3e5;
+var IDLE_END_MIN_MS = 5e3;
+var GLOW_FADE_MS = 250;
+var GLOW_ON = "1";
+var GLOW_OFF2 = "0";
+var DATA_ON2 = "data-on";
+var MIN_ATTR = "data-iris-min";
+var THROTTLED_ATTR = "data-iris-throttled";
+var Presenter = class {
+  #paceMs;
+  #root;
+  #glow;
+  #cursor;
+  #ring;
+  #hud;
+  #actLine;
+  #chip;
+  #liveLine;
+  #mode = PresenterMode.IDLE;
+  #now;
+  #idleAfterMs;
+  #glowFadeMs;
+  #heartbeatMs;
+  #idleNoticeMs;
+  #borderMode;
+  #phase = GlowPhase.IDLE;
+  #lastActivityMs = 0;
+  #idleCheckTimer;
+  #fadeTimer;
+  /** Liveness: the most recent action text + a 1s ticker that ages it into an "idle · {dur}" clock. */
+  #lastActionText = "";
+  #heartbeatTimer;
+  /** Session lifecycle: idle-end window (tweakable), session id, start/end cursors, structured run log. */
+  #idleEndMs;
+  #sessionId;
+  #startMs;
+  #endMs;
+  #runLog = [];
+  /** Tracks sessionStart/sessionEnd so both are idempotent (no strobe / no spurious off-write). */
+  #sessionActive = false;
+  // v2: narration + action status accumulate in a persistent, timestamped, scrollable log.
+  #logMax;
+  #log;
+  /** now() of the first row, the baseline for the +elapsed timestamps. */
+  #logBaseMs;
+  // Live-control panel: the two-way control surface (Pause/Resume + End + message Send).
+  #onControl;
+  #panel;
+  constructor(options = {}) {
+    this.#paceMs = options.paceMs ?? DEFAULT_PACE;
+    this.#now = options.now ?? nativeNow;
+    this.#idleAfterMs = options.idleAfterMs ?? IDLE_AFTER_MS;
+    this.#glowFadeMs = options.glowFadeMs ?? GLOW_FADE_MS;
+    this.#heartbeatMs = options.heartbeatMs ?? HEARTBEAT_MS;
+    this.#idleNoticeMs = options.idleNoticeMs ?? IDLE_NOTICE_MS;
+    this.#idleEndMs = options.idleEndMs ?? IDLE_END_MS;
+    this.#sessionId = options.sessionId ?? "";
+    this.#borderMode = options.border ?? DEFAULT_BORDER_MODE;
+    this.#logMax = clampLogMax(options.logMax);
+    this.#onControl = options.onControl;
+    this.#panel = new ControlPanel({
+      emit: (kind, text) => this.#onControl?.(text !== void 0 ? { kind, text } : { kind }),
+      logHuman: (text) => {
+        this.log(LOG_KIND.HUMAN, HUMAN_ROW_PREFIX + text);
+      },
+      endedFadeMs: options.endedFadeMs ?? ENDED_FADE_MS,
+      runState: () => this.runState()
+    });
+  }
+  /** Setter so iris.ts can wire the control callback after construction. */
+  setControlHandler(handler) {
+    this.#onControl = handler;
+  }
+  /** Current live-control session state mirrored onto the panel (data-iris-state). */
+  get state() {
+    return this.#panel.state;
+  }
+  /** Whether a run is currently being presented (false before the agent's first activity / after end). */
+  get sessionActive() {
+    return this.#sessionActive;
+  }
+  /** Drive the panel's live-control visual state (server-push / agent path; never emits). */
+  setState(state, text) {
+    this.#panel.setState(state, text);
+  }
+  /** Current cap on accumulated log rows. */
+  get logMax() {
+    return this.#logMax;
+  }
+  set logMax(n) {
+    this.#logMax = clampLogMax(n);
+    this.#pruneLog();
+  }
+  mount() {
+    if (this.#root !== void 0 || typeof document === "undefined")
+      return;
+    const style = document.createElement("style");
+    style.setAttribute("data-iris-overlay", "");
+    style.textContent = CSS;
+    document.head.appendChild(style);
+    const root = document.createElement("div");
+    root.setAttribute("data-iris-overlay", "");
+    root.innerHTML = `
+      <div data-iris-glow></div>
+      <div data-iris-cursor></div>
+      <div data-iris-ring></div>
+      <div data-iris-hud>
+        <div class="iris-hud-head"><span class="iris-dot"></span><span class="iris-brand">iris</span><span class="iris-chip" data-iris-chip></span><span class="iris-live"></span><span class="iris-head-sp"></span><button type="button" data-iris-min-btn title="Minimise" aria-label="Minimise the panel">\u2304</button>${CONTROLS_HEAD_HTML}<span class="iris-maxhint" aria-hidden="true">\u2303</span></div>
+        <div class="iris-act-strip"><span class="iris-act">idle</span></div>
+        ${CONTROLS_BANNER_HTML}
+        <div ${DATA_IRIS_LOG}></div>
+        ${CONTROLS_FOOT_HTML}
+      </div>`;
+    document.body.appendChild(root);
+    this.#root = root;
+    this.#glow = root.querySelector("[data-iris-glow]") ?? void 0;
+    this.#cursor = root.querySelector("[data-iris-cursor]") ?? void 0;
+    this.#ring = root.querySelector("[data-iris-ring]") ?? void 0;
+    this.#hud = root.querySelector("[data-iris-hud]") ?? void 0;
+    this.#actLine = root.querySelector(".iris-act") ?? void 0;
+    this.#log = root.querySelector(`[${DATA_IRIS_LOG}]`) ?? void 0;
+    this.#chip = root.querySelector("[data-iris-chip]") ?? void 0;
+    this.#liveLine = root.querySelector(".iris-live") ?? void 0;
+    const setMin = (on) => root.setAttribute(MIN_ATTR, on ? "1" : "0");
+    root.querySelector("[data-iris-min-btn]")?.addEventListener("click", (e) => {
+      e.stopPropagation();
+      setMin(true);
+    });
+    root.querySelector(".iris-hud-head")?.addEventListener("click", () => {
+      if (root.getAttribute(MIN_ATTR) === "1")
+        setMin(false);
+    });
+    this.#panel.mount(root, this.#glow);
+    this.setMode(this.#mode);
+  }
+  destroy() {
+    if (this.#idleCheckTimer !== void 0)
+      nativeClearTimeout(this.#idleCheckTimer);
+    if (this.#fadeTimer !== void 0)
+      nativeClearTimeout(this.#fadeTimer);
+    if (this.#heartbeatTimer !== void 0)
+      nativeClearTimeout(this.#heartbeatTimer);
+    this.#heartbeatTimer = void 0;
+    this.#panel.teardown();
+    this.#idleCheckTimer = void 0;
+    this.#fadeTimer = void 0;
+    this.#sessionActive = false;
+    this.#logBaseMs = void 0;
+    this.#log = void 0;
+    this.#root?.remove();
+    document.querySelectorAll("style[data-iris-overlay]").forEach((s) => s.remove());
+    this.#root = void 0;
+  }
+  /**
+   * Session start: in 'session' border mode this fades the base border IN and keeps it on until
+   * sessionEnd(). Idempotent, and a no-op when unmounted or in 'busy' border mode.
+   */
+  sessionStart() {
+    if (this.state === SessionState.ENDED) {
+      this.#revive();
+      return;
+    }
+    if (this.#sessionActive)
+      return;
+    this.#sessionActive = true;
+    this.#startMs ??= this.#now();
+    this.#endMs = void 0;
+    this.#showSession();
+    this.#lastActivityMs = this.#now();
+    this.#startHeartbeat();
+  }
+  /** Turn the base border (session mode) + the HUD/log on — the visible "session is live" state. */
+  #showSession() {
+    this.#hud?.setAttribute(DATA_ON2, GLOW_ON);
+    if (this.#borderMode === BorderMode.SESSION)
+      this.#glow?.setAttribute(DATA_ON2, GLOW_ON);
+  }
+  /** Revive after an ended session (new agent activity): clear the ended state + glow back on. */
+  #revive() {
+    this.#panel.setState(SessionState.ACTIVE);
+    this.#endMs = void 0;
+    this.#showSession();
+    this.#lastActivityMs = this.#now();
+    this.#startHeartbeat();
+  }
+  /**
+   * Session end: hides the log/HUD and (in 'session' mode) clears the base border. Idempotent; a
+   * no-op without a prior sessionStart or when unmounted.
+   */
+  sessionEnd() {
+    if (!this.#sessionActive)
+      return;
+    this.#sessionActive = false;
+    if (this.#heartbeatTimer !== void 0) {
+      nativeClearTimeout(this.#heartbeatTimer);
+      this.#heartbeatTimer = void 0;
+    }
+    this.#hud?.setAttribute(DATA_ON2, GLOW_OFF2);
+    if (this.#borderMode === BorderMode.SESSION) {
+      this.#glow?.setAttribute(DATA_ON2, GLOW_OFF2);
+      this.#glow?.setAttribute(DATA_BUSY, BUSY_OFF);
+    }
+  }
+  /**
+   * Record agent activity. Idempotent while busy — only the first activity from idle/fading flips
+   * the glow on, so a burst never restarts the iris-pulse animation (no strobe). Subsequent calls
+   * just refresh the last-activity timestamp and re-arm the idle check.
+   */
+  markActivity() {
+    this.#markActivityAt(this.#now());
+  }
+  /** markActivity with a caller-supplied timestamp so log() reads the clock exactly once per row. */
+  #markActivityAt(ms) {
+    this.#lastActivityMs = ms;
+    if (this.#phase === GlowPhase.IDLE || this.#phase === GlowPhase.FADING) {
+      this.#enterBusy();
+    }
+    this.#armIdleCheck();
+  }
+  /** Re-arm the quiet-window idle check (kept for iris.ts's finally block). */
+  scheduleIdle() {
+    this.#armIdleCheck();
+  }
+  /** Test/diagnostic accessor for the current glow phase. */
+  glowPhase() {
+    return this.#phase;
+  }
+  /** Current intent (reading vs acting), exposed for tests + the watcher. */
+  get mode() {
+    return this.#mode;
+  }
+  /**
+   * Set the presenter intent. READING shows a cyan scan + chip and hides the cursor; ACTING
+   * keeps the warm cursor/ripple + chip; IDLE clears the chip. Drives color via data-iris-mode.
+   */
+  setMode(mode) {
+    this.#mode = mode;
+    this.#root?.setAttribute("data-iris-mode", mode);
+    if (this.#chip !== void 0) {
+      this.#chip.textContent = CHIP_LABEL[mode];
+      this.#chip.setAttribute("data-mode", mode);
+    }
+    if (mode === PresenterMode.READING)
+      this.#cursor?.setAttribute(DATA_ON2, GLOW_OFF2);
+  }
+  #enterBusy() {
+    if (this.#fadeTimer !== void 0) {
+      nativeClearTimeout(this.#fadeTimer);
+      this.#fadeTimer = void 0;
+    }
+    this.#phase = GlowPhase.BUSY;
+    if (this.#borderMode === BorderMode.SESSION) {
+      this.#glow?.setAttribute(DATA_BUSY, BUSY_ON);
+    } else {
+      this.#glow?.setAttribute(DATA_ON2, GLOW_ON);
+    }
+    this.#cursor?.setAttribute(DATA_ON2, GLOW_ON);
+  }
+  #armIdleCheck() {
+    if (this.#idleCheckTimer !== void 0)
+      nativeClearTimeout(this.#idleCheckTimer);
+    this.#idleCheckTimer = nativeSetTimeout(() => this.#checkIdle(), this.#idleAfterMs);
+  }
+  #checkIdle() {
+    this.#idleCheckTimer = void 0;
+    if (this.#phase !== GlowPhase.BUSY)
+      return;
+    const quietFor = this.#now() - this.#lastActivityMs;
+    if (quietFor < this.#idleAfterMs) {
+      this.#idleCheckTimer = nativeSetTimeout(() => this.#checkIdle(), this.#idleAfterMs - quietFor);
+      return;
+    }
+    this.#beginFade();
+  }
+  #beginFade() {
+    this.#phase = GlowPhase.FADING;
+    if (this.#borderMode === BorderMode.SESSION) {
+      this.#glow?.setAttribute(DATA_BUSY, BUSY_OFF);
+    } else {
+      this.#glow?.setAttribute(DATA_ON2, GLOW_OFF2);
+    }
+    this.#cursor?.setAttribute(DATA_ON2, GLOW_OFF2);
+    this.setMode(PresenterMode.IDLE);
+    this.#fadeTimer = nativeSetTimeout(() => {
+      this.#fadeTimer = void 0;
+      if (this.#phase === GlowPhase.FADING)
+        this.#phase = GlowPhase.IDLE;
+    }, this.#glowFadeMs);
+  }
+  status(text) {
+    this.markActivity();
+    this.#lastActionText = text;
+    if (this.#actLine !== void 0)
+      this.#actLine.textContent = text;
+  }
+  /**
+   * Liveness heartbeat (native 1s timer — never rAF, so it ticks in a foreground tab regardless of
+   * agent activity). Once the agent has been quiet for IDLE_NOTICE_MS, the act strip shows a LIVE,
+   * growing "◌ idle · {duration} since last action" — the signal that was missing when a stopped
+   * agent left the panel frozen and indistinguishable from one still thinking.
+   */
+  #startHeartbeat() {
+    if (this.#heartbeatTimer !== void 0)
+      nativeClearTimeout(this.#heartbeatTimer);
+    const tick = () => {
+      this.#tickLiveness();
+      this.#heartbeatTimer = nativeSetTimeout(tick, this.#heartbeatMs);
+    };
+    this.#heartbeatTimer = nativeSetTimeout(tick, this.#heartbeatMs);
+  }
+  #tickLiveness() {
+    if (!this.#sessionActive || this.#actLine === void 0)
+      return;
+    if (this.state === SessionState.ENDED)
+      return;
+    const idleMs = this.#now() - this.#lastActivityMs;
+    if (idleMs >= this.#idleEndMs) {
+      this.#endIdle(idleMs);
+      return;
+    }
+    if (idleMs < this.#idleNoticeMs)
+      return;
+    const since = this.#lastActionText !== "" ? ` since last action` : "";
+    this.#actLine.textContent = `\u25CC idle \xB7 ${humanDuration(idleMs)}${since}`;
+  }
+  /** Auto-end after the idle window: stamp the end, drive the panel to ENDED, stop the heartbeat. */
+  #endIdle(idleMs) {
+    this.#endMs = this.#now();
+    this.#panel.setState(SessionState.ENDED, `idle ${humanDuration(idleMs)}`);
+    if (this.#heartbeatTimer !== void 0) {
+      nativeClearTimeout(this.#heartbeatTimer);
+      this.#heartbeatTimer = void 0;
+    }
+  }
+  /** Agent-tunable idle-end window (iris_session). Floored so it can't be set uselessly small. */
+  setIdleEndMs(ms) {
+    if (!Number.isFinite(ms))
+      return;
+    this.#idleEndMs = Math.max(IDLE_END_MIN_MS, Math.floor(ms));
+  }
+  /**
+   * The exported "run state" for the Copy/Export buttons — everything the page holds about this
+   * run: session id, url, duration, capability surface, per-kind counts, and the full activity log.
+   * (The full network/console ring-buffer lives server-side; this is the in-page run summary.)
+   */
+  runState() {
+    const now = this.#now();
+    const start = this.#startMs ?? now;
+    const counts = { reads: 0, acts: 0, narrations: 0, human: 0, passes: 0, fails: 0 };
+    for (const e of this.#runLog) {
+      if (e.kind === LOG_KIND.READ)
+        counts.reads += 1;
+      else if (e.kind === LOG_KIND.ACT)
+        counts.acts += 1;
+      else if (e.kind === LOG_KIND.NARRATION)
+        counts.narrations += 1;
+      else if (e.kind === LOG_KIND.HUMAN)
+        counts.human += 1;
+      if (e.result === LOG_RESULT.PASS)
+        counts.passes += 1;
+      else if (e.result === LOG_RESULT.FAIL)
+        counts.fails += 1;
+    }
+    return {
+      session: this.#sessionId,
+      url: typeof location === "undefined" ? "" : location.href,
+      state: this.state,
+      startedMs: start,
+      durationMs: Math.max(0, (this.#endMs ?? now) - start),
+      counts,
+      capabilities: getCapabilities(),
+      log: this.#runLog.map((e) => ({ ...e }))
+    };
+  }
+  /**
+   * Append an activity-log row. Accumulates (never overwrites): each call adds a timestamped row
+   * with a mode chip + text. Returns a handle to stamp the row's outcome glyph (✓/✗) later, or
+   * undefined when unmounted / when the text is empty after trimming.
+   */
+  log(kind, text, result2) {
+    const ms = this.#now();
+    this.#markActivityAt(ms);
+    if (this.#log === void 0)
+      return void 0;
+    const trimmed = text.trim();
+    if (trimmed.length === 0)
+      return void 0;
+    this.#logBaseMs ??= ms;
+    const entry = result2 !== void 0 ? { at: ms - this.#logBaseMs, kind, text: trimmed, result: result2 } : { at: ms - this.#logBaseMs, kind, text: trimmed };
+    this.#runLog.push(entry);
+    while (this.#runLog.length > this.#logMax)
+      this.#runLog.shift();
+    const ts = formatElapsed(ms - this.#logBaseMs);
+    const handle = appendLogRow(this.#log, kind, trimmed, ts, this.#logMax);
+    if (result2 !== void 0)
+      handle.result(result2);
+    if (this.#liveLine !== void 0)
+      this.#liveLine.textContent = trimmed;
+    return {
+      result: (r) => {
+        handle.result(r);
+        entry.result = r;
+      }
+    };
+  }
+  /** Back-compat: narration appends to the live log (append-only, never overwrites). */
+  narrate(text, level = "info") {
+    const line = level === "info" ? text : `[${level}] ${text}`;
+    return this.log(LOG_KIND.NARRATION, line);
+  }
+  #pruneLog() {
+    if (this.#log === void 0)
+      return;
+    while (this.#log.childElementCount > this.#logMax) {
+      this.#log.firstElementChild?.remove();
+    }
+  }
+  /** Legacy no-op kept for source compat; outcomes now flow through LogHandle.result(). */
+  result(_ok) {
+  }
+  /**
+   * Mirror the server's session.throttled() state onto the HUD border. When throttled (tab
+   * backgrounded or stale), the border turns amber so the developer knows actions are no-oping —
+   * the same signal the agent already reads from result.session.throttled.
+   */
+  setThrottled(throttled) {
+    this.#root?.setAttribute(THROTTLED_ATTR, throttled ? "1" : "0");
+    if (throttled && this.#actLine !== void 0) {
+      this.#actLine.textContent = "Tab backgrounded \u2014 actions throttled. Bring tab to front or use `iris drive`.";
+    }
+  }
+  /** Fly the cursor to an element, play the action's effect, then pace for the human. */
+  async beforeAct(refId, action, label) {
+    const el = refs.resolve(refId);
+    this.status(`${actionVerb(action)} ${label}`);
+    if (!(el instanceof HTMLElement)) {
+      await this.#pause();
+      return;
+    }
+    const rect = el.getBoundingClientRect();
+    const cx = rect.left + rect.width / 2;
+    const cy = rect.top + rect.height / 2;
+    this.#moveCursor(cx, cy);
+    this.#ringAround(rect);
+    await this.#pause();
+    if (action === "click" || action === "dblclick" || action === "submit")
+      this.#ripple(cx, cy);
+  }
+  #moveCursor(x, y) {
+    if (this.#cursor === void 0)
+      return;
+    this.#cursor.setAttribute("data-on", "1");
+    this.#cursor.style.transform = `translate(${String(x)}px, ${String(y)}px)`;
+  }
+  #ringAround(rect) {
+    if (this.#ring === void 0)
+      return;
+    this.#ring.style.left = `${String(rect.left - 4)}px`;
+    this.#ring.style.top = `${String(rect.top - 4)}px`;
+    this.#ring.style.width = `${String(rect.width + 8)}px`;
+    this.#ring.style.height = `${String(rect.height + 8)}px`;
+    this.#ring.setAttribute("data-on", "1");
+    nativeSetTimeout(() => this.#ring?.setAttribute("data-on", "0"), 700);
+  }
+  #ripple(x, y) {
+    if (this.#root === void 0)
+      return;
+    const r = document.createElement("div");
+    r.setAttribute("data-iris-ripple", "");
+    r.style.left = `${String(x)}px`;
+    r.style.top = `${String(y)}px`;
+    this.#root.appendChild(r);
+    nativeSetTimeout(() => r.remove(), 520);
+  }
+  #pause() {
+    return new Promise((res) => nativeSetTimeout(res, this.#paceMs));
+  }
+};
+
+// ../browser/dist/recorder/recorder-styles.js
+var TOOLBAR_CSS = [
+  "position:fixed",
+  "top:8px",
+  "left:50%",
+  "transform:translateX(-50%)",
+  "z-index:2147483647",
+  "display:flex",
+  "gap:6px",
+  "align-items:center",
+  "flex-wrap:wrap",
+  "max-width:90vw",
+  "font:12px ui-sans-serif,system-ui,sans-serif",
+  "background:#151823",
+  "color:#e6e9f0",
+  "border:1px solid #2a2f3d",
+  "border-radius:10px",
+  "padding:6px 10px",
+  "box-shadow:0 8px 30px rgba(0,0,0,.5)"
+].join(";");
+var BTN_CSS = [
+  "font:inherit",
+  "cursor:pointer",
+  "background:#262b3a",
+  "color:#e6e9f0",
+  "border:1px solid #3a4151",
+  "border-radius:7px",
+  "padding:3px 9px"
+].join(";");
+var NAME_CSS = [
+  "font:inherit",
+  "background:#0e1018",
+  "color:#e6e9f0",
+  "border:1px solid #3a4151",
+  "border-radius:7px",
+  "padding:3px 8px"
+].join(";");
+var STATUS_CSS = ["opacity:.75", "margin-left:4px"].join(";");
+var MENU_CSS = ["display:flex", "gap:6px", "align-items:center", "flex-wrap:wrap"].join(";");
+
+// ../browser/dist/recorder/recorder.js
+var RECORDER_EMPTY_MSG = "recorded 0 steps";
+var STATUS_RECORDING = "recording\u2026";
+var STATUS_IDLE = "ready";
+var STATUS_ANNOTATE = "pick an annotation";
+var TESTID_ATTR2 = "data-testid";
+var TOOL = "iris_act";
+var BUTTON_LABEL = {
+  record: "Record",
+  stop: "Stop",
+  annotate: "Annotate"
+};
+var ANNOTATION_LABEL = {
+  [AnnotationKind.ASSERT_SIGNAL]: "assert signal",
+  [AnnotationKind.ASSERT_VISIBLE]: "assert visible",
+  [AnnotationKind.MARK_DYNAMIC]: "mark dynamic",
+  [AnnotationKind.SUCCESS_STATE]: "success state"
+};
+var NEEDS_SIGNAL = /* @__PURE__ */ new Set([
+  AnnotationKind.ASSERT_SIGNAL,
+  AnnotationKind.SUCCESS_STATE
+]);
+var DEFAULT_NAME = "recorded-flow";
+function anchorFor(el) {
+  const testid = el.getAttribute(TESTID_ATTR2);
+  if (testid !== null && testid.length > 0) {
+    return { anchor: { kind: AnchorKind.TESTID, value: testid }, degraded: false };
+  }
+  const role = getRole(el);
+  const name = getAccessibleName(el);
+  if (role !== "generic" && (role.length > 0 || name.length > 0)) {
+    const anchor = name.length > 0 ? { kind: AnchorKind.ROLE, role, name } : { kind: AnchorKind.ROLE, role };
+    return { anchor, degraded: false };
+  }
+  return { anchor: { kind: AnchorKind.ROLE, role: DEGRADED_ANCHOR_ROLE }, degraded: true };
+}
+function isTextbox(el) {
+  if (el instanceof HTMLTextAreaElement)
+    return true;
+  return el instanceof HTMLInputElement && inputRole2(el) === "textbox";
+}
+function inputRole2(el) {
+  const type = el.type.toLowerCase();
+  if (type === "checkbox")
+    return "checkbox";
+  if (type === "radio")
+    return "radio";
+  if (["text", "email", "tel", "url", "search", "password", ""].includes(type))
+    return "textbox";
+  return "other";
+}
+function buildStep(el, action, args) {
+  const { anchor, degraded } = anchorFor(el);
+  const step = { tool: TOOL, anchor, action };
+  if (args !== void 0)
+    step.args = args;
+  if (degraded)
+    step.degraded = true;
+  return step;
+}
+function compileRecording(name, steps, annotations, createdAt) {
+  const out = steps.map((s) => ({ ...s }));
+  const dynamic = [];
+  let success;
+  for (const ann of annotations) {
+    if (ann.kind === AnnotationKind.MARK_DYNAMIC) {
+      dynamic.push(ann.anchor);
+      continue;
+    }
+    if (ann.kind === AnnotationKind.SUCCESS_STATE) {
+      if (ann.signal !== void 0)
+        success = { signal: ann.signal };
+      continue;
+    }
+    const target = out.at(-1);
+    if (target === void 0)
+      continue;
+    if (ann.kind === AnnotationKind.ASSERT_SIGNAL && ann.signal !== void 0) {
+      target.expect = { ...target.expect, signal: ann.signal };
+    } else if (ann.kind === AnnotationKind.ASSERT_VISIBLE) {
+      target.expect = { ...target.expect, element: anchorToElement(ann.anchor) };
+    }
+  }
+  const flow = { version: FLOW_FILE_VERSION, name, createdAt, steps: out };
+  if (dynamic.length > 0)
+    flow.dynamic = dynamic;
+  if (success !== void 0)
+    flow.success = success;
+  return flow;
+}
+function anchorToElement(anchor) {
+  if (anchor.kind === AnchorKind.TESTID)
+    return { testid: anchor.value };
+  if (anchor.kind === AnchorKind.ROLE) {
+    return anchor.name !== void 0 ? { role: anchor.role, name: anchor.name } : { role: anchor.role };
+  }
+  return {};
+}
+var Recorder = class {
+  #deps;
+  #phase = RecorderPhase.IDLE;
+  #steps = [];
+  #annotations = [];
+  #pendingFill;
+  #teardowns = [];
+  #root;
+  #statusEl;
+  #menuEl;
+  /** The annotation being assembled in ANNOTATING phase. */
+  #draft;
+  constructor(deps) {
+    this.#deps = deps;
+  }
+  phase() {
+    return this.#phase;
+  }
+  steps() {
+    return this.#steps.map((s) => ({ ...s }));
+  }
+  mount() {
+    if (this.#root !== void 0)
+      return;
+    if (typeof document === "undefined")
+      return;
+    this.#buildToolbar();
+    this.#installCapture();
+  }
+  destroy() {
+    for (const t of this.#teardowns)
+      t();
+    this.#teardowns = [];
+    this.#root?.remove();
+    this.#root = void 0;
+    this.#statusEl = void 0;
+    this.#menuEl = void 0;
+    this.#phase = RecorderPhase.IDLE;
+    this.#steps = [];
+    this.#annotations = [];
+    this.#draft = void 0;
+    this.#pendingFill = void 0;
+  }
+  // ---- capture ----
+  #installCapture() {
+    const onClick = (ev) => this.#onClick(ev);
+    const onInput = (ev) => this.#onInput(ev);
+    const onChange = (ev) => this.#onChange(ev);
+    const onSubmit = (ev) => this.#onSubmit(ev);
+    document.addEventListener("click", onClick, true);
+    document.addEventListener("input", onInput, true);
+    document.addEventListener("change", onChange, true);
+    document.addEventListener("submit", onSubmit, true);
+    this.#teardowns.push(() => {
+      document.removeEventListener("click", onClick, true);
+      document.removeEventListener("input", onInput, true);
+      document.removeEventListener("change", onChange, true);
+      document.removeEventListener("submit", onSubmit, true);
+    });
+  }
+  /** True if the event should be ignored (toolbar self-click or non-element target). */
+  #ignore(ev) {
+    const target = ev.target;
+    if (!(target instanceof Element))
+      return void 0;
+    if (isIrisOverlay(target))
+      return void 0;
+    return target;
+  }
+  #onClick(ev) {
+    const target = this.#ignore(ev);
+    if (target === void 0)
+      return;
+    if (this.#phase === RecorderPhase.ANNOTATING) {
+      this.#captureAnnotationTarget(target);
+      return;
+    }
+    if (this.#phase !== RecorderPhase.RECORDING)
+      return;
+    this.#flushPendingFill();
+    this.#steps.push(buildStep(target, ActionType.CLICK));
+  }
+  #onInput(ev) {
+    if (this.#phase !== RecorderPhase.RECORDING)
+      return;
+    const target = this.#ignore(ev);
+    if (target === void 0 || !isTextbox(target))
+      return;
+    this.#pendingFill = { el: target, value: target.value };
+  }
+  #onChange(ev) {
+    if (this.#phase !== RecorderPhase.RECORDING)
+      return;
+    const target = this.#ignore(ev);
+    if (target === void 0)
+      return;
+    if (target instanceof HTMLInputElement && inputRole2(target) === "checkbox") {
+      this.#flushPendingFill();
+      this.#steps.push(buildStep(target, target.checked ? ActionType.CHECK : ActionType.UNCHECK));
+      return;
+    }
+    if (target instanceof HTMLInputElement && inputRole2(target) === "radio") {
+      this.#flushPendingFill();
+      this.#steps.push(buildStep(target, ActionType.CHECK));
+      return;
+    }
+    if (isTextbox(target)) {
+      this.#pendingFill = { el: target, value: target.value };
+      this.#flushPendingFill();
+    }
+  }
+  #onSubmit(ev) {
+    if (this.#phase !== RecorderPhase.RECORDING)
+      return;
+    const target = this.#ignore(ev);
+    if (target === void 0)
+      return;
+    this.#flushPendingFill();
+    this.#steps.push(buildStep(target, ActionType.SUBMIT));
+  }
+  #flushPendingFill() {
+    const pending = this.#pendingFill;
+    if (pending === void 0)
+      return;
+    this.#pendingFill = void 0;
+    this.#steps.push(buildStep(pending.el, ActionType.FILL, { value: pending.value }));
+  }
+  // ---- annotation ----
+  #captureAnnotationTarget(target) {
+    const draft = this.#draft;
+    if (draft === void 0)
+      return;
+    const { anchor } = anchorFor(target);
+    const ann = { kind: draft.kind, anchor };
+    const signal = this.#selectedSignal();
+    if (signal !== void 0)
+      ann.signal = signal;
+    this.#annotations.push(ann);
+    this.#draft = void 0;
+    this.#setPhase(RecorderPhase.RECORDING);
+    this.#closeMenu();
+  }
+  /** Annotate-on-prior: confirm the most-recent step as the target (no extra click needed). */
+  #confirmAnnotationOnPrior() {
+    const draft = this.#draft;
+    if (draft === void 0)
+      return;
+    const last = this.#steps.at(-1);
+    if (last === void 0) {
+      this.#draft = void 0;
+      this.#setPhase(RecorderPhase.RECORDING);
+      this.#closeMenu();
+      return;
+    }
+    const ann = { kind: draft.kind, anchor: last.anchor };
+    const signal = this.#selectedSignal();
+    if (signal !== void 0)
+      ann.signal = signal;
+    this.#annotations.push(ann);
+    this.#draft = void 0;
+    this.#setPhase(RecorderPhase.RECORDING);
+    this.#closeMenu();
+  }
+  #selectedSignal() {
+    const select = this.#menuEl?.querySelector("[data-iris-signal]");
+    const value = select?.value ?? "";
+    return value.length > 0 ? value : void 0;
+  }
+  // ---- toolbar lifecycle actions ----
+  #start() {
+    this.#steps = [];
+    this.#annotations = [];
+    this.#pendingFill = void 0;
+    this.#draft = void 0;
+    this.#setPhase(RecorderPhase.RECORDING);
+    this.#setStatus(STATUS_RECORDING);
+  }
+  #stop() {
+    this.#flushPendingFill();
+    const name = this.#nameField() ?? this.#deps.defaultName ?? DEFAULT_NAME;
+    const flow = compileRecording(name, this.#steps, this.#annotations, this.#deps.now());
+    this.#deps.emit(EventType.FLOW_RECORDED, { name, flow });
+    this.#setStatus(this.#steps.length === 0 ? RECORDER_EMPTY_MSG : STATUS_IDLE);
+    this.#setPhase(RecorderPhase.IDLE);
+    this.#closeMenu();
+  }
+  #openAnnotateMenu() {
+    if (this.#phase !== RecorderPhase.RECORDING)
+      return;
+    this.#setPhase(RecorderPhase.ANNOTATING);
+    this.#setStatus(STATUS_ANNOTATE);
+    this.#renderMenu();
+  }
+  #setPhase(phase) {
+    this.#phase = phase;
+  }
+  // ---- toolbar DOM (all nodes data-iris-overlay → snapshot-excluded via dom-ignore.ts) ----
+  #buildToolbar() {
+    const root = document.createElement("div");
+    root.setAttribute("data-iris-overlay", "");
+    root.style.cssText = TOOLBAR_CSS;
+    const name = document.createElement("input");
+    name.setAttribute("data-iris-name", "");
+    name.setAttribute("placeholder", "flow name");
+    name.style.cssText = NAME_CSS;
+    root.appendChild(name);
+    root.appendChild(this.#button("record", BUTTON_LABEL.record, () => this.#start()));
+    root.appendChild(this.#button("stop", BUTTON_LABEL.stop, () => this.#stop()));
+    root.appendChild(this.#button("annotate", BUTTON_LABEL.annotate, () => this.#openAnnotateMenu()));
+    const status = document.createElement("span");
+    status.setAttribute("data-iris-status", "");
+    status.style.cssText = STATUS_CSS;
+    status.textContent = STATUS_IDLE;
+    root.appendChild(status);
+    const menu = document.createElement("div");
+    menu.setAttribute("data-iris-menu", "");
+    menu.style.cssText = MENU_CSS;
+    root.appendChild(menu);
+    document.body.appendChild(root);
+    this.#root = root;
+    this.#statusEl = status;
+    this.#menuEl = menu;
+  }
+  #button(action, label, onClick) {
+    const btn = document.createElement("button");
+    btn.setAttribute("data-iris-action", action);
+    btn.textContent = label;
+    btn.style.cssText = BTN_CSS;
+    btn.addEventListener("click", onClick);
+    return btn;
+  }
+  #renderMenu() {
+    const menu = this.#menuEl;
+    if (menu === void 0)
+      return;
+    menu.textContent = "";
+    for (const kind of Object.values(AnnotationKind)) {
+      const item = document.createElement("button");
+      item.setAttribute("data-iris-annkind", kind);
+      item.textContent = ANNOTATION_LABEL[kind];
+      item.style.cssText = BTN_CSS;
+      item.addEventListener("click", () => this.#chooseKind(kind));
+      menu.appendChild(item);
+    }
+  }
+  #chooseKind(kind) {
+    this.#draft = { kind };
+    const menu = this.#menuEl;
+    if (menu === void 0)
+      return;
+    if (NEEDS_SIGNAL.has(kind)) {
+      const select = document.createElement("select");
+      select.setAttribute("data-iris-signal", "");
+      select.style.cssText = NAME_CSS;
+      for (const sig of getCapabilities().signals) {
+        const opt = document.createElement("option");
+        opt.value = sig;
+        opt.textContent = sig;
+        select.appendChild(opt);
+      }
+      menu.appendChild(select);
+    }
+    const confirm = document.createElement("button");
+    confirm.setAttribute("data-iris-action", "annotate-confirm");
+    confirm.textContent = "on prior step";
+    confirm.style.cssText = BTN_CSS;
+    confirm.addEventListener("click", () => this.#confirmAnnotationOnPrior());
+    menu.appendChild(confirm);
+  }
+  #closeMenu() {
+    if (this.#menuEl !== void 0)
+      this.#menuEl.textContent = "";
+  }
+  #setStatus(text) {
+    if (this.#statusEl !== void 0)
+      this.#statusEl.textContent = text;
+  }
+  #nameField() {
+    const input = this.#root?.querySelector("[data-iris-name]");
+    const value = input?.value.trim() ?? "";
+    return value.length > 0 ? value : void 0;
+  }
+};
+function installRecorder(deps) {
+  return new Recorder(deps);
+}
+
+// ../browser/dist/iris.js
+function str2(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+var BRIDGE_LOST_SUMMARY = "Session ended \u2014 lost connection to Iris (the agent is no longer running).";
+function resolveSessionLabel(option, gen) {
+  return option === void 0 || option === SESSION_AUTO ? gen() : option;
+}
+function isSessionState(value) {
+  return value === SessionState.ACTIVE || value === SessionState.PAUSED || value === SessionState.ENDED;
+}
+function refLabel(refId) {
+  const el = refs.resolve(refId);
+  if (!(el instanceof Element))
+    return refId;
+  const d = describe(el);
+  return d.name.length > 0 ? `${d.role} "${d.name}"` : `${d.role} (${refId})`;
+}
+var Iris = class {
+  #transport;
+  #registry = /* @__PURE__ */ new Map();
+  #teardowns = [];
+  #connected = false;
+  #session = "default";
+  #start = 0;
+  #overlay;
+  #presenter;
+  #recorder;
+  #eventCount = 0;
+  /** Act-row log handle for the in-flight act/act_sequence, so its outcome stamps the right row. */
+  #actHandle;
+  connect(options = {}) {
+    if (this.#connected)
+      return;
+    if (typeof window === "undefined" || typeof document === "undefined")
+      return;
+    this.#session = resolveSessionLabel(options.session, () => `s${Date.now().toString(36)}`);
+    this.#start = performance.now();
+    this.#registry = createCommandRegistry();
+    const url = options.url ?? `ws://localhost:${String(IRIS_DEFAULT_PORT)}${IRIS_WS_PATH}`;
+    this.#transport = new Transport({
+      url,
+      hello: () => this.#hello(),
+      handleCommand: (command) => this.#handleCommand(command),
+      // Liveness fallback: if the bridge stays unreachable (the agent killed the server process),
+      // no server-pushed end can arrive — so end the run we're presenting ourselves. A returning
+      // agent revives it via the normal sessionStart() path on its next command.
+      onConnectionLost: () => {
+        if (this.#presenter?.sessionActive === true) {
+          this.#presenter.setState(SessionState.ENDED, BRIDGE_LOST_SUMMARY);
+        }
+      }
+    });
+    const emit = this.#emit;
+    this.#teardowns = [
+      installNetwork(emit),
+      installRoute(emit),
+      installConsole(emit),
+      installAnimation(emit),
+      installScroll(emit),
+      installDom(emit),
+      installHealth(emit)
+      // page visibility/focus health + heartbeat
+    ];
+    if (options.overlay === true) {
+      this.#overlay = installOverlay();
+      this.#overlay.update({ connected: true, events: 0 });
+    }
+    if (options.present === true) {
+      const presenterOptions = {};
+      if (options.pace !== void 0)
+        presenterOptions.paceMs = options.pace;
+      if (options.narrationDwellMs !== void 0) {
+        presenterOptions.narrationDwellMs = options.narrationDwellMs;
+      }
+      if (options.border !== void 0)
+        presenterOptions.border = options.border;
+      if (options.logMax !== void 0)
+        presenterOptions.logMax = options.logMax;
+      if (options.endedFadeMs !== void 0)
+        presenterOptions.endedFadeMs = options.endedFadeMs;
+      if (options.idleEndMs !== void 0)
+        presenterOptions.idleEndMs = options.idleEndMs;
+      presenterOptions.sessionId = this.#session;
+      presenterOptions.onControl = (intent) => this.#emit(EventType.HUMAN_CONTROL, intent.text !== void 0 ? { kind: intent.kind, text: intent.text } : { kind: intent.kind });
+      this.#presenter = new Presenter(presenterOptions);
+      this.#presenter.mount();
+    }
+    if (options.recorder === true) {
+      this.#recorder = installRecorder({ emit, now: () => Date.now() });
+      this.#recorder.mount();
+    }
+    this.#transport.connect();
+    this.#connected = true;
+  }
+  /** Whether the in-page SDK is connected to the bridge (read by createIrisEmitter, P5a). */
+  get connected() {
+    return this.#connected;
+  }
+  /** Surface an arbitrary app-domain observation the DOM can't express (plan/03 §7). */
+  signal(name, data = {}) {
+    this.#emit(EventType.SIGNAL, { name, data });
+  }
+  /** Report a framework/store state change the agent can observe and assert on. */
+  state(name, value) {
+    this.#emit(EventType.STATE_CHANGE, { name, value });
+  }
+  /** Advertise the app's testable surface so the agent learns it without reading source. */
+  describe(input) {
+    registerCapabilities(input);
+  }
+  /** Live-control: end the session programmatically from the host app (drives the panel to ended). */
+  endSession() {
+    this.#presenter?.setState(SessionState.ENDED);
+  }
+  disconnect() {
+    if (!this.#connected)
+      return;
+    for (const teardown of this.#teardowns)
+      teardown();
+    this.#teardowns = [];
+    this.#transport?.close();
+    this.#transport = void 0;
+    this.#overlay?.destroy();
+    this.#overlay = void 0;
+    this.#presenter?.sessionEnd();
+    this.#presenter?.destroy();
+    this.#presenter = void 0;
+    this.#recorder?.destroy();
+    this.#recorder = void 0;
+    resetClock();
+    this.#connected = false;
+  }
+  #emit = (type, data, ref) => {
+    const event = {
+      t: Math.round(performance.now() - this.#start),
+      type,
+      sessionId: this.#session,
+      ref,
+      data
+    };
+    this.#transport?.sendEvent(event);
+    this.#eventCount += 1;
+    this.#overlay?.update({ connected: true, events: this.#eventCount });
+  };
+  #hello() {
+    return {
+      kind: MessageKind.HELLO,
+      protocolVersion: IRIS_PROTOCOL_VERSION,
+      sessionId: this.#session,
+      url: location.href,
+      title: document.title,
+      adapters: adapterNames(),
+      hasCapabilities: hasCapabilities()
+    };
+  }
+  async #handleCommand(command) {
+    if (command.name === IrisCommand.NARRATE) {
+      this.#presenter?.sessionStart();
+      this.#presenter?.narrate(str2(command.args["text"]), str2(command.args["level"], "info"));
+      return { ok: true, result: { shown: this.#presenter !== void 0 } };
+    }
+    if (command.name === IrisCommand.SESSION_CONFIG) {
+      const idleEndMs = command.args["idleEndMs"];
+      if (typeof idleEndMs === "number")
+        this.#presenter?.setIdleEndMs(idleEndMs);
+      return { ok: true, result: { applied: this.#presenter !== void 0, idleEndMs } };
+    }
+    if (command.name === IrisCommand.PRESENTER) {
+      const state = command.args["state"];
+      if (isSessionState(state)) {
+        this.#presenter?.setState(state, str2(command.args["text"]) || void 0);
+      }
+      return { ok: true, result: { applied: this.#presenter !== void 0 } };
+    }
+    const handler = this.#registry.get(command.name);
+    if (handler === void 0) {
+      return { ok: false, error: `unknown command '${command.name}'` };
+    }
+    this.#presenter?.sessionStart();
+    await this.#presentBefore(command);
+    try {
+      const result2 = await handler(command.args);
+      this.#actHandle?.result(LOG_RESULT.PASS);
+      return { ok: true, result: result2 };
+    } catch (error) {
+      this.#actHandle?.result(LOG_RESULT.FAIL);
+      return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    } finally {
+      this.#actHandle = void 0;
+      this.#presenter?.scheduleIdle();
+    }
+  }
+  /** Drive the presenter (cursor/effects/status) before the real action runs. */
+  async #presentBefore(command) {
+    const p = this.#presenter;
+    if (p === void 0)
+      return;
+    p.setMode(modeForCommand(command.name));
+    this.#actHandle = void 0;
+    if (command.name === IrisCommand.ACT) {
+      const ref = str2(command.args["ref"]);
+      const label = refLabel(ref);
+      this.#actHandle = p.log(LOG_KIND.ACT, `${actionVerb(str2(command.args["action"]))} ${label}`);
+      await p.beforeAct(ref, str2(command.args["action"]), label);
+    } else if (command.name === IrisCommand.ACT_SEQUENCE) {
+      const steps = Array.isArray(command.args["steps"]) ? command.args["steps"] : [];
+      for (const step of steps) {
+        const s = step;
+        const ref = str2(s.ref);
+        const label = refLabel(ref);
+        this.#actHandle = p.log(LOG_KIND.ACT, `${actionVerb(str2(s.action))} ${label}`);
+        await p.beforeAct(ref, str2(s.action), label);
+      }
+    } else {
+      const label = presentStatus(command.name, command.args);
+      p.status(label);
+      p.log(LOG_KIND.READ, label);
+    }
+  }
+};
+function modeForCommand(commandName) {
+  switch (commandName) {
+    case IrisCommand.ACT:
+    case IrisCommand.ACT_SEQUENCE:
+      return PresenterMode.ACTING;
+    case IrisCommand.SNAPSHOT:
+    case IrisCommand.QUERY:
+    case IrisCommand.MATCH:
+    case IrisCommand.INSPECT:
+    case IrisCommand.ANIMATIONS:
+    case IrisCommand.STATE_READ:
+    case IrisCommand.CAPABILITIES:
+      return PresenterMode.READING;
+    default:
+      return PresenterMode.IDLE;
+  }
+}
+function presentStatus(commandName, args = {}) {
+  switch (commandName) {
+    case IrisCommand.SNAPSHOT:
+      return "Looking at the page";
+    case IrisCommand.QUERY:
+    case IrisCommand.MATCH: {
+      const q = commandName === IrisCommand.MATCH ? args["query"] ?? {} : args;
+      const target = queryTarget(q);
+      return target !== void 0 ? `Finding ${target}` : "Finding an element";
+    }
+    case IrisCommand.INSPECT: {
+      const ref = str2(args["ref"]);
+      return ref !== void 0 ? `Inspecting ${refLabel(ref)}` : "Inspecting an element";
+    }
+    case IrisCommand.ANIMATIONS:
+      return "Reading animations";
+    case IrisCommand.STATE_READ: {
+      const store = str2(args["store"]);
+      return store !== void 0 ? `Reading state: ${store}` : "Reading state";
+    }
+    case IrisCommand.CAPABILITIES:
+      return "Reading capabilities";
+    default:
+      return commandName;
+  }
+}
+function queryTarget(q) {
+  const testid = str2(q["testid"]) ?? (str2(q["by"]) === "testid" ? str2(q["value"]) : void 0);
+  if (testid !== void 0)
+    return `[testid=${testid}]`;
+  const name = str2(q["name"]);
+  const value = str2(q["value"]) ?? str2(q["text"]) ?? str2(q["label"]) ?? str2(q["role"]);
+  if (value !== void 0)
+    return name !== void 0 ? `"${value}" (${name})` : `"${value}"`;
+  return name !== void 0 ? `"${name}"` : void 0;
+}
+
+// ../browser/dist/registry/emitter.js
+function createIrisEmitter(options = {}) {
+  const target = options.target ?? iris;
+  return {
+    signal(name, data = {}) {
+      if (!target.connected)
+        return;
+      target.signal(name, data);
+    },
+    state(name, value) {
+      if (!target.connected)
+        return;
+      target.state(name, value);
+    }
+  };
+}
+
+// ../browser/dist/registry/commit-and-signal.js
+function commitAndSignal(emitter, mutate, name, data) {
+  const result2 = mutate();
+  emitter.signal(name, data);
+  return result2;
+}
+
+// ../browser/dist/registry/domains.js
+function registerIrisDomain(domain) {
+  const input = {};
+  if (domain.testids !== void 0)
+    input.testids = [...domain.testids];
+  if (domain.signals !== void 0)
+    input.signals = [...domain.signals];
+  if (domain.stores !== void 0)
+    input.stores = [...domain.stores];
+  registerCapabilities(input);
+}
+
+// ../browser/dist/index.js
+var globalStore4 = globalThis;
+var iris = globalStore4.__irisInstance ??= new Iris();
+
+// ../react/dist/index.js
+var FIBER_PREFIXES = ["__reactFiber$", "__reactInternalInstance$"];
+var MAX_DEPTH = 200;
+var MAX_HOOKS = 100;
+var MAX_SERIALIZE_DEPTH = 4;
+var MAX_SERIALIZE_KEYS = 50;
+var MAX_SERIALIZE_ITEMS = 50;
+var DOM_NODE_MARKER = "[Node]";
+var FRAMEWORK_NOISE = /(Context|Boundary|Provider|Router|Handler)$|^(Root|ServerRoot|HotReload|Fragment|__next)/;
+function isFrameworkNoise(name) {
+  return FRAMEWORK_NOISE.test(name);
+}
+function getFiber(el) {
+  const key = Object.keys(el).find((k) => FIBER_PREFIXES.some((p) => k.startsWith(p)));
+  if (key === void 0)
+    return null;
+  const value = el[key];
+  return value ?? null;
+}
+function componentName(type) {
+  if (typeof type === "function") {
+    const fn = type;
+    if (fn.displayName !== void 0 && fn.displayName.length > 0)
+      return fn.displayName;
+    return fn.name !== void 0 && fn.name.length > 0 ? fn.name : null;
+  }
+  if (typeof type === "object" && type !== null) {
+    const obj = type;
+    return obj.displayName !== void 0 && obj.displayName.length > 0 ? obj.displayName : null;
+  }
+  return null;
+}
+function identify(el) {
+  let fiber = getFiber(el);
+  const stack = [];
+  const rawStack = [];
+  let source;
+  let depth = 0;
+  while (fiber !== null && depth < MAX_DEPTH) {
+    depth += 1;
+    const name = componentName(fiber.elementType ?? fiber.type);
+    if (name !== null && rawStack[rawStack.length - 1] !== name) {
+      rawStack.push(name);
+      if (!isFrameworkNoise(name) && stack[stack.length - 1] !== name)
+        stack.push(name);
+    }
+    if (source === void 0 && fiber._debugSource !== void 0) {
+      source = { file: fiber._debugSource.fileName, line: fiber._debugSource.lineNumber };
+      if (fiber._debugSource.columnNumber !== void 0) {
+        source.column = fiber._debugSource.columnNumber;
+      }
+    }
+    fiber = fiber.return;
+  }
+  if (source === void 0) {
+    source = sourceFromAttribute(el);
+  }
+  const componentStack = stack.length > 0 ? stack : rawStack.slice(0, 1);
+  if (componentStack.length === 0 && source === void 0)
+    return null;
+  const info = { componentStack };
+  if (source !== void 0)
+    info.source = source;
+  return info;
+}
+function sourceFromAttribute(el) {
+  const stamped = el.closest("[data-iris-source]");
+  const raw = stamped?.getAttribute("data-iris-source");
+  if (raw === null || raw === void 0)
+    return void 0;
+  const match = /^(.*):(\d+):(\d+)$/.exec(raw);
+  if (match === null)
+    return void 0;
+  const [, file, line, column] = match;
+  if (file === void 0 || line === void 0 || column === void 0)
+    return void 0;
+  return { file, line: Number(line), column: Number(column) };
+}
+function nearestComponentFiber(el) {
+  let fiber = getFiber(el);
+  let depth = 0;
+  while (fiber !== null && depth < MAX_DEPTH) {
+    depth += 1;
+    if (typeof fiber.type === "function" || typeof fiber.elementType === "function")
+      return fiber;
+    fiber = fiber.return;
+  }
+  return null;
+}
+function safeValue(value, depth, seen) {
+  if (value === null)
+    return null;
+  const t = typeof value;
+  if (t === "string" || t === "number" || t === "boolean")
+    return value;
+  if (t === "undefined" || t === "function" || t === "symbol" || t === "bigint")
+    return null;
+  if (typeof Node !== "undefined" && value instanceof Node)
+    return DOM_NODE_MARKER;
+  if (depth >= MAX_SERIALIZE_DEPTH)
+    return null;
+  const obj = value;
+  if (seen.has(obj))
+    return null;
+  seen.add(obj);
+  if (Array.isArray(value)) {
+    const out2 = value.slice(0, MAX_SERIALIZE_ITEMS).map((v) => safeValue(v, depth + 1, seen));
+    seen.delete(obj);
+    return out2;
+  }
+  const out = {};
+  const keys = Object.keys(obj).slice(0, MAX_SERIALIZE_KEYS);
+  for (const key of keys) {
+    out[key] = safeValue(obj[key], depth + 1, seen);
+  }
+  seen.delete(obj);
+  return out;
+}
+function ok(name, hooks) {
+  return name === null ? { ok: true, hooks } : { ok: true, component: name, hooks };
+}
+function readState2(el) {
+  try {
+    const fiber = nearestComponentFiber(el);
+    if (fiber === null) {
+      return { ok: false, reason: ComponentStateReason.UNAVAILABLE };
+    }
+    const name = componentName(fiber.elementType ?? fiber.type);
+    const head = fiber.memoizedState;
+    if (typeof head !== "object" || head === null) {
+      return ok(name, []);
+    }
+    const hooks = [];
+    const seen = /* @__PURE__ */ new WeakSet();
+    let hook = head;
+    let i = 0;
+    while (typeof hook === "object" && i < MAX_HOOKS) {
+      hooks.push(safeValue(hook.memoizedState, 0, seen));
+      const next = hook.next;
+      if (next === null || typeof next !== "object")
+        break;
+      hook = next;
+      i += 1;
+    }
+    return ok(name, hooks);
+  } catch {
+    return { ok: false, reason: ComponentStateReason.UNAVAILABLE };
+  }
+}
+var HOVER_HANDLER_KEYS = [
+  "onMouseEnter",
+  "onMouseLeave",
+  "onPointerEnter",
+  "onPointerLeave"
+];
+function hasHoverHandlers(el) {
+  const fiber = getFiber(el);
+  const props = fiber?.memoizedProps;
+  if (typeof props !== "object" || props === null)
+    return false;
+  const p = props;
+  return HOVER_HANDLER_KEYS.some((k) => typeof p[k] === "function");
+}
+var installed2 = false;
+function install() {
+  if (installed2)
+    return;
+  installed2 = true;
+  registerAdapter({ name: "react", identify, readState: readState2, hasHoverHandlers });
+}
+export {
+  Iris,
+  RefRegistry,
+  SESSION_AUTO,
+  adapterNames,
+  buildSnapshot,
+  commitAndSignal,
+  createIrisEmitter,
+  describe,
+  elementHasHoverHandlers,
+  executeAction,
+  executeSequence,
+  getAccessibleName,
+  getCapabilities,
+  getRole,
+  getStates,
+  hasCapabilities,
+  hasHoverHandlers,
+  identify,
+  identifyComponent,
+  install,
+  iris,
+  isVisible,
+  matchQuery,
+  readComponentState,
+  readState2 as readState,
+  readStores,
+  refs,
+  registerAdapter,
+  registerCapabilities,
+  registerIrisDomain,
+  registerStore,
+  runQuery,
+  setIgnoreSelectors,
+  storeNames,
+  unregisterStore
+};