pinomad 0.7.0 → 0.9.0

package/dist/chunk-4sepcfpy.js

@@ -0,0 +1,2994 @@
+import {
+  HOST_STREAM_NAMES,
+  MAX_ATTACHMENTS_PER_MESSAGE,
+  PROTOCOL,
+  RTC_DATA_CHANNEL_LABEL,
+  UNAUTHORIZED_CLOSE_CODE,
+  checkoutOf,
+  conversationStream,
+  docStream,
+  homeOf,
+  hostStreams,
+  hostSupportsCall,
+  hostSupportsFeature,
+  isRtcHello,
+  organize,
+  parseRtcMaxMessageSize,
+  rtcSelectedPair
+} from "./chunk-jgd38rna.js";
+import {
+  SECURE_PROLOGUE,
+  SecureSession,
+  decodeHostHello,
+  encodeClientHello,
+  initiateIK,
+  isLoopbackUrl,
+  parseEndpointSet
+} from "./chunk-sygeb9qb.js";
+
+// packages/protocol/src/remote-durable.ts
+import { applyImmutable } from "@earendil-works/chord/delta";
+
+// packages/protocol/src/remote-candidates.ts
+var MIXED_CONTENT_REASON = "mixed content: this HTTPS page blocks the insecure ws:// connection";
+function filterCandidatesForMode(candidates, mode) {
+  if (mode === "auto")
+    return [...candidates];
+  if (mode === "relayOnly") {
+    return candidates.filter((candidate) => candidate.role === "loopback" || candidate.role === "relay" || candidate.role === "legacy");
+  }
+  return candidates.filter((candidate) => candidate.role === "loopback" || candidate.role === "direct");
+}
+function signalCandidates(candidates) {
+  return candidates.filter((candidate) => candidate.role === "relay" || candidate.role === "legacy");
+}
+var DIRECT_UNAVAILABLE = "Direct connection unavailable: this host cannot be reached without the relay and WebRTC did not connect.";
+var isInsecureRemote = (url) => {
+  try {
+    return new URL(url).protocol === "ws:" && !isLoopbackUrl(url);
+  } catch {
+    return false;
+  }
+};
+var reasonFor = (url, options) => options.pageProtocol === "https:" && isInsecureRemote(url) ? MIXED_CONTENT_REASON : undefined;
+function candidatePlan(legacyUrl, endpointSet, options = {}) {
+  const candidates = [];
+  const seen = new Set;
+  const add = (url, role) => {
+    if (seen.has(url))
+      return;
+    seen.add(url);
+    const unsupported = reasonFor(url, options);
+    candidates.push({ url, role, ...unsupported === undefined ? {} : { unsupported } });
+  };
+  if (isLoopbackUrl(legacyUrl))
+    add(legacyUrl, "loopback");
+  if (endpointSet !== undefined) {
+    for (const endpoint of endpointSet.endpoints)
+      if (endpoint.role === "relay")
+        add(endpoint.url, "relay");
+    for (const endpoint of endpointSet.endpoints)
+      if (endpoint.role === "direct")
+        add(endpoint.url, "direct");
+  } else if (!isLoopbackUrl(legacyUrl)) {
+    add(legacyUrl, "legacy");
+  }
+  return candidates;
+}
+
+// packages/protocol/src/rtc-carrier.ts
+var RTC_HIGH_WATER_BYTES = 256 * 1024;
+var RTC_LOW_WATER_BYTES = 64 * 1024;
+var RTC_STALL_MS = 1e4;
+var SYSTEM_RTC_CLOCK = {
+  now: () => typeof performance === "undefined" ? Date.now() : performance.now(),
+  setTimeout: (callback, ms) => setTimeout(callback, ms),
+  clearTimeout: (handle) => clearTimeout(handle)
+};
+function rtcTransport(options) {
+  return {
+    label: `webrtc:${RTC_DATA_CHANNEL_LABEL}`,
+    open(handlers) {
+      const clock = options.clock ?? SYSTEM_RTC_CLOCK;
+      const stallMs = options.stallMs ?? RTC_STALL_MS;
+      const prologue = options.prologue ?? SECURE_PROLOGUE;
+      const ik = initiateIK({ prologue, static: options.device, remoteStatic: options.hostKey });
+      const frames = [];
+      const records = [];
+      let peer;
+      let channel;
+      let session;
+      let opened = false;
+      let closed = false;
+      let lastProgress = clock.now();
+      let stallTimer;
+      let retryTimer;
+      let handshakeStarted = false;
+      const clearStall = () => {
+        if (stallTimer !== undefined)
+          clock.clearTimeout(stallTimer);
+        stallTimer = undefined;
+      };
+      const clearRetry = () => {
+        if (retryTimer !== undefined)
+          clock.clearTimeout(retryTimer);
+        retryTimer = undefined;
+      };
+      const fail = (reason) => {
+        if (closed)
+          return;
+        closed = true;
+        clearStall();
+        clearRetry();
+        try {
+          peer?.close();
+        } catch {}
+        handlers.closed(1006, reason);
+      };
+      const armStall = () => {
+        if (closed || records.length === 0 || stallTimer !== undefined)
+          return;
+        stallTimer = clock.setTimeout(() => {
+          stallTimer = undefined;
+          if (closed)
+            return;
+          if (records.length === 0)
+            return;
+          if (clock.now() - lastProgress < stallMs) {
+            armStall();
+            return;
+          }
+          fail(`the DataChannel made no progress for ${stallMs}ms`);
+        }, stallMs);
+      };
+      const pump = () => {
+        if (closed || channel === undefined)
+          return;
+        if (records.length === 0) {
+          clearStall();
+          clearRetry();
+          return;
+        }
+        if (channel.bufferedAmount >= RTC_HIGH_WATER_BYTES)
+          return;
+        let outcome;
+        try {
+          outcome = channel.send(records[0]);
+        } catch (error) {
+          fail(error instanceof Error ? error.message : "the DataChannel send failed");
+          return;
+        }
+        if (outcome === "rejected") {
+          if (retryTimer === undefined) {
+            retryTimer = clock.setTimeout(() => {
+              retryTimer = undefined;
+              pump();
+            }, 50);
+          }
+          return;
+        }
+        clearRetry();
+        records.shift();
+        lastProgress = clock.now();
+        armStall();
+        queueMicrotask(pump);
+      };
+      const enqueue = (next) => {
+        if (closed || next.length === 0)
+          return;
+        records.push(...next);
+        lastProgress = clock.now();
+        armStall();
+        pump();
+      };
+      const sealFrames = () => {
+        if (session === undefined)
+          return;
+        for (const text of frames.splice(0))
+          enqueue(session.seal(text));
+      };
+      const receive = (bytes) => {
+        if (closed)
+          return;
+        try {
+          if (session === undefined) {
+            const { payload, result } = ik.readMessage2(bytes);
+            decodeHostHello(payload);
+            session = new SecureSession(result);
+            handlers.authenticated?.();
+            sealFrames();
+            return;
+          }
+          const text = session.open(bytes);
+          if (text !== undefined)
+            handlers.message(text);
+        } catch (error) {
+          fail(error instanceof Error ? error.message : "secure DataChannel failure");
+        }
+      };
+      options.platform.createPeer(options.stun).then((created) => {
+        if (closed) {
+          created.close();
+          return;
+        }
+        peer = created;
+        channel = created.channel;
+        channel.onOpen(() => {
+          if (closed || opened)
+            return;
+          opened = true;
+          options.onSelectedPair?.(created.selectedPair?.());
+          handlers.opened?.();
+          if (!handshakeStarted) {
+            handshakeStarted = true;
+            enqueue([ik.writeMessage1(encodeClientHello({ v: 1 }))]);
+          }
+        });
+        channel.onMessage(receive);
+        channel.onClosed((reason) => {
+          if (!closed)
+            fail(reason === undefined ? "the DataChannel closed" : `the DataChannel closed: ${reason}`);
+        });
+        channel.onBufferedAmountLow(pump);
+        let answer;
+        return options.offer(created.offerSdp).then((sdp) => {
+          if (closed)
+            return;
+          const limit = parseRtcMaxMessageSize(sdp);
+          if (limit.kind === "invalid")
+            throw new Error(limit.reason);
+          answer = sdp;
+          created.acceptAnswer(answer);
+          handlers.signaled?.();
+        });
+      }, (error) => fail(error instanceof Error ? error.message : String(error))).catch((error) => fail(error instanceof Error ? error.message : String(error)));
+      return {
+        send(text) {
+          if (closed)
+            return;
+          if (session === undefined) {
+            frames.push(text);
+            return;
+          }
+          enqueue(session.seal(text));
+        },
+        close() {
+          if (closed)
+            return;
+          closed = true;
+          clearStall();
+          clearRetry();
+          try {
+            peer?.close();
+          } catch {}
+        }
+      };
+    }
+  };
+}
+
+// packages/protocol/src/transport.ts
+function webSocketTransport(url, token) {
+  return {
+    label: url,
+    open(handlers) {
+      const address = new URL(url);
+      address.searchParams.set("token", token);
+      const socket = new WebSocket(address);
+      socket.onopen = () => {
+        handlers.opened?.();
+        handlers.authenticated?.();
+      };
+      socket.onmessage = (event) => handlers.message(String(event.data));
+      socket.onclose = (event) => handlers.closed(event.code);
+      return { send: (data) => socket.send(data), close: () => socket.close() };
+    }
+  };
+}
+
+// packages/protocol/src/transcript.ts
+function isBusy(view) {
+  const live = view.docs?.["pi.live"];
+  return live?.run !== undefined;
+}
+
+// packages/protocol/src/remote-durable.ts
+var DEFAULT_CANDIDATE_TIMEOUTS = {
+  socketOpenMs: 5000,
+  noiseMs: 5000,
+  helloMs: 5000,
+  syncMs: 1e4
+};
+
+class ConnectionFailedError extends Error {
+  failures;
+  constructor(failures) {
+    super(`Could not connect to the host: ${failures.map(describeFailure).join("; ")}`);
+    this.name = "ConnectionFailedError";
+    this.failures = failures;
+  }
+}
+
+class DirectUnavailableError extends Error {
+  reason;
+  constructor(reason) {
+    super(`${DIRECT_UNAVAILABLE} (${reason})`);
+    this.name = "DirectUnavailableError";
+    this.reason = reason;
+  }
+}
+var REMOTE_ACCESS_UNAVAILABLE = "Remote access is unavailable: the host published no remote path and this device has no local entry.";
+var LIVENESS_INTERVAL_MS = 5000;
+var LIVENESS_BUDGET_MS = 15000;
+var LIVENESS_VERIFY_MS = 3000;
+var UPGRADE_DELAY_MS = 1000;
+var UPGRADE_IDLE_MS = 300;
+var UPGRADE_IDLE_LIMIT_MS = 30000;
+var UPGRADE_DEADLINE_MS = 25000;
+var PREPARE_RETRY_MS = 1000;
+var COOLDOWN_START_MS = 30000;
+var COOLDOWN_MAX_MS = 10 * 60000;
+var P2P_STABLE_MS = 10 * 60000;
+var FALLBACK_QUIET_MS = 60000;
+var COOLDOWN_CLEAR_INTERVAL_MS = 60000;
+var SUBMISSION_TIMEOUT_MS = 30000;
+var asError = (error) => error instanceof Error ? error : new Error(String(error));
+var randomHex = (bytes) => Array.from(crypto.getRandomValues(new Uint8Array(bytes)), (byte) => byte.toString(16).padStart(2, "0")).join("");
+var describeFailure = (failure) => {
+  const role = failure.candidate.role === "loopback" ? "local" : failure.candidate.role;
+  const where = `${role} ${failure.candidate.url}`;
+  if (failure.stage === "unsupported")
+    return `${where} skipped (${failure.reason ?? "unsupported"})`;
+  const code = failure.code === undefined ? "" : ` (close ${failure.code})`;
+  return `${where} failed at ${failure.stage}${code}${failure.reason === undefined ? "" : `: ${failure.reason}`}`;
+};
+function connectRemoteDurable(options) {
+  return new RemoteClient(options).ready;
+}
+
+class UnauthorizedError extends Error {
+  constructor() {
+    super("Unauthorized: this client is not allowed (wrong token, or the device is not paired or was revoked)");
+    this.name = "UnauthorizedError";
+  }
+}
+
+class DisconnectedError extends Error {
+  constructor() {
+    super("Disconnected from host");
+    this.name = "DisconnectedError";
+  }
+}
+
+class ProtocolMismatchError extends Error {
+  hostMajor;
+  clientMajor;
+  hostVersion;
+  direction;
+  constructor(hostMajor, clientMajor, hostVersion) {
+    const direction = hostMajor > clientMajor ? "client-older" : "host-older";
+    super(direction === "client-older" ? `Client out of date: the host speaks protocol major ${hostMajor}, this client speaks ${clientMajor}` : `Host out of date: this client speaks protocol major ${clientMajor}, the host speaks ${hostMajor}`);
+    this.name = "ProtocolMismatchError";
+    this.hostMajor = hostMajor;
+    this.clientMajor = clientMajor;
+    if (hostVersion !== undefined)
+      this.hostVersion = hostVersion;
+    this.direction = direction;
+  }
+}
+function needsImageRefs(images) {
+  return images.some((image) => {
+    const data = "data" in image ? image.data : "";
+    const ref = "ref" in image ? image.ref : "";
+    return data === "" && ref !== "";
+  });
+}
+
+class RemoteClient {
+  ready;
+  #options;
+  #listeners = new Set;
+  #values = new Map;
+  #wanted = new Set;
+  #fresh = new Set;
+  #docs = [];
+  #toolPresentations = {};
+  #snapshotWaiters = new Map;
+  #pending = new Map;
+  #fullCandidates;
+  #candidates;
+  #mode;
+  #rtc;
+  #clock;
+  #hostRtc;
+  #signalOnlyHint;
+  #standby;
+  #signalAttempt;
+  #handoff;
+  #syncGate;
+  #upgradeTimer;
+  #upgradeSeq = 0;
+  #upgradeFailures = 0;
+  #cooldownUntil = 0;
+  #noUpgradeUntil = 0;
+  #lastCooldownClear = Number.NEGATIVE_INFINITY;
+  #stableTimer;
+  #activePath = "loopback";
+  #p2pFailure;
+  #selectedPair;
+  #livenessTimer;
+  #livenessDeadline = 0;
+  #livenessNext = 0;
+  #background = false;
+  #probes = new Map;
+  #roundCandidates = [];
+  #openTransport;
+  #baseUrl;
+  #pageProtocol;
+  #timeouts;
+  #roundTimeoutMs;
+  #followsHostEndpoints;
+  #pairing;
+  #dial;
+  #generation = 0;
+  #round = 0;
+  #candidateIndex = 0;
+  #failures = [];
+  #roundTimer;
+  #backoffTimer;
+  #backoffGeneration = 0;
+  #networkUnsubscribe;
+  #lifecycleUnsubscribe;
+  #signalCleanup;
+  #roundExpired = false;
+  #roundActive = false;
+  #everReady = false;
+  #outageNoticed = false;
+  #state;
+  #current;
+  #side;
+  #nextCall = 1;
+  #nextNotice = 1;
+  #submissions = new Map;
+  #submissionOrder = [];
+  #submissionLocks = new Set;
+  #streamVersions = new Map;
+  #hostMinor = 0;
+  #helloReceived = false;
+  #helloModels = [];
+  #helloDefaults = {};
+  #hostVersion;
+  #attempt = 0;
+  #rtcAttemptNonce = randomHex(8);
+  #closed = false;
+  #notifying = false;
+  #commands = Promise.resolve();
+  #resolveReady;
+  #rejectReady;
+  constructor(options) {
+    this.#options = options;
+    this.#mode = options.connectionMode ?? "auto";
+    this.#rtc = options.rtc;
+    this.#clock = options.clock ?? SYSTEM_RTC_CLOCK;
+    this.#signalOnlyHint = options.rtc?.signalOnlyHint === true;
+    this.#followsHostEndpoints = "candidates" in options;
+    if ("candidates" in options) {
+      this.#fullCandidates = [...options.candidates];
+      this.#openTransport = options.openTransport;
+      this.#pairing = options.pairing;
+      this.#baseUrl = options.legacyUrl ?? options.candidates[0]?.url ?? "";
+      this.#pageProtocol = options.pageProtocol;
+    } else if ("transport" in options) {
+      this.#fullCandidates = [{ url: options.transport.label, role: "legacy" }];
+      this.#openTransport = () => options.transport;
+      this.#baseUrl = options.transport.label;
+      this.#pageProtocol = undefined;
+    } else {
+      this.#fullCandidates = candidatePlan(options.url, undefined);
+      this.#openTransport = () => webSocketTransport(options.url, options.token);
+      this.#baseUrl = options.url;
+      this.#pageProtocol = undefined;
+    }
+    this.#candidates = filterCandidatesForMode(this.#fullCandidates, this.#mode);
+    this.#timeouts = { ...DEFAULT_CANDIDATE_TIMEOUTS, ...options.candidateTimeouts };
+    this.#roundTimeoutMs = options.roundTimeoutMs;
+    this.ready = new Promise((resolve, reject) => {
+      this.#resolveReady = resolve;
+      this.#rejectReady = reject;
+    });
+    const signal = options.signal;
+    const initiallyAborted = signal?.aborted === true;
+    if (signal !== undefined) {
+      const abort = () => this.#abort();
+      if (initiallyAborted)
+        queueMicrotask(abort);
+      else {
+        signal.addEventListener("abort", abort, { once: true });
+        this.#signalCleanup = () => signal.removeEventListener("abort", abort);
+      }
+    }
+    this.#networkUnsubscribe = options.network?.subscribe(() => this.#networkChanged());
+    this.#lifecycleUnsubscribe = options.lifecycle?.subscribe((state) => {
+      if (state === "background")
+        this.#enterBackground();
+      else
+        this.#enterForeground();
+    });
+    if (!initiallyAborted)
+      this.#beginRound();
+  }
+  #isActive(dial) {
+    return !this.#closed && this.#dial === dial && !dial.done && dial.generation === this.#generation;
+  }
+  #clearTimer(dial) {
+    if (dial.timer === undefined)
+      return;
+    clearTimeout(dial.timer);
+    dial.timer = undefined;
+  }
+  #arm(dial, phase, ms) {
+    this.#clearTimer(dial);
+    dial.timer = setTimeout(() => {
+      dial.timer = undefined;
+      if (!this.#isActive(dial))
+        return;
+      this.#failDial(dial, phase, undefined, `no progress within ${ms}ms`);
+    }, Math.max(0, ms));
+  }
+  #beginRound() {
+    if (this.#closed || this.#dial !== undefined)
+      return;
+    this.#clearRoundTimers();
+    this.#clearBackoff();
+    this.#round += 1;
+    const round = this.#round;
+    this.#roundCandidates = [...this.#candidates];
+    this.#candidateIndex = 0;
+    this.#failures = [];
+    this.#roundExpired = false;
+    this.#roundActive = true;
+    const perCandidate = this.#timeouts.socketOpenMs + this.#timeouts.noiseMs + this.#timeouts.helloMs + this.#timeouts.syncMs;
+    const budget = this.#roundTimeoutMs ?? this.#roundCandidates.length * perCandidate + 1000;
+    this.#roundTimer = setTimeout(() => {
+      this.#roundTimer = undefined;
+      if (this.#closed || !this.#roundActive || this.#round !== round)
+        return;
+      const dial = this.#dial;
+      this.#roundExpired = true;
+      if (dial !== undefined) {
+        this.#recordFailure(dial.candidate, "round", false, undefined, `the connection round exceeded ${budget}ms`);
+        this.#abandonDial(dial);
+      }
+      this.#roundFailed();
+    }, budget);
+    this.#openCandidate();
+  }
+  #openCandidate() {
+    if (this.#closed || !this.#roundActive || this.#dial !== undefined)
+      return;
+    if (this.#roundExpired) {
+      this.#roundFailed();
+      return;
+    }
+    const candidate = this.#roundCandidates[this.#candidateIndex++];
+    if (candidate === undefined) {
+      this.#roundFailed();
+      return;
+    }
+    if (candidate.unsupported !== undefined) {
+      this.#recordFailure(candidate, "unsupported", false, undefined, candidate.unsupported);
+      queueMicrotask(() => this.#openCandidate());
+      return;
+    }
+    const dial = {
+      candidate,
+      generation: ++this.#generation,
+      phase: "open",
+      done: false
+    };
+    this.#dial = dial;
+    this.#helloReceived = false;
+    this.#arm(dial, "open", this.#timeouts.socketOpenMs);
+    const handlers = {
+      opened: () => {
+        if (this.#isActive(dial))
+          this.#phase(dial, "noise", this.#timeouts.noiseMs);
+      },
+      authenticated: () => {
+        if (!this.#isActive(dial))
+          return;
+        this.#phase(dial, "hello", this.#timeouts.helloMs);
+        this.#paired();
+      },
+      message: (data) => {
+        if (this.#isActive(dial))
+          this.#message(dial, data);
+      },
+      closed: (code, reason) => {
+        if (this.#isActive(dial))
+          this.#failDial(dial, dial.phase === "ready" ? "closed" : dial.phase, code, reason);
+      }
+    };
+    let transport;
+    try {
+      transport = this.#openTransport(candidate, this.#pairing);
+    } catch (error) {
+      this.#failDial(dial, "open", undefined, asError(error).message);
+      return;
+    }
+    let connection;
+    try {
+      connection = transport.open(handlers);
+    } catch (error) {
+      this.#failDial(dial, "open", undefined, asError(error).message);
+      return;
+    }
+    if (!this.#isActive(dial)) {
+      connection.close();
+      return;
+    }
+    dial.connection = connection;
+  }
+  #phase(dial, phase, ms) {
+    if (!this.#isActive(dial))
+      return;
+    dial.phase = phase;
+    this.#arm(dial, phase, ms);
+  }
+  #paired() {
+    if (this.#pairing === undefined)
+      return;
+    this.#pairing = undefined;
+    if (this.#options.onPaired === undefined)
+      return;
+    const report = (error) => {
+      try {
+        this.#options.onPairedError?.(asError(error));
+      } catch {}
+    };
+    try {
+      Promise.resolve(this.#options.onPaired()).catch(report);
+    } catch (error) {
+      report(error);
+    }
+  }
+  #message(dial, data) {
+    let frame;
+    try {
+      frame = JSON.parse(data);
+    } catch {
+      this.#failDial(dial, dial.phase === "ready" ? "closed" : dial.phase, undefined, "the host sent a frame that is not JSON");
+      return;
+    }
+    if (frame === null || typeof frame !== "object")
+      return;
+    if (frame.type === "hello") {
+      this.#onHello(dial, frame);
+      return;
+    }
+    this.#receive(frame);
+  }
+  #onHello(dial, frame) {
+    const announced = frame.protocol;
+    const hostMajor = typeof announced === "number" ? announced : announced !== null && typeof announced === "object" ? announced.major : undefined;
+    if (hostMajor !== PROTOCOL.major) {
+      const mismatch = new ProtocolMismatchError(typeof hostMajor === "number" ? hostMajor : Number.NaN, PROTOCOL.major, frame.hostVersion);
+      this.#closed = true;
+      this.#clearTimers();
+      this.#stopCoordination();
+      this.#stopListeners();
+      this.#abandonDial();
+      if (this.#state === undefined) {
+        this.#rejectReady(mismatch);
+      } else {
+        this.#update({
+          connection: "outdated",
+          protocolMismatch: {
+            hostMajor: mismatch.hostMajor,
+            clientMajor: mismatch.clientMajor,
+            ...mismatch.hostVersion === undefined ? {} : { hostVersion: mismatch.hostVersion },
+            direction: mismatch.direction
+          }
+        });
+        this.#notice("error", mismatch.message);
+      }
+      return;
+    }
+    this.#clearTimer(dial);
+    dial.phase = "sync";
+    this.#arm(dial, "sync", this.#timeouts.syncMs);
+    const hostMinor = announced !== null && typeof announced === "object" && typeof announced.minor === "number" ? announced.minor : 0;
+    this.#hostMinor = hostMinor;
+    this.#helloReceived = true;
+    this.#hostRtc = frame.rtc !== undefined && isRtcHello(frame.rtc) ? frame.rtc : undefined;
+    if (this.#hostRtc?.signalOnly === true && !this.#signalOnlyHint) {
+      this.#signalOnlyHint = true;
+      this.#reportSignalOnly();
+    }
+    this.#docs = frame.docs;
+    this.#toolPresentations = frame.toolPresentations;
+    this.#helloModels = frame.models;
+    this.#helloDefaults = frame.defaults ?? {};
+    this.#hostVersion = frame.hostVersion;
+    this.#fresh.clear();
+    const covered = new Set(hostStreams(hostMinor));
+    for (const name of HOST_STREAM_NAMES) {
+      if (covered.has(name)) {
+        this.#wanted.add(name);
+      } else {
+        this.#wanted.delete(name);
+        this.#values.delete(name);
+        this.#fresh.delete(name);
+      }
+    }
+    if (this.#current !== undefined)
+      for (const stream of this.#conversationStreams(this.#current))
+        this.#wanted.add(stream);
+    if (this.#side !== undefined)
+      for (const stream of this.#conversationStreams(this.#side))
+        this.#wanted.add(stream);
+    for (const stream of this.#wanted)
+      this.#subscribe(stream);
+    if (frame.endpointSet !== undefined) {
+      const parsed = parseEndpointSet(frame.endpointSet);
+      if (parsed.kind === "valid") {
+        if (this.#followsHostEndpoints) {
+          this.#fullCandidates = candidatePlan(this.#baseUrl, parsed.endpointSet, { pageProtocol: this.#pageProtocol });
+          this.#candidates = filterCandidatesForMode(this.#fullCandidates, this.#mode);
+        }
+        if (this.#options.onEndpointSet !== undefined) {
+          const report = (error) => {
+            try {
+              this.#options.onEndpointSetError?.(asError(error));
+            } catch {}
+          };
+          try {
+            Promise.resolve(this.#options.onEndpointSet(parsed.endpointSet)).catch(report);
+          } catch (error) {
+            report(error);
+          }
+        }
+      }
+    }
+    if (this.#state !== undefined) {
+      this.#update({
+        session: frame.session,
+        toolPresentations: frame.toolPresentations,
+        connection: "reconnecting",
+        host: this.#hostInfo()
+      });
+      this.#refresh();
+    }
+    this.#afterHello(dial, frame, hostMinor);
+  }
+  async#afterHello(dial, hello, hostMinor) {
+    try {
+      const all = this.#syncStreams(hostMinor);
+      const hostOnly = new Set(hostStreams(hostMinor));
+      const missingHost = all.filter((stream) => hostOnly.has(stream) && !this.#fresh.has(stream));
+      await Promise.all(missingHost.map((stream) => this.#snapshot(stream, true)));
+      if (this.#state !== undefined && dial.p2p !== true) {
+        this.#update({ connection: "connected" });
+        this.#refresh();
+        this.#clearRoundTimer();
+        this.#roundActive = false;
+        dial.phase = "ready";
+      }
+      const missing = all.filter((stream) => !this.#fresh.has(stream));
+      if (this.#state !== undefined && dial.p2p !== true && missing.length > 0) {
+        this.#syncGate = { entries: [] };
+      }
+      await Promise.all(missing.map((stream) => this.#snapshot(stream, true)));
+    } catch {
+      return;
+    }
+    if (!this.#isActive(dial))
+      return;
+    this.#clearTimer(dial);
+    this.#clearRoundTimer();
+    dial.phase = "ready";
+    this.#roundActive = false;
+    this.#attempt = 0;
+    this.#everReady = true;
+    this.#outageNoticed = false;
+    this.#activePath = this.#pathOf(dial.candidate, dial.p2p === true);
+    if (this.#state === undefined) {
+      this.#state = {
+        session: hello.session,
+        organized: { chats: [], projects: [], archived: [] },
+        models: this.#host("models") ?? hello.models,
+        defaults: this.#effectiveDefaults(hello.defaults ?? {}),
+        notices: [],
+        connection: "connected",
+        docs: [],
+        submissions: [],
+        toolPresentations: hello.toolPresentations,
+        devices: [],
+        mcp: null,
+        auth: null,
+        providers: null,
+        settings: null,
+        agents: null,
+        host: this.#hostInfo()
+      };
+      this.#refresh();
+      this.#resolveReady({
+        view: this.#viewSource(),
+        controller: this.#controller(),
+        setConnectionMode: (mode) => this.setConnectionMode(mode),
+        rtcDiagnostics: () => this.rtcDiagnostics(),
+        close: () => this.#close()
+      });
+      this.#finishSyncGate();
+      this.#afterCarrierReady(dial);
+      return;
+    }
+    this.#update({ session: hello.session, connection: "connected" });
+    this.#refresh();
+    await this.#recoverSubmissions();
+    if (!this.#isActive(dial))
+      return;
+    this.#finishSyncGate();
+    this.#afterCarrierReady(dial);
+  }
+  #afterCarrierReady(dial) {
+    if (dial.p2p === true) {
+      this.#finishHandoff();
+      this.#startLiveness();
+      this.#startStableTimer();
+      return;
+    }
+    this.#stopLiveness();
+    this.#scheduleUpgrade(this.#upgradeDelayMs());
+  }
+  #recordFailure(candidate, stage, unauthorized, code, reason) {
+    const failure = {
+      candidate,
+      stage,
+      unauthorized,
+      ...code === undefined ? {} : { code },
+      ...reason === undefined ? {} : { reason }
+    };
+    this.#failures.push(failure);
+    try {
+      this.#options.onCandidateFailure?.(failure);
+    } catch {}
+  }
+  #failDial(dial, stage, code, reason) {
+    if (!this.#isActive(dial))
+      return;
+    const wasReady = dial.phase === "ready";
+    if (dial.p2p === true) {
+      this.#recordP2PFailure(wasReady ? "liveness" : "commit", reason, this.#selectedPair);
+      if (wasReady) {
+        this.#noUpgradeUntil = this.#now() + FALLBACK_QUIET_MS;
+        this.#stopLiveness();
+        this.#clearStableTimer();
+      }
+    }
+    this.#recordFailure(dial.candidate, stage, code === UNAUTHORIZED_CLOSE_CODE, code, reason);
+    this.#abandonDial(dial);
+    this.#loseSubmissions();
+    this.#rejectPending();
+    if (this.#handoff !== undefined && (this.#handoff.old === dial || this.#handoff.standby.installed && this.#handoff.standby === this.#standby)) {
+      this.#abortHandoff(new DisconnectedError);
+    }
+    if (this.#closed)
+      return;
+    if (dial.p2p === true && !wasReady) {
+      this.#update({ connection: "reconnecting" });
+      this.#beginRound();
+      return;
+    }
+    if (wasReady) {
+      this.#update({ connection: "reconnecting" });
+      this.#beginRound();
+      return;
+    }
+    if (this.#roundExpired) {
+      this.#roundFailed();
+      return;
+    }
+    queueMicrotask(() => this.#openCandidate());
+  }
+  #abandonDial(expected) {
+    const dial = this.#dial;
+    if (dial === undefined || expected !== undefined && dial !== expected)
+      return;
+    if (dial.p2p === true)
+      this.#selectedPair = undefined;
+    this.#dial = undefined;
+    dial.done = true;
+    this.#clearTimer(dial);
+    if (this.#syncGate !== undefined) {
+      for (const entry of this.#syncGate.entries.splice(0))
+        entry.reject(new DisconnectedError);
+      this.#syncGate = undefined;
+    }
+    this.#rejectSnapshotWaiters(new DisconnectedError);
+    dial.connection?.close();
+  }
+  #rejectPending() {
+    for (const pending of this.#pending.values())
+      pending.reject(new DisconnectedError);
+    this.#pending.clear();
+  }
+  #rejectSnapshotWaiters(error) {
+    for (const waiters of this.#snapshotWaiters.values()) {
+      for (const waiter of waiters.splice(0))
+        waiter.reject(error);
+    }
+  }
+  #dialedFailures(failures) {
+    return failures.filter((failure) => failure.stage !== "unsupported");
+  }
+  #unauthorizedRound(failures) {
+    const dialed = this.#dialedFailures(failures);
+    return dialed.length > 0 && dialed.every((failure) => failure.unauthorized);
+  }
+  #roundFailed() {
+    if (!this.#roundActive)
+      return;
+    this.#roundActive = false;
+    this.#clearRoundTimers();
+    this.#clearBackoff();
+    if (this.#syncGate !== undefined) {
+      for (const entry of this.#syncGate.entries.splice(0))
+        entry.reject(new DisconnectedError);
+      this.#syncGate = undefined;
+    }
+    this.#dial = undefined;
+    if (this.#closed)
+      return;
+    const failures = [...this.#failures];
+    const dialed = this.#dialedFailures(failures);
+    const unauthorized = this.#unauthorizedRound(failures);
+    const emptyPlan = this.#roundCandidates.length === 0;
+    if (!unauthorized && this.#mode === "directOnly" && this.#rtc !== undefined && (this.#signalOnlyHint || this.#hostRtc !== undefined) && this.#signalAttempt === undefined && this.#standby === undefined && this.#dial === undefined) {
+      this.#openSignalAttempt();
+      return;
+    }
+    if (!this.#everReady) {
+      this.#closed = true;
+      this.#clearTimers();
+      this.#stopListeners();
+      this.#rejectReady(unauthorized ? new UnauthorizedError : emptyPlan ? new Error(REMOTE_ACCESS_UNAVAILABLE) : this.#aggregateError(failures));
+      return;
+    }
+    if (unauthorized) {
+      this.#closed = true;
+      this.#clearTimers();
+      this.#stopListeners();
+      this.#update({ connection: "closed", unauthorized: true });
+      this.#notice("error", new UnauthorizedError().message);
+      return;
+    }
+    if (dialed.length === 0) {
+      this.#closed = true;
+      this.#clearTimers();
+      this.#stopListeners();
+      this.#update({ connection: "closed" });
+      this.#notice("error", emptyPlan ? REMOTE_ACCESS_UNAVAILABLE : this.#aggregateError(failures).message);
+      return;
+    }
+    this.#update({ connection: "reconnecting" });
+    if (!this.#outageNoticed) {
+      this.#outageNoticed = true;
+      this.#notice("error", this.#aggregateError(failures).message);
+    }
+    this.#scheduleBackoff();
+  }
+  #aggregateError(failures) {
+    if (this.#unauthorizedRound(failures))
+      return new UnauthorizedError;
+    if (failures.length === 0)
+      return new Error(REMOTE_ACCESS_UNAVAILABLE);
+    return new ConnectionFailedError(failures);
+  }
+  #scheduleBackoff() {
+    this.#clearBackoff();
+    const { min, max } = this.#options.reconnectDelayMs ?? { min: 200, max: 2000 };
+    const delay = Math.min(max, min * 2 ** this.#attempt++);
+    const generation = this.#backoffGeneration;
+    this.#backoffTimer = setTimeout(() => {
+      if (this.#backoffGeneration !== generation)
+        return;
+      this.#backoffTimer = undefined;
+      if (!this.#closed)
+        this.#beginRound();
+    }, delay);
+  }
+  #networkChanged() {
+    if (this.#closed)
+      return;
+    this.#clearCooldownRateLimited();
+    if (this.#dial?.p2p === true && this.#dial.phase === "ready") {
+      this.#verifyLiveness();
+      return;
+    }
+    if (this.#dial?.phase === "ready")
+      return;
+    this.#clearBackoff();
+    this.#clearRoundTimers();
+    this.#abandonDial();
+    this.#attempt = 0;
+    this.#beginRound();
+  }
+  #now() {
+    return this.#clock.now();
+  }
+  #upgradeDelayMs() {
+    return UPGRADE_DELAY_MS;
+  }
+  #pathOf(candidate, p2p = false) {
+    if (p2p)
+      return "p2p";
+    return candidate.role === "legacy" ? "relay" : candidate.role;
+  }
+  #reportSignalOnly(signalOnly = true) {
+    const report = (error) => {
+      try {
+        this.#rtc?.onSignalOnlyError?.(asError(error));
+      } catch {}
+    };
+    try {
+      Promise.resolve(this.#rtc?.onSignalOnly?.(signalOnly)).catch(report);
+    } catch (error) {
+      report(error);
+    }
+  }
+  #hasSnapshotWaiters() {
+    for (const waiters of this.#snapshotWaiters.values())
+      if (waiters.length > 0)
+        return true;
+    return false;
+  }
+  #scheduleUpgrade(delayMs) {
+    if (this.#closed || this.#rtc === undefined || this.#mode === "relayOnly")
+      return;
+    this.#clearUpgradeTimer();
+    const seq = ++this.#upgradeSeq;
+    this.#upgradeTimer = this.#clock.setTimeout(() => {
+      this.#upgradeTimer = undefined;
+      if (seq !== this.#upgradeSeq)
+        return;
+      this.#maybeStartUpgrade();
+    }, Math.max(0, delayMs));
+  }
+  #clearUpgradeTimer() {
+    if (this.#upgradeTimer === undefined)
+      return;
+    this.#clock.clearTimeout(this.#upgradeTimer);
+    this.#upgradeTimer = undefined;
+  }
+  #maybeStartUpgrade() {
+    if (this.#closed || this.#rtc === undefined || this.#mode === "relayOnly")
+      return;
+    if (this.#standby !== undefined || this.#handoff !== undefined || this.#signalAttempt !== undefined)
+      return;
+    const now = this.#now();
+    const blockedUntil = Math.max(this.#cooldownUntil, this.#noUpgradeUntil);
+    if (now < blockedUntil) {
+      this.#scheduleUpgrade(blockedUntil - now);
+      return;
+    }
+    const active = this.#dial;
+    if (active?.phase === "ready" && active.connection !== undefined && this.#state?.connection === "connected") {
+      if (this.#hostRtc === undefined)
+        return;
+      this.#beginRtcStandby(active.connection, false);
+      return;
+    }
+    if (this.#mode !== "directOnly")
+      return;
+    if (this.#hostRtc === undefined && !this.#signalOnlyHint)
+      return;
+    this.#openSignalAttempt();
+  }
+  #beginRtcStandby(signal, signalOnly) {
+    const rtc = this.#rtc;
+    if (rtc === undefined || this.#standby !== undefined || this.#closed)
+      return;
+    const generation = ++this.#upgradeSeq;
+    const standby = {
+      generation,
+      phase: "signal",
+      signal,
+      signalOnly,
+      installed: false
+    };
+    this.#standby = standby;
+    this.#p2pFailure = undefined;
+    standby.timer = this.#clock.setTimeout(() => {
+      if (this.#standby !== standby || this.#handoff !== undefined)
+        return;
+      this.#failStandby(standby, "warm", `WebRTC preparation exceeded ${UPGRADE_DEADLINE_MS}ms`);
+    }, UPGRADE_DEADLINE_MS);
+    const attempt = `rtc-${this.#rtcAttemptNonce}-${generation}`;
+    const transport = rtcTransport({
+      platform: rtc.platform,
+      stun: this.#hostRtc?.stun ?? [],
+      hostKey: rtc.hostKey,
+      device: rtc.device,
+      clock: this.#clock,
+      offer: (sdp) => this.#rtcOfferOn(signal, attempt, sdp),
+      onSelectedPair: (pair) => {
+        if (pair !== undefined)
+          standby.selectedPair = rtcSelectedPair(pair.local, pair.remote);
+      }
+    });
+    const handlers = {
+      signaled: () => {
+        if (this.#standby === standby)
+          standby.phase = "ice";
+      },
+      opened: () => {
+        if (this.#standby === standby)
+          standby.phase = "noise";
+      },
+      authenticated: () => {
+        if (this.#standby !== standby)
+          return;
+        standby.phase = "noise";
+        if (standby.signalOnly) {
+          try {
+            standby.signal?.close();
+          } catch {}
+          standby.signal = undefined;
+        }
+      },
+      message: (data) => {
+        if (standby.installed) {
+          const dial = standby.installed && this.#dial?.connection === standby.connection ? this.#dial : undefined;
+          if (dial !== undefined && this.#isActive(dial))
+            this.#message(dial, data);
+          return;
+        }
+        this.#standbyMessage(standby, data);
+      },
+      closed: (code, reason) => {
+        if (standby.installed) {
+          const dial = this.#dial?.connection === standby.connection ? this.#dial : undefined;
+          if (dial !== undefined && this.#isActive(dial)) {
+            this.#failDial(dial, dial.phase === "ready" ? "closed" : dial.phase, code, reason);
+          }
+          return;
+        }
+        if (this.#standby === standby)
+          this.#failStandby(standby, standby.phase, reason ?? `DataChannel closed (${code})`);
+      }
+    };
+    try {
+      standby.connection = transport.open(handlers);
+    } catch (error) {
+      this.#failStandby(standby, "signal", asError(error).message);
+    }
+  }
+  #rtcOfferOn(connection, attempt, sdp) {
+    const id = this.#nextCall++;
+    return new Promise((resolve, reject) => {
+      this.#pending.set(id, { resolve, reject });
+      try {
+        connection.send(JSON.stringify({ type: "call", id, method: "rtcOffer", args: { attempt, sdp } }));
+      } catch (error) {
+        this.#pending.delete(id);
+        reject(asError(error));
+      }
+    }).then((value) => {
+      const answer = value;
+      if (answer === null || typeof answer !== "object" || typeof answer.sdp !== "string") {
+        throw new Error("the host returned a malformed rtcOffer answer");
+      }
+      return answer.sdp;
+    });
+  }
+  #standbyMessage(standby, data) {
+    if (this.#standby !== standby)
+      return;
+    let frame;
+    try {
+      frame = JSON.parse(data);
+    } catch {
+      this.#failStandby(standby, "noise", "the DataChannel sent a frame that is not JSON");
+      return;
+    }
+    if (frame === null || typeof frame !== "object")
+      return;
+    if (frame.type === "hello") {
+      standby.hello = frame;
+      if (standby.pingId === undefined)
+        this.#warmStandby(standby);
+      return;
+    }
+    if (frame.type === "result" && standby.verify?.id === frame.id) {
+      const verify = standby.verify;
+      standby.verify = undefined;
+      if (verify.timer !== undefined)
+        this.#clock.clearTimeout(verify.timer);
+      if (frame.ok)
+        verify.resolve();
+      else
+        verify.reject(new Error(frame.error));
+      return;
+    }
+  }
+  #warmStandby(standby) {
+    if (this.#standby !== standby || standby.hello === undefined)
+      return;
+    const id = this.#nextCall++;
+    standby.pingId = id;
+    this.#probeStandby(standby, id, 5000).then(() => {
+      if (this.#standby !== standby || standby.installed)
+        return;
+      standby.phase = "warm";
+      standby.warmAt = this.#now();
+      if (standby.timer !== undefined)
+        this.#clock.clearTimeout(standby.timer);
+      standby.timer = this.#clock.setTimeout(() => {
+        if (this.#standby === standby && this.#handoff === undefined) {
+          this.#deferStandby(standby, `no idle window within ${UPGRADE_IDLE_LIMIT_MS}ms`);
+        }
+      }, UPGRADE_IDLE_LIMIT_MS);
+      this.#pollStandby(standby);
+    }, (error) => {
+      if (this.#standby === standby)
+        this.#failStandby(standby, "warm", asError(error).message);
+    });
+  }
+  #probeStandby(standby, id, timeoutMs) {
+    if (this.#standby !== standby || standby.connection === undefined) {
+      return Promise.reject(new Error("the RTC carrier is gone"));
+    }
+    return new Promise((resolve, reject) => {
+      const timer = this.#clock.setTimeout(() => {
+        if (standby.verify?.id !== id)
+          return;
+        standby.verify = undefined;
+        reject(new Error(`the RTC carrier did not answer a ping within ${timeoutMs}ms`));
+      }, timeoutMs);
+      standby.verify = { id, resolve, reject, timer };
+      try {
+        standby.connection.send(JSON.stringify({ type: "call", id, method: "ping", args: { id: `rtc-${id}` } }));
+      } catch (error) {
+        this.#clock.clearTimeout(timer);
+        standby.verify = undefined;
+        reject(asError(error));
+      }
+    });
+  }
+  #pollStandby(standby) {
+    if (this.#standby !== standby || standby.phase !== "warm" || standby.installed)
+      return;
+    if (this.#handoff !== undefined)
+      return;
+    if (this.#dial?.phase !== "ready") {
+      this.#beginHandoff(standby);
+      return;
+    }
+    const busy = this.#pending.size > 0 || this.#hasSnapshotWaiters();
+    if (busy) {
+      standby.idleSince = undefined;
+    } else {
+      const now = this.#now();
+      standby.idleSince ??= now;
+      if (now - standby.idleSince >= UPGRADE_IDLE_MS) {
+        this.#beginHandoff(standby);
+        return;
+      }
+    }
+    if (standby.idleTimer !== undefined)
+      this.#clock.clearTimeout(standby.idleTimer);
+    standby.idleTimer = this.#clock.setTimeout(() => this.#pollStandby(standby), 100);
+  }
+  #beginHandoff(standby) {
+    if (this.#standby !== standby || this.#handoff !== undefined || standby.hello === undefined)
+      return;
+    if (standby.idleTimer !== undefined)
+      this.#clock.clearTimeout(standby.idleTimer);
+    standby.idleTimer = undefined;
+    const handoff = {
+      standby,
+      old: this.#dial,
+      entries: [],
+      warmAt: standby.warmAt ?? this.#now(),
+      prepared: false,
+      released: false
+    };
+    this.#handoff = handoff;
+    if (handoff.old?.phase === "ready" && handoff.old.connection !== undefined) {
+      const id = this.#nextCall++;
+      standby.verify = undefined;
+      this.#probeStandby(standby, id, 3000).then(() => {
+        if (this.#handoff !== handoff || handoff.released)
+          return;
+        handoff.prepared = true;
+        this.#installStandby(handoff);
+      }, (error) => {
+        if (this.#handoff !== handoff || handoff.released)
+          return;
+        this.#releaseToOld(handoff, asError(error).message);
+      });
+    } else {
+      handoff.prepared = true;
+      this.#installStandby(handoff);
+    }
+  }
+  #installStandby(handoff) {
+    if (this.#handoff !== handoff || handoff.released)
+      return;
+    const standby = handoff.standby;
+    const hello = standby.hello;
+    if (hello === undefined || standby.connection === undefined) {
+      this.#abortHandoff(new Error("the RTC carrier lost its hello before handoff"));
+      return;
+    }
+    const old = handoff.old;
+    if (old !== undefined) {
+      old.done = true;
+      try {
+        old.connection?.close();
+      } catch {}
+    }
+    const dial = {
+      candidate: { url: "webrtc", role: "direct" },
+      generation: ++this.#generation,
+      phase: "sync",
+      connection: standby.connection,
+      done: false,
+      p2p: true
+    };
+    this.#dial = dial;
+    standby.installed = true;
+    this.#activePath = "p2p";
+    this.#selectedPair = standby.selectedPair;
+    if (standby.signalOnly)
+      standby.signal = undefined;
+    this.#onHello(dial, hello);
+  }
+  #releaseToOld(handoff, reason) {
+    this.#handoff = undefined;
+    this.#standby = undefined;
+    this.#clearStandbyTimers(handoff.standby);
+    try {
+      handoff.standby.connection?.close();
+    } catch {}
+    if (handoff.standby.signalOnly && handoff.standby.signal !== undefined) {
+      try {
+        handoff.standby.signal.close();
+      } catch {}
+    }
+    this.#recordP2PFailure("commit", reason, handoff.standby.selectedPair);
+    this.#preparationFailed();
+    const old = handoff.old;
+    for (const entry of handoff.entries.splice(0)) {
+      if (old === undefined)
+        entry.reject(new Error("Not connected to the host"));
+      else
+        this.#deliverDeferred(old, entry);
+    }
+    this.#scheduleUpgrade(this.#cooldownRemainingMs());
+  }
+  #abortHandoff(error) {
+    const handoff = this.#handoff;
+    if (handoff === undefined)
+      return;
+    this.#handoff = undefined;
+    this.#standby = undefined;
+    this.#clearStandbyTimers(handoff.standby);
+    try {
+      handoff.standby.connection?.close();
+    } catch {}
+    if (handoff.standby.signalOnly && handoff.standby.signal !== undefined) {
+      try {
+        handoff.standby.signal.close();
+      } catch {}
+    }
+    for (const entry of handoff.entries.splice(0))
+      entry.reject(error);
+  }
+  #finishSyncGate() {
+    const gate = this.#syncGate;
+    if (gate === undefined)
+      return;
+    this.#syncGate = undefined;
+    const dial = this.#dial;
+    for (const entry of gate.entries.splice(0)) {
+      if (dial === undefined)
+        entry.reject(new DisconnectedError);
+      else
+        this.#deliverDeferred(dial, entry);
+    }
+  }
+  #finishHandoff() {
+    const handoff = this.#handoff;
+    if (handoff === undefined || !handoff.standby.installed)
+      return;
+    this.#handoff = undefined;
+    this.#standby = undefined;
+    const dial = this.#dial;
+    for (const entry of handoff.entries.splice(0)) {
+      if (dial === undefined)
+        entry.reject(new Error("Not connected to the host"));
+      else
+        this.#deliverDeferred(dial, entry);
+    }
+    this.#startStableTimer();
+  }
+  #deliverDeferred(dial, entry) {
+    if (!this.#isActive(dial) || dial.phase !== "ready" || dial.connection === undefined) {
+      entry.reject(new Error("Not connected to the host"));
+      return;
+    }
+    this.#pending.set(entry.id, { resolve: entry.resolve, reject: entry.reject });
+    try {
+      dial.connection.send(JSON.stringify(entry.frame));
+    } catch (error) {
+      this.#pending.delete(entry.id);
+      entry.reject(asError(error));
+    }
+  }
+  #clearStandbyTimers(standby) {
+    for (const timer of [standby.timer, standby.pingTimer, standby.idleTimer, standby.verify?.timer]) {
+      if (timer !== undefined)
+        this.#clock.clearTimeout(timer);
+    }
+    standby.timer = undefined;
+    standby.pingTimer = undefined;
+    standby.idleTimer = undefined;
+    standby.verify = undefined;
+  }
+  #failStandby(standby, stage, reason) {
+    if (this.#standby !== standby)
+      return;
+    const handoff = this.#handoff;
+    if (handoff !== undefined && handoff.standby === standby) {
+      this.#releaseToOld(handoff, reason);
+      return;
+    }
+    this.#standby = undefined;
+    this.#clearStandbyTimers(standby);
+    try {
+      standby.connection?.close();
+    } catch {}
+    if (standby.signalOnly && standby.signal !== undefined) {
+      try {
+        standby.signal.close();
+      } catch {}
+    }
+    this.#recordP2PFailure(stage, reason, standby.selectedPair);
+    if (standby.signalOnly && stage === "signal") {
+      this.#signalOnlyHint = false;
+      this.#reportSignalOnly(false);
+    }
+    this.#preparationFailed();
+    if (this.#state === undefined && this.#mode === "directOnly" && this.#dial === undefined) {
+      this.#directUnavailable(reason);
+      return;
+    }
+    this.#scheduleUpgrade(this.#cooldownRemainingMs());
+  }
+  #deferStandby(standby, reason) {
+    if (this.#standby !== standby)
+      return;
+    this.#standby = undefined;
+    this.#clearStandbyTimers(standby);
+    try {
+      standby.connection?.close();
+    } catch {}
+    if (standby.signalOnly && standby.signal !== undefined) {
+      try {
+        standby.signal.close();
+      } catch {}
+    }
+    this.#recordP2PFailure("commit", reason, standby.selectedPair);
+    this.#scheduleUpgrade(PREPARE_RETRY_MS);
+  }
+  #recordP2PFailure(stage, reason, pair) {
+    this.#p2pFailure = {
+      stage,
+      ...reason === undefined ? {} : { reason },
+      atMs: this.#now(),
+      ...pair === undefined ? {} : { pair }
+    };
+  }
+  #preparationFailed() {
+    this.#upgradeFailures += 1;
+    const delay = Math.min(COOLDOWN_MAX_MS, COOLDOWN_START_MS * 2 ** (this.#upgradeFailures - 1));
+    this.#cooldownUntil = this.#now() + delay;
+  }
+  #cooldownRemainingMs() {
+    return Math.max(0, Math.max(this.#cooldownUntil, this.#noUpgradeUntil) - this.#now());
+  }
+  #startStableTimer() {
+    if (this.#stableTimer !== undefined)
+      this.#clock.clearTimeout(this.#stableTimer);
+    this.#stableTimer = this.#clock.setTimeout(() => {
+      this.#stableTimer = undefined;
+      if (this.#activePath === "p2p" && this.#dial?.phase === "ready") {
+        this.#upgradeFailures = 0;
+        this.#cooldownUntil = 0;
+        this.#noUpgradeUntil = 0;
+      }
+    }, P2P_STABLE_MS);
+  }
+  #clearCooldown() {
+    this.#upgradeFailures = 0;
+    this.#cooldownUntil = 0;
+    this.#noUpgradeUntil = 0;
+  }
+  #openSignalAttempt() {
+    const rtc = this.#rtc;
+    if (rtc === undefined || this.#signalAttempt !== undefined || this.#closed)
+      return;
+    if (rtc.openSignalTransport === undefined) {
+      this.#directUnavailable("the platform has no signal-only transport");
+      return;
+    }
+    const candidates = signalCandidates(this.#fullCandidates);
+    if (candidates.length === 0) {
+      this.#directUnavailable("no relay candidate is available for signaling");
+      return;
+    }
+    const attempt = { generation: ++this.#upgradeSeq, index: 0, token: 0, done: false };
+    this.#signalAttempt = attempt;
+    this.#openSignalCandidate(attempt, candidates);
+  }
+  #openSignalCandidate(attempt, candidates) {
+    if (this.#signalAttempt !== attempt || attempt.done || this.#closed)
+      return;
+    if (attempt.timer !== undefined) {
+      this.#clock.clearTimeout(attempt.timer);
+      attempt.timer = undefined;
+    }
+    while (attempt.index < candidates.length) {
+      const candidate = candidates[attempt.index++];
+      if (candidate.unsupported !== undefined)
+        continue;
+      const openSignal = this.#rtc?.openSignalTransport;
+      if (openSignal === undefined) {
+        this.#failSignalAttempt(attempt, "the platform has no signal-only transport");
+        return;
+      }
+      let transport;
+      try {
+        transport = openSignal(candidate);
+      } catch (error) {
+        this.#failSignalAttempt(attempt, asError(error).message);
+        return;
+      }
+      const token = ++attempt.token;
+      const timeoutMs = this.#timeouts.socketOpenMs + this.#timeouts.noiseMs + this.#timeouts.helloMs;
+      attempt.timer = this.#clock.setTimeout(() => {
+        if (this.#signalAttempt !== attempt || attempt.done || attempt.token !== token)
+          return;
+        attempt.done = true;
+        attempt.token += 1;
+        try {
+          attempt.connection?.close();
+        } catch {}
+        attempt.connection = undefined;
+        attempt.done = false;
+        this.#openSignalCandidate(attempt, candidates);
+      }, timeoutMs);
+      const handlers = {
+        message: (data) => this.#receiveSignalFrame(attempt, data),
+        closed: (_code, _reason) => {
+          if (attempt.token !== token)
+            return;
+          if (this.#signalAttempt !== attempt || attempt.done) {
+            const standby = this.#standby;
+            if (standby?.signalOnly === true && standby.signal === attempt.connection && !standby.installed && standby.phase !== "noise" && standby.phase !== "warm") {
+              this.#failStandby(standby, standby.phase, "the signal-only connection closed");
+            }
+            return;
+          }
+          attempt.done = true;
+          attempt.connection = undefined;
+          attempt.done = false;
+          this.#openSignalCandidate(attempt, candidates);
+        }
+      };
+      try {
+        attempt.connection = transport.open(handlers);
+      } catch {
+        continue;
+      }
+      return;
+    }
+    this.#failSignalAttempt(attempt, "every relay signal path failed");
+  }
+  #receiveSignalFrame(attempt, data) {
+    let frame;
+    try {
+      frame = JSON.parse(data);
+    } catch {
+      return;
+    }
+    if (frame === null || typeof frame !== "object")
+      return;
+    if (frame.type === "result") {
+      const pending = this.#pending.get(frame.id);
+      this.#pending.delete(frame.id);
+      if (frame.ok)
+        pending?.resolve(frame.value);
+      else
+        pending?.reject(new Error(frame.error));
+      return;
+    }
+    if (frame.type !== "signalHello")
+      return;
+    if (this.#signalAttempt !== attempt || attempt.done)
+      return;
+    attempt.done = true;
+    this.#signalAttempt = undefined;
+    if (attempt.timer !== undefined)
+      this.#clock.clearTimeout(attempt.timer);
+    attempt.timer = undefined;
+    if (frame.rtc === undefined) {
+      this.#directUnavailable("the host did not advertise WebRTC on its signal connection");
+      return;
+    }
+    this.#hostRtc = frame.rtc;
+    if (frame.rtc.signalOnly)
+      this.#reportSignalOnly();
+    const connection = attempt.connection;
+    if (connection === undefined) {
+      this.#directUnavailable("the signal-only connection vanished before its offer");
+      return;
+    }
+    this.#beginRtcStandby(connection, true);
+  }
+  #failSignalAttempt(attempt, reason) {
+    if (this.#signalAttempt !== attempt)
+      return;
+    this.#signalAttempt = undefined;
+    if (attempt.timer !== undefined)
+      this.#clock.clearTimeout(attempt.timer);
+    attempt.timer = undefined;
+    this.#recordP2PFailure("signal", reason);
+    this.#signalOnlyHint = false;
+    this.#directUnavailable(reason);
+  }
+  #directUnavailable(reason) {
+    if (this.#closed)
+      return;
+    if (this.#state === undefined) {
+      this.#closed = true;
+      this.#clearTimers();
+      this.#stopListeners();
+      this.#rejectPending();
+      this.#rejectSnapshotWaiters(new DisconnectedError);
+      this.#rejectReady(new DirectUnavailableError(reason));
+      return;
+    }
+    this.#notice("error", `${DIRECT_UNAVAILABLE} (${reason})`);
+    this.#update({ connection: "reconnecting" });
+    this.#scheduleBackoff();
+  }
+  #enterBackground() {
+    if (this.#closed)
+      return;
+    this.#background = true;
+    this.#stopLiveness();
+  }
+  #enterForeground() {
+    if (this.#closed)
+      return;
+    this.#background = false;
+    if (this.#dial?.p2p === true && this.#dial.phase === "ready") {
+      this.#verifyLiveness();
+      return;
+    }
+    if (this.#dial?.phase === "ready")
+      return;
+    this.#networkChanged();
+  }
+  #startLiveness() {
+    this.#stopLiveness();
+    if (this.#closed || this.#background || this.#dial?.p2p !== true || this.#dial.phase !== "ready")
+      return;
+    const now = this.#now();
+    this.#livenessDeadline = now + LIVENESS_BUDGET_MS;
+    this.#livenessNext = now + LIVENESS_INTERVAL_MS;
+    this.#scheduleLiveness();
+  }
+  #scheduleLiveness() {
+    if (this.#closed || this.#background || this.#dial?.p2p !== true || this.#dial.phase !== "ready")
+      return;
+    const delay = Math.max(0, this.#livenessNext - this.#now());
+    this.#livenessTimer = this.#clock.setTimeout(() => {
+      this.#livenessTimer = undefined;
+      this.#livenessTick();
+    }, delay);
+  }
+  #stopLiveness() {
+    if (this.#livenessTimer !== undefined)
+      this.#clock.clearTimeout(this.#livenessTimer);
+    this.#livenessTimer = undefined;
+    for (const probe of this.#probes.values()) {
+      if (probe.timer !== undefined)
+        this.#clock.clearTimeout(probe.timer);
+    }
+    this.#probes.clear();
+  }
+  #livenessTick() {
+    const dial = this.#dial;
+    if (this.#closed || this.#background || dial?.p2p !== true || dial.phase !== "ready")
+      return;
+    const now = this.#now();
+    if (now >= this.#livenessDeadline) {
+      this.#fallbackFromP2P("no pong within 15000ms");
+      return;
+    }
+    this.#sendProbe(false);
+    this.#livenessNext += LIVENESS_INTERVAL_MS;
+    if (this.#livenessNext <= now)
+      this.#livenessNext = now + LIVENESS_INTERVAL_MS;
+    this.#scheduleLiveness();
+  }
+  #verifyLiveness() {
+    this.#stopLiveness();
+    if (this.#dial?.p2p !== true || this.#dial.phase !== "ready")
+      return;
+    const probe = this.#sendProbe(true);
+    if (probe === undefined)
+      return;
+    this.#livenessNext = this.#now() + LIVENESS_INTERVAL_MS;
+    this.#scheduleLiveness();
+  }
+  #sendProbe(verify) {
+    const dial = this.#dial;
+    if (dial?.connection === undefined || dial.p2p !== true)
+      return;
+    const id = this.#nextCall++;
+    const entry = { generation: dial.generation };
+    this.#probes.set(id, entry);
+    if (verify) {
+      entry.timer = this.#clock.setTimeout(() => {
+        if (!this.#probes.has(id))
+          return;
+        this.#probes.delete(id);
+        this.#fallbackFromP2P("the foreground verification ping did not answer within 3000ms");
+      }, LIVENESS_VERIFY_MS);
+    }
+    try {
+      dial.connection.send(JSON.stringify({ type: "call", id, method: "ping", args: { id: `probe-${id}` } }));
+    } catch (error) {
+      this.#probes.delete(id);
+      if (entry.timer !== undefined)
+        this.#clock.clearTimeout(entry.timer);
+      this.#fallbackFromP2P(asError(error).message);
+      return;
+    }
+    return id;
+  }
+  #fallbackFromP2P(reason) {
+    const dial = this.#dial;
+    if (dial?.p2p !== true)
+      return;
+    this.#recordP2PFailure("liveness", reason, this.#selectedPair);
+    this.#selectedPair = undefined;
+    this.#noUpgradeUntil = this.#now() + FALLBACK_QUIET_MS;
+    this.#stopLiveness();
+    this.#clearStableTimer();
+    dial.done = true;
+    try {
+      dial.connection?.close();
+    } catch {}
+    if (this.#dial === dial)
+      this.#dial = undefined;
+    this.#rejectPending();
+    this.#rejectSnapshotWaiters(new DisconnectedError);
+    this.#clearRoundTimers();
+    this.#update({ connection: "reconnecting" });
+    this.#beginRound();
+  }
+  #clearStableTimer() {
+    if (this.#stableTimer === undefined)
+      return;
+    this.#clock.clearTimeout(this.#stableTimer);
+    this.#stableTimer = undefined;
+  }
+  #livenessBudgetMs() {
+    return LIVENESS_BUDGET_MS;
+  }
+  #clearCooldownRateLimited() {
+    const now = this.#now();
+    if (now - this.#lastCooldownClear < COOLDOWN_CLEAR_INTERVAL_MS)
+      return;
+    this.#lastCooldownClear = now;
+    this.#clearCooldown();
+  }
+  setConnectionMode(mode) {
+    if (mode === this.#mode)
+      return;
+    this.#mode = mode;
+    this.#candidates = filterCandidatesForMode(this.#fullCandidates, mode);
+    this.#clearUpgradeTimer();
+    this.#stopLiveness();
+    this.#clearStableTimer();
+    if (this.#handoff !== undefined)
+      this.#abortHandoff(new DisconnectedError);
+    if (this.#standby !== undefined) {
+      const standby = this.#standby;
+      this.#standby = undefined;
+      this.#clearStandbyTimers(standby);
+      try {
+        standby.connection?.close();
+      } catch {}
+    }
+    if (this.#signalAttempt !== undefined) {
+      const attempt = this.#signalAttempt;
+      this.#signalAttempt = undefined;
+      if (attempt.timer !== undefined)
+        this.#clock.clearTimeout(attempt.timer);
+      try {
+        attempt.connection?.close();
+      } catch {}
+    }
+    if (this.#closed)
+      return;
+    this.#clearRoundTimers();
+    this.#clearBackoff();
+    this.#abandonDial();
+    this.#rejectPending();
+    this.#rejectSnapshotWaiters(new DisconnectedError);
+    if (this.#state !== undefined)
+      this.#update({ connection: "reconnecting" });
+    this.#beginRound();
+  }
+  rtcDiagnostics() {
+    const standby = this.#standby;
+    const cooldownRemainingMs = this.#cooldownRemainingMs();
+    let phase;
+    if (standby !== undefined)
+      phase = standby.phase;
+    else if (this.#dial?.p2p === true && this.#dial.phase === "ready")
+      phase = "active";
+    else if (this.#handoff !== undefined)
+      phase = "warm";
+    else if (cooldownRemainingMs > 0)
+      phase = "cooldown";
+    else if (this.#upgradeTimer !== undefined)
+      phase = "scheduled";
+    else
+      phase = "idle";
+    const failure = this.#p2pFailure;
+    return {
+      path: this.#activePath,
+      phase,
+      ...failure === undefined ? {} : {
+        lastFailure: {
+          stage: failure.stage,
+          ...failure.reason === undefined ? {} : { reason: failure.reason },
+          agoMs: Math.max(0, this.#now() - failure.atMs),
+          ...failure.pair === undefined ? {} : { pair: failure.pair }
+        }
+      },
+      ...this.#selectedPair === undefined ? {} : { selectedPair: this.#selectedPair },
+      cooldownRemainingMs
+    };
+  }
+  #clearTimerDial() {
+    if (this.#dial !== undefined)
+      this.#clearTimer(this.#dial);
+  }
+  #clearRoundTimer() {
+    if (this.#roundTimer === undefined)
+      return;
+    clearTimeout(this.#roundTimer);
+    this.#roundTimer = undefined;
+  }
+  #clearRoundTimers() {
+    this.#clearRoundTimer();
+    this.#clearTimerDial();
+  }
+  #clearBackoff() {
+    this.#backoffGeneration += 1;
+    if (this.#backoffTimer === undefined)
+      return;
+    clearTimeout(this.#backoffTimer);
+    this.#backoffTimer = undefined;
+  }
+  #clearTimers() {
+    for (const record of this.#submissionOrder)
+      this.#clearSubmissionTimer(record);
+    this.#clearRoundTimer();
+    this.#clearBackoff();
+    this.#clearUpgradeTimer();
+    this.#stopLiveness();
+    this.#clearStableTimer();
+    if (this.#dial !== undefined)
+      this.#clearTimer(this.#dial);
+  }
+  #stopCoordination() {
+    this.#clearUpgradeTimer();
+    this.#stopLiveness();
+    this.#clearStableTimer();
+    if (this.#handoff !== undefined)
+      this.#abortHandoff(new DisconnectedError);
+    if (this.#standby !== undefined) {
+      const standby = this.#standby;
+      this.#standby = undefined;
+      this.#clearStandbyTimers(standby);
+      try {
+        standby.connection?.close();
+      } catch {}
+      if (standby.signalOnly && standby.signal !== undefined) {
+        try {
+          standby.signal.close();
+        } catch {}
+      }
+    }
+    if (this.#signalAttempt !== undefined) {
+      const attempt = this.#signalAttempt;
+      this.#signalAttempt = undefined;
+      if (attempt.timer !== undefined)
+        this.#clock.clearTimeout(attempt.timer);
+      try {
+        attempt.connection?.close();
+      } catch {}
+    }
+  }
+  #stopListeners() {
+    this.#networkUnsubscribe?.();
+    this.#networkUnsubscribe = undefined;
+    this.#lifecycleUnsubscribe?.();
+    this.#lifecycleUnsubscribe = undefined;
+    this.#signalCleanup?.();
+    this.#signalCleanup = undefined;
+  }
+  #abort() {
+    if (this.#closed)
+      return;
+    this.#closed = true;
+    this.#clearTimers();
+    this.#stopCoordination();
+    this.#stopListeners();
+    this.#abandonDial();
+    this.#rejectPending();
+    this.#rejectSnapshotWaiters(new DisconnectedError);
+    this.#update({ connection: "closed" });
+    this.#rejectReady(new Error("Connection attempt aborted"));
+  }
+  #send(frame) {
+    this.#dial?.connection?.send(JSON.stringify(frame));
+  }
+  #receive(frame) {
+    if (frame === null || typeof frame !== "object")
+      return;
+    switch (frame.type) {
+      case "snapshot":
+        if (!this.#wanted.has(frame.stream))
+          return;
+        this.#values.set(frame.stream, frame.value);
+        this.#fresh.add(frame.stream);
+        this.#streamVersions.set(frame.stream, (this.#streamVersions.get(frame.stream) ?? 0) + 1);
+        this.#refresh();
+        for (const waiter of this.#snapshotWaiters.get(frame.stream)?.splice(0) ?? [])
+          waiter.resolve();
+        return;
+      case "ops":
+        if (!this.#wanted.has(frame.stream) || !this.#values.has(frame.stream))
+          return;
+        this.#values.set(frame.stream, applyImmutable(this.#values.get(frame.stream), frame.ops));
+        this.#refresh();
+        return;
+      case "ended": {
+        this.#wanted.delete(frame.stream);
+        this.#values.delete(frame.stream);
+        this.#fresh.delete(frame.stream);
+        const ended = new Error(`Stream ${frame.stream} ended: ${frame.reason}`);
+        for (const waiter of this.#snapshotWaiters.get(frame.stream)?.splice(0) ?? []) {
+          if (waiter.endSatisfies)
+            waiter.resolve();
+          else
+            waiter.reject(ended);
+        }
+        if (this.#current !== undefined && this.#conversationStreams(this.#current).includes(frame.stream)) {
+          this.#unshow();
+        } else if (this.#side !== undefined && this.#conversationStreams(this.#side).includes(frame.stream)) {
+          this.#side = undefined;
+        }
+        this.#refresh();
+        return;
+      }
+      case "result": {
+        const probe = this.#probes.get(frame.id);
+        if (probe !== undefined) {
+          this.#probes.delete(frame.id);
+          if (probe.timer !== undefined)
+            this.#clock.clearTimeout(probe.timer);
+          if (frame.ok && this.#dial?.generation === probe.generation) {
+            this.#livenessDeadline = Math.max(this.#livenessDeadline, this.#clock.now() + this.#livenessBudgetMs());
+          }
+          if (this.#standby?.phase === "warm")
+            this.#pollStandby(this.#standby);
+          return;
+        }
+        const pending = this.#pending.get(frame.id);
+        this.#pending.delete(frame.id);
+        if (frame.ok)
+          pending?.resolve(frame.value);
+        else
+          pending?.reject(new Error(frame.error));
+        if (this.#standby?.phase === "warm")
+          this.#pollStandby(this.#standby);
+        return;
+      }
+      case "notice":
+        this.#notice(frame.level, frame.message);
+        return;
+    }
+  }
+  #snapshot(stream, endSatisfies = false) {
+    if (!this.#wanted.has(stream))
+      return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      const waiters = this.#snapshotWaiters.get(stream) ?? [];
+      waiters.push({ resolve, reject, endSatisfies });
+      this.#snapshotWaiters.set(stream, waiters);
+    });
+  }
+  #syncStreams(hostMinor) {
+    const streams = new Set(hostStreams(hostMinor));
+    for (const id of [this.#current, this.#side]) {
+      if (id === undefined)
+        continue;
+      for (const stream of this.#conversationStreams(id))
+        streams.add(stream);
+    }
+    return [...streams];
+  }
+  #conversationStreams(id) {
+    return [conversationStream(id), ...this.#docs.map((doc) => docStream(doc.kind, id))];
+  }
+  async#acquire(id) {
+    const missing = this.#conversationStreams(id).filter((stream) => !this.#wanted.has(stream));
+    const stale = this.#conversationStreams(id).filter((stream) => this.#wanted.has(stream) && !this.#fresh.has(stream));
+    for (const stream of missing)
+      this.#wanted.add(stream);
+    const shown = Promise.all([...missing, ...stale].map((stream) => this.#snapshot(stream)));
+    for (const stream of missing) {
+      if (this.#helloReceived)
+        this.#subscribe(stream);
+    }
+    await shown;
+  }
+  #release(id, other) {
+    const keep = new Set(other === undefined ? [] : this.#conversationStreams(other));
+    for (const stream of this.#conversationStreams(id)) {
+      if (keep.has(stream))
+        continue;
+      this.#wanted.delete(stream);
+      this.#values.delete(stream);
+      this.#fresh.delete(stream);
+      for (const waiter of this.#snapshotWaiters.get(stream)?.splice(0) ?? [])
+        waiter.resolve();
+      this.#send({ type: "unsubscribe", stream });
+    }
+  }
+  #subscribe(stream) {
+    const refs = stream.startsWith("conversation:") && hostSupportsFeature(this.#hostMinor, "imageRefs");
+    this.#send({ type: "subscribe", stream, ...refs ? { images: "ref" } : {} });
+  }
+  #host(name) {
+    return this.#values.get(name);
+  }
+  #hostInfo() {
+    return {
+      protocol: { major: PROTOCOL.major, minor: this.#hostMinor },
+      ...this.#hostVersion === undefined ? {} : { version: this.#hostVersion }
+    };
+  }
+  #effectiveDefaults(fallback) {
+    const settings = this.#host("settings");
+    if (settings === undefined)
+      return fallback;
+    return {
+      ...settings.defaultModel === null ? {} : { model: settings.defaultModel },
+      ...settings.defaultThinkingLevel === null ? {} : { thinkingLevel: settings.defaultThinkingLevel }
+    };
+  }
+  #descendsFrom(id, ancestor) {
+    const summaries = this.#host("conversations") ?? [];
+    const parentOf = new Map(summaries.map((summary) => [summary.id, summary.parent]));
+    let cursor = id;
+    for (let depth = 0;cursor !== undefined && depth < 8; depth++) {
+      if (cursor === ancestor)
+        return true;
+      cursor = parentOf.get(cursor);
+    }
+    return false;
+  }
+  #loseSubmissions() {
+    for (const record of this.#submissionOrder) {
+      if (record.phase !== "inFlight" || record.admitted)
+        continue;
+      record.phase = "unknown";
+      this.#clearSubmissionTimer(record);
+    }
+  }
+  #activeSubmissions() {
+    return this.#submissionOrder.filter((record) => record.phase !== "settled").map((record) => ({
+      requestId: record.requestId,
+      ...record.conversationId === undefined ? {} : { conversationId: record.conversationId },
+      text: record.text,
+      whenBusy: record.whenBusy,
+      placement: record.placement,
+      phase: record.phase,
+      images: record.images,
+      ...record.imageViews === undefined ? {} : { imageViews: record.imageViews },
+      skills: record.skills ?? [],
+      attachments: record.attachments,
+      ...record.attachmentDetails === undefined ? {} : { attachmentDetails: record.attachmentDetails },
+      ...record.submissionId === undefined ? {} : { submissionId: record.submissionId },
+      ...record.entry === undefined ? {} : { entry: record.entry },
+      ...record.error === undefined ? {} : { error: record.error }
+    }));
+  }
+  #touchSubmissions() {
+    this.#refresh();
+  }
+  #startSubmissionTimer(record) {
+    this.#clearSubmissionTimer(record);
+    record.timer = setTimeout(() => {
+      record.timer = undefined;
+      if (this.#closed || record.phase === "settled" || record.admitted)
+        return;
+      if (record.phase === "inFlight")
+        record.phase = "unknown";
+      const resolve = record.timeoutResolve;
+      record.timeoutResolve = undefined;
+      this.#touchSubmissions();
+      resolve?.();
+    }, SUBMISSION_TIMEOUT_MS);
+  }
+  #armSubmissionDeadline(record) {
+    this.#startSubmissionTimer(record);
+    let resolve;
+    const deadline = new Promise((done) => {
+      resolve = done;
+    });
+    record.timeoutResolve = resolve;
+    return deadline;
+  }
+  #clearSubmissionTimer(record) {
+    const resolve = record.timeoutResolve;
+    record.timeoutResolve = undefined;
+    if (record.timer !== undefined) {
+      clearTimeout(record.timer);
+      record.timer = undefined;
+    }
+    resolve?.();
+  }
+  #submissionSettled(record) {
+    return record.phase === "settled";
+  }
+  #settleSubmission(record) {
+    if (this.#submissionSettled(record))
+      return;
+    record.phase = "settled";
+    record.error = undefined;
+    this.#clearSubmissionTimer(record);
+  }
+  #entriesOf(id) {
+    if (id === undefined)
+      return [];
+    const view = this.#values.get(conversationStream(id));
+    return view?.entries ?? [];
+  }
+  #entryPresent(record) {
+    if (record.entry === undefined)
+      return false;
+    return this.#entriesOf(record.conversationId).some((entry) => String(entry.id) === String(record.entry));
+  }
+  #inboxHas(record) {
+    if (record.conversationId === undefined || record.submissionId === undefined)
+      return false;
+    const inbox = this.#values.get(docStream("pi.inbox", record.conversationId));
+    return (inbox?.items ?? []).some((item) => String(item.id) === String(record.submissionId));
+  }
+  #applySubmissionRecord(record, found) {
+    record.admitted = true;
+    record.submissionId = found.submissionId;
+    record.error = undefined;
+    this.#clearSubmissionTimer(record);
+    if (found.entry !== undefined)
+      record.entry = found.entry;
+    if (record.entry !== undefined) {
+      if (this.#entryPresent(record) || found.status === "done")
+        this.#settleSubmission(record);
+      else
+        record.phase = "inFlight";
+    } else if (this.#inboxHas(record)) {
+      this.#settleSubmission(record);
+    } else if (found.status === "placed" || found.status === "done" || found.status === "unanswered") {
+      this.#settleSubmission(record);
+    } else {
+      record.phase = "inFlight";
+    }
+    this.#touchSubmissions();
+  }
+  #reconcileSubmissions() {
+    for (const record of this.#submissionOrder) {
+      if (record.phase === "settled" || record.submissionId === undefined)
+        continue;
+      if (this.#entryPresent(record) || this.#inboxHas(record)) {
+        this.#settleSubmission(record);
+        continue;
+      }
+      if (record.conversationId !== undefined && record.submissionId !== undefined && record.admitted && (record.entry !== undefined || !this.#inboxHas(record))) {
+        const stream = conversationStream(record.conversationId);
+        const version = (this.#streamVersions.get(stream) ?? 0) + (this.#streamVersions.get(docStream("pi.inbox", record.conversationId)) ?? 0);
+        if (this.#fresh.has(stream) && record.checkedVersion !== version) {
+          record.checkedVersion = version;
+          this.#confirmSubmission(record);
+        }
+      }
+    }
+  }
+  #querySubmission(record, direct = false) {
+    if (!hostSupportsCall(this.#hostMinor, "submission")) {
+      return Promise.reject(new Error("The host is too old for submission receipts (needs protocol 5.25); run `pinomad upgrade` on the host"));
+    }
+    if (record.conversationId === undefined) {
+      return Promise.reject(new Error("No conversation selected"));
+    }
+    const args = { conversationId: record.conversationId, requestId: record.requestId };
+    const call = direct ? this.#callNow("submission", args) : this.#call("submission", args);
+    return call;
+  }
+  async#confirmSubmission(record) {
+    if (record.confirming || record.phase === "settled" || !hostSupportsCall(this.#hostMinor, "submission"))
+      return;
+    record.confirming = true;
+    try {
+      const found = await this.#querySubmission(record);
+      if (this.#closed || this.#submissionSettled(record))
+        return;
+      if (found !== null) {
+        this.#applySubmissionRecord(record, found);
+      } else if (record.admitted && record.entry === undefined) {
+        this.#settleSubmission(record);
+        this.#touchSubmissions();
+      }
+    } catch {} finally {
+      record.confirming = false;
+    }
+  }
+  #submissionArgs(record) {
+    const conversationId = record.conversationId;
+    if (conversationId === undefined)
+      throw new Error("No conversation selected");
+    return {
+      conversationId,
+      text: record.text,
+      whenBusy: record.whenBusy,
+      requestId: record.requestId,
+      ...record.images.length === 0 ? {} : { images: record.images },
+      ...this.#boundSkills(record.skills),
+      ...record.attachments.length === 0 ? {} : { attachments: record.attachments }
+    };
+  }
+  #validateSubmission(record) {
+    if (record.images.length > 0 && !hostSupportsFeature(this.#hostMinor, "images")) {
+      throw new Error("The host is too old for images (needs protocol 5.5); run `pinomad upgrade` on the host");
+    }
+    if (needsImageRefs(record.images) && !hostSupportsFeature(this.#hostMinor, "imageRefs")) {
+      throw new Error("The host is too old for image refs (needs protocol 5.15); run `pinomad upgrade` on the host");
+    }
+    if (record.attachments.length > MAX_ATTACHMENTS_PER_MESSAGE) {
+      throw new Error("At most " + MAX_ATTACHMENTS_PER_MESSAGE + " attachments per message");
+    }
+    if (record.attachments.length > 0 && !hostSupportsFeature(this.#hostMinor, "attachments")) {
+      throw new Error("The host is too old for attachments (needs protocol 5.19); run `pinomad upgrade` on the host");
+    }
+  }
+  #applySubmitResult(record, result) {
+    if (this.#closed)
+      return;
+    this.#clearSubmissionTimer(record);
+    record.admitted = true;
+    record.submissionId = result.submissionId;
+    if (result.entry !== undefined)
+      record.entry = result.entry;
+    if (!hostSupportsFeature(this.#hostMinor, "submitEntry")) {
+      this.#settleSubmission(record);
+    } else if (record.entry !== undefined) {
+      record.phase = "inFlight";
+      if (this.#entryPresent(record))
+        this.#settleSubmission(record);
+    } else {
+      record.phase = "inFlight";
+      if (record.conversationId !== undefined) {
+        record.checkedVersion = (this.#streamVersions.get(conversationStream(record.conversationId)) ?? 0) + (this.#streamVersions.get(docStream("pi.inbox", record.conversationId)) ?? 0);
+      }
+      this.#confirmSubmission(record);
+    }
+    this.#touchSubmissions();
+  }
+  #applySubmitError(record, error) {
+    if (this.#closed)
+      return;
+    this.#clearSubmissionTimer(record);
+    if (error instanceof DisconnectedError || error instanceof Error && error.message === "Not connected to the host") {
+      record.phase = "unknown";
+    } else {
+      record.phase = "failed";
+      record.error = error instanceof Error ? error.message : String(error);
+    }
+    this.#touchSubmissions();
+  }
+  async#sendSubmission(record, direct, deadline) {
+    if (record.phase === "settled" || this.#closed)
+      return;
+    if (deadline !== undefined && record.timer === undefined) {
+      if (record.phase !== "failed") {
+        record.phase = "unknown";
+        this.#touchSubmissions();
+      }
+      return;
+    }
+    record.phase = "inFlight";
+    record.error = undefined;
+    const call = direct ? this.#callNow("submit", this.#submissionArgs(record)) : this.#call("submit", this.#submissionArgs(record));
+    const timedOut = deadline ?? this.#armSubmissionDeadline(record);
+    this.#touchSubmissions();
+    const handled = (async () => {
+      try {
+        const result = await call;
+        this.#applySubmitResult(record, result);
+      } catch (error) {
+        this.#applySubmitError(record, error);
+      }
+    })();
+    await Promise.race([handled, timedOut]);
+  }
+  async#runSubmission(record) {
+    if (record.phase === "settled" || this.#closed)
+      return;
+    try {
+      this.#validateSubmission(record);
+    } catch (error) {
+      if (this.#closed)
+        return;
+      record.phase = "failed";
+      record.error = error instanceof Error ? error.message : String(error);
+      this.#touchSubmissions();
+      return;
+    }
+    if (!record.fixed) {
+      const target = this.#current;
+      if (target === undefined) {
+        record.phase = "failed";
+        record.error = "No conversation selected";
+        this.#touchSubmissions();
+        return;
+      }
+      record.conversationId = target;
+      record.fixed = true;
+    }
+    await this.#sendSubmission(record, false);
+  }
+  async#recoverSubmissions() {
+    const unknown = this.#submissionOrder.filter((record) => record.phase === "unknown");
+    if (this.#syncGate === undefined && unknown.some((record) => record.fixed) && hostSupportsCall(this.#hostMinor, "submission")) {
+      this.#syncGate = { entries: [] };
+    }
+    for (const record of unknown) {
+      if (this.#closed || record.phase !== "unknown" || !record.fixed)
+        continue;
+      try {
+        if (!hostSupportsCall(this.#hostMinor, "submission")) {
+          continue;
+        }
+        const deadline = this.#armSubmissionDeadline(record);
+        const found = await this.#querySubmissionWithinDeadline(record, true, deadline);
+        if (found === "deadline")
+          continue;
+        if (found !== null) {
+          this.#applySubmissionRecord(record, found);
+          continue;
+        }
+        if (record.phase !== "unknown" || record.timer === undefined)
+          continue;
+        await this.#sendSubmission(record, true, deadline);
+      } catch (error) {
+        if (this.#closed)
+          return;
+        this.#clearSubmissionTimer(record);
+        record.phase = "unknown";
+        this.#touchSubmissions();
+        if (error instanceof DisconnectedError || error instanceof Error && error.message === "Not connected to the host") {
+          return;
+        }
+      }
+    }
+  }
+  #submissionDraft(record, images = record.images) {
+    return {
+      text: record.text,
+      whenBusy: record.whenBusy,
+      images,
+      skills: record.skills ?? [],
+      attachments: record.attachments,
+      ...record.attachmentDetails === undefined ? {} : { attachmentDetails: record.attachmentDetails }
+    };
+  }
+  async#resolveSubmissionImages(record) {
+    const views = record.imageViews ?? record.images;
+    const resolved = [];
+    for (const image of views) {
+      if ("data" in image) {
+        resolved.push(image);
+      } else {
+        const bytes = await this.#call("image", { ref: image.ref });
+        resolved.push({ data: bytes.data, mimeType: bytes.mimeType });
+      }
+    }
+    return resolved;
+  }
+  async#querySubmissionWithinDeadline(record, direct, deadline) {
+    const query = this.#querySubmission(record, direct);
+    const outcome = await Promise.race([
+      query.then((found) => ({ kind: "found", found }), (error) => ({ kind: "error", error })),
+      deadline.then(() => ({ kind: "deadline" }))
+    ]);
+    if (outcome.kind === "deadline") {
+      query.then((found) => {
+        if (this.#closed || found === null || record.phase === "settled")
+          return;
+        this.#applySubmissionRecord(record, found);
+      }, () => {});
+      return "deadline";
+    }
+    if (outcome.kind === "error")
+      throw outcome.error;
+    return outcome.found;
+  }
+  async#retrySubmission(record) {
+    if (record.phase !== "unknown" && record.phase !== "failed")
+      return;
+    const deadline = this.#armSubmissionDeadline(record);
+    try {
+      if (record.phase === "unknown" && hostSupportsCall(this.#hostMinor, "submission")) {
+        const found = await this.#querySubmissionWithinDeadline(record, false, deadline);
+        if (found === "deadline")
+          return;
+        if (found !== null) {
+          this.#applySubmissionRecord(record, found);
+          return;
+        }
+        if (record.phase !== "unknown" || record.timer === undefined)
+          return;
+      }
+      await this.#sendSubmission(record, false, deadline);
+    } catch (error) {
+      if (this.#closed)
+        return;
+      this.#clearSubmissionTimer(record);
+      if (error instanceof DisconnectedError || error instanceof Error && error.message === "Not connected to the host") {
+        record.phase = "unknown";
+        record.error = undefined;
+        this.#touchSubmissions();
+        return;
+      }
+      record.phase = "failed";
+      record.error = error instanceof Error ? error.message : String(error);
+      this.#touchSubmissions();
+      throw error;
+    }
+  }
+  async#takeBackSubmission(record) {
+    let resolved;
+    const images = async () => {
+      if (resolved !== undefined)
+        return resolved;
+      try {
+        resolved = await this.#resolveSubmissionImages(record);
+        return resolved;
+      } catch {
+        throw new Error("Couldn't load the original images — try again");
+      }
+    };
+    if (record.phase === "queued" || record.phase === "failed") {
+      const draft2 = await images();
+      this.#settleSubmission(record);
+      this.#touchSubmissions();
+      return this.#submissionDraft(record, draft2);
+    }
+    if (record.phase !== "unknown" && !(record.phase === "inFlight" && record.submissionId !== undefined)) {
+      return;
+    }
+    if (!hostSupportsCall(this.#hostMinor, "submission"))
+      return;
+    const found = await this.#querySubmission(record);
+    if (found === null) {
+      const draft2 = await images();
+      this.#settleSubmission(record);
+      this.#touchSubmissions();
+      return this.#submissionDraft(record, draft2);
+    }
+    this.#applySubmissionRecord(record, found);
+    if (this.#submissionSettled(record))
+      return;
+    if (found.status === "placed" || found.status === "done" || found.entry !== undefined)
+      return;
+    if (found.status === "unanswered") {
+      const draft2 = await images();
+      this.#settleSubmission(record);
+      this.#touchSubmissions();
+      return this.#submissionDraft(record, draft2);
+    }
+    if (record.conversationId === undefined)
+      return;
+    const draft = await images();
+    const { outcome } = await this.#call("withdrawQueued", {
+      conversationId: record.conversationId,
+      submissionId: found.submissionId
+    });
+    if (outcome === "sent") {
+      this.#settleSubmission(record);
+      this.#touchSubmissions();
+      return;
+    }
+    this.#settleSubmission(record);
+    this.#touchSubmissions();
+    return this.#submissionDraft(record, draft);
+  }
+  #docsOf(id) {
+    return this.#docs.flatMap((doc) => {
+      const stream = docStream(doc.kind, id);
+      return this.#values.has(stream) ? [{ kind: doc.kind, presentation: doc.presentation, value: this.#values.get(stream) }] : [];
+    });
+  }
+  #refresh() {
+    if (this.#state === undefined)
+      return;
+    this.#reconcileSubmissions();
+    const current = this.#current;
+    const side = this.#side;
+    const conversation = current === undefined ? undefined : this.#values.get(conversationStream(current));
+    const summaries = this.#host("conversations") ?? [];
+    const index = this.#host("index") ?? { projects: [], conversations: [] };
+    const devices = this.#host("devices")?.devices ?? [];
+    const tasks = this.#wanted.has("tasks") ? this.#values.get("tasks") : undefined;
+    this.#update({
+      conversation,
+      models: this.#host("models") ?? this.#helloModels,
+      organized: organize(index, summaries),
+      home: current === undefined ? undefined : homeOf(index, summaries, current),
+      checkout: current === undefined ? undefined : checkoutOf(index, summaries, current),
+      tasks,
+      docs: current === undefined ? [] : this.#docsOf(current),
+      submissions: this.#activeSubmissions(),
+      side: side === undefined ? undefined : {
+        id: side,
+        conversation: this.#values.get(conversationStream(side)),
+        docs: this.#docsOf(side)
+      },
+      devices,
+      mcp: this.#host("mcp") ?? null,
+      auth: this.#host("auth") ?? null,
+      providers: this.#host("providers") ?? null,
+      settings: this.#host("settings") ?? null,
+      agents: this.#host("agents") ?? null,
+      defaults: this.#effectiveDefaults(this.#helloDefaults)
+    });
+  }
+  #update(patch) {
+    if (this.#state === undefined)
+      return;
+    this.#state = { ...this.#state, ...patch };
+    if (this.#notifying)
+      return;
+    this.#notifying = true;
+    queueMicrotask(() => {
+      this.#notifying = false;
+      for (const listener of this.#listeners)
+        listener();
+    });
+  }
+  #boundSkills(skills) {
+    return skills === undefined || !hostSupportsFeature(this.#hostMinor, "boundSkills") ? {} : { skills };
+  }
+  #notice(level, message) {
+    if (this.#state === undefined)
+      return;
+    this.#update({ notices: [...this.#state.notices, { id: this.#nextNotice++, level, message }].slice(-20) });
+  }
+  #requireProviders() {
+    if (!hostSupportsCall(this.#hostMinor, "beginLogin")) {
+      throw new Error("The host is too old for this (needs protocol 5.21); run `pinomad upgrade` on the host");
+    }
+  }
+  #call(method, args) {
+    const handoff = this.#handoff;
+    if (handoff !== undefined || this.#syncGate !== undefined) {
+      const id = this.#nextCall++;
+      const frame = { type: "call", id, method, args };
+      const entries = handoff?.entries ?? this.#syncGate.entries;
+      return new Promise((resolve, reject) => {
+        entries.push({ id, frame, resolve, reject });
+      });
+    }
+    if (this.#dial?.phase !== "ready" || this.#state?.connection !== "connected") {
+      return Promise.reject(new Error("Not connected to the host"));
+    }
+    return this.#deliverCall(this.#dial, this.#nextCall++, method, args);
+  }
+  #callNow(method, args) {
+    if (this.#dial?.phase !== "ready" || this.#state?.connection !== "connected") {
+      return Promise.reject(new Error("Not connected to the host"));
+    }
+    return this.#deliverCall(this.#dial, this.#nextCall++, method, args);
+  }
+  #deliverCall(dial, id, method, args) {
+    if (!this.#isActive(dial) || dial.phase !== "ready" || dial.connection === undefined) {
+      return Promise.reject(new Error("Not connected to the host"));
+    }
+    return new Promise((resolve, reject) => {
+      this.#pending.set(id, { resolve, reject });
+      try {
+        dial.connection.send(JSON.stringify({ type: "call", id, method, args }));
+      } catch (error) {
+        this.#pending.delete(id);
+        reject(asError(error));
+      }
+    });
+  }
+  #command(operation) {
+    this.#commands = this.#commands.then(operation).then(() => {}, (error) => this.#notice("error", error instanceof Error ? error.message : String(error)));
+    return this.#commands;
+  }
+  #request(operation) {
+    const request = this.#commands.then(operation);
+    this.#commands = request.then(() => {}, () => {});
+    return request;
+  }
+  #viewSource() {
+    return {
+      current: () => this.#state,
+      subscribe: (listener) => {
+        this.#listeners.add(listener);
+        return () => this.#listeners.delete(listener);
+      }
+    };
+  }
+  #controller() {
+    const newRequestId = () => Array.from(crypto.getRandomValues(new Uint8Array(16)), (byte) => byte.toString(16).padStart(2, "0")).join("");
+    const conversationId = () => {
+      if (this.#current === undefined)
+        throw new Error("No conversation selected");
+      return this.#current;
+    };
+    return {
+      addProject: (path) => this.#request(() => this.#call("addProject", { path })),
+      listFolders: (path) => this.#request(() => {
+        if (!hostSupportsCall(this.#hostMinor, "listFolders")) {
+          throw new Error("The host is too old for this (needs protocol 5.3); run `pinomad upgrade` on the host");
+        }
+        return this.#call("listFolders", path === undefined ? {} : { path });
+      }),
+      removeProject: (path) => this.#command(() => this.#call("removeProject", { path })),
+      renameConversation: (id, title) => this.#request(async () => {
+        if (!hostSupportsCall(this.#hostMinor, "renameConversation")) {
+          throw new Error("The host is too old for this (needs protocol 5.4); run `pinomad upgrade` on the host");
+        }
+        await this.#call("renameConversation", { conversationId: id, title });
+      }),
+      createConversation: (home, text, options) => this.#command(async () => {
+        const images = options?.images ?? [];
+        if (images.length > 0 && !hostSupportsFeature(this.#hostMinor, "images")) {
+          throw new Error("The host is too old for images (needs protocol 5.5); run `pinomad upgrade` on the host");
+        }
+        if (needsImageRefs(images) && !hostSupportsFeature(this.#hostMinor, "imageRefs")) {
+          throw new Error("The host is too old for image refs (needs protocol 5.15); run `pinomad upgrade` on the host");
+        }
+        const attachments = options?.attachments ?? [];
+        if (attachments.length > MAX_ATTACHMENTS_PER_MESSAGE) {
+          throw new Error(`At most ${MAX_ATTACHMENTS_PER_MESSAGE} attachments per message`);
+        }
+        if (attachments.length > 0 && !hostSupportsFeature(this.#hostMinor, "attachments")) {
+          throw new Error("The host is too old for attachments (needs protocol 5.19); run `pinomad upgrade` on the host");
+        }
+        if (options?.agent !== undefined && !hostSupportsFeature(this.#hostMinor, "agentConversations")) {
+          throw new Error("The host is too old for named agents (needs protocol 5.10); run `pinomad upgrade` on the host");
+        }
+        const { conversationId: conversationId2 } = await this.#call("createConversation", {
+          home,
+          text,
+          requestId: newRequestId(),
+          ...options?.checkout === undefined ? {} : { checkout: options.checkout },
+          ...options?.model === undefined ? {} : { model: options.model },
+          ...options?.thinkingLevel === undefined ? {} : { thinkingLevel: options.thinkingLevel },
+          ...options?.agent === undefined ? {} : { agent: options.agent },
+          ...images.length === 0 ? {} : { images },
+          ...this.#boundSkills(options?.skills),
+          ...attachments.length === 0 ? {} : { attachments }
+        });
+        await this.#switch(conversationId2);
+      }),
+      archive: (id, archived) => this.#command(async () => {
+        await this.#call("archive", { conversationId: id, archived });
+        if (archived && id === this.#current)
+          this.#unshow();
+        if (archived && this.#side !== undefined && this.#descendsFrom(this.#side, id))
+          await this.#showSide(undefined);
+      }),
+      submit: (text, whenBusy, options) => {
+        const requestId = options?.requestId ?? newRequestId();
+        if (this.#submissions.has(requestId))
+          return Promise.resolve();
+        const target = options?.target ?? this.#current;
+        const shown = target === undefined ? undefined : this.#values.get(conversationStream(target));
+        const record = {
+          requestId,
+          text,
+          whenBusy,
+          placement: shown !== undefined && isBusy(shown) ? "queue" : "conversation",
+          images: options?.images ?? [],
+          ...options?.imageViews === undefined ? {} : { imageViews: options.imageViews },
+          ...options?.skills === undefined ? {} : { skills: options.skills },
+          attachments: options?.attachments ?? [],
+          ...options?.attachmentDetails === undefined ? {} : { attachmentDetails: options.attachmentDetails },
+          phase: "queued",
+          ...target === undefined ? {} : { conversationId: target },
+          fixed: options?.target !== undefined,
+          admitted: false,
+          confirming: false
+        };
+        this.#submissions.set(requestId, record);
+        this.#submissionOrder.push(record);
+        this.#touchSubmissions();
+        return this.#request(() => this.#runSubmission(record)).then(() => {}, () => {});
+      },
+      retrySubmission: (requestId) => {
+        const record = this.#submissions.get(requestId);
+        if (record === undefined || this.#submissionLocks.has(requestId))
+          return Promise.resolve();
+        this.#submissionLocks.add(requestId);
+        return this.#request(() => this.#retrySubmission(record)).finally(() => this.#submissionLocks.delete(requestId));
+      },
+      takeBackSubmission: (requestId) => {
+        const record = this.#submissions.get(requestId);
+        if (record === undefined || this.#submissionLocks.has(requestId))
+          return Promise.resolve(undefined);
+        this.#submissionLocks.add(requestId);
+        return this.#request(() => this.#takeBackSubmission(record)).finally(() => this.#submissionLocks.delete(requestId));
+      },
+      compact: (instructions) => this.#command(() => this.#call("compact", { conversationId: conversationId(), ...instructions === undefined ? {} : { instructions } })),
+      runCommand: (name, args, target) => this.#command(() => {
+        if (!hostSupportsCall(this.#hostMinor, "runCommand")) {
+          throw new Error("The host is too old for this (needs protocol 5.17); run `pinomad upgrade` on the host");
+        }
+        return this.#call("runCommand", {
+          conversationId: target ?? conversationId(),
+          name,
+          ...args === undefined ? {} : { args }
+        });
+      }),
+      abort: (target) => {
+        const targetConversation = target ?? this.#current;
+        if (targetConversation === undefined) {
+          this.#notice("error", "No conversation selected");
+          return Promise.resolve();
+        }
+        return this.#call("abort", { conversationId: targetConversation }).then(() => {}, (error) => this.#notice("error", error instanceof Error ? error.message : String(error)));
+      },
+      withdrawQueued: (submissionId, target) => this.#request(async () => {
+        if (!hostSupportsCall(this.#hostMinor, "withdrawQueued")) {
+          throw new Error("The host is too old for this (needs protocol 5.14); run `pinomad upgrade` on the host");
+        }
+        const { outcome } = await this.#call("withdrawQueued", {
+          conversationId: target ?? conversationId(),
+          submissionId
+        });
+        return outcome;
+      }),
+      steerQueued: (submissionId, target) => this.#request(async () => {
+        if (!hostSupportsCall(this.#hostMinor, "steerQueued")) {
+          throw new Error("The host is too old for this (needs protocol 5.14); run `pinomad upgrade` on the host");
+        }
+        const { outcome } = await this.#call("steerQueued", {
+          conversationId: target ?? conversationId(),
+          submissionId
+        });
+        return outcome;
+      }),
+      setThinkingLevel: (level) => this.#command(() => this.#call("setThinkingLevel", { conversationId: conversationId(), level })),
+      setModel: (model) => this.#command(() => this.#call("setModel", { conversationId: conversationId(), model })),
+      setAgent: (agent) => this.#command(() => {
+        if (!hostSupportsCall(this.#hostMinor, "setAgent")) {
+          throw new Error("The host is too old for this (needs protocol 5.18); run `pinomad upgrade` on the host");
+        }
+        return this.#call("setAgent", { conversationId: conversationId(), agent });
+      }),
+      toggleTasks: () => this.#command(async () => {
+        if (this.#wanted.delete("tasks")) {
+          this.#send({ type: "unsubscribe", stream: "tasks" });
+          this.#values.delete("tasks");
+          this.#refresh();
+          return;
+        }
+        this.#wanted.add("tasks");
+        const shown = this.#snapshot("tasks");
+        this.#send({ type: "subscribe", stream: "tasks" });
+        await shown;
+      }),
+      switchConversation: (id) => this.#command(() => this.#switch(id)),
+      showSide: (id) => this.#command(() => this.#showSide(id)),
+      clearConversation: () => this.#command(() => this.#clear()),
+      fork: (entryId, prompt, removeTools, options) => this.#command(async () => {
+        const { conversationId: forked } = await this.#call("fork", {
+          conversationId: conversationId(),
+          entryId,
+          ...removeTools === undefined ? {} : { removeTools }
+        });
+        if (options?.show === "side")
+          await this.#showSide(forked);
+        else
+          await this.#switch(forked);
+        await this.#call("submit", { conversationId: forked, text: prompt, whenBusy: "followUp", requestId: newRequestId() });
+      }),
+      answer: (kind, requestId, answers, target) => this.#command(() => this.#call("answer", { conversationId: target ?? conversationId(), kind, requestId, answers })),
+      changes: () => this.#request(() => this.#call("changes", { conversationId: conversationId() })),
+      listFiles: (scope, query) => {
+        if (!hostSupportsCall(this.#hostMinor, "listFiles")) {
+          return Promise.reject(new Error("The host is too old for this (needs protocol 5.10); run `pinomad upgrade` on the host"));
+        }
+        return this.#call("listFiles", { scope, query });
+      },
+      beginAttachment: (name, size) => {
+        if (!hostSupportsCall(this.#hostMinor, "beginAttachment")) {
+          return Promise.reject(new Error("The host is too old for attachments (needs protocol 5.19); run `pinomad upgrade` on the host"));
+        }
+        return this.#call("beginAttachment", { name, size }).then(({ attachmentId }) => attachmentId);
+      },
+      appendAttachment: (attachmentId, offset, data) => {
+        if (!hostSupportsCall(this.#hostMinor, "appendAttachment")) {
+          return Promise.reject(new Error("The host is too old for attachments (needs protocol 5.19); run `pinomad upgrade` on the host"));
+        }
+        return this.#call("appendAttachment", { attachmentId, offset, data });
+      },
+      image: (ref, variant = "original") => {
+        if (!hostSupportsCall(this.#hostMinor, "image")) {
+          return Promise.reject(new Error("The host is too old for this (needs protocol 5.15); run `pinomad upgrade` on the host"));
+        }
+        const derived = variant !== "original" && hostSupportsFeature(this.#hostMinor, "imageVariants");
+        return this.#call("image", { ref, ...derived ? { variant } : {} });
+      },
+      listSkills: (scope) => {
+        if (!hostSupportsCall(this.#hostMinor, "listSkills")) {
+          return Promise.reject(new Error("The host is too old for this (needs protocol 5.13); run `pinomad upgrade` on the host"));
+        }
+        return this.#call("listSkills", { scope });
+      },
+      listCommands: (id) => {
+        if (!hostSupportsCall(this.#hostMinor, "listCommands")) {
+          return Promise.reject(new Error("The host is too old for this (needs protocol 5.17); run `pinomad upgrade` on the host"));
+        }
+        return this.#call("listCommands", { conversationId: id });
+      },
+      createPairing: () => this.#request(() => this.#call("createPairing", {})),
+      revokeDevice: (publicKey) => this.#command(() => this.#call("revokeDevice", { publicKey })),
+      logout: (providerId) => this.#command(() => {
+        if (!hostSupportsCall(this.#hostMinor, "logout")) {
+          throw new Error("The host is too old for this (needs protocol 5.1); run `pinomad upgrade` on the host");
+        }
+        return this.#call("logout", { providerId });
+      }),
+      beginLogin: (providerId, method) => this.#request(async () => {
+        this.#requireProviders();
+        return (await this.#call("beginLogin", { providerId, method })).loginId;
+      }),
+      answerLogin: (loginId, promptId, value) => this.#request(async () => {
+        this.#requireProviders();
+        await this.#call("answerLogin", { loginId, promptId, value });
+      }),
+      cancelLogin: (loginId) => this.#request(async () => {
+        this.#requireProviders();
+        await this.#call("cancelLogin", { loginId });
+      }),
+      saveCustomProvider: (provider, apiKey) => this.#request(async () => {
+        this.#requireProviders();
+        await this.#call("saveCustomProvider", apiKey === undefined ? { provider } : { provider, apiKey });
+      }),
+      removeCustomProvider: (providerId) => this.#request(async () => {
+        this.#requireProviders();
+        await this.#call("removeCustomProvider", { providerId });
+      }),
+      listEndpointModels: async (input) => {
+        this.#requireProviders();
+        return (await this.#call("listEndpointModels", input)).models;
+      },
+      updateSettings: (patch) => this.#command(() => {
+        if (!hostSupportsCall(this.#hostMinor, "updateSettings")) {
+          throw new Error("The host is too old for this (needs protocol 5.2); run `pinomad upgrade` on the host");
+        }
+        if (patch.acceptAccountDevices !== undefined && !hostSupportsFeature(this.#hostMinor, "acceptAccountDevices")) {
+          throw new Error("The host is too old for this (needs protocol 5.8); run `pinomad upgrade` on the host");
+        }
+        if (patch.hostName !== undefined && !hostSupportsFeature(this.#hostMinor, "hostName")) {
+          throw new Error("The host is too old for this (needs protocol 5.12); run `pinomad upgrade` on the host");
+        }
+        return this.#call("updateSettings", { patch });
+      }),
+      createAgent: (role) => this.#request(async () => {
+        if (!hostSupportsCall(this.#hostMinor, "createAgent")) {
+          throw new Error("The host is too old for this (needs protocol 5.6); run `pinomad upgrade` on the host");
+        }
+        await this.#call("createAgent", { role });
+      }),
+      updateAgent: (role) => this.#request(async () => {
+        if (!hostSupportsCall(this.#hostMinor, "updateAgent")) {
+          throw new Error("The host is too old for this (needs protocol 5.6); run `pinomad upgrade` on the host");
+        }
+        await this.#call("updateAgent", { role });
+      }),
+      deleteAgent: (name) => this.#request(async () => {
+        if (!hostSupportsCall(this.#hostMinor, "deleteAgent")) {
+          throw new Error("The host is too old for this (needs protocol 5.6); run `pinomad upgrade` on the host");
+        }
+        await this.#call("deleteAgent", { name });
+      }),
+      setPushToken: (token) => this.#request(async () => {
+        if (!hostSupportsCall(this.#hostMinor, "setPushToken")) {
+          throw new Error("The host is too old for this (needs protocol 5.7); run `pinomad upgrade` on the host");
+        }
+        if (token !== null && typeof token !== "string" && !hostSupportsFeature(this.#hostMinor, "apnsPush")) {
+          throw new Error("The host is too old for this (needs protocol 5.9); run `pinomad upgrade` on the host");
+        }
+        await this.#call("setPushToken", { token });
+      })
+    };
+  }
+  async#switch(id) {
+    const previous = this.#current;
+    if (id === previous)
+      return;
+    await this.#acquire(id);
+    this.#current = id;
+    if (previous !== undefined)
+      this.#release(previous, this.#side);
+    this.#refresh();
+  }
+  #unshow() {
+    const previous = this.#current;
+    if (previous === undefined)
+      return;
+    this.#current = undefined;
+    this.#release(previous, this.#side);
+    this.#refresh();
+  }
+  async#clear() {
+    this.#unshow();
+    await this.#showSide(undefined);
+  }
+  async#showSide(id) {
+    const previous = this.#side;
+    if (id === previous)
+      return;
+    if (id !== undefined)
+      await this.#acquire(id);
+    this.#side = id;
+    if (previous !== undefined)
+      this.#release(previous, this.#current);
+    this.#refresh();
+  }
+  #close() {
+    if (this.#closed)
+      return;
+    this.#closed = true;
+    this.#clearTimers();
+    this.#stopCoordination();
+    this.#stopListeners();
+    this.#abandonDial();
+    this.#rejectPending();
+    this.#rejectSnapshotWaiters(new DisconnectedError);
+    this.#update({ connection: "closed" });
+  }
+}
+
+export { connectRemoteDurable, ProtocolMismatchError };