@bivy/bivy 0.18.5-staging.4 → 0.18.5-staging.6

package/dist/apps/styles.css

@@ -3056,7 +3056,7 @@ p.setup-note .btn.link { min-height: 44px; margin-block: calc((1lh - 44px) / 2);
 .review-card { margin-block: var(--space-2); max-inline-size: 440px; }
 .review-stage { display: flex; flex-direction: column; align-items: center; gap: var(--space-2); margin: 0 var(--space-3); padding: var(--space-3); border-radius: var(--radius-md); background: var(--surface-2); }
 .review-shot { display: grid; place-items: center; padding: 0; border: 1px solid var(--line); border-radius: var(--radius-md); background: var(--bg); overflow: hidden; cursor: zoom-in; box-shadow: var(--shadow-sm); }
-.review-shot img { display: block; inline-size: auto; block-size: auto; max-inline-size: 100%; max-block-size: min(300px, 40vh); }
+.review-shot img { display: block; inline-size: auto; block-size: auto; max-inline-size: 100%; max-block-size: var(--review-shot-height); }
 .review-loading { display: grid; place-items: center; inline-size: 139px; block-size: min(300px, 40vh); max-inline-size: 100%; }
 .review-gone { margin: 0; padding: var(--space-6) var(--space-3); color: var(--muted); font-size: var(--text-sm); text-align: center; }
 .review-side .seg-btn { min-block-size: 44px; min-inline-size: 72px; }

package/dist/apps/tokens.css

@@ -105,6 +105,9 @@
   --space-1: 4px;  --space-2: 8px;  --space-3: 12px; --space-4: 16px;
   --space-5: 24px; --space-6: 32px; --space-7: 48px; --space-8: 64px;
 
+  /* Stable review thumbnail footprint, including while its bytes load. */
+  --review-shot-height: min(300px, 40vh);
+
   /* ---- Radius ---- */
   --radius: 8px;        /* app default — same value as --radius-md */
   --radius-sm: 6px;

package/dist/relay-attach.js

@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 // Copyright (c) 2026 Petter André Sjulstad
+import { EventTransferReceiver } from "./remote/event-transfer-receiver.js";
 //
 // Relay-tunnelled attach bridge for `bivy run --node <account-node>`.
 //
@@ -155,7 +156,7 @@ async function main() {
         throw new Error("no relay URL available for the target node");
     // 3. open the relay /client socket in the target's room and pair.
     const rly = new WebSocket(`${relayBase}/client?ticket=${encodeURIComponent(ticket)}&nodeId=${encodeURIComponent(args.nodeId)}`);
-    const reassembler = new FrameReassembler();
+    const reassembler = new FrameReassembler({ onReject: message => fail(message) });
     let cipher = null;
     let local = null;
     let paired = false;
@@ -170,6 +171,18 @@ async function main() {
         }
         process.exit(code);
     };
+    const transfers = new EventTransferReceiver({
+        send: async (command) => {
+            if (!cipher || rly.readyState !== WebSocket.OPEN)
+                throw new Error("Relay disconnected");
+            for (const frame of frameMessages(cipher.seal(command)))
+                rly.send(frame);
+        },
+        emit: event => { if (local?.readyState === WebSocket.OPEN)
+            local.send(JSON.stringify(event)); },
+        fault: message => fail(message),
+    });
+    rly.on("close", () => { transfers.reset(); reassembler.reset(); });
     const pairTimer = setTimeout(() => {
         if (!paired)
             fail(`Node "${args.nodeName}" did not respond to pairing — it may be offline.`, 1);
@@ -258,8 +271,7 @@ async function main() {
                 return; // undecryptable frame — ignore
             }
             // Forward the bare terminal.* event to the local attach socket verbatim.
-            if (local && local.readyState === WebSocket.OPEN)
-                local.send(JSON.stringify(event));
+            transfers.accept(event);
         }
     });
     // Stand up the loopback /ws server + spawn attach, only once paired.
@@ -293,8 +305,8 @@ async function main() {
                             rly.send(frame);
                     }
                 }
-                catch {
-                    /* seal/send failure — the relay close handler will surface it */
+                catch (error) {
+                    sock.send(JSON.stringify({ type: "session.error", code: "delivery_failed", error: error.message }));
                 }
             });
             sock.on("close", () => {

package/dist/relay-chunk.js

@@ -11,6 +11,8 @@ export { FRAME_CHUNK_BYTES };
  * chunk messages for large ones.
  */
 export function frameMessages(payload) {
+    if (payload.length > MAX_REASSEMBLY_BYTES)
+        throw new Error("Relay payload exceeds the receiver limit; use a bounded transfer.");
     if (payload.length <= FRAME_CHUNK_BYTES) {
         return [JSON.stringify({ t: "frame", p: payload })];
     }
@@ -23,51 +25,82 @@ export function frameMessages(payload) {
     }
     return out;
 }
-/**
- * Buffers inbound frame chunks and yields the full payload once a group is
- * complete. A non-chunked frame passes straight through.
- */
-export class FrameReassembler {
-    groups = new Map();
-    /**
-     * Feed one inbound frame envelope. Returns the reassembled payload string when
-     * complete (or the payload itself when the frame was not chunked), or null
-     * while more chunks are still outstanding / the frame was invalid.
-     */
-    accept(env) {
-        if (typeof env.p !== "string")
+/** null means incomplete or rejected; onReject distinguishes delivery failure.
+ * Limits apply to aggregate buffering as well as individual messages. */
+export function createFrameReassembler(opts = {}) {
+    const groups = new Map();
+    const rejected = new Map();
+    const maxGroups = opts.maxGroups ?? MAX_REASSEMBLY_GROUPS;
+    const maxBytes = opts.maxBytes ?? MAX_REASSEMBLY_BYTES;
+    const timeoutMs = opts.timeoutMs ?? 30_000;
+    let buffered = 0;
+    const remove = (id) => {
+        const group = groups.get(id);
+        if (group) {
+            clearTimeout(group.timer);
+            buffered -= group.bytes;
+            groups.delete(id);
+        }
+    };
+    const reject = (id, reason) => {
+        remove(id);
+        if (rejected.size >= 256)
+            rejected.delete(rejected.keys().next().value);
+        rejected.set(id, Date.now() + timeoutMs);
+        opts.onReject?.(reason);
+        return null;
+    };
+    const accept = (env) => {
+        for (const [id, expires] of rejected)
+            if (expires <= Date.now())
+                rejected.delete(id);
+        if (!env || typeof env.p !== "string")
             return null;
         if (env.fc === undefined)
-            return env.p; // not chunked
+            return env.p.length <= maxBytes ? env.p : reject("unchunked", "Relay response exceeds the receive limit.");
         const id = String(env.fc);
-        const index = Number(env.fi);
-        const total = Number(env.fn);
-        if (!Number.isInteger(index) || !Number.isInteger(total) || total <= 0 || total > MAX_FRAME_CHUNKS || index < 0 || index >= total) {
+        if (rejected.has(id))
             return null;
-        }
-        let group = this.groups.get(id);
+        const i = Number(env.fi);
+        const n = Number(env.fn);
+        if (!Number.isInteger(i) || !Number.isInteger(n) || n <= 0 || n > MAX_FRAME_CHUNKS || i < 0 || i >= n)
+            return reject(id, "Invalid relay chunk metadata.");
+        let group = groups.get(id);
+        if (group && group.total !== n)
+            return reject(id, "Inconsistent relay chunk count.");
         if (!group) {
-            // Bound concurrent groups; evict the oldest (insertion order) if needed.
-            if (this.groups.size >= MAX_REASSEMBLY_GROUPS) {
-                const oldest = this.groups.keys().next().value;
-                if (oldest !== undefined)
-                    this.groups.delete(oldest);
-            }
-            group = { total, parts: new Array(total), have: 0, bytes: 0 };
-            this.groups.set(id, group);
+            if (groups.size >= maxGroups)
+                return reject(id, "Too many incomplete relay responses.");
+            const timer = setTimeout(() => reject(id, "Relay response timed out before all chunks arrived."), timeoutMs);
+            timer.unref?.();
+            group = { total: n, parts: new Array(n), have: 0, bytes: 0, timer };
+            groups.set(id, group);
         }
-        if (group.parts[index] !== undefined)
-            return null; // duplicate chunk
-        group.parts[index] = env.p;
-        group.have += 1;
-        group.bytes += env.p.length;
-        if (group.bytes > MAX_REASSEMBLY_BYTES) {
-            this.groups.delete(id);
+        if (group.parts[i] !== undefined)
             return null;
-        }
+        if (buffered + env.p.length > maxBytes)
+            return reject(id, "Relay responses exceed the receive memory limit.");
+        group.parts[i] = env.p;
+        group.have++;
+        group.bytes += env.p.length;
+        buffered += env.p.length;
         if (group.have < group.total)
             return null;
-        this.groups.delete(id);
-        return group.parts.join("");
-    }
+        const payload = group.parts.join("");
+        remove(id);
+        // Ignore straggling duplicates of a completed group instead of creating a
+        // new incomplete group that later reports a spurious timeout.
+        if (rejected.size >= 256)
+            rejected.delete(rejected.keys().next().value);
+        rejected.set(id, Date.now() + timeoutMs);
+        return payload;
+    };
+    return Object.assign(accept, { reset() { for (const id of groups.keys())
+            remove(id); rejected.clear(); } });
+}
+export class FrameReassembler {
+    acceptFrame;
+    constructor(options = {}) { this.acceptFrame = createFrameReassembler(options); }
+    accept(env) { return this.acceptFrame(env); }
+    reset() { this.acceptFrame.reset(); }
 }

package/dist/remote/event-transfer-receiver.js

@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+// Standalone node mirror of packages/core/src/event-transfer.ts. The release
+// omits packages/; behavior is covered by the cross-stack transfer tests.
+const unb64 = (data) => Uint8Array.from(atob(data), c => c.charCodeAt(0));
+import { TRANSFER_PAGE_BYTES, MAX_TRANSFER_BYTES } from "../wire-format.js";
+export { TRANSFER_PAGE_BYTES, MAX_TRANSFER_BYTES };
+const MAX_QUEUED_BYTES = 8 * 1024 * 1024;
+/** Deliver complete events in wire order. A history snapshot and its baseline
+ * are never exposed partially; later live events wait behind that snapshot.
+ * Only one page is in flight, with bounded retries and memory. */
+export class EventTransferReceiver {
+    deps;
+    queue = [];
+    queuedBytes = 0;
+    pending;
+    timer;
+    generation = 0;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    accept(event) {
+        if (event.type === "transfer.part") {
+            void this.part(event);
+            return;
+        }
+        if (this.pending || this.queue.length) {
+            this.queuedBytes += new TextEncoder().encode(JSON.stringify(event)).length;
+            if (this.queuedBytes > MAX_QUEUED_BYTES || this.queue.length >= 4096) {
+                this.reset();
+                this.deps.fault("Transcript delivery fell behind. Reconnecting to synchronize again.");
+                return;
+            }
+            this.queue.push(event);
+            return;
+        }
+        this.deliver(event);
+    }
+    deliver(event) {
+        if (event.code !== "transfer_required") {
+            this.deps.emit(event);
+            return;
+        }
+        const offer = event.transfer;
+        if (!offer || !/^[a-f0-9]{48}$/.test(offer.id) || !/^[a-f0-9]{64}$/.test(offer.key) || !/^[a-f0-9]{24}$/.test(offer.iv) ||
+            !Number.isSafeInteger(offer.bytes) || offer.bytes <= 0 || offer.bytes > MAX_TRANSFER_BYTES || offer.pageBytes !== TRANSFER_PAGE_BYTES) {
+            this.deps.emit({ type: "session.error", code: "delivery_invalid", sessionId: event.sessionId, requestId: event.requestId, error: "Invalid large-response transfer. Update the app and retry." });
+            return;
+        }
+        this.pending = { offer, envelope: event, bytes: new Uint8Array(offer.bytes), offset: 0, requestId: "", retries: 0 };
+        this.request();
+    }
+    request() {
+        const pending = this.pending;
+        if (!pending)
+            return;
+        pending.requestId = `transfer-${crypto.randomUUID()}`;
+        clearTimeout(this.timer);
+        this.timer = setTimeout(() => {
+            if (this.pending !== pending)
+                return;
+            if (++pending.retries <= 2)
+                this.request();
+            else
+                this.fail("Large-response delivery timed out. Retry to synchronize.");
+        }, this.deps.timeoutMs ?? 10_000);
+        void this.deps.send({ kind: "transfer.read", transferId: pending.offer.id, offset: pending.offset, requestId: pending.requestId })
+            .catch(() => { if (this.pending === pending)
+            this.fail("Could not request the next response page. Retry to synchronize."); });
+    }
+    async part(event) {
+        const pending = this.pending;
+        // Other paired clients use the same encrypted room; their replies are not ours.
+        if (!pending || event.requestId !== pending.requestId || event.transferId !== pending.offer.id || event.offset !== pending.offset)
+            return;
+        clearTimeout(this.timer);
+        if (typeof event.error === "string") {
+            this.fail(event.error);
+            return;
+        }
+        try {
+            if (typeof event.data !== "string" || event.data.length > Math.ceil(TRANSFER_PAGE_BYTES / 3) * 4)
+                throw new Error("Invalid response page.");
+            const bytes = unb64(event.data);
+            if (bytes.length !== Math.min(TRANSFER_PAGE_BYTES, pending.offer.bytes - pending.offset))
+                throw new Error("Incomplete response page.");
+            pending.bytes.set(bytes, pending.offset);
+            pending.offset += bytes.length;
+            pending.retries = 0;
+            if (pending.offset < pending.offer.bytes) {
+                this.request();
+                return;
+            }
+            // Reject duplicate final pages while the authenticated decryption is asynchronous.
+            pending.requestId = "";
+            const generation = this.generation;
+            const fromHex = (value) => Uint8Array.from(value.match(/../g), pair => parseInt(pair, 16));
+            const key = await crypto.subtle.importKey("raw", fromHex(pending.offer.key), "AES-GCM", false, ["decrypt"]);
+            let plaintext;
+            try {
+                plaintext = await crypto.subtle.decrypt({ name: "AES-GCM", iv: fromHex(pending.offer.iv) }, key, pending.bytes);
+            }
+            catch {
+                throw new Error("Response integrity check failed.");
+            }
+            if (generation !== this.generation || this.pending !== pending)
+                return;
+            const complete = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(plaintext));
+            if (!complete || typeof complete.type !== "string" || complete.code === "transfer_required" || complete.type === "transfer.part")
+                throw new Error("Invalid response envelope.");
+            this.pending = undefined;
+            this.deps.emit(complete);
+            this.drain();
+        }
+        catch (error) {
+            if (this.pending === pending)
+                this.fail(`${error.message} Retry to synchronize.`);
+        }
+    }
+    fail(message) {
+        const envelope = this.pending?.envelope;
+        this.reset();
+        this.deps.emit({ type: "session.error", code: "delivery_failed", sessionId: envelope?.sessionId, requestId: envelope?.requestId, error: message });
+        // Dropping queued events invalidates the stream. Reconnect triggers the
+        // existing history/replay recovery; never apply a tail as a full snapshot.
+        this.deps.fault(message);
+    }
+    drain() {
+        while (!this.pending && this.queue.length) {
+            const next = this.queue.shift();
+            this.queuedBytes -= new TextEncoder().encode(JSON.stringify(next)).length;
+            this.deliver(next);
+        }
+    }
+    reset() {
+        clearTimeout(this.timer);
+        this.pending = undefined;
+        this.queue = [];
+        this.queuedBytes = 0;
+        this.generation++;
+    }
+}

package/dist/remote/event-transfer.js

@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+import { createCipheriv, randomBytes } from "node:crypto";
+// A logical event is immutable while clients pull its pages. Pages are encoded
+// independently, so neither history nor an individual attachment must fit in a
+// single sealed frame. Keep in sync with core/event-transfer.ts (conformance test).
+import { TRANSFER_PAGE_BYTES, MAX_TRANSFER_BYTES } from "../wire-format.js";
+export { TRANSFER_PAGE_BYTES, MAX_TRANSFER_BYTES };
+const MAX_STORED_BYTES = 128 * 1024 * 1024;
+const TTL_MS = 120_000;
+const INLINE_EVENT_BYTES = 4 * 1024 * 1024;
+const MAX_LIFETIME_MS = 10 * 60_000;
+export class EventTransferStore {
+    now;
+    inlineBytes;
+    entries = new Map();
+    bytes = 0;
+    timer;
+    constructor(now = Date.now, inlineBytes = INLINE_EVENT_BYTES) {
+        this.now = now;
+        this.inlineBytes = inlineBytes;
+    }
+    prune() {
+        for (const [id, entry] of this.entries)
+            if (entry.expires <= this.now()) {
+                this.bytes -= entry.body.length;
+                this.entries.delete(id);
+            }
+    }
+    offer(event) {
+        const body = Buffer.from(JSON.stringify(event));
+        if (body.length <= this.inlineBytes)
+            return null;
+        const source = event;
+        const context = { sessionId: source.sessionId, requestId: source.requestId };
+        this.prune();
+        if (body.length + 16 > MAX_TRANSFER_BYTES)
+            return {
+                type: "session.error", ...context, code: "delivery_too_large",
+                error: "This response exceeds the machine's 64 MiB delivery limit. The original data is retained on the machine.",
+            };
+        // Retain only authenticated ciphertext. This is response encryption, not
+        // a password digest or a second durable copy of credential-bearing events.
+        if (this.bytes + body.length + 16 > MAX_STORED_BYTES || this.entries.size >= 16)
+            return {
+                type: "session.error", ...context, code: "delivery_busy", error: "The machine is serving large responses. Please retry shortly.",
+            };
+        const id = randomBytes(24).toString("hex");
+        const key = randomBytes(32);
+        const iv = randomBytes(12);
+        const cipher = createCipheriv("aes-256-gcm", key, iv);
+        // WebCrypto's native AES-GCM layout is ciphertext followed by its tag.
+        const sealed = Buffer.concat([cipher.update(body), cipher.final(), cipher.getAuthTag()]);
+        this.entries.set(id, { body: sealed, key: key.toString("hex"), iv: iv.toString("hex"),
+            expires: this.now() + TTL_MS, deadline: this.now() + MAX_LIFETIME_MS });
+        this.bytes += sealed.length;
+        if (!this.timer) {
+            this.timer = setInterval(() => this.prune(), TTL_MS);
+            this.timer.unref();
+        }
+        // Legacy clients already display session.notice messages. Updated clients consume the
+        // transfer before the reducer sees this compatibility envelope.
+        return { type: "session.notice", ...context, code: "transfer_required",
+            message: "Update the Bivy app to load this large response.",
+            transfer: { id, bytes: sealed.length, key: key.toString("hex"), iv: iv.toString("hex"), pageBytes: TRANSFER_PAGE_BYTES } };
+    }
+    read(command) {
+        this.prune();
+        const { transferId, offset, requestId } = command;
+        const entry = typeof transferId === "string" ? this.entries.get(transferId) : undefined;
+        const base = { type: "transfer.part", transferId, requestId, offset };
+        if (!entry)
+            return { ...base, error: "This response expired. Retry to fetch a fresh snapshot." };
+        if (typeof offset !== "number" || !Number.isSafeInteger(offset) || offset < 0 || offset >= entry.body.length || offset % TRANSFER_PAGE_BYTES !== 0) {
+            return { ...base, error: "Invalid transfer offset." };
+        }
+        entry.expires = Math.min(entry.deadline, this.now() + TTL_MS);
+        return { ...base, data: entry.body.subarray(offset, offset + TRANSFER_PAGE_BYTES).toString("base64") };
+    }
+    clear() { clearInterval(this.timer); this.timer = undefined; this.entries.clear(); this.bytes = 0; }
+}

package/dist/remote/relay-client.js

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 // Copyright (c) 2026 Petter André Sjulstad
 import fs from "node:fs";
+import { EventTransferStore } from "./event-transfer.js";
 import path from "node:path";
 import { WebSocket } from "ws";
 import { seal, sealFrame, openFrame, ReplayGuard } from "../e2e.js";
@@ -94,7 +95,11 @@ export class RelayConnector {
     // explains why instead of silently showing "configured".
     lastErrorMessage;
     replay = new ReplayGuard();
-    reassembler = new FrameReassembler();
+    transfers = new EventTransferStore();
+    reassembler = new FrameReassembler({ onReject: message => {
+            console.warn(`[relay] ${message}`);
+            this.sendEvent({ type: "session.error", code: "delivery_failed", error: message });
+        } });
     pairing;
     onWorkAvailable;
     constructor(config, onClientMessage, options) {
@@ -135,6 +140,8 @@ export class RelayConnector {
         void this.connect();
     }
     stop() {
+        this.transfers.clear();
+        this.reassembler.reset();
         this.options.previews?.disconnect();
         this.closed = true;
         this.ready = false;
@@ -204,7 +211,8 @@ export class RelayConnector {
     sendEvent(event) {
         if (this.ws?.readyState !== WebSocket.OPEN)
             return;
-        const payload = sealFrame(this.roomKey(), event);
+        const offered = event?.type === "transfer.part" ? null : this.transfers.offer(event);
+        const payload = sealFrame(this.roomKey(), offered ?? event);
         // Large events (big file reads, long diffs, image attachments) are split
         // into multiple relay frames so none exceeds the relay's max-frame limit;
         // the client reassembles them before decrypting.
@@ -395,7 +403,11 @@ export class RelayConnector {
                         console.warn("[relay] dropped stale or replayed client frame");
                         return;
                     }
-                    this.onClientMessage(frame.data);
+                    const command = frame.data;
+                    if (command.kind === "transfer.read")
+                        this.sendEvent(this.transfers.read(command));
+                    else
+                        this.onClientMessage(command);
                 }
                 catch {
                     console.warn("[relay] failed to decrypt client frame");
@@ -424,6 +436,7 @@ export class RelayConnector {
         ws.on("close", () => {
             if (this.ws !== ws)
                 return;
+            this.reassembler.reset();
             this.options.previews?.disconnect();
             this.ready = false;
             this.remoteClients = 0;

package/dist/server.js

@@ -55,6 +55,7 @@ import { createSessionNamer, fallbackSessionName } from "./session/session-namer
 import { createBranchPublish } from "./session/branch-publish.js";
 import { createForkStandUp } from "./session/fork-standup.js";
 import { createForkRetire } from "./session/fork-retire.js";
+import { createClientProjection } from "./session/client-projection.js";
 import { createTranscriptPersistence } from "./session/transcript-persistence.js";
 import { createRunTerminals } from "./session/run-terminal.js";
 import { createRunLogStore } from "./session/run-log-store.js";
@@ -1450,7 +1451,11 @@ const commands = [
 // A local client whose send buffer has grown past this is behind on reads (slow
 // network, background tab); used by both broadcast paths below.
 const CLIENT_BACKPRESSURE_BYTES = 8 * 1024 * 1024;
+let projectClientMessage;
 function broadcast(payload) {
+    const p = payload;
+    if (p?.type === "session.event" && p.sessionId && projectClientMessage)
+        payload = projectClientMessage(p.sessionId, payload);
     const data = JSON.stringify(payload);
     for (const client of clients) {
         if (client.readyState !== WebSocket.OPEN)
@@ -1481,6 +1486,9 @@ function broadcast(payload) {
 // out as broadcast(), but skips any local client that is backed up: dropping a
 // superseded update is lossless because a newer one always follows.
 function broadcastCoalesced(payload) {
+    const p = payload;
+    if (p?.type === "session.event" && p.sessionId && projectClientMessage)
+        payload = projectClientMessage(p.sessionId, payload);
     const data = JSON.stringify(payload);
     for (const client of clients) {
         if (client.readyState !== WebSocket.OPEN)
@@ -1630,6 +1638,7 @@ const attachmentStore = new AttachmentStore(path.join(appDir, "attachments"), {
     maxStoreBytes: positiveEnvNumber("BIVY_ATTACHMENT_STORE_MAX_BYTES", 2 * 1024 * 1024 * 1024),
     retentionMs: positiveEnvNumber("BIVY_ATTACHMENT_RETENTION_MS", 30 * 24 * 60 * 60 * 1000),
 });
+projectClientMessage = createClientProjection(attachmentStore, eventLog);
 let attachmentGcStats = attachmentStore.stats();
 function referencedAttachmentHashes() {
     // If transcript history is unreadable, collecting nothing would make its

package/dist/session/client-projection.js

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+import { createHash } from "node:crypto";
+/** A display-only projection. Never edit runtime messages or persisted bases:
+ * the model still needs its native image blocks when a session resumes. */
+export function createClientProjection(store, log) {
+    const refs = new Map();
+    return (sessionId, value) => {
+        let retained;
+        let changed = false;
+        function visit(value) {
+            if (!value || typeof value !== "object")
+                return value;
+            if (Array.isArray(value))
+                return value.map(visit);
+            const block = value;
+            const source = block.source;
+            let data;
+            let mime;
+            if (block.type === "image") {
+                data = block.data ?? (source?.type === "base64" ? source.data : undefined);
+                mime = block.mimeType ?? source?.media_type;
+            }
+            else if (block.type === "image_url" || block.type === "input_image") {
+                const url = typeof block.image_url === "string" ? block.image_url : block.image_url?.url;
+                if (typeof url === "string") {
+                    const match = /^data:(image\/[a-zA-Z0-9.+-]+);base64,([\s\S]*)$/.exec(url);
+                    if (match) {
+                        mime = match[1];
+                        data = match[2];
+                    }
+                }
+            }
+            if (typeof data === "string") {
+                try {
+                    if (data.length > 36 * 1024 * 1024 || !/^[A-Za-z0-9+/]*={0,2}$/.test(data) || data.length % 4 === 1)
+                        throw new Error("Invalid image encoding");
+                    const mimeType = typeof mime === "string" && /^image\/[a-zA-Z0-9.+-]+$/.test(mime) ? mime : "image/png";
+                    const cacheKey = createHash("sha256").update(mimeType).update(data).digest("hex");
+                    let ref = refs.get(cacheKey);
+                    if (!ref || !store.getPath(ref.hash)) {
+                        ref = store.put(Buffer.from(data, "base64"), { name: `image.${mimeType.split("/")[1]}`, mimeType, kind: "image" });
+                        if (refs.size >= 1024)
+                            refs.delete(refs.keys().next().value);
+                        refs.set(cacheKey, ref);
+                    }
+                    const url = `bivy-embedded:${ref.hash}`;
+                    retained ??= new Set(log.readInlineImages(sessionId).map(([url]) => url));
+                    if (!retained.has(url)) {
+                        log.appendInlineImage(sessionId, { url, ref });
+                        retained.add(url);
+                        changed = true;
+                    }
+                    return { type: "bivy_attachment", ref };
+                }
+                catch {
+                    // Failure is visible in the display, while original data remains in
+                    // the native transcript. Never fall back to sending the huge bytes.
+                    return { type: "text", text: "[Image unavailable: could not store this image for display. The original is retained on the machine.]" };
+                }
+            }
+            // Only recognized image blocks are rewritten. Arbitrary strings and tool
+            // arguments remain byte-for-byte intact, including large textual results.
+            return Object.fromEntries(Object.entries(block).map(([key, child]) => [key, visit(child)]));
+        }
+        const projected = visit(value);
+        if (changed)
+            log.flush(sessionId);
+        return projected;
+    };
+}

package/dist/session/sibling-client.js

@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 // Copyright (c) 2026 Petter André Sjulstad
+import { EventTransferReceiver } from "../remote/event-transfer-receiver.js";
 //
 // A NODE acting as a relay CLIENT of a sibling node it co-owns — the transport
 // that lets an owner daemon stream replication frames to its standby
@@ -30,7 +31,12 @@ export class SiblingClient {
     ws;
     cipher;
     keypair = newDeviceKeypair();
-    reassembler = new FrameReassembler();
+    reassembler = new FrameReassembler({ onReject: () => this.ws?.close() });
+    transfers = new EventTransferReceiver({
+        send: async (command) => this.sendSealed(command),
+        emit: event => this.dispatchEvent(event),
+        fault: () => this.ws?.close(),
+    });
     pending = new Map();
     paired;
     resolvePaired;
@@ -101,7 +107,7 @@ export class SiblingClient {
                 return;
             try {
                 const frame = this.cipher.open(full);
-                this.dispatchEvent(frame.data);
+                this.transfers.accept(frame.data);
             }
             catch {
                 /* undecryptable frame — ignore */
@@ -179,6 +185,8 @@ export class SiblingClient {
         return (await res.json());
     }
     handleClose() {
+        this.transfers.reset();
+        this.reassembler.reset();
         if (this.closed)
             return;
         for (const [, waiter] of this.pending) {
@@ -190,6 +198,8 @@ export class SiblingClient {
         this.opts.onClose?.();
     }
     close() {
+        this.transfers.reset();
+        this.reassembler.reset();
         this.closed = true;
         try {
             this.ws?.close();

package/dist/session/transcript-persistence.js

@@ -13,6 +13,7 @@
 // so its logic is unit-testable without a live daemon. The EventLog /
 // AttachmentStore singletons stay server-owned (GC, delete, replication use them)
 // and are injected.
+import { createClientProjection } from "./client-projection.js";
 import { randomBytes } from "node:crypto";
 import { mergeBases } from "./event-log.js";
 import { thinkingTextFromContent } from "./transcript-merge.js";
@@ -72,6 +73,7 @@ function thinkingTextFromEvent(event) {
 const INLINE_IMAGE_RETRY_COOLDOWN_MS = 10 * 60 * 1000;
 export function createTranscriptPersistence(deps) {
     const { eventLog, attachmentStore } = deps;
+    const project = createClientProjection(attachmentStore, eventLog);
     const liveIntermediateBySession = new Map();
     const lastPersistedIntermediateText = new Map();
     // In-flight dedupe + failure cooldown so a repeated remote image URL only ever
@@ -204,7 +206,8 @@ export function createTranscriptPersistence(deps) {
         return eventLog.deriveHistory(record.id, record.session.getMessages());
     }
     function buildHistoryEvent(opts) {
-        const delta = historyDelta(opts.messages, opts.cursor);
+        const messages = opts.sessionId ? project(opts.sessionId, opts.messages) : opts.messages;
+        const delta = historyDelta(messages, opts.cursor);
         const record = opts.sessionId ? deps.getOpenSession(opts.sessionId) : undefined;
         const bSess = record ? deps.bivySessionEnvelope(record) : undefined;
         return {
@@ -244,7 +247,7 @@ export function createTranscriptPersistence(deps) {
             epoch: deps.streamEpoch,
             mode: outcome.mode,
             head: outcome.head,
-            events: outcome.mode === "replay" ? outcome.events : [],
+            events: outcome.mode === "replay" ? project(sessionId, outcome.events) : [],
         };
     }
     return {

package/dist/wire-format.js

@@ -69,3 +69,6 @@ export const FRAME_CHUNK_BYTES = 192 * 1024;
 export const MAX_REASSEMBLY_BYTES = 32 * 1024 * 1024;
 export const MAX_FRAME_CHUNKS = 4096;
 export const MAX_REASSEMBLY_GROUPS = 16;
+/** Independently sealed large-response pages and maximum logical JSON size. */
+export const TRANSFER_PAGE_BYTES = 384 * 1024;
+export const MAX_TRANSFER_BYTES = 64 * 1024 * 1024;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bivy/bivy",
-  "version": "0.18.5-staging.4",
+  "version": "0.18.5-staging.6",
   "type": "module",
   "license": "AGPL-3.0-only",
   "description": "Run coding agents on machines you own. Open-source, self-hostable agent workspace.",