@cjhyy/code-shell-web 0.9.29 → 0.9.31

package/dist/lib/mobileOutputRecovery.js

@@ -0,0 +1,123 @@
+import { applyOutputJournalPage, compareOutputCursors, } from "./outputJournalRecovery.js";
+import { initialChatState, reduceStream } from "./streamReducer.js";
+/** Valid identities may arrive before their new Core Run acquires a durable anchor. */
+export class MobilePendingInput extends Error {
+    ids;
+    constructor(ids) {
+        super("Recovery input has no recorded anchor");
+        this.ids = ids;
+    }
+}
+/** No journal has ever been published by this explicitly journal-owned producer. */
+export class MobileAwaitingJournal extends Error {
+    constructor() {
+        super("Awaiting the first durable output cursor");
+    }
+}
+/** Verified pages progressed, but the observed live head kept moving within the bound. */
+export class MobileOutputCatchupPending extends Error {
+    cursor;
+    resume;
+    constructor(cursor, resume) {
+        super("Recovery could not catch up within its bound");
+        this.cursor = cursor;
+        this.resume = resume;
+    }
+}
+/** Build a private candidate, then join its frozen prefix to an actual Main snapshot. */
+export async function recoverMobileOutput(args) {
+    let reply = await args.read({});
+    if (!args.canContinue())
+        throw new Error("Recovery cancelled");
+    if (reply.page.status === "unavailable" && args.requireJournal) {
+        const snapshot = reply.snapshot;
+        if (!snapshot ||
+            snapshot.unpaired ||
+            !snapshot.epoch ||
+            !Number.isSafeInteger(snapshot.nextSeq) ||
+            snapshot.nextSeq < 1)
+            throw new Error("Required output journal is unavailable");
+        if (snapshot.outputCursor || args.latestCursor()) {
+            // The first canonical commit may happen after Main's unavailable read
+            // but before its snapshot/live reply. Re-read once, requiring real proof.
+            reply = await args.read({});
+            if (!args.canContinue())
+                throw new Error("Recovery cancelled");
+            if (reply.page.status === "unavailable")
+                throw new Error("Required output journal is unavailable");
+        }
+        else
+            throw new MobileAwaitingJournal();
+    }
+    if (reply.page.status === "unavailable")
+        return null;
+    if (reply.page.status !== "ok" ||
+        !reply.legacyBaseComplete ||
+        !reply.legacyBase ||
+        !Array.isArray(reply.legacyBase.events) ||
+        reply.legacyBase.events[0]?.type !== "session_started" ||
+        reply.legacyBase.throughEventId !== reply.page.legacyBaseThroughEventId ||
+        new TextEncoder().encode(JSON.stringify(reply.legacyBase)).length > 1024 * 1024 + 4096)
+        throw new Error("Recovery base is incomplete");
+    let chat = initialChatState();
+    for (const event of reply.legacyBase.events)
+        chat = reduceStream(chat, event);
+    // A legacy transcript establishes display history, never live completion.
+    chat = { ...chat, run: chat.run === "error" ? "error" : "idle", liveByAgent: {} };
+    let recovery = { incomplete: false };
+    let pages = 0;
+    // A continuation retains the verified private candidate and the same total
+    // page budget. No prefix is published until the eventual frozen join passes.
+    const advance = async () => {
+        for (let round = 0; round < 8; round++) {
+            while (true) {
+                if (!args.canContinue() || ++pages > 2048)
+                    throw new Error("Recovery cancelled or bounded");
+                const complete = applyOutputJournalPage(recovery, reply.page, (event) => {
+                    chat = reduceStream(chat, event);
+                });
+                if (recovery.incomplete)
+                    throw new Error("Recovery is incomplete");
+                if (complete)
+                    break;
+                reply = await args.read({ after: recovery.cursor, through: recovery.through });
+            }
+            if (!args.canContinue())
+                throw new Error("Recovery cancelled");
+            const snapshot = reply.snapshot;
+            if (!snapshot ||
+                snapshot.unpaired ||
+                !snapshot.epoch ||
+                !Number.isSafeInteger(snapshot.nextSeq) ||
+                snapshot.nextSeq < 1)
+                throw new Error("Recovery snapshot is unpaired");
+            let target = recovery.cursor;
+            for (const value of [snapshot.outputCursor, args.latestCursor()]) {
+                if (value === undefined)
+                    continue;
+                const order = compareOutputCursors(value, target);
+                if (order === undefined)
+                    throw new Error("Recovery identity changed");
+                if (order > 0)
+                    target = value;
+            }
+            if (target === recovery.cursor) {
+                const ids = snapshot.inputIds;
+                if (ids !== undefined &&
+                    (!Array.isArray(ids) ||
+                        ids.length > 128 ||
+                        new Set(ids).size !== ids.length ||
+                        ids.some((id) => typeof id !== "string" || !id.trim() || id.length > 512)))
+                    throw new Error("Recovery input identity is unpaired");
+                const missing = ids?.filter((id) => !chat.items.some((item) => item.kind === "user" && item.clientMessageId === id));
+                if (missing?.length)
+                    throw new MobilePendingInput(missing);
+                return { chat, outputCursor: recovery.cursor, snapshot };
+            }
+            recovery = { incomplete: false, cursor: recovery.appliedCursor };
+            reply = await args.read({ after: recovery.cursor, through: target });
+        }
+        throw new MobileOutputCatchupPending(recovery.cursor, advance);
+    };
+    return advance();
+}