@athenaintel/react 0.41.2 → 0.42.1

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

@@ -0,0 +1,696 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+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_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 {
+  constructor() {
+    super(CHAT_EDIT_KEPT_MESSAGE);
+    this.name = "ChatEditUnreachableError";
+  }
+}
+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;
+}
+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() {
+  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 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 sameChatOutboxSnapshot(a, b) {
+  if (a === b) return true;
+  if (a.countdownEndsAt !== b.countdownEndsAt || a.durable !== b.durable || a.loaded !== b.loaded) return false;
+  if (a.rows.length !== b.rows.length || a.elsewhere.length !== b.elsewhere.length) return false;
+  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;
+  }
+  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)) {
+      return false;
+    }
+  }
+  return true;
+}
+function createChatOutbox(options) {
+  const {
+    threadId,
+    isNewChat,
+    store,
+    reachability,
+    foreground,
+    thread,
+    restore,
+    openThread,
+    onEvent,
+    checkAttachments,
+    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,
+    setTimer = (task, ms) => {
+      const timer = setTimeout(task, ms);
+      return () => clearTimeout(timer);
+    }
+  } = 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;
+  const asked = /* @__PURE__ */ new Set();
+  const listeners = /* @__PURE__ */ new Set();
+  let snapshot = {
+    rows: [],
+    countdownEndsAt: null,
+    durable: true,
+    loaded,
+    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 settledFor = (id, listing) => {
+    if (!unsettled.has(id)) return true;
+    const settledAt = unsettled.get(id);
+    return settledAt !== void 0 && listing > settledAt;
+  };
+  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 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" };
+    return { kind: "waiting" };
+  };
+  const computeLine = () => {
+    const run = [];
+    for (const entry of entries) {
+      const phase = phaseOf(entry.id);
+      if (phase.kind === "failed") continue;
+      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);
+    }
+    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,
+      elsewhere
+    };
+    if (sameChatOutboxSnapshot(snapshot, next)) return;
+    snapshot = next;
+    for (const listener of listeners) {
+      try {
+        listener();
+      } catch {
+      }
+    }
+  };
+  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;
+    }
+    if (writePending(entry.id)) {
+      phases.set(entry.id, { kind: "awaiting-thread" });
+      return;
+    }
+    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;
+    }
+    return true;
+  };
+  const checkThenDispatch = (entry, auto) => {
+    const attachments = entry.attachments ?? [];
+    if (attachments.length === 0 || !checkAttachments) {
+      readyToGo.set(entry.id, auto);
+      releaseReady();
+      return;
+    }
+    let answered = false;
+    let stopTimer = () => void 0;
+    const answer = (verdict) => {
+      if (answered) return;
+      answered = true;
+      stopTimer();
+      checkTimers.delete(stopTimer);
+      if (disposed || phaseOf(entry.id).kind !== "claiming") return;
+      if (!stillGoes(entry)) return;
+      if (verdict === "ok") {
+        readyToGo.set(entry.id, auto);
+        releaseReady();
+        return;
+      }
+      fail(entry.id, verdict === "refused" ? "attachment" : "error");
+      evaluate();
+    };
+    stopTimer = setTimer(() => answer("unknown"), attachmentCheckTimeoutMs);
+    checkTimers.add(stopTimer);
+    let checking;
+    try {
+      checking = checkAttachments(attachments);
+    } catch (error) {
+      checking = Promise.reject(error);
+    }
+    void checking.then(answer, () => answer("unknown"));
+  };
+  function releaseReady() {
+    if (releasing || disposed) return;
+    releasing = true;
+    try {
+      for (const entry of [...entries]) {
+        if (phaseOf(entry.id).kind !== "claiming") continue;
+        const auto = readyToGo.get(entry.id);
+        if (auto === void 0) return;
+        readyToGo.delete(entry.id);
+        if (stillGoes(entry)) dispatch(entry, auto);
+      }
+    } finally {
+      releasing = false;
+    }
+  }
+  const dispatch = (entry, auto) => {
+    handedInRegain.set(entry.id, regain);
+    phases.set(entry.id, { kind: "handed", journaled: false });
+    emit({ type: "handed", threadId, messageId: entry.id, auto, ageMs: now() - entry.queuedAt });
+    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;
+        }
+        fail(entry.id, "error");
+        evaluate();
+      }
+    );
+  };
+  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;
+        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;
+        }
+        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") {
+        for (const entry of entries) {
+          if (phaseOf(entry.id).kind === "awaiting-thread") {
+            phases.set(entry.id, { kind: "idle" });
+            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);
+    }
+    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 });
+      }
+    }
+    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);
+    }
+    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);
+    }
+    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
+        });
+      }
+    }
+    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;
+      }
+    ).finally(() => {
+      reading = null;
+      if (disposed) return;
+      evaluate();
+      if (readAgain) {
+        readAgain = false;
+        reload();
+      }
+    });
+  };
+  const unsubscribers = [
+    reachability.subscribe(evaluate),
+    foreground.subscribe(evaluate),
+    thread.subscribe(evaluate),
+    ...store ? [store.subscribe(reload)] : []
+  ];
+  reload();
+  publish();
+  return {
+    threadId,
+    reachability,
+    getSnapshot: () => snapshot,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    shouldHold() {
+      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);
+      });
+    },
+    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.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 });
+      }
+      evaluate();
+      return entry;
+    },
+    cancel(id) {
+      const entry = entries.find((candidate) => candidate.id === id);
+      if (!entry || isBusy(phaseOf(id))) return;
+      dropEntry(id);
+      emit({ type: "cancelled", threadId, messageId: id });
+      if (store) void store.remove(threadId, id).catch(() => void 0);
+      try {
+        restore(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);
+      }
+      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);
+      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 });
+          return;
+        }
+        letGo(id, { type: "delivered", threadId, messageId: id, status: update.status });
+        evaluate();
+        return;
+      }
+      if (entries.some((entry) => entry.id === id)) evaluate();
+    },
+    openThread: openThread ?? null,
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      stopCountdown();
+      leaseTimer == null ? void 0 : leaseTimer();
+      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);
+        }
+      }
+    }
+  };
+}
+exports.CHAT_EDIT_KEPT_MESSAGE = CHAT_EDIT_KEPT_MESSAGE;
+exports.CHAT_EDIT_UNREACHABLE_LABEL = CHAT_EDIT_UNREACHABLE_LABEL;
+exports.CHAT_OUTBOX_ASK_AFTER_MS = CHAT_OUTBOX_ASK_AFTER_MS;
+exports.CHAT_OUTBOX_ATTACHMENT_CHECK_TIMEOUT_MS = CHAT_OUTBOX_ATTACHMENT_CHECK_TIMEOUT_MS;
+exports.CHAT_OUTBOX_CLAIM_LEASE_MS = CHAT_OUTBOX_CLAIM_LEASE_MS;
+exports.CHAT_OUTBOX_COUNTDOWN_MS = CHAT_OUTBOX_COUNTDOWN_MS;
+exports.ChatEditUnreachableError = ChatEditUnreachableError;
+exports.chatOutboxCommandMessageId = chatOutboxCommandMessageId;
+exports.chatOutboxFailureMessage = chatOutboxFailureMessage;
+exports.createChatOutbox = createChatOutbox;
+exports.sameChatOutboxSnapshot = sameChatOutboxSnapshot;
+//# sourceMappingURL=chat-outbox.cjs.map