snapback2 0.0.1

package/dist/templates/chat/expo/index.js

@@ -0,0 +1,3 @@
+import { registerRootComponent } from 'expo';
+import App from './App';
+registerRootComponent(App);

package/dist/templates/chat/expo/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/expo/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/expo/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/expo/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/expo/src/Chat.tsx

@@ -0,0 +1,23 @@
+import React, { useState } from "react";
+import { SafeAreaView, ScrollView, Text, Button } from "react-native";
+import { api } from "snapback2/client";
+import { useConnection, useQuery } from "snapback2/react-native";
+import type { LogRow } from "../shared/log.js";
+import { Inbox } from "./screens/Inbox";
+import { Thread } from "./screens/Thread";
+import { Search } from "./screens/Search";
+
+export function Chat() {
+  const connection = useConnection();
+  const inbox = useQuery(api.deliveries.inbox, { c: null }, { drain: true });
+  const rows: LogRow[] = "data" in inbox && Array.isArray(inbox.data) ? inbox.data : [];
+  const [selected, select] = useState<string>();
+  return <SafeAreaView style={{ flex: 1, backgroundColor: "#f7f7fb" }}>
+    <Text style={{ fontSize: 24, padding: 16 }}>Snapback Chat · {connection}</Text>
+    {selected ? <><Button title="Inbox" onPress={() => select(undefined)} /><Thread conversationId={selected} /></>
+      : <ScrollView contentContainerStyle={{ padding: 16 }}>
+        <Search rows={rows} onOpen={select} /><Inbox rows={rows} onSelect={select} />
+        {inbox.state === "refused" ? <Text>{inbox.refusal.rewrite ?? inbox.refusal.message}</Text> : null}
+      </ScrollView>}
+  </SafeAreaView>;
+}

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

@@ -0,0 +1,23 @@
+import React, { useState } from "react";
+import { Button, Text, TextInput, View } from "react-native";
+import { api, isSnapbackRefusal } from "snapback2/client";
+import { useMutation, useOutbox } from "snapback2/react-native";
+export function Composer({ conversationId }: { conversationId: string }) {
+  const post = useMutation(api.deliveries.post);
+  const { fence } = useOutbox();
+  const [body, setBody] = useState("");
+  const [note, setNote] = useState("");
+  const send = async () => {
+    if (!body.trim() || !post.ready) return;
+    try {
+      const result = await post.run({ conversationId, body: body.trim() });
+      if (result.state === "rejected") setNote(result.rewrite ?? result.message);
+      else { setBody(""); setNote(result.state === "queued" ? "Queued until the next sync." : ""); }
+    } catch (error) { setNote(isSnapbackRefusal(error) ? error.envelope.rewrite ?? error.message : String(error)); }
+  };
+  return <View style={{ padding: 16 }}><TextInput accessibilityLabel="Message" placeholder="Message" value={body} onChangeText={setBody} multiline />
+    <Button title="Send" disabled={!post.ready || post.inFlight || !body.trim()} onPress={() => { void send(); }} />
+    {!post.ready ? <Text>Sending opens once the log has downloaded.</Text> : fence === "past" ? <Text>Queued until the next sync.</Text> : null}
+    {note ? <Text accessibilityRole="alert">{note}</Text> : null}
+  </View>;
+}

package/dist/templates/chat/expo/src/MediaView.tsx

@@ -0,0 +1,29 @@
+import React, { useCallback } from "react";
+import type { AssetRecord } from "snapback2/client";
+import { AssetImage, AssetVideo } from "snapback2/react-native";
+
+export interface Media {
+  asset: AssetRecord; nonce: number; once: boolean; hidden?: boolean;
+  loaded: boolean; uri?: string; resolve(value: unknown): void;
+}
+/** The witness observes the source actually passed to the native renderer. */
+export function MediaView({ media }: { media: Media }) {
+  const source = useCallback((uri: string | undefined, settled: boolean) => {
+    media.uri = uri;
+    if (media.hidden && settled) media.resolve({ loaded: media.loaded, uri });
+  }, [media]);
+  const loaded = useCallback((loadedUri?: string) => {
+    const uri = media.uri;
+    if (!uri) { media.resolve({ loaded: false }); return; }
+    if (loadedUri && loadedUri !== uri) return; // a late event from the prior memory source
+    media.loaded = true;
+    if (media.once ? uri.startsWith("data:") : uri.startsWith("file://"))
+      media.resolve({ loaded: true, uri, ...( "duration" in media.asset ? { playing: true } : {}) });
+  }, [media]);
+  const refusal = useCallback((error: { envelope: unknown }) => media.resolve({ loaded: false, refusal: error.envelope }), [media]);
+  return "duration" in media.asset
+    ? <AssetVideo asset={media.asset} width={64} autoPlay={!media.hidden} testID="witness-media"
+        onSourceChange={source} onPlaybackStart={loaded} onRefusal={refusal} />
+    : <AssetImage asset={media.asset} width={64} testID="witness-media"
+        onSourceChange={source} onLoad={(event) => loaded(event?.nativeEvent?.source?.uri)} onRefusal={refusal} />;
+}

package/dist/templates/chat/expo/src/Witness.tsx

@@ -0,0 +1,131 @@
+import { twinLastDecline } from "snapback2/expo/witness";
+import React, { useEffect, useState } from "react";
+import { Text, View } from "react-native";
+import { api, SnapbackRefusal, type AssetRecord, type ImageAsset, type RangeStore, type SnapbackClient, type Subscription } from "snapback2/client";
+import { createExpoClient, expoSqliteStore, expoSqliteDriver, SnapbackProvider } from "snapback2/expo";
+import { MediaView, type Media } from "./MediaView";
+import { witnessControl, runSqliteDriverConformance, type WitnessHooks } from "snapback2/expo/witness";
+import { chatOffline } from "../shared/offline.js";
+import { searchHeld, threadBubbles } from "../shared/log.js";
+import { configuration, persist, databaseState, markerSwap, listFiles, DATABASE } from "./witness-state";
+import { Chat } from "./Chat";
+
+export default function Witness({ url, controlUrl }: { url: string; controlUrl: string }) {
+  const [client, setClient] = useState<SnapbackClient>();
+  const [media, setMedia] = useState<Media>();
+  const [error, setError] = useState<string>();
+  useEffect(() => {
+    let live: SnapbackClient | undefined, store: RangeStore | undefined, selected = "conversation-1";
+    let subscriptions: Subscription<unknown>[] = [];
+    let currentMedia: Media | undefined, viewNonce = 0;
+    const dispose = async () => { for (const sub of subscriptions) sub.close(); subscriptions = []; await live?.close(); live = undefined; setClient(undefined); };
+    const construct = async (hooks: WitnessHooks, args: Record<string, unknown>) => {
+      await dispose();
+      if (args.fresh === true) {
+        const initial = expoSqliteStore(DATABASE)();
+        try { await initial.wipe("dev:alice"); } finally { await initial.close?.(); }
+        await persist({ name: "alice", offline: false, fault: "none" });
+      }
+      if (typeof args.name === "string") await persist({ name: args.name });
+      if (Array.isArray(args.once) || Array.isArray(args.assets)) await persist({
+        ...(Array.isArray(args.once) ? { once: args.once as string[] } : {}),
+        ...(Array.isArray(args.assets) ? { assets: args.assets as AssetRecord[] } : {}),
+      });
+      const config = await configuration();
+      store = expoSqliteStore(DATABASE, { beforeCommit: hooks.beforeCommit })();
+      if (config.fault === "carrier") store.open = async () => { throw new SnapbackRefusal({
+        code: "E_OFFLINE_CARRIER", family: "offline", site: "witness construct", message: "persisted witness carrier fault",
+        rewrite: "send fault(none), then construct", guide: "offline",
+      }); };
+      live = createExpoClient({ url, as: config.name, startOffline: config.offline,
+        offline: { ...chatOffline, store: () => store!, viewOnce: (table, row) => chatOffline.viewOnce(table, row) || (table === "messages" && config.once.includes(String(row.id))) } });
+      try { await live.ready; setClient(live); setError(undefined); return live; }
+      catch (error) { setError(String(error)); throw error; }
+    };
+    const control = witnessControl({ construct, persist,
+      async command(client, verb, args) {
+        // The carrier can be read before any client constructs: the harness inspects a
+        // reopened database before the app mounts anything that writes to it.
+        if (verb === "stores") return { stores: await databaseState(), files: listFiles() };
+        if (!client || !store) throw new Error("construct first");
+        if (verb === "drain") {
+          const sub = client.subscribe(api.deliveries.inbox, { c: null }, () => {}, { drain: true });
+          subscriptions.push(sub);
+          return sub.until((value) => "caughtUp" in value && value.caughtUp === true);
+        }
+        if (verb === "open") {
+          selected = String(args.conversationId);
+          const sub = client.subscribe(api.deliveries.thread, { conversationId: selected, c: null }, () => {});
+          subscriptions.push(sub);
+          await sub.until((value) => value.state === "complete");
+          // Media mutations predate the delivery recipe; drain this named read to
+          // hold their row leases too (messages.sendPhoto has no delivery fanout).
+          await client.query(api.messages.thread, { conversationId: selected, c: null });
+          return client.query(api.deliveries.thread, { conversationId: selected, c: null });
+        }
+        if (verb === "send") return client.mutation(api.deliveries.post, {
+          conversationId: typeof args.conversationId === "string" ? args.conversationId : selected, body: String(args.body),
+        });
+        if (verb === "view") {
+          const config = await configuration();
+          const asset = config.assets.find((asset) => asset.id === args.assetId) as AssetRecord | undefined;
+          if (!asset) throw new Error("unknown witness asset");
+          const once = Boolean(await client.assetCache?.viewOnce(asset.id) || await client.assetCache?.viewed(asset.id));
+          const result = await new Promise<Record<string, unknown>>((resolve) => {
+            currentMedia = { asset, nonce: ++viewNonce, once, hidden: args.hidden === true,
+              loaded: false, resolve: (value) => resolve(value as Record<string, unknown>) };
+            setMedia(currentMedia);
+          });
+          if (!once && result.loaded === true) {
+            // The ordinary source may first load from memory; acknowledge only
+            // the materialized file, after the bridge's directory reports it.
+            // Compare paths, not spellings: the bridge's URI percent-encodes the partition
+            // (`dev%3Aalice`) while the directory listing may not.
+            const path = (uri: string) => decodeURIComponent(uri).replace(/\/+$/, "");
+            const served = path(String(result.uri));
+            const deadline = Date.now() + 10_000;
+            while (!listFiles().some((file) => path(file) === served)) {
+              if (Date.now() >= deadline) throw new Error(`ordinary media did not materialize a file: served ${result.uri}; listed ${JSON.stringify(listFiles().slice(0, 6))}`);
+              await new Promise((resolve) => setTimeout(resolve, 10));
+            }
+          }
+          return { ...result, viewed: await client.assetCache?.viewed(asset.id),
+            files: listFiles().filter((file) => file.includes(asset.id)) };
+        }
+
+        if (verb === "swap") {
+          if (args.phase !== "pre" && args.phase !== "post") throw new Error("swap needs pre or post");
+          await markerSwap(store, args.phase, await client.outbox.entries());
+          return { phase: args.phase };
+        }
+        if (verb === "conformance") return runSqliteDriverConformance(() => expoSqliteDriver("snapback2-conformance.db"));
+        if (verb === "settled") {
+          // A retryable refusal stops the replay and keeps the intent queued; the supported
+          // retry is an explicit drain of the same envelope, then settled again (LLP 1012 §7).
+          await client.outbox.settled();
+          if ((await client.outbox.entries()).some((entry) => entry.state === "queued")) {
+            await client.outbox.drain();
+            await client.outbox.settled();
+          }
+          const entries = await client.outbox.entries();
+          if (entries.some((entry) => entry.state === "queued")) throw new Error("outbox did not settle");
+          return entries;
+        }
+        if (verb === "state") {
+          const answer = typeof args.conversationId === "string"
+            ? await client.query(api.deliveries.thread, { conversationId: args.conversationId, c: null }) : undefined;
+          const entries = await client.outbox.entries();
+          const rows = answer && "data" in answer && Array.isArray(answer.data) ? answer.data : [];
+          return { snapshot: client.snapshot, coverage: await store.coverage(), outbox: entries,
+            bubbles: typeof args.conversationId === "string" ? threadBubbles(rows, entries, args.conversationId) : [],
+            search: typeof args.search === "string" ? searchHeld(rows, args.search) : [],
+            answer, twin: twinLastDecline(), stores: await databaseState(), files: listFiles(), media: currentMedia ? { loaded: currentMedia.loaded, uri: currentMedia.uri } : null };
+        }
+        throw new Error(`unknown witness command ${verb}`);
+      },
+    }, controlUrl);
+    return () => { control.close(); void dispose(); };
+  }, [url, controlUrl]);
+  return client ? <SnapbackProvider client={client}><View style={{ flex: 1 }}><Chat />{media ? <MediaView key={media.nonce} media={media} /> : null}</View></SnapbackProvider>
+    : <Text>{error ?? "Witness connected; waiting for construct."}</Text>;
+}

package/dist/templates/chat/expo/src/screens/Inbox.tsx

@@ -0,0 +1,9 @@
+import React from "react";
+import { Pressable, Text, View } from "react-native";
+import { conversations, type LogRow } from "../../shared/log.js";
+export function Inbox({ rows, onSelect }: { rows: readonly LogRow[]; onSelect(id: string): void }) {
+  return <View accessibilityLabel="Inbox">{conversations(rows).map((item) =>
+    <Pressable key={item.conversationId} onPress={() => onSelect(item.conversationId)} style={{ paddingVertical: 16 }}>
+      <Text style={{ fontWeight: "600" }}>{item.conversationId}</Text><Text>{item.latestBody ?? `${item.messages} messages`}</Text>
+    </Pressable>)}{rows.length === 0 ? <Text>No downloaded messages yet.</Text> : null}</View>;
+}

package/dist/templates/chat/expo/src/screens/Search.tsx

@@ -0,0 +1,10 @@
+import React, { useState } from "react";
+import { Pressable, Text, TextInput, View } from "react-native";
+import { searchHeld, type LogRow } from "../../shared/log.js";
+export function Search({ rows, onOpen }: { rows: readonly LogRow[]; onOpen(id: string): void }) {
+  const [term, setTerm] = useState("");
+  return <View><TextInput accessibilityLabel="Search downloaded messages" placeholder="Search" value={term} onChangeText={setTerm} />
+    {term ? <Text>in downloaded messages</Text> : null}
+    {searchHeld(rows, term).map((row) => <Pressable key={row.messageId} onPress={() => onOpen(row.conversationId)}><Text>{row.message?.body}</Text></Pressable>)}
+  </View>;
+}

package/dist/templates/chat/expo/src/screens/Thread.tsx

@@ -0,0 +1,22 @@
+import React from "react";
+import { ScrollView, Text, View } from "react-native";
+import { api } from "snapback2/client";
+import { AssetImage, AssetVideo, useOutbox, useQuery } from "snapback2/react-native";
+import { intentLabel, threadBubbles, type LogRow } from "../../shared/log.js";
+import { Composer } from "../Composer";
+export function Thread({ conversationId }: { conversationId: string }) {
+  const result = useQuery(api.deliveries.thread, { conversationId, c: null });
+  const { entries } = useOutbox();
+  const rows: LogRow[] = "data" in result && Array.isArray(result.data) ? result.data : [];
+  return <View style={{ flex: 1 }}><ScrollView contentContainerStyle={{ padding: 16 }}>
+    {result.state === "partial" ? <Text>Some messages are not downloaded.</Text> : null}
+    {result.state === "refused" ? <Text>{result.refusal.rewrite ?? result.refusal.message}</Text> : null}
+    {threadBubbles(rows, entries, conversationId).map((bubble) => <View key={bubble.key} testID={`message-${bubble.key}`} style={{ padding: 12, marginVertical: 4, backgroundColor: "#e7edff", borderRadius: 12 }}>
+      {bubble.kind === "pending" ? <><Text>{bubble.body}</Text><Text>{intentLabel(bubble.entry)}</Text></>
+        : <><Text>{bubble.message.body}</Text>
+          {bubble.message.photo ? <AssetImage asset={bubble.message.photo} width={240} /> : null}
+          {bubble.message.clip ? <AssetVideo asset={bubble.message.clip} width={240} /> : null}
+          <Text>{new Date(bubble.at).toLocaleTimeString()}</Text></>}
+    </View>)}
+  </ScrollView><Composer conversationId={conversationId} /></View>;
+}

package/dist/templates/chat/expo/src/witness-state.ts

@@ -0,0 +1,68 @@
+import { Directory, File, Paths } from "expo-file-system";
+import { expoSqliteDriver } from "snapback2/expo";
+import type { AssetRecord, OutboxEntry, RangeStore, StoreSwap } from "snapback2/client";
+
+export const DATABASE = "snapback2-witness.db";
+export interface Configuration { offline: boolean; fault: "carrier" | "none"; name: string; once: string[]; assets: AssetRecord[] }
+const configDirectory = () => new Directory(Paths.document, "snapback2-witness-config");
+const defaultConfiguration = (): Configuration => ({ offline: false, fault: "none", name: "alice", once: [], assets: [] });
+function versions(): File[] {
+  const directory = configDirectory();
+  return directory.exists ? directory.list().filter((file): file is File => file instanceof File && /\/\d{16}\.json$/.test(file.uri)).sort((a, b) => a.uri.localeCompare(b.uri)) : [];
+}
+export async function configuration(): Promise<Configuration> {
+  const file = versions().at(-1);
+  return file ? JSON.parse(await file.text()) : defaultConfiguration();
+}
+let persistTail: Promise<unknown> = Promise.resolve();
+export function persist(patch: Partial<Configuration>): Promise<void> {
+  const write = persistTail.then(async () => {
+    const directory = configDirectory(); directory.create({ intermediates: true, idempotent: true });
+    const previous = versions();
+    const last = previous.at(-1);
+    const sequence = last ? Number(last.uri.match(/(\d{16})\.json$/)![1]) + 1 : 1;
+    const temp = new File(directory, "next.tmp");
+    temp.write(JSON.stringify({ ...await configuration(), ...patch }));
+    // Expo File.move cannot replace an existing destination atomically. Rename
+    // into a fresh numbered leaf; readers choose the latest committed leaf.
+    temp.move(new File(directory, `${String(sequence).padStart(16, "0")}.json`));
+    for (const old of previous) old.delete();
+  });
+  persistTail = write.catch(() => undefined);
+  return write;
+}
+export function listFiles(directory = new Directory(Paths.cache, "snapback2")): string[] {
+  if (!directory.exists) return [];
+  return directory.list().flatMap((item) => item instanceof Directory ? listFiles(item) : [item.uri]);
+}
+export async function databaseState(): Promise<Record<string, unknown>> {
+  const driver = expoSqliteDriver(DATABASE);
+  const result: Record<string, unknown> = {};
+  try {
+    for (const table of ["state", "rows", "answers", "outbox", "bytes"]) {
+      const rows = await driver.all<Record<string, unknown>>(`SELECT * FROM ${table} ORDER BY partition${table === "state" ? "" : ", key"}`);
+      result[table] = rows.map((row) => Object.fromEntries(Object.entries(row).map(([key, value]) =>
+        [key, value instanceof Uint8Array ? Array.from(value) : value])));
+    }
+    return result;
+  } finally { await driver.close(); }
+}
+const markerId = "s2id-eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee-0000000000000001";
+/** A dev-only swap touching every persisted projection with distinct pre/post markers. */
+export async function markerSwap(store: RangeStore, phase: "pre" | "post", entries: OutboxEntry[]): Promise<void> {
+  if (!entries[0]) throw new Error("enqueue both messages before the atomicity marker");
+  const byte = phase === "pre" ? 11 : 22;
+  const swap: StoreSwap = {
+    // The markers are schema-valid rows of real tables: the twin hydrates every held row
+    // through the schema and treats a row of an unknown table as corruption (`hydrating`),
+    // which is the fail-closed answer the spec wants — so a witness marker must look like
+    // the app's own data. A messages row in a conversation no member ever opens.
+    deliveries: [{ op: "deliveries.thread", args: { conversationId: "witness-marker", c: null }, seq: phase === "pre" ? 1 : 2, state: "complete", next: null,
+      data: { $row: { table: "messages", id: "witness-marker" } },
+      rows: [{ table: "messages", id: "witness-marker", row: { id: "witness-marker", conversationId: "witness-marker", authorId: "witness", body: phase, photo: { id: markerId, width: 1, height: 1 }, at: 1 } }],
+      receipt: { ranges: [], absences: [], verdicts: [] } }],
+    outbox: { put: [{ ...entries[0], intent: "__witness", state: "committed", op: "deliveries.post", args: { conversationId: "witness-marker", body: phase }, predicted: false }] },
+    bytes: { put: [{ assetId: markerId, width: null, type: `witness/${phase}`, bytes: new Uint8Array([byte]) }] },
+  };
+  await store.commit(swap);
+}

package/dist/templates/chat/expo/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "expo/tsconfig.base",
+  "compilerOptions": { "strict": true, "skipLibCheck": true },
+  "include": ["App.tsx", "src", "shared", ".snapback/build/api.d.ts"]
+}

package/dist/templates/chat/react/index.html

@@ -0,0 +1,5 @@
+<!doctype html>
+<html lang="en">
+  <head><meta charset="UTF-8" /><meta name="viewport" content="width=device-width, initial-scale=1.0" /><title>Snapback 2 chat</title></head>
+  <body><div id="root"></div><script type="module" src="/src/main.tsx"></script></body>
+</html>