@athenaintel/react 0.57.2 → 0.59.0

package/dist/agent-runtime/src/chat-outbox.js

@@ -1,7 +1,14 @@
+import { withAddressedAgents } from "./addressed-agents.js";
+import { withoutTransientLocalMeta, readChatOutboxLocalMeta, CHAT_OUTBOX_LOCAL_META_KIND, chatOutboxEntryOf } from "./chat-outbox-entry.js";
+import { migrateLegacyChatOutbox } from "./chat-outbox-legacy.js";
+import { chatOutboxWireAnchorId } from "./chat-outbox-thread.js";
+import { reanchorRunSend } from "./statewire-held-sends.js";
+import { DEEP_AGENT_STATEWIRE_PROTOCOL } from "./statewire-transport.js";
 const CHAT_OUTBOX_COUNTDOWN_MS = 5e3;
 const CHAT_OUTBOX_ASK_AFTER_MS = 24 * 60 * 60 * 1e3;
-const CHAT_OUTBOX_CLAIM_LEASE_MS = 3e4;
 const CHAT_OUTBOX_ATTACHMENT_CHECK_TIMEOUT_MS = 15e3;
+const CHAT_OUTBOX_ATTACHMENT_REFUSED_CODE = "attachment-unavailable";
+const CHAT_OUTBOX_ATTACHMENT_UNKNOWN_CODE = "attachment-check-failed";
 const CHAT_EDIT_UNREACHABLE_LABEL = "Can't edit while Athena can't be reached";
 const CHAT_EDIT_KEPT_MESSAGE = "Can't reach Athena right now. Your edit stays here — submit it once Athena is back.";
 class ChatEditUnreachableError extends Error {
@@ -11,51 +18,59 @@ class ChatEditUnreachableError extends Error {
   }
 }
 function chatOutboxFailureMessage(reason) {
-  switch (reason) {
-    case "refused":
-      return "This conversation can't be reached right now.";
-    case "prepare":
-      return "Couldn't prepare this message to send.";
-    case "attachment":
-      return "An attachment is no longer available to you.";
-    default:
-      return "Couldn't send this message.";
-  }
-}
-const AWAY_CAUSES = /* @__PURE__ */ new Set(["unmount", "stream-gone"]);
-function chatOutboxCommandMessageId(params) {
-  var _a;
-  const first = params == null ? void 0 : params[0];
-  const id = (_a = first == null ? void 0 : first.message) == null ? void 0 : _a.id;
-  return typeof id === "string" ? id : null;
+  return reason === "attachment" ? "An attachment is no longer available to you." : "Couldn't send this message.";
 }
-function failureOf(error) {
-  const failure = error == null ? void 0 : error.failure;
-  const fate = typeof (failure == null ? void 0 : failure.fate) === "string" ? failure.fate : void 0;
-  const cause = typeof (failure == null ? void 0 : failure.cause) === "string" ? failure.cause : void 0;
-  const message = error instanceof Error ? error.message : String(error);
-  return { fate, cause, message };
-}
-function defaultMessageId() {
+const MIGRATION_CONFIRM_ATTEMPTS = 20;
+const MIGRATION_CONFIRM_DELAY_MS = 250;
+function randomId() {
   var _a;
   const host = globalThis;
   if (typeof ((_a = host.crypto) == null ? void 0 : _a.randomUUID) === "function") return host.crypto.randomUUID();
   const hex = Array.from({ length: 32 }, () => Math.floor(Math.random() * 16).toString(16)).join("");
   return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-a${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
 }
-function sameChatOutboxRowState(a, b) {
-  if (a.kind !== b.kind) return false;
-  switch (a.kind) {
-    case "countdown":
-      return a.endsAt === b.endsAt;
-    case "failed":
-      return a.reason === b.reason && a.message === b.message;
-    default:
-      return true;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function reanchorHeldSendParams(command, view) {
+  const params = command.params[0];
+  if (!isRecord(params)) return null;
+  const rest = command.params.slice(1);
+  if (command.method === "run/edit") {
+    const next = reanchorRunSend(command, { wireMessages: view.wireMessages, runId: view.runId });
+    return (next == null ? void 0 : next.method) === "run/edit" ? next.params : null;
   }
+  if (command.method !== "run/send") return null;
+  if (view.runId !== null && params.runId === view.runId) return null;
+  const { runAnchorMessageId: _anchor, ...unanchored } = params;
+  if (view.runId !== null) return [{ ...unanchored, runId: view.runId }, ...rest];
+  const wire = view.wireMessages ?? [];
+  return [
+    { ...unanchored, runId: randomId(), runAnchorMessageId: wire.length > 0 ? chatOutboxWireAnchorId(wire) : null },
+    ...rest
+  ];
+}
+function failureReason(error) {
+  return "code" in error && error.code === CHAT_OUTBOX_ATTACHMENT_REFUSED_CODE ? "attachment" : "error";
 }
-function sameChatOutboxEntry(a, b) {
-  return a === b || a.id === b.id && a.threadId === b.threadId && a.text === b.text && a.newChat === b.newChat && a.queuedAt === b.queuedAt && a.composerMarkdown === b.composerMarkdown;
+function sameEntry(a, b) {
+  return a.id === b.id && a.outboxId === b.outboxId && a.threadId === b.threadId && a.text === b.text && a.queuedAt === b.queuedAt && a.newChat === b.newChat && a.durable === b.durable && a.composerMarkdown === b.composerMarkdown && a.composerHtml === b.composerHtml && sameJson(a.metadata, b.metadata) && sameJson(a.files, b.files) && sameJson(a.attachments, b.attachments);
+}
+function sameJson(a, b) {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((item, index) => sameJson(item, b[index]));
+  }
+  const ka = Object.keys(a);
+  const kb = Object.keys(b);
+  return ka.length === kb.length && ka.every((key) => Object.hasOwn(b, key) && sameJson(Reflect.get(a, key), Reflect.get(b, key)));
+}
+function sameState(a, b) {
+  if (a.kind !== b.kind) return false;
+  if (a.kind === "countdown") return a.endsAt === b.endsAt;
+  if (a.kind === "failed") return a.reason === b.reason && a.message === b.message;
+  return true;
 }
 function sameChatOutboxSnapshot(a, b) {
   if (a === b) return true;
@@ -64,12 +79,12 @@ function sameChatOutboxSnapshot(a, b) {
   for (let index = 0; index < a.rows.length; index += 1) {
     const x = a.rows[index];
     const y = b.rows[index];
-    if (!x || !y || x.entry !== y.entry || !sameChatOutboxRowState(x.state, y.state)) return false;
+    if (!x || !y || x.entry !== y.entry || !sameState(x.state, y.state)) return false;
   }
   for (let index = 0; index < a.elsewhere.length; index += 1) {
     const x = a.elsewhere[index];
     const y = b.elsewhere[index];
-    if (!x || !y || x.threadId !== y.threadId || x.count !== y.count || x.newChat !== y.newChat || !sameChatOutboxEntry(x.first, y.first)) {
+    if (!x || !y || x.threadId !== y.threadId || x.count !== y.count || x.newChat !== y.newChat || x.first !== y.first) {
       return false;
     }
   }
@@ -79,7 +94,6 @@ function createChatOutbox(options) {
   const {
     threadId,
     isNewChat,
-    store,
     reachability,
     foreground,
     thread,
@@ -87,117 +101,128 @@ function createChatOutbox(options) {
     openThread,
     onEvent,
     checkAttachments,
-    sendGate,
+    directory,
+    legacy,
     now = () => Date.now(),
     countdownMs = CHAT_OUTBOX_COUNTDOWN_MS,
     askAfterMs = CHAT_OUTBOX_ASK_AFTER_MS,
-    claimLeaseMs = CHAT_OUTBOX_CLAIM_LEASE_MS,
     attachmentCheckTimeoutMs = CHAT_OUTBOX_ATTACHMENT_CHECK_TIMEOUT_MS,
-    newMessageId = defaultMessageId,
+    newMessageId = randomId,
     setTimer = (task, ms) => {
-      const timer = setTimeout(task, ms);
-      return () => clearTimeout(timer);
+      const timer2 = setTimeout(task, ms);
+      return () => clearTimeout(timer2);
     }
   } = options;
-  const claimant = newMessageId();
   let disposed = false;
-  let loaded = store === null;
-  let entries = [];
-  let elsewhere = [];
-  let claims = /* @__PURE__ */ new Map();
-  const persisted = /* @__PURE__ */ new Set();
-  const unsettled = /* @__PURE__ */ new Map();
-  let listingsStarted = 0;
-  const phases = /* @__PURE__ */ new Map();
-  const sendNow = /* @__PURE__ */ new Set();
-  const handedInRegain = /* @__PURE__ */ new Map();
-  let regain = 0;
-  let wasReachable = reachability.get();
-  let countdown = null;
-  let leaseTimer = null;
-  const checkTimers = /* @__PURE__ */ new Set();
-  const readyToGo = /* @__PURE__ */ new Map();
-  let releasing = false;
+  let openSince = null;
+  let pending = [];
+  const landing = /* @__PURE__ */ new Map();
+  const dropOnLanding = /* @__PURE__ */ new Set();
+  const countdownRequested = /* @__PURE__ */ new Set();
+  const released = /* @__PURE__ */ new Set();
+  const legacyAwaitingDelivery = /* @__PURE__ */ new Map();
+  const checking = /* @__PURE__ */ new Set();
+  const failing = /* @__PURE__ */ new Set();
   const asked = /* @__PURE__ */ new Set();
+  const checkTimers = /* @__PURE__ */ new Set();
+  let timer = null;
+  let migration = legacy ? "idle" : "done";
+  let migrationAttempts = 0;
+  const entryCache = /* @__PURE__ */ new Map();
   const listeners = /* @__PURE__ */ new Set();
-  let snapshot = {
-    rows: [],
-    countdownEndsAt: null,
-    durable: true,
-    loaded,
-    elsewhere
-  };
+  let rows = [];
+  let snapshot = { rows: [], countdownEndsAt: null, durable: true, loaded: false, elsewhere: [] };
   const emit = (event) => {
     try {
       onEvent == null ? void 0 : onEvent(event);
     } catch {
     }
   };
-  const phaseOf = (id) => phases.get(id) ?? { kind: "idle" };
-  const isBusy = (phase) => phase.kind === "claiming" || phase.kind === "handed" || phase.kind === "awaiting-thread";
-  const claimedElsewhere = (id) => {
-    const claim = claims.get(id);
-    return claim !== void 0 && claim.by !== claimant && now() - claim.at < claimLeaseMs;
+  const gateOpen = () => reachability.get() && foreground.get() && thread.outbox() !== null;
+  const stable = (entry) => {
+    const key = entry.outboxId ?? `pending:${entry.id}`;
+    const cached = entryCache.get(key);
+    if (cached && sameEntry(cached, entry)) return cached;
+    entryCache.set(key, entry);
+    return entry;
   };
-  const settledFor = (id, listing) => {
-    if (!unsettled.has(id)) return true;
-    const settledAt = unsettled.get(id);
-    return settledAt !== void 0 && listing > settledAt;
+  const readRows = (outbox) => {
+    if (!outbox) return [];
+    const result = [];
+    for (const stored of outbox.entries) {
+      if (stored.state !== "held") continue;
+      const entry = chatOutboxEntryOf(stored, threadId);
+      if (!entry) continue;
+      result.push({ stored, entry: stable(entry), meta: readChatOutboxLocalMeta(stored.localMeta) });
+    }
+    return result;
   };
-  const writePending = (id) => unsettled.has(id) && unsettled.get(id) === void 0;
-  const markUnsettled = (id, write) => {
-    unsettled.set(id, void 0);
-    const settle = () => {
-      if (!unsettled.has(id)) return;
-      unsettled.set(id, listingsStarted);
-      evaluate();
-    };
-    void write.then(settle, settle);
+  const isAsk = (row) => now() - row.entry.queuedAt > askAfterMs;
+  const lineOf = (current) => {
+    const line = [];
+    for (const row of current) {
+      if (row.meta.error || failing.has(row.stored.id) || isAsk(row)) break;
+      if (checking.has(row.stored.id) || released.has(row.stored.id)) continue;
+      line.push(row);
+    }
+    return line;
   };
-  const rowState = (entry, line) => {
-    const phase = phaseOf(entry.id);
-    if (phase.kind === "failed") {
-      return { kind: "failed", reason: phase.reason, message: chatOutboxFailureMessage(phase.reason) };
-    }
-    if (isBusy(phase) || claimedElsewhere(entry.id)) return { kind: "sending" };
-    if (countdown !== null && line.run.some((candidate) => candidate.id === entry.id)) {
-      return { kind: "countdown", endsAt: countdown.endsAt };
-    }
-    if (line.askId === entry.id) return { kind: "ask" };
+  const countdownCurrent = (meta, since) => meta.countdownEndsAt !== void 0 && meta.countdownFrom !== void 0 && meta.countdownFrom >= since;
+  const lineEndsAt = (line) => {
+    if (openSince === null || line.length === 0) return null;
+    let endsAt = 0;
+    for (const row of line) {
+      if (!countdownCurrent(row.meta, openSince)) return null;
+      endsAt = Math.max(endsAt, row.meta.countdownEndsAt ?? 0);
+    }
+    return endsAt;
+  };
+  const rowState = (row, line, endsAt, blocked) => {
+    if (row.meta.error) {
+      const reason = failureReason(row.meta.error);
+      return { kind: "failed", reason, message: chatOutboxFailureMessage(reason) };
+    }
+    if (checking.has(row.stored.id) || released.has(row.stored.id)) return { kind: "sending" };
+    if (blocked) return { kind: "waiting" };
+    if (isAsk(row)) return { kind: "ask" };
+    if (endsAt !== null && line.includes(row)) return { kind: "countdown", endsAt };
     return { kind: "waiting" };
   };
-  const keyOf = (entry) => (sendGate == null ? void 0 : sendGate.keyOf(entry)) ?? "";
-  const mayHandOff = (entry) => (sendGate == null ? void 0 : sendGate.mayHandOff(entry)) ?? true;
-  const computeLine = () => {
-    const run = [];
-    let lineKey = null;
-    for (const entry of entries) {
-      const phase = phaseOf(entry.id);
-      if (phase.kind === "failed") continue;
-      const key = keyOf(entry);
-      if (lineKey === null) lineKey = key;
-      else if (key !== lineKey) break;
-      if (isBusy(phase) || claimedElsewhere(entry.id)) continue;
-      if (handedInRegain.get(entry.id) === regain && !sendNow.has(entry.id)) continue;
-      if (!sendNow.has(entry.id) && now() - entry.queuedAt > askAfterMs) {
-        return { run, askId: run.length === 0 ? entry.id : null };
-      }
-      run.push(entry);
+  const publish = (current, line, endsAt) => {
+    const outbox = thread.outbox();
+    const built = [];
+    let blocked = false;
+    for (const row of current) {
+      const state = rowState(row, line, endsAt, blocked);
+      built.push({ entry: row.entry, state });
+      if (state.kind === "failed" || state.kind === "ask") blocked = true;
+    }
+    for (const entry of landing.values()) built.push({ entry, state: { kind: "waiting" } });
+    for (const waiting of pending) built.push({ entry: waiting.entry, state: { kind: "waiting" } });
+    const elsewhere = [];
+    for (const other of (directory == null ? void 0 : directory.getSnapshot().threads) ?? []) {
+      const first = other.entries[0];
+      if (other.threadId === threadId || !first) continue;
+      elsewhere.push({
+        threadId: other.threadId,
+        count: other.entries.length,
+        first,
+        newChat: other.entries.every((entry) => entry.newChat)
+      });
     }
-    const head = run[0];
-    if (head !== void 0 && !mayHandOff(head)) return { run: [], askId: null };
-    return { run, askId: null };
-  };
-  const gateOpen = () => reachability.get() && foreground.get();
-  const publish = () => {
-    const line = gateOpen() ? computeLine() : { run: [], askId: null };
     const next = {
-      rows: entries.map((entry) => ({ entry, state: rowState(entry, line) })),
-      countdownEndsAt: (countdown == null ? void 0 : countdown.endsAt) ?? null,
-      durable: entries.every((entry) => persisted.has(entry.id)),
-      loaded,
+      rows: built,
+      countdownEndsAt: endsAt,
+      durable: built.every((row) => row.entry.durable),
+      loaded: outbox !== null,
       elsewhere
     };
+    if (elsewhere.length === snapshot.elsewhere.length) {
+      next.elsewhere = elsewhere.map((item, index) => {
+        const previous = snapshot.elsewhere[index];
+        return previous && previous.threadId === item.threadId && previous.count === item.count && previous.newChat === item.newChat && sameEntry(previous.first, item.first) ? previous : item;
+      });
+    }
     if (sameChatOutboxSnapshot(snapshot, next)) return;
     snapshot = next;
     for (const listener of listeners) {
@@ -207,110 +232,55 @@ function createChatOutbox(options) {
       }
     }
   };
-  const stopCountdown = () => {
-    countdown == null ? void 0 : countdown.cancel();
-    countdown = null;
-  };
-  const dropEntry = (id) => {
-    entries = entries.filter((entry) => entry.id !== id);
-    unsettled.delete(id);
-    phases.delete(id);
-    readyToGo.delete(id);
-    sendNow.delete(id);
-    persisted.delete(id);
-    claims.delete(id);
-    asked.delete(id);
-    if (countdown == null ? void 0 : countdown.ids.includes(id)) stopCountdown();
-  };
-  const letGo = (id, event) => {
-    if (!entries.some((entry) => entry.id === id)) return;
-    dropEntry(id);
-    emit(event);
-    if (store) void store.remove(threadId, id).catch(() => void 0);
-  };
-  const fail = (id, reason) => {
-    phases.set(id, { kind: "failed", reason });
-    sendNow.delete(id);
-    emit({ type: "failed", threadId, messageId: id, message: chatOutboxFailureMessage(reason), reason });
-    if (store) {
-      void store.markFailed({ threadId, id, claimant, failure: { reason, at: now() } }).catch(() => void 0);
-    }
-  };
-  const releaseClaim = (id) => {
-    if (store) void store.release({ threadId, id, claimant }).catch(() => void 0);
-  };
-  const handOff = (entry, auto) => {
-    if (thread.heldIds().has(entry.id)) {
-      letGo(entry.id, { type: "adopted", threadId, messageId: entry.id });
-      return;
-    }
-    const readiness = thread.readiness();
-    if (readiness === "refused") {
-      fail(entry.id, "refused");
-      return;
-    }
-    if (readiness === "connecting") {
-      phases.set(entry.id, { kind: "awaiting-thread" });
-      return;
+  const releaseNow = (row, auto) => {
+    var _a;
+    const outbox = thread.outbox();
+    if (!outbox) return;
+    const view = thread.view();
+    released.add(row.stored.id);
+    emit({ type: "handed", threadId, messageId: row.entry.id, auto, ageMs: now() - row.entry.queuedAt });
+    try {
+      outbox.update(row.stored.id, (current) => {
+        if (current.state !== "held") return {};
+        const params = reanchorHeldSendParams(current.command, view);
+        return {
+          held: false,
+          localMeta: withoutTransientLocalMeta(current.localMeta),
+          ...params !== null && { command: { params } }
+        };
+      });
+    } catch {
     }
-    if (writePending(entry.id)) {
-      phases.set(entry.id, { kind: "awaiting-thread" });
-      return;
+    (_a = thread.wake) == null ? void 0 : _a.call(thread);
+    if (legacy && row.meta.legacyId !== void 0 && !row.entry.durable) {
+      legacyAwaitingDelivery.set(row.entry.id, row.meta.legacyId);
     }
-    sendNow.delete(entry.id);
-    phases.set(entry.id, { kind: "claiming" });
-    const claim = store ? store.claim({ threadId, id: entry.id, claimant, now: now(), leaseMs: claimLeaseMs }) : Promise.resolve("claimed");
-    void claim.then(
-      (result) => {
-        if (disposed || phaseOf(entry.id).kind !== "claiming") return;
-        if (result === "gone") {
-          dropEntry(entry.id);
-          evaluate();
-          return;
-        }
-        if (result === "taken") {
-          phases.set(entry.id, { kind: "idle" });
-          claims.set(entry.id, { by: "elsewhere", at: now() });
-          evaluate();
-          return;
-        }
-        if (!stillGoes(entry)) return;
-        checkThenDispatch(entry, auto);
-      },
-      () => {
-        if (disposed || phaseOf(entry.id).kind !== "claiming") return;
-        fail(entry.id, "prepare");
-        evaluate();
-      }
-    );
   };
-  const stillGoes = (entry) => {
-    if (thread.heldIds().has(entry.id)) {
-      letGo(entry.id, { type: "adopted", threadId, messageId: entry.id });
-      evaluate();
-      return false;
-    }
-    const ready = thread.readiness();
-    if (ready === "refused") {
-      fail(entry.id, "refused");
-      evaluate();
-      return false;
-    }
-    if (!gateOpen() || ready !== "ready") {
-      phases.set(entry.id, gateOpen() ? { kind: "awaiting-thread" } : { kind: "idle" });
-      releaseClaim(entry.id);
-      evaluate();
-      return false;
+  const markFailed = (row, code) => {
+    const outbox = thread.outbox();
+    checking.delete(row.stored.id);
+    if (!outbox) return;
+    failing.add(row.stored.id);
+    const error = { fate: "rejected", cause: "server", code };
+    try {
+      outbox.update(row.stored.id, (current) => {
+        if (current.state !== "held") return {};
+        const base = withoutTransientLocalMeta(current.localMeta);
+        return { localMeta: { ...isRecord(base) ? base : {}, error } };
+      });
+    } catch {
     }
-    return true;
+    const reason = failureReason(error);
+    emit({ type: "failed", threadId, messageId: row.entry.id, message: chatOutboxFailureMessage(reason), reason });
   };
-  const checkThenDispatch = (entry, auto) => {
-    const attachments = entry.attachments ?? [];
+  const release = (row, auto) => {
+    const attachments = row.entry.attachments ?? [];
     if (attachments.length === 0 || !checkAttachments) {
-      readyToGo.set(entry.id, auto);
-      releaseReady();
+      releaseNow(row, auto);
       return;
     }
+    if (checking.has(row.stored.id)) return;
+    checking.add(row.stored.id);
     let answered = false;
     let stopTimer = () => void 0;
     const answer = (verdict) => {
@@ -318,284 +288,255 @@ function createChatOutbox(options) {
       answered = true;
       stopTimer();
       checkTimers.delete(stopTimer);
-      if (disposed || phaseOf(entry.id).kind !== "claiming") return;
-      if (!stillGoes(entry)) return;
+      if (disposed || !checking.has(row.stored.id)) return;
       if (verdict === "ok") {
-        readyToGo.set(entry.id, auto);
-        releaseReady();
+        checking.delete(row.stored.id);
+        if (!auto || gateOpen()) releaseNow(row, auto);
+        evaluate();
         return;
       }
-      fail(entry.id, verdict === "refused" ? "attachment" : "error");
+      markFailed(row, verdict === "refused" ? CHAT_OUTBOX_ATTACHMENT_REFUSED_CODE : CHAT_OUTBOX_ATTACHMENT_UNKNOWN_CODE);
       evaluate();
     };
     stopTimer = setTimer(() => answer("unknown"), attachmentCheckTimeoutMs);
     checkTimers.add(stopTimer);
-    let checking;
+    let checked;
     try {
-      checking = checkAttachments(attachments);
+      checked = checkAttachments(attachments);
     } catch (error) {
-      checking = Promise.reject(error);
+      checked = Promise.reject(error);
     }
-    void checking.then(answer, () => answer("unknown"));
+    void checked.then(answer, () => answer("unknown"));
   };
-  function releaseReady() {
-    if (releasing || disposed) return;
-    releasing = true;
-    let heldBack = false;
-    try {
-      for (const entry of [...entries]) {
-        if (phaseOf(entry.id).kind !== "claiming") continue;
-        const auto = readyToGo.get(entry.id);
-        if (auto === void 0) return;
-        if (!mayHandOff(entry)) {
-          holdBackFrom(entry);
-          heldBack = true;
-          return;
-        }
-        readyToGo.delete(entry.id);
-        if (stillGoes(entry)) dispatch(entry, auto);
-      }
-    } finally {
-      releasing = false;
-      if (heldBack) evaluateLine();
-    }
-  }
-  function holdBackFrom(first) {
-    let behind = false;
-    for (const entry of entries) {
-      if (entry.id === first.id) behind = true;
-      if (!behind || phaseOf(entry.id).kind !== "claiming") continue;
-      readyToGo.delete(entry.id);
-      phases.set(entry.id, { kind: "idle" });
-      releaseClaim(entry.id);
-    }
-  }
-  const dispatch = (entry, auto) => {
-    handedInRegain.set(entry.id, regain);
-    phases.set(entry.id, { kind: "handed", journaled: false });
-    emit({
-      type: "handed",
+  const startMigration = (outbox) => {
+    if (!legacy || migration !== "idle") return;
+    migration = "running";
+    const isKept = legacy.isKept === void 0 ? async (messageId) => {
+      var _a;
+      return ((_a = thread.outbox()) == null ? void 0 : _a.entries.some((entry) => {
+        var _a2;
+        return entry.durable && ((_a2 = chatOutboxEntryOf(entry, threadId)) == null ? void 0 : _a2.id) === messageId;
+      })) ?? false;
+    } : (messageId) => legacy.isKept(threadId, messageId);
+    void migrateLegacyChatOutbox({
       threadId,
-      messageId: entry.id,
-      auto,
-      ageMs: now() - entry.queuedAt,
-      ...entry.sendContext !== void 0 && { sendContext: entry.sendContext }
-    });
-    let sent;
-    try {
-      sent = thread.send(entry);
-    } catch (error) {
-      sent = Promise.reject(error);
-    }
-    void sent.then(
-      () => {
-        if (disposed) return;
-        letGo(entry.id, { type: "delivered", threadId, messageId: entry.id, status: "accepted" });
-        evaluate();
-      },
-      (error) => {
-        if (disposed) return;
-        const phase = phaseOf(entry.id);
-        if (phase.kind === "handed" && phase.journaled) return;
-        if (phase.kind !== "handed") return;
-        const failure = failureOf(error);
-        if (failure.cause !== void 0 && AWAY_CAUSES.has(failure.cause)) {
-          phases.set(entry.id, { kind: "idle" });
-          handedInRegain.delete(entry.id);
-          releaseClaim(entry.id);
-          evaluate();
-          return;
+      reader: legacy.reader,
+      outbox,
+      isKept,
+      messageIdsShown: () => thread.view().messageIds
+    }).then(
+      (result) => {
+        var _a;
+        migration = "done";
+        if (result.inserted + result.removed + result.kept > 0) emit({ type: "migrated", threadId, ...result });
+        directory == null ? void 0 : directory.refresh();
+        const inMemory = ((_a = thread.outbox()) == null ? void 0 : _a.entries.some((entry) => !entry.durable)) ?? false;
+        if (result.kept > 0 && !inMemory && migrationAttempts < MIGRATION_CONFIRM_ATTEMPTS && !disposed) {
+          migrationAttempts += 1;
+          const stop = setTimer(() => {
+            checkTimers.delete(stop);
+            migration = "idle";
+            evaluate();
+          }, MIGRATION_CONFIRM_DELAY_MS);
+          checkTimers.add(stop);
         }
-        fail(entry.id, "error");
-        evaluate();
+      },
+      () => {
+        migration = "idle";
       }
     );
   };
-  const startCountdown = (run) => {
-    stopCountdown();
-    const ids = run.map((entry) => entry.id);
-    const endsAt = now() + countdownMs;
-    const cancel = setTimer(() => {
-      if (disposed || (countdown == null ? void 0 : countdown.endsAt) !== endsAt) return;
-      countdown = null;
-      if (!gateOpen()) {
-        evaluate();
-        return;
-      }
-      for (const id of ids) {
-        const entry = entries.find((candidate) => candidate.id === id);
-        if (!entry) continue;
-        const phase = phaseOf(id);
-        if (phase.kind !== "idle" || claimedElsewhere(id)) continue;
-        if (!mayHandOff(entry)) break;
-        handOff(entry, true);
-      }
-      evaluate();
-    }, countdownMs);
-    countdown = { endsAt, ids, cancel };
-    emit({ type: "countdown-started", threadId, count: ids.length });
-  };
-  const scheduleLeaseCheck = () => {
-    leaseTimer == null ? void 0 : leaseTimer();
-    leaseTimer = null;
-    let soonest = Number.POSITIVE_INFINITY;
-    for (const [id, claim] of claims) {
-      if (claim.by === claimant || !entries.some((entry) => entry.id === id)) continue;
-      const expires = claim.at + claimLeaseMs - now();
-      if (expires > 0) soonest = Math.min(soonest, expires);
-    }
-    if (Number.isFinite(soonest)) leaseTimer = setTimer(() => evaluate(), soonest + 1);
-  };
   function evaluate() {
-    evaluateLine();
-    releaseReady();
-  }
-  function evaluateLine() {
     if (disposed) return;
-    const reachable = reachability.get();
-    if (reachable && !wasReachable) regain += 1;
-    wasReachable = reachable;
-    if (loaded) {
-      const held = thread.heldIds();
-      for (const entry of [...entries]) {
-        const phase = phaseOf(entry.id);
-        if (phase.kind === "handed") {
-          if (held.has(entry.id)) phases.set(entry.id, { kind: "handed", journaled: true });
-          continue;
+    const outbox = thread.outbox();
+    if (outbox && pending.length > 0) {
+      const waiting = pending;
+      pending = [];
+      for (let index = 0; index < waiting.length; index += 1) {
+        const item = waiting[index];
+        try {
+          outbox.insert(item.insert);
+          landing.set(item.entry.id, item.entry);
+          emit({ type: "held", threadId, messageId: item.entry.id, durable: true });
+        } catch {
+          pending = waiting.slice(index);
+          break;
         }
-        if (phase.kind === "claiming") continue;
-        if (held.has(entry.id)) letGo(entry.id, { type: "adopted", threadId, messageId: entry.id });
       }
-      if (!gateOpen()) {
-        for (const entry of entries) {
-          if (phaseOf(entry.id).kind === "awaiting-thread") phases.set(entry.id, { kind: "idle" });
-        }
-      } else if (thread.readiness() !== "connecting") {
-        let held2 = false;
-        let handedKey = null;
-        for (const entry of entries) {
-          if (phaseOf(entry.id).kind !== "awaiting-thread") continue;
-          phases.set(entry.id, { kind: "idle" });
-          const key = keyOf(entry);
-          held2 || (held2 = handedKey !== null && key !== handedKey || !mayHandOff(entry));
-          if (held2) continue;
-          handedKey = key;
-          handOff(entry, true);
-        }
-      }
-    }
-    if (!loaded || !gateOpen()) {
-      stopCountdown();
-      publish();
-      return;
-    }
-    const line = computeLine();
-    if (line.askId !== null && !asked.has(line.askId)) {
-      asked.add(line.askId);
-      const entry = entries.find((candidate) => candidate.id === line.askId);
-      if (entry) emit({ type: "asked", threadId, messageId: entry.id, ageMs: now() - entry.queuedAt });
     }
-    const immediate = [];
-    for (const entry of line.run) {
-      if (!sendNow.has(entry.id)) break;
-      immediate.push(entry);
-    }
-    for (const entry of immediate) handOff(entry, false);
-    const run = line.run.slice(immediate.length).filter((entry) => !sendNow.has(entry.id));
-    if (run.length === 0) {
-      stopCountdown();
-    } else if (countdown === null || countdown.ids.length !== run.length || run.some((entry, index) => (countdown == null ? void 0 : countdown.ids[index]) !== entry.id)) {
-      startCountdown(run);
+    if (outbox) startMigration(outbox);
+    if (legacy && legacyAwaitingDelivery.size > 0) {
+      const delivered = thread.view().messageIds;
+      for (const [messageId, legacyId] of legacyAwaitingDelivery) {
+        if (!delivered.has(messageId)) continue;
+        legacyAwaitingDelivery.delete(messageId);
+        void legacy.reader.remove(threadId, legacyId).catch(() => void 0);
+      }
     }
-    scheduleLeaseCheck();
-    publish();
-  }
-  const applyRecords = (records, listing) => {
-    const mine = records.filter((record) => record.entry.threadId === threadId);
-    const stored = new Map(mine.map((record) => [record.entry.id, record]));
-    claims = new Map(
-      mine.flatMap((record) => record.claim ? [[record.entry.id, record.claim]] : [])
-    );
-    for (const record of mine) {
-      if (!settledFor(record.entry.id, listing)) continue;
-      if (record.memoryOnly) persisted.delete(record.entry.id);
-      else persisted.add(record.entry.id);
-      const phase = phaseOf(record.entry.id);
-      if (record.failure && phase.kind !== "failed" && !isBusy(phase)) {
-        phases.set(record.entry.id, { kind: "failed", reason: record.failure.reason });
+    let current = readRows(outbox);
+    const dropped = /* @__PURE__ */ new Set();
+    for (const row of current) {
+      landing.delete(row.entry.id);
+      if (!dropOnLanding.delete(row.entry.id) || !outbox) continue;
+      dropped.add(row.stored.id);
+      try {
+        outbox.remove(row.stored.id);
+      } catch {
       }
     }
-    const kept = entries.filter(
-      (entry) => stored.has(entry.id) || !settledFor(entry.id, listing) || isBusy(phaseOf(entry.id))
-    );
-    for (const entry of entries) {
-      if (kept.includes(entry)) continue;
-      if (countdown == null ? void 0 : countdown.ids.includes(entry.id)) stopCountdown();
-      phases.delete(entry.id);
-      persisted.delete(entry.id);
-      sendNow.delete(entry.id);
+    current = current.filter((row) => !dropped.has(row.stored.id));
+    const shown = current.length > 0 ? thread.view().messageIds : /* @__PURE__ */ new Set();
+    for (const row of current) {
+      if (!shown.has(row.entry.id) || !outbox) continue;
+      try {
+        outbox.remove(row.stored.id);
+      } catch {
+      }
+      emit({ type: "adopted", threadId, messageId: row.entry.id });
+    }
+    current = current.filter((row) => !shown.has(row.entry.id));
+    const heldIds = new Set(current.map((row) => row.stored.id));
+    for (const id of released) if (!heldIds.has(id)) released.delete(id);
+    for (const id of checking) if (!heldIds.has(id)) checking.delete(id);
+    for (const row of current) if (row.meta.error) failing.delete(row.stored.id);
+    for (const id of failing) if (!heldIds.has(id)) failing.delete(id);
+    for (const key of entryCache.keys()) if (!key.startsWith("pending:") && !heldIds.has(key)) entryCache.delete(key);
+    rows = current;
+    const open = gateOpen();
+    if (open && openSince === null) openSince = now();
+    if (!open) openSince = null;
+    let line = [];
+    let endsAt = null;
+    if (open && openSince !== null) {
+      line = lineOf(current);
+      const head = current.find(
+        (row) => !row.meta.error && !failing.has(row.stored.id) && !checking.has(row.stored.id) && !released.has(row.stored.id)
+      );
+      if (head && isAsk(head) && !asked.has(head.stored.id)) {
+        asked.add(head.stored.id);
+        emit({ type: "asked", threadId, messageId: head.entry.id, ageMs: now() - head.entry.queuedAt });
+      }
+      const since = openSince;
+      const starting = line.filter((row) => !countdownCurrent(row.meta, since));
+      for (const row of line) if (countdownCurrent(row.meta, since)) countdownRequested.delete(row.stored.id);
+      const toRequest = starting.filter((row) => !countdownRequested.has(row.stored.id));
+      if (toRequest.length > 0 && outbox) {
+        const from = now();
+        for (const row of toRequest) {
+          countdownRequested.add(row.stored.id);
+          try {
+            outbox.update(row.stored.id, (stored) => {
+              const meta = readChatOutboxLocalMeta(stored.localMeta);
+              if (stored.state !== "held" || countdownCurrent(meta, since)) return {};
+              const base = isRecord(stored.localMeta) ? stored.localMeta : {};
+              return { localMeta: { ...base, countdownFrom: from, countdownEndsAt: from + countdownMs } };
+            });
+          } catch {
+            countdownRequested.delete(row.stored.id);
+          }
+        }
+        emit({ type: "countdown-started", threadId, count: line.length });
+      }
+      endsAt = lineEndsAt(line);
+    }
+    if (endsAt !== null && endsAt <= now()) {
+      timer == null ? void 0 : timer.cancel();
+      timer = null;
+      for (const row of line) release(row, true);
+      queueMicrotask(evaluate);
+      publish(current, [], null);
+      return;
     }
-    const known = new Set(kept.map((entry) => entry.id));
-    const added = mine.filter((record) => !known.has(record.entry.id)).map((record) => record.entry);
-    entries = [...kept, ...added].sort((a, b) => a.queuedAt - b.queuedAt);
-    for (const [id, settledAt] of unsettled) {
-      if (settledAt !== void 0 && listing > settledAt) unsettled.delete(id);
+    if (endsAt === null) {
+      timer == null ? void 0 : timer.cancel();
+      timer = null;
+    } else if ((timer == null ? void 0 : timer.at) !== endsAt) {
+      timer == null ? void 0 : timer.cancel();
+      const at = endsAt;
+      timer = {
+        at,
+        cancel: setTimer(
+          () => {
+            if ((timer == null ? void 0 : timer.at) === at) timer = null;
+            evaluate();
+          },
+          Math.max(0, at - now())
+        )
+      };
     }
-    const byThread = /* @__PURE__ */ new Map();
-    for (const record of records) {
-      if (record.entry.threadId === threadId) continue;
-      const current = byThread.get(record.entry.threadId);
-      if (current) {
-        current.count += 1;
-        current.newChat && (current.newChat = record.entry.newChat);
-      } else {
-        byThread.set(record.entry.threadId, {
-          count: 1,
-          first: record.entry,
-          newChat: record.entry.newChat
-        });
-      }
+    publish(current, line, endsAt);
+  }
+  const findRow = (id) => rows.find((row) => row.entry.id === id);
+  const forgetLegacy = (row) => {
+    legacyAwaitingDelivery.delete(row.entry.id);
+    if (legacy && row.meta.legacyId !== void 0) {
+      void legacy.reader.remove(threadId, row.meta.legacyId).catch(() => void 0);
     }
-    elsewhere = [...byThread].map(([otherThreadId, other]) => ({ threadId: otherThreadId, ...other })).sort((a, b) => a.first.queuedAt - b.first.queuedAt);
   };
-  let reading = null;
-  let readAgain = false;
-  const reload = () => {
-    if (!store || disposed) return;
-    if (reading) {
-      readAgain = true;
-      return;
-    }
-    listingsStarted += 1;
-    const listing = listingsStarted;
-    reading = store.listAll().then(
-      (records) => {
-        if (disposed) return;
-        applyRecords(records, listing);
-        loaded = true;
-      },
-      () => {
-        loaded = true;
+  const buildInsert = (id, input) => {
+    const queuedAt = now();
+    const newChat = typeof isNewChat === "function" ? isNewChat() : isNewChat;
+    const files = input.files ?? [];
+    const metadata = withAddressedAgents(input.metadata, input.addressedAgents);
+    const parts = [
+      ...files.map((file) => ({
+        type: "file",
+        mediaType: file.mediaType,
+        url: file.url,
+        ...file.filename !== void 0 && { filename: file.filename }
+      })),
+      ...input.text.length > 0 ? [{ type: "text", text: input.text }] : []
+    ];
+    const view = thread.view();
+    const params = {
+      type: "run/send",
+      behavior: "auto",
+      runId: view.runId ?? randomId(),
+      message: { id, role: "user", parts, ...metadata !== void 0 && { metadata } },
+      ...view.runId === null && {
+        runAnchorMessageId: view.wireMessages && view.wireMessages.length > 0 ? chatOutboxWireAnchorId(view.wireMessages) : null
       }
-    ).finally(() => {
-      reading = null;
-      if (disposed) return;
-      evaluate();
-      if (readAgain) {
-        readAgain = false;
-        reload();
+    };
+    const attachments = input.attachments && input.attachments.length > 0 ? input.attachments : void 0;
+    const localMeta = {
+      kind: CHAT_OUTBOX_LOCAL_META_KIND,
+      threadId,
+      queuedAt,
+      newChat,
+      ...input.composerMarkdown !== void 0 && { composerMarkdown: input.composerMarkdown },
+      ...input.composerHtml !== void 0 && { composerHtml: input.composerHtml },
+      ...attachments && { attachments }
+    };
+    const entry = {
+      id,
+      threadId,
+      text: input.text,
+      queuedAt,
+      newChat,
+      durable: false,
+      ...input.composerMarkdown !== void 0 && { composerMarkdown: input.composerMarkdown },
+      ...input.composerHtml !== void 0 && { composerHtml: input.composerHtml },
+      ...metadata !== void 0 && { metadata },
+      ...files.length > 0 && { files },
+      ...attachments && { attachments }
+    };
+    return {
+      entry,
+      insert: {
+        protocol: DEEP_AGENT_STATEWIRE_PROTOCOL,
+        command: { method: "run/send", params: [params] },
+        held: true,
+        localMeta
       }
-    });
+    };
   };
   const unsubscribers = [
     reachability.subscribe(evaluate),
     foreground.subscribe(evaluate),
     thread.subscribe(evaluate),
-    ...sendGate ? [sendGate.subscribe(evaluate)] : [],
-    ...store ? [store.subscribe(reload)] : []
+    ...directory ? [directory.subscribe(evaluate)] : []
   ];
-  reload();
-  publish();
+  evaluate();
   return {
     threadId,
     reachability,
@@ -607,117 +548,120 @@ function createChatOutbox(options) {
       };
     },
     shouldHold() {
+      if (thread.outbox() === null && pending.length === 0) return false;
       if (!reachability.get()) return true;
-      if (!loaded) return true;
-      return entries.some((entry) => {
-        const phase = phaseOf(entry.id);
-        return phase.kind !== "failed" && !(phase.kind === "handed" && phase.journaled);
-      });
+      return pending.length > 0 || landing.size > 0 || readRows(thread.outbox()).length > 0;
     },
     hold(input) {
-      const entry = {
-        id: newMessageId(),
-        threadId,
-        text: input.text,
-        queuedAt: now(),
-        newChat: typeof isNewChat === "function" ? isNewChat() : isNewChat,
-        ...input.composerMarkdown !== void 0 && { composerMarkdown: input.composerMarkdown },
-        ...input.composerHtml !== void 0 && { composerHtml: input.composerHtml },
-        ...input.metadata !== void 0 && { metadata: input.metadata },
-        ...input.sendContext !== void 0 && { sendContext: input.sendContext },
-        ...input.files !== void 0 && input.files.length > 0 && { files: input.files },
-        ...input.attachments !== void 0 && input.attachments.length > 0 && { attachments: input.attachments }
-      };
-      if (!loaded && gateOpen()) sendNow.add(entry.id);
-      entries = [...entries, entry];
-      if (store) {
-        persisted.add(entry.id);
-        const write = store.put(entry);
-        markUnsettled(entry.id, write);
-        void write.then(
-          (kept) => {
-            if (!kept) persisted.delete(entry.id);
-            emit({ type: "held", threadId, messageId: entry.id, durable: kept });
-            publish();
-          },
-          () => {
-            persisted.delete(entry.id);
-            emit({ type: "held", threadId, messageId: entry.id, durable: false });
-            publish();
-          }
-        );
-      } else {
-        emit({ type: "held", threadId, messageId: entry.id, durable: false });
+      const built = buildInsert(newMessageId(), input);
+      const outbox = thread.outbox();
+      let inserted = false;
+      if (outbox && pending.length === 0) {
+        try {
+          outbox.insert(built.insert);
+          landing.set(built.entry.id, built.entry);
+          inserted = true;
+        } catch {
+          inserted = false;
+        }
       }
+      if (!inserted) pending = [...pending, built];
+      else emit({ type: "held", threadId, messageId: built.entry.id, durable: true });
       evaluate();
-      return entry;
+      const row = findRow(built.entry.id);
+      return (row == null ? void 0 : row.entry) ?? built.entry;
     },
     cancel(id) {
-      const entry = entries.find((candidate) => candidate.id === id);
-      if (!entry || isBusy(phaseOf(id))) return;
-      dropEntry(id);
+      var _a, _b;
+      const row = findRow(id);
+      if (!row) {
+        const waiting = ((_a = pending.find((item) => item.entry.id === id)) == null ? void 0 : _a.entry) ?? landing.get(id);
+        if (!waiting) return;
+        pending = pending.filter((item) => item.entry !== waiting);
+        if (landing.delete(id)) dropOnLanding.add(id);
+        emit({ type: "cancelled", threadId, messageId: id });
+        try {
+          restore(waiting);
+        } finally {
+          evaluate();
+        }
+        return;
+      }
+      try {
+        (_b = thread.outbox()) == null ? void 0 : _b.remove(row.stored.id);
+      } catch {
+        return;
+      }
+      forgetLegacy(row);
       emit({ type: "cancelled", threadId, messageId: id });
-      if (store) void store.remove(threadId, id).catch(() => void 0);
       try {
-        restore(entry);
+        restore(row.entry);
       } finally {
         evaluate();
       }
     },
     send(id) {
-      const entry = entries.find((candidate) => candidate.id === id);
-      if (!entry || isBusy(phaseOf(id))) return;
-      const wasFailed = phaseOf(id).kind === "failed";
-      phases.set(id, { kind: "idle" });
-      handedInRegain.delete(id);
-      sendNow.add(id);
-      if (wasFailed && store) {
-        const write = store.clearFailure({ threadId, id });
-        markUnsettled(id, write);
-        void write.catch(() => void 0);
-      }
+      const row = findRow(id);
+      if (!row || released.has(row.stored.id)) return;
+      failing.delete(row.stored.id);
+      release(row, false);
       evaluate();
     },
-    discard(id) {
-      const entry = entries.find((candidate) => candidate.id === id);
-      if (!entry || isBusy(phaseOf(id))) return;
-      dropEntry(id);
-      emit({ type: "discarded", threadId, messageId: id });
-      if (store) void store.remove(threadId, id).catch(() => void 0);
+    edit(id, input) {
+      const row = findRow(id);
+      const outbox = thread.outbox();
+      if (!row || !outbox) return;
+      const rebuilt = buildInsert(id, input);
+      const message = rebuilt.insert.command.params[0].message;
+      try {
+        outbox.update(row.stored.id, (current) => {
+          if (current.state !== "held") return {};
+          const params = current.command.params[0];
+          const stripped = withoutTransientLocalMeta(current.localMeta);
+          const base = isRecord(stripped) ? stripped : {};
+          const { composerMarkdown: _md, composerHtml: _html, attachments: _attachments, ...kept } = base;
+          return {
+            localMeta: { ...kept, ...rebuilt.insert.localMeta, queuedAt: row.entry.queuedAt },
+            command: { params: [{ ...isRecord(params) ? params : {}, message }, ...current.command.params.slice(1)] }
+          };
+        });
+      } catch {
+        return;
+      }
+      evaluate();
+      failing.delete(row.stored.id);
+      const edited = findRow(id);
+      if (edited) release(edited, false);
       evaluate();
     },
-    observeCommand(update) {
-      if (disposed) return;
-      const id = chatOutboxCommandMessageId(update.params);
-      if (id === null) return;
-      const phase = phaseOf(id);
-      if (phase.kind === "handed") {
-        if (update.status === "queued") {
-          phases.set(id, { kind: "handed", journaled: true });
+    discard(id) {
+      var _a;
+      const row = findRow(id);
+      if (!row) {
+        if (!pending.some((item) => item.entry.id === id) && !landing.has(id)) return;
+        pending = pending.filter((item) => item.entry.id !== id);
+        if (landing.delete(id)) dropOnLanding.add(id);
+      } else {
+        try {
+          (_a = thread.outbox()) == null ? void 0 : _a.remove(row.stored.id);
+        } catch {
           return;
         }
-        letGo(id, { type: "delivered", threadId, messageId: id, status: update.status });
-        evaluate();
-        return;
+        forgetLegacy(row);
       }
-      if (entries.some((entry) => entry.id === id)) evaluate();
+      emit({ type: "discarded", threadId, messageId: id });
+      evaluate();
     },
     openThread: openThread ?? null,
     dispose() {
       if (disposed) return;
       disposed = true;
-      stopCountdown();
-      leaseTimer == null ? void 0 : leaseTimer();
+      timer == null ? void 0 : timer.cancel();
+      timer = null;
       for (const stop of checkTimers) stop();
       checkTimers.clear();
-      readyToGo.clear();
       for (const unsubscribe of unsubscribers) unsubscribe();
       listeners.clear();
-      if (store) {
-        for (const [id, phase] of phases) {
-          if (phase.kind === "claiming") releaseClaim(id);
-        }
-      }
     }
   };
 }
@@ -726,12 +670,13 @@ export {
   CHAT_EDIT_UNREACHABLE_LABEL,
   CHAT_OUTBOX_ASK_AFTER_MS,
   CHAT_OUTBOX_ATTACHMENT_CHECK_TIMEOUT_MS,
-  CHAT_OUTBOX_CLAIM_LEASE_MS,
+  CHAT_OUTBOX_ATTACHMENT_REFUSED_CODE,
+  CHAT_OUTBOX_ATTACHMENT_UNKNOWN_CODE,
   CHAT_OUTBOX_COUNTDOWN_MS,
   ChatEditUnreachableError,
-  chatOutboxCommandMessageId,
   chatOutboxFailureMessage,
   createChatOutbox,
+  reanchorHeldSendParams,
   sameChatOutboxSnapshot
 };
 //# sourceMappingURL=chat-outbox.js.map