snapback2 0.0.1

package/dist/templates/chat/react/shared/log.js

@@ -0,0 +1,92 @@
+function conversations(rows) {
+  const byConversation = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const current = byConversation.get(row.conversationId) ?? {
+      conversationId: row.conversationId,
+      latestAt: row.at,
+      latestBody: void 0,
+      messages: 0
+    };
+    if (row.kind === "message") current.messages += 1;
+    if (row.at >= current.latestAt) {
+      current.latestAt = row.at;
+      current.latestBody = row.message?.body ?? current.latestBody;
+    }
+    byConversation.set(row.conversationId, current);
+  }
+  return [...byConversation.values()].sort((a, b) => b.latestAt - a.latestAt);
+}
+function postArgs(entry) {
+  const args = entry.args;
+  return entry.op === "deliveries.post" && args && typeof args.conversationId === "string" && typeof args.body === "string" ? { conversationId: args.conversationId, body: args.body } : void 0;
+}
+function editArgs(entry) {
+  const args = entry.args;
+  return entry.op === "deliveries.edit" && args && typeof args.messageId === "string" && typeof args.body === "string" ? { messageId: args.messageId, body: args.body, baseBody: args.baseBody ?? "" } : void 0;
+}
+function intentLabel(entry) {
+  switch (entry.state) {
+    case "queued":
+      return entry.reason === "fence" ? "Will be checked by the server" : "Sending\u2026";
+    case "committed":
+      return "Sent";
+    case "expired":
+      return "Expired";
+    case "rejected": {
+      const response = entry.response;
+      if (response?.reason === "conflict" || response?.code === "CONFLICT") return "Not sent \xB7 Message changed";
+      return `Not sent \xB7 ${response?.rewrite ?? response?.message ?? response?.code ?? "refused"}`;
+    }
+  }
+}
+function threadBubbles(rows, entries, conversationId) {
+  const hidden = new Set(rows.filter((row) => row.kind === "removed" || row.kind === "expired").map((row) => row.messageId));
+  const edits = new Map(entries.map((entry) => [editArgs(entry)?.messageId, entry]).filter(([id]) => id !== void 0));
+  const seen = /* @__PURE__ */ new Set();
+  const bubbles = [];
+  const pending = new Map(entries.filter((entry) => entry.state === "queued" && postArgs(entry) !== void 0).map((entry) => [entry.ids[0] ?? entry.intent, entry]));
+  const chronological = [...rows].sort((a, b) => a.at - b.at || (a.messageId < b.messageId ? -1 : a.messageId > b.messageId ? 1 : 0));
+  for (const row of chronological) {
+    if (row.kind !== "message" || !row.message || hidden.has(row.messageId) || seen.has(row.messageId)) continue;
+    seen.add(row.messageId);
+    const predicted = pending.get(row.messageId);
+    if (predicted) {
+      bubbles.push({ key: row.messageId, kind: "pending", entry: predicted, body: postArgs(predicted).body });
+      continue;
+    }
+    const edit = edits.get(row.messageId);
+    bubbles.push({ key: row.messageId, kind: "row", message: row.message, at: row.at, ...edit ? { edit } : {} });
+  }
+  for (const entry of entries) {
+    const args = postArgs(entry);
+    if (!args || args.conversationId !== conversationId) continue;
+    const key = entry.ids[0] ?? entry.intent;
+    if (seen.has(key)) continue;
+    bubbles.push({ key, kind: "pending", entry, body: args.body });
+  }
+  return bubbles;
+}
+function settledByRows(rows, entries) {
+  const held = new Set(rows.map((row) => row.messageId));
+  return entries.filter((entry) => entry.state === "committed" && postArgs(entry) !== void 0 && held.has(entry.ids[0] ?? ""));
+}
+function searchHeld(rows, term) {
+  const needle = term.trim().toLowerCase();
+  if (!needle) return [];
+  const seen = /* @__PURE__ */ new Set();
+  return rows.filter((row) => {
+    const body = row.message?.body;
+    if (row.kind !== "message" || !body || seen.has(row.messageId) || !body.toLowerCase().includes(needle)) return false;
+    seen.add(row.messageId);
+    return true;
+  });
+}
+export {
+  conversations,
+  editArgs,
+  intentLabel,
+  postArgs,
+  searchHeld,
+  settledByRows,
+  threadBubbles
+};

package/dist/templates/chat/react/shared/log.ts

@@ -0,0 +1,130 @@
+// The delivery log is the app's source of truth on the device (LLP 1012 §3):
+// every screen is a pure function over held log rows plus the durable outbox.
+import type { Api, OutboxEntry } from "snapback2/client";
+
+type ResultOf<T> = T extends { readonly __result?: infer Result } ? NonNullable<Result> : never;
+export type LogRow = ResultOf<Api["deliveries"]["inbox"]>[number];
+export type MessageRow = NonNullable<LogRow["message"]>;
+
+export interface ConversationSummary {
+  conversationId: string;
+  latestAt: number;
+  latestBody: string | undefined;
+  messages: number;
+}
+
+/** One line per conversation, newest activity first, from the held log. */
+export function conversations(rows: readonly LogRow[]): ConversationSummary[] {
+  const byConversation = new Map<string, ConversationSummary>();
+  for (const row of rows) {
+    const current = byConversation.get(row.conversationId) ?? {
+      conversationId: row.conversationId,
+      latestAt: row.at,
+      latestBody: undefined,
+      messages: 0,
+    };
+    if (row.kind === "message") current.messages += 1;
+    if (row.at >= current.latestAt) {
+      current.latestAt = row.at;
+      current.latestBody = row.message?.body ?? current.latestBody;
+    }
+    byConversation.set(row.conversationId, current);
+  }
+  return [...byConversation.values()].sort((a, b) => b.latestAt - a.latestAt);
+}
+
+export type PostArgs = { conversationId: string; body: string };
+export type EditArgs = { messageId: string; body: string; baseBody: string };
+
+export function postArgs(entry: OutboxEntry): PostArgs | undefined {
+  const args = entry.args as Partial<PostArgs> | null;
+  return entry.op === "deliveries.post" && args && typeof args.conversationId === "string" && typeof args.body === "string"
+    ? { conversationId: args.conversationId, body: args.body }
+    : undefined;
+}
+
+export function editArgs(entry: OutboxEntry): EditArgs | undefined {
+  const args = entry.args as Partial<EditArgs> | null;
+  return entry.op === "deliveries.edit" && args && typeof args.messageId === "string" && typeof args.body === "string"
+    ? { messageId: args.messageId, body: args.body, baseBody: args.baseBody ?? "" }
+    : undefined;
+}
+
+/** The label a settled or queued intent shows; never a client clock. */
+export function intentLabel(entry: OutboxEntry): string {
+  switch (entry.state) {
+    case "queued": return entry.reason === "fence" ? "Will be checked by the server" : "Sending…";
+    case "committed": return "Sent";
+    case "expired": return "Expired";
+    case "rejected": {
+      const response = entry.response as { reason?: string; code?: string; rewrite?: string; message?: string } | undefined;
+      // @ref LLP 1012#7-writes-offline — a trace conflict, or the recipe's own
+      // compare-and-set (`require msg.body = baseBody else CONFLICT`), reads the same.
+      if (response?.reason === "conflict" || response?.code === "CONFLICT") return "Not sent · Message changed";
+      return `Not sent · ${response?.rewrite ?? response?.message ?? response?.code ?? "refused"}`;
+    }
+  }
+}
+
+export type Bubble =
+  | { key: string; kind: "row"; message: MessageRow; at: number; edit?: OutboxEntry }
+  | { key: string; kind: "pending"; entry: OutboxEntry; body: string };
+
+/**
+ * The thread as bubbles: one per message id from the log (tombstoned ids
+ * hidden), then the outbox's intents for this conversation. A pending post is
+ * keyed by its first pinned id, the id the server row will carry, so the same
+ * bubble becomes the row on `committed` and nothing jumps.
+ */
+export function threadBubbles(rows: readonly LogRow[], entries: readonly OutboxEntry[], conversationId: string): Bubble[] {
+  const hidden = new Set(rows.filter((row) => row.kind === "removed" || row.kind === "expired").map((row) => row.messageId));
+  const edits = new Map(entries.map((entry) => [editArgs(entry)?.messageId, entry] as const).filter(([id]) => id !== undefined));
+  const seen = new Set<string>();
+  const bubbles: Bubble[] = [];
+  // @ref LLP 1012#7-writes-offline — a queued send the twin predicted is inside
+  // the log's rows under its pinned id; it is still the pending bubble, with
+  // `args.body` and "Sending…" and no time, until the server's row settles it.
+  const pending = new Map(entries
+    .filter((entry) => entry.state === "queued" && postArgs(entry) !== undefined)
+    .map((entry) => [entry.ids[0] ?? entry.intent, entry] as const));
+  // The log's thread page is newest-first (`last 50`); a thread reads oldest-first.
+  const chronological = [...rows].sort((a, b) => a.at - b.at || (a.messageId < b.messageId ? -1 : a.messageId > b.messageId ? 1 : 0));
+  for (const row of chronological) {
+    if (row.kind !== "message" || !row.message || hidden.has(row.messageId) || seen.has(row.messageId)) continue;
+    seen.add(row.messageId);
+    const predicted = pending.get(row.messageId);
+    if (predicted) {
+      bubbles.push({ key: row.messageId, kind: "pending", entry: predicted, body: postArgs(predicted)!.body });
+      continue;
+    }
+    const edit = edits.get(row.messageId);
+    bubbles.push({ key: row.messageId, kind: "row", message: row.message, at: row.at, ...(edit ? { edit } : {}) });
+  }
+  for (const entry of entries) {
+    const args = postArgs(entry);
+    if (!args || args.conversationId !== conversationId) continue;
+    const key = entry.ids[0] ?? entry.intent;
+    if (seen.has(key)) continue;
+    bubbles.push({ key, kind: "pending", entry, body: args.body });
+  }
+  return bubbles;
+}
+
+/** Committed posts whose server row is now held can leave the outbox. */
+export function settledByRows(rows: readonly LogRow[], entries: readonly OutboxEntry[]): OutboxEntry[] {
+  const held = new Set(rows.map((row) => row.messageId));
+  return entries.filter((entry) => entry.state === "committed" && postArgs(entry) !== undefined && held.has(entry.ids[0] ?? ""));
+}
+
+/** Offline search is a filter over the downloaded log (LLP 1012 §6); it finds nothing evicted. */
+export function searchHeld(rows: readonly LogRow[], term: string): LogRow[] {
+  const needle = term.trim().toLowerCase();
+  if (!needle) return [];
+  const seen = new Set<string>();
+  return rows.filter((row) => {
+    const body = row.message?.body;
+    if (row.kind !== "message" || !body || seen.has(row.messageId) || !body.toLowerCase().includes(needle)) return false;
+    seen.add(row.messageId);
+    return true;
+  });
+}

package/dist/templates/chat/react/shared/offline.js

@@ -0,0 +1,8 @@
+const chatOffline = {
+  onTombstone: (item) => item.table === "deliveries" && (item.row.kind === "removed" || item.row.kind === "expired") && typeof item.row.messageId === "string" ? [{ table: "messages", id: item.row.messageId }] : [],
+  // Optional on the recipe's message row; absent/null is ordinary media.
+  viewOnce: (table, row) => table === "messages" && row.viewOnce === true
+};
+export {
+  chatOffline
+};

package/dist/templates/chat/react/shared/offline.ts

@@ -0,0 +1,9 @@
+type StoredRow = { table: string; row: Record<string, unknown> };
+
+export const chatOffline = {
+  onTombstone: (item: StoredRow) =>
+    item.table === "deliveries" && (item.row.kind === "removed" || item.row.kind === "expired")
+      && typeof item.row.messageId === "string" ? [{ table: "messages", id: item.row.messageId }] : [],
+  // Optional on the recipe's message row; absent/null is ordinary media.
+  viewOnce: (table: string, row: Record<string, unknown>) => table === "messages" && row.viewOnce === true,
+};

package/dist/templates/chat/react/src/App.tsx

@@ -0,0 +1,36 @@
+import { useState } from "react";
+import { api } from "snapback2/client";
+import { DevOverlay, useAuth, useConnection, useQuery } from "snapback2/react";
+import { Inbox } from "./Inbox";
+import { Search } from "./Search";
+import { Thread } from "./Thread";
+import type { LogRow } from "../shared/log.js";
+
+// @ref LLP 1012#3-the-model-on-one-page-and-the-program-shape — one drained
+// delivery log is "everything on the phone"; the inbox, every thread, and
+// search read the same held rows.
+export function App() {
+  const connection = useConnection();
+  const auth = useAuth();
+  const inbox = useQuery(api.deliveries.inbox, { c: null }, { drain: true });
+  const rows: LogRow[] = "data" in inbox && Array.isArray(inbox.data) ? inbox.data : [];
+  const [selected, setSelected] = useState<string>();
+  const [note, setNote] = useState("");
+  const caughtUp = "caughtUp" in inbox && inbox.caughtUp === true;
+  return (
+    <main>
+      <header>
+        <h1>Snapback 2 chat</h1>
+        <p role="status" data-connection={connection}>
+          {connection === "connected" ? "Connected" : connection === "offline" ? "Offline" : "Reconnecting…"}
+          {caughtUp ? " · log downloaded" : inbox.state === "hydrating" ? " · loading" : ""}
+        </p>
+        {note ? <p role="alert">{note}</p> : null}
+      </header>
+      <Search rows={rows} onOpen={setSelected} />
+      <Inbox rows={rows} selected={selected} onSelect={setSelected} />
+      {selected ? <Thread conversationId={selected} viewer={auth.viewer} onNote={setNote} /> : <p>Pick a conversation.</p>}
+      <DevOverlay />
+    </main>
+  );
+}

package/dist/templates/chat/react/src/Composer.tsx

@@ -0,0 +1,45 @@
+import { useState, type FormEvent } from "react";
+import { api, isSnapbackRefusal } from "snapback2/client";
+import { useMutation, useOutbox } from "snapback2/react";
+
+// @ref LLP 1012#7-writes-offline — `run()` resolves `queued` when the owner is
+// unreachable; the durable outbox, not this component, owns the message from then on.
+// A device with a store writes only when this op has a replay grant, a certified
+// bound, and enough ids for its slice: until then the send is disabled with the
+// reason shown, never retried blindly, and a refusal's rewrite is surfaced as the note.
+export function Composer({ conversationId, onNote }: { conversationId: string; onNote(note: string): void }) {
+  const post = useMutation(api.deliveries.post);
+  const { fence } = useOutbox();
+  const [body, setBody] = useState("");
+
+  const submit = async (event: FormEvent<HTMLFormElement>) => {
+    event.preventDefault();
+    const text = body.trim();
+    if (!text) return;
+    setBody("");
+    try {
+      const result = await post.run({ conversationId, body: text });
+      if (result.state === "queued") onNote(fence === "past" ? "Queued until the next sync." : "Queued; it sends when the connection returns.");
+      else if (result.state === "rejected") onNote(`Not sent: ${result.rewrite ?? result.message}`);
+      else onNote("");
+    } catch (error) {
+      onNote(isSnapbackRefusal(error) ? (error.envelope.rewrite ?? error.message) : String(error));
+    }
+  };
+
+  return (
+    <form aria-label="Composer" onSubmit={(event) => { void submit(event); }}>
+      <input
+        aria-label="Message"
+        value={body}
+        placeholder="Message"
+        onChange={(event) => setBody(event.target.value)}
+      />
+      <button type="submit" disabled={post.inFlight || !post.ready}>Send</button>
+      {!post.ready
+        ? <small data-waiting="grant">Sending opens once the log has downloaded.</small>
+        : fence === "past" ? <small data-waiting="fence">Queued until the next sync.</small>
+        : post.pending.length > 0 ? <small>{`${post.pending.length} queued`}</small> : null}
+    </form>
+  );
+}

package/dist/templates/chat/react/src/Inbox.tsx

@@ -0,0 +1,24 @@
+import { useMemo } from "react";
+import { conversations, type LogRow } from "../shared/log.js";
+
+export function Inbox({ rows, selected, onSelect }: {
+  rows: readonly LogRow[];
+  selected: string | undefined;
+  onSelect(conversationId: string): void;
+}) {
+  const items = useMemo(() => conversations(rows), [rows]);
+  return (
+    <nav aria-label="Inbox">
+      <ul>
+        {items.map((item) => (
+          <li key={item.conversationId} data-conversation={item.conversationId} aria-current={item.conversationId === selected ? "true" : undefined}>
+            <button type="button" onClick={() => onSelect(item.conversationId)}>
+              <strong>{item.conversationId}</strong>
+              <span>{item.latestBody ?? `${item.messages} messages`}</span>
+            </button>
+          </li>
+        ))}
+      </ul>
+    </nav>
+  );
+}

package/dist/templates/chat/react/src/Search.tsx

@@ -0,0 +1,26 @@
+import { useMemo, useState } from "react";
+import { searchHeld, type LogRow } from "../shared/log.js";
+
+// @ref LLP 1012#6-reads-offline — a search op has no held answer for a new
+// term, so the recipe filters the downloaded log and says so.
+export function Search({ rows, onOpen }: { rows: readonly LogRow[]; onOpen(conversationId: string): void }) {
+  const [term, setTerm] = useState("");
+  const hits = useMemo(() => searchHeld(rows, term), [rows, term]);
+  return (
+    <section aria-label="Search">
+      <input aria-label="Search downloaded messages" value={term} placeholder="Search" onChange={(event) => setTerm(event.target.value)} />
+      {term.trim() ? (
+        <>
+          <p className="scope">in downloaded messages</p>
+          <ul className="hits">
+            {hits.map((row) => (
+              <li key={row.messageId} data-message={row.messageId}>
+                <button type="button" onClick={() => onOpen(row.conversationId)}>{row.message?.body}</button>
+              </li>
+            ))}
+          </ul>
+        </>
+      ) : null}
+    </section>
+  );
+}

package/dist/templates/chat/react/src/Thread.tsx

@@ -0,0 +1,126 @@
+import { useEffect, useMemo } from "react";
+import { api, isSnapbackRefusal } from "snapback2/client";
+import { useMutation, useOutbox, useQuery } from "snapback2/react";
+import { Composer } from "./Composer";
+import { intentLabel, settledByRows, threadBubbles, type Bubble, type LogRow } from "../shared/log.js";
+
+function when(at: number): string {
+  return new Date(at).toLocaleTimeString();
+}
+
+function describe(error: unknown): string {
+  return isSnapbackRefusal(error) ? (error.envelope.rewrite ?? error.message) : String(error);
+}
+
+// @ref LLP 1012#7-writes-offline — a pending bubble shows `args.body` and
+// "Sending…" with no time; the same key becomes the server row on `committed`.
+function BubbleView({ bubble, viewer, onDismiss, onEdit, onUnsend }: {
+  bubble: Bubble;
+  viewer: string | undefined;
+  onDismiss(intent: string): void;
+  onEdit(messageId: string, body: string): void;
+  onUnsend(messageId: string): void;
+}) {
+  if (bubble.kind === "pending") {
+    const settled = bubble.entry.state !== "queued";
+    return (
+      <li data-message={bubble.key} data-state={bubble.entry.state} className="bubble pending">
+        <p>{bubble.body}</p>
+        <small>{intentLabel(bubble.entry)}</small>
+        {settled ? <button type="button" onClick={() => onDismiss(bubble.entry.intent)}>Dismiss</button> : null}
+      </li>
+    );
+  }
+  const own = viewer !== undefined && bubble.message.authorId === viewer;
+  const body = bubble.message.body ?? "";
+  return (
+    <li data-message={bubble.key} data-state="row" className={own ? "bubble own" : "bubble"}>
+      <p>{body || (bubble.message.photo ? "[photo]" : bubble.message.clip ? "[clip]" : "")}</p>
+      <time dateTime={new Date(bubble.at).toISOString()}>{when(bubble.at)}</time>
+      {bubble.edit ? (
+        <small data-edit={bubble.edit.state}>
+          {`Edit ${intentLabel(bubble.edit).toLowerCase()}`}
+          {bubble.edit.state !== "queued"
+            ? <button type="button" onClick={() => onDismiss(bubble.edit!.intent)}>Dismiss</button>
+            : null}
+        </small>
+      ) : null}
+      {own && body ? (
+        <span className="actions">
+          <button type="button" onClick={() => onEdit(bubble.key, body)}>Edit</button>
+          <button type="button" onClick={() => onUnsend(bubble.key)}>Unsend</button>
+        </span>
+      ) : null}
+    </li>
+  );
+}
+
+export function Thread({ conversationId, viewer, onNote }: {
+  conversationId: string;
+  viewer: string | undefined;
+  onNote(note: string): void;
+}) {
+  const thread = useQuery(api.deliveries.thread, { conversationId, c: null });
+  const { entries, dismiss } = useOutbox();
+  const edit = useMutation(api.deliveries.edit);
+  const unsend = useMutation(api.deliveries.unsend);
+  const rows: LogRow[] = "data" in thread && Array.isArray(thread.data) ? thread.data : [];
+  const bubbles = useMemo(() => threadBubbles(rows, entries, conversationId), [rows, entries, conversationId]);
+  useEffect(() => {
+    for (const entry of settledByRows(rows, entries)) void dismiss(entry.intent);
+  }, [rows, entries, dismiss]);
+
+  const status = thread.state === "hydrating"
+    ? "Loading…"
+    : thread.state === "refused"
+      ? `Refused: ${thread.refusal.rewrite ?? thread.refusal.message}`
+      : thread.state === "denied"
+        ? "You are not a member of this conversation."
+        : [
+            thread.state === "partial" ? "Some messages are no longer held." : undefined,
+            "stale" in thread && thread.stale ? "Showing downloaded messages." : undefined,
+          ].filter(Boolean).join(" ");
+
+  const onEdit = async (messageId: string, body: string) => {
+    const next = typeof window === "undefined" ? null : window.prompt("Edit message", body);
+    if (next === null || next === body) return;
+    try {
+      const result = await edit.run({ messageId, body: next, baseBody: body });
+      if (result.state === "queued") onNote("Edit queued; it sends when the connection returns.");
+      else if (result.state === "rejected") onNote(`Edit not sent: ${result.rewrite ?? result.message}`);
+    } catch (error) {
+      onNote(describe(error));
+    }
+  };
+  const onUnsend = async (messageId: string) => {
+    try {
+      const result = await unsend.run({ messageId });
+      if (result.state === "queued") onNote("Unsend queued; it sends when the connection returns.");
+      else if (result.state === "rejected") onNote(`Unsend refused: ${result.rewrite ?? result.message}`);
+    } catch (error) {
+      onNote(describe(error));
+    }
+  };
+
+  return (
+    <section aria-label="Thread">
+      <header>
+        <h2>{conversationId}</h2>
+        {status ? <p role="status">{status}</p> : null}
+      </header>
+      <ol className="bubbles">
+        {bubbles.map((bubble) => (
+          <BubbleView
+            key={bubble.key}
+            bubble={bubble}
+            viewer={viewer}
+            onDismiss={(intent) => { void dismiss(intent); }}
+            onEdit={(messageId, body) => { void onEdit(messageId, body); }}
+            onUnsend={(messageId) => { void onUnsend(messageId); }}
+          />
+        ))}
+      </ol>
+      <Composer conversationId={conversationId} onNote={onNote} />
+    </section>
+  );
+}

package/dist/templates/chat/react/src/env.d.ts

@@ -0,0 +1 @@
+interface ImportMeta { readonly env: { readonly VITE_SNAPBACK_URL?: string } }

package/dist/templates/chat/react/src/main.tsx

@@ -0,0 +1,20 @@
+import { StrictMode } from "react";
+import { createRoot } from "react-dom/client";
+import { indexedDbRangeStore, SnapbackProvider } from "snapback2/react";
+import { App } from "./App";
+
+const url = import.meta.env.VITE_SNAPBACK_URL ?? "http://127.0.0.1:3210";
+// @ref LLP 1012#3-the-model-on-one-page-and-the-program-shape — a `removed` or
+// `expired` log row evicts the body it names in the same swap it arrives in.
+const offline = {
+  store: indexedDbRangeStore(),
+  onTombstone: (item: { table: string; row: Record<string, unknown> }) =>
+    item.table === "deliveries"
+      && (item.row.kind === "removed" || item.row.kind === "expired")
+      && typeof item.row.messageId === "string"
+      ? [{ table: "messages", id: item.row.messageId }]
+      : [],
+};
+createRoot(document.getElementById("root")!).render(
+  <StrictMode><SnapbackProvider url={url} as="alice" offline={offline}><App /></SnapbackProvider></StrictMode>,
+);

package/dist/templates/chat/shared/log.js

@@ -0,0 +1,92 @@
+function conversations(rows) {
+  const byConversation = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const current = byConversation.get(row.conversationId) ?? {
+      conversationId: row.conversationId,
+      latestAt: row.at,
+      latestBody: void 0,
+      messages: 0
+    };
+    if (row.kind === "message") current.messages += 1;
+    if (row.at >= current.latestAt) {
+      current.latestAt = row.at;
+      current.latestBody = row.message?.body ?? current.latestBody;
+    }
+    byConversation.set(row.conversationId, current);
+  }
+  return [...byConversation.values()].sort((a, b) => b.latestAt - a.latestAt);
+}
+function postArgs(entry) {
+  const args = entry.args;
+  return entry.op === "deliveries.post" && args && typeof args.conversationId === "string" && typeof args.body === "string" ? { conversationId: args.conversationId, body: args.body } : void 0;
+}
+function editArgs(entry) {
+  const args = entry.args;
+  return entry.op === "deliveries.edit" && args && typeof args.messageId === "string" && typeof args.body === "string" ? { messageId: args.messageId, body: args.body, baseBody: args.baseBody ?? "" } : void 0;
+}
+function intentLabel(entry) {
+  switch (entry.state) {
+    case "queued":
+      return entry.reason === "fence" ? "Will be checked by the server" : "Sending\u2026";
+    case "committed":
+      return "Sent";
+    case "expired":
+      return "Expired";
+    case "rejected": {
+      const response = entry.response;
+      if (response?.reason === "conflict" || response?.code === "CONFLICT") return "Not sent \xB7 Message changed";
+      return `Not sent \xB7 ${response?.rewrite ?? response?.message ?? response?.code ?? "refused"}`;
+    }
+  }
+}
+function threadBubbles(rows, entries, conversationId) {
+  const hidden = new Set(rows.filter((row) => row.kind === "removed" || row.kind === "expired").map((row) => row.messageId));
+  const edits = new Map(entries.map((entry) => [editArgs(entry)?.messageId, entry]).filter(([id]) => id !== void 0));
+  const seen = /* @__PURE__ */ new Set();
+  const bubbles = [];
+  const pending = new Map(entries.filter((entry) => entry.state === "queued" && postArgs(entry) !== void 0).map((entry) => [entry.ids[0] ?? entry.intent, entry]));
+  const chronological = [...rows].sort((a, b) => a.at - b.at || (a.messageId < b.messageId ? -1 : a.messageId > b.messageId ? 1 : 0));
+  for (const row of chronological) {
+    if (row.kind !== "message" || !row.message || hidden.has(row.messageId) || seen.has(row.messageId)) continue;
+    seen.add(row.messageId);
+    const predicted = pending.get(row.messageId);
+    if (predicted) {
+      bubbles.push({ key: row.messageId, kind: "pending", entry: predicted, body: postArgs(predicted).body });
+      continue;
+    }
+    const edit = edits.get(row.messageId);
+    bubbles.push({ key: row.messageId, kind: "row", message: row.message, at: row.at, ...edit ? { edit } : {} });
+  }
+  for (const entry of entries) {
+    const args = postArgs(entry);
+    if (!args || args.conversationId !== conversationId) continue;
+    const key = entry.ids[0] ?? entry.intent;
+    if (seen.has(key)) continue;
+    bubbles.push({ key, kind: "pending", entry, body: args.body });
+  }
+  return bubbles;
+}
+function settledByRows(rows, entries) {
+  const held = new Set(rows.map((row) => row.messageId));
+  return entries.filter((entry) => entry.state === "committed" && postArgs(entry) !== void 0 && held.has(entry.ids[0] ?? ""));
+}
+function searchHeld(rows, term) {
+  const needle = term.trim().toLowerCase();
+  if (!needle) return [];
+  const seen = /* @__PURE__ */ new Set();
+  return rows.filter((row) => {
+    const body = row.message?.body;
+    if (row.kind !== "message" || !body || seen.has(row.messageId) || !body.toLowerCase().includes(needle)) return false;
+    seen.add(row.messageId);
+    return true;
+  });
+}
+export {
+  conversations,
+  editArgs,
+  intentLabel,
+  postArgs,
+  searchHeld,
+  settledByRows,
+  threadBubbles
+};