narraeon 0.4.0 → 0.5.1

package/dist/node/runtime/world-revision/WorldRevisionSession.js

@@ -0,0 +1,709 @@
+import { authoringRequestPreviews } from "../authoring/AuthoringRequestSnapshot.js";
+import { createHash } from "node:crypto";
+import { emptyAggregatedModelUsage } from "../../protocol/modelUsage.js";
+import { appendAuthoringUserMessage, ModelToolConversation, rememberAuthoringRequest, } from "../authoring/ModelToolConversation.js";
+import { contentTreeFingerprint } from "../content/ContentTreeFingerprint.js";
+import { equalModelHostBinding } from "../model/ModelHost.js";
+import { settingImprovementPromptForBinding, } from "../play/FileNativePlayPresetStore.js";
+import { WorldDocumentStore } from "../world/WorldDocumentStore.js";
+import { WorldRevisionAuthoringTransaction, worldRevisionRuntimeContract, worldRevisionToolDefinitions, } from "./WorldRevisionAuthoringTransaction.js";
+import { WorldRevisionWorkspaceError } from "./WorldRevisionWorkspace.js";
+/** Conversation orchestration over the shared locked revision worktree. */
+export class WorldRevisionSession {
+    #store;
+    #workspace;
+    #worlds;
+    #compiler;
+    #locale;
+    #bindModelHost;
+    #bindExistingModelHost;
+    #bindPlayPreset;
+    #preview;
+    #conversation = new ModelToolConversation();
+    #changed;
+    #mutationTail = Promise.resolve();
+    constructor(input) {
+        this.#changed =
+            input.changed ??
+                (() => {
+                    /* No observers attached. */
+                });
+        this.#store = input.store;
+        this.#workspace = input.workspace;
+        this.#worlds = input.worlds;
+        this.#compiler = input.compiler;
+        this.#locale = input.locale;
+        this.#bindModelHost = input.bindModelHost;
+        this.#bindExistingModelHost = input.bindExistingModelHost;
+        this.#bindPlayPreset = input.bindPlayPreset;
+        this.#preview = input.preview;
+    }
+    async open(worldId) {
+        await this.#mutate(async () => {
+            await this.#recoverWorldSessions(worldId);
+            await this.#workspace.open(worldId);
+        });
+        return this.overview(worldId);
+    }
+    async activeEpoch(worldId) {
+        return this.#mutate(async () => {
+            const epoch = await this.#workspace.active(worldId);
+            return epoch === null ? null : this.#workspace.view(epoch, true);
+        });
+    }
+    async overview(worldId) {
+        return this.#mutate(async () => {
+            const activeEpoch = await this.#workspace.active(worldId);
+            const [sessions, sealedEpochs] = await Promise.all([
+                this.#recoverWorldSessions(worldId),
+                this.#workspace.sealed(worldId),
+            ]);
+            const latest = sessions[0] ?? null;
+            const shownEpoch = activeEpoch ?? (await this.#workspace.latest(worldId));
+            return {
+                epoch: shownEpoch === null
+                    ? null
+                    : this.#workspace.view(shownEpoch, activeEpoch?.epochId === shownEpoch.epochId),
+                sealedEpochs,
+                latest: latest === null ? null : this.#view(latest),
+                history: sessions.map(historyItem),
+            };
+        });
+    }
+    observeProgress(status) {
+        const selected = status.selected;
+        if (selected === null)
+            return status;
+        return {
+            ...status,
+            selected: {
+                ...selected,
+                progress: {
+                    ...selected.progress,
+                    streaming: this.#conversation.streaming(selected.sessionId),
+                },
+            },
+        };
+    }
+    async status(worldId, sessionId) {
+        return this.#mutate(async () => {
+            const sessions = await this.#store.listSessions(worldId);
+            const selectedIndex = sessionId === undefined
+                ? sessions.length === 0
+                    ? -1
+                    : 0
+                : sessions.findIndex((session) => session.sessionId === sessionId);
+            let selected = selectedIndex < 0 ? null : sessions[selectedIndex];
+            if (selected !== null &&
+                !this.#conversation.isRunning(selected.sessionId) &&
+                (selected.runStatus === "running" ||
+                    selected.pendingSettlement !== null)) {
+                selected = await this.#recoverIfNeeded(selected);
+                sessions[selectedIndex] = selected;
+            }
+            const active = await this.#workspace.active(worldId);
+            const epoch = active ?? (await this.#workspace.latest(worldId));
+            return {
+                revision: statusFingerprint(epoch, sessions),
+                selected: selected === null ? null : this.#statusView(selected),
+            };
+        });
+    }
+    async readSession(worldId, sessionId) {
+        return this.#mutate(async () => {
+            const session = await this.#store.readSession(sessionId);
+            assertWorld(session, worldId);
+            return this.#view(await this.#recoverIfNeeded(session));
+        });
+    }
+    async deleteSession(worldId, sessionId) {
+        await this.#mutate(async () => {
+            if (this.#conversation.isRunning(sessionId))
+                throw new WorldRevisionWorkspaceError("A running world-revision conversation cannot be deleted");
+            const session = await this.#store.readSession(sessionId);
+            assertWorld(session, worldId);
+            await this.#recoverIfNeeded(session);
+            await this.#store.deleteSession(worldId, sessionId);
+        });
+        return this.overview(worldId);
+    }
+    async replaceFiles(input) {
+        await this.#mutate(async () => {
+            await this.#assertNoRunningConversation(input.worldId);
+            await this.#workspace.replace(input);
+        });
+        return this.overview(input.worldId);
+    }
+    async rollback(input) {
+        const result = await this.#mutate(async () => {
+            await this.#assertNoRunningConversation(input.worldId);
+            return this.#workspace.rollback(input);
+        });
+        return {
+            status: result.status,
+            changeSetId: result.changeSetId,
+            path: result.path,
+            changes: result.changes,
+        };
+    }
+    async apply(input) {
+        await this.#mutate(async () => {
+            await this.#assertNoRunningConversation(input.worldId);
+            const epoch = await this.#workspace.active(input.worldId);
+            if (epoch?.epochId !== input.epochId)
+                throw new WorldRevisionWorkspaceError("The world-revision epoch is no longer active");
+            await this.#validateApply(epoch);
+            await this.#workspace.apply(input);
+        });
+        return this.overview(input.worldId);
+    }
+    async discard(input) {
+        await this.#mutate(async () => {
+            await this.#assertNoRunningConversation(input.worldId);
+            await this.#workspace.discard(input);
+        });
+        return this.overview(input.worldId);
+    }
+    async send(input) {
+        const message = requiredMessage(input.message);
+        const requestId = requiredRequestId(input.requestId);
+        const prepared = await this.#mutate(async () => {
+            let session;
+            if (input.continuation.kind === "fresh_context") {
+                session = await this.#store.findByCreationRequest(input.worldId, requestId);
+            }
+            else {
+                session = await this.#store.readSession(input.continuation.sessionId);
+                assertWorld(session, input.worldId);
+            }
+            if (session !== null) {
+                session = await this.#recoverIfNeeded(session);
+                if (session.completedRequestIds.includes(requestId))
+                    return { session, run: null };
+                const running = this.#conversation.running(session.sessionId);
+                if (running !== null) {
+                    if (running.requestId !== requestId)
+                        throw new Error("Another message in this world-revision conversation is still running");
+                    return { session, run: running.promise };
+                }
+            }
+            await this.#assertNoRunningConversation(input.worldId, session?.sessionId);
+            const epoch = await this.#workspace.open(input.worldId);
+            session ??= await this.#create(input.worldId, epoch, requestId);
+            if (session.epochId !== epoch.epochId) {
+                retargetSession(session, epoch, this.#locale());
+                await this.#store.saveSession(session);
+            }
+            const host = await this.#bindExistingModelHost(session.modelBinding);
+            if (!equalModelHostBinding(session.modelBinding, host.binding()))
+                throw new Error("No saved model connection matches this world-revision conversation");
+            const { playPreset, bootstrap } = await this.#compileCurrent(input.worldId, session.modelBinding);
+            session.schemaVersion = 2;
+            session.requests ??= [];
+            session.requests.push({
+                requestId,
+                modelItemStart: session.modelItems.length,
+                bootstrap,
+                playPreset: structuredClone(playPreset),
+            });
+            appendAuthoringUserMessage(session, message, requestId);
+            await this.#store.saveSession(session);
+            return {
+                session,
+                run: this.#startRun(session, host, requestId),
+            };
+        });
+        return prepared.run ?? this.#view(prepared.session);
+    }
+    async preview(worldId, sessionId) {
+        const session = sessionId === undefined ? null : await this.#store.readSession(sessionId);
+        if (session !== null)
+            assertWorld(session, worldId);
+        const host = session === null
+            ? await this.#bindModelHost()
+            : await this.#bindExistingModelHost(session.modelBinding);
+        if (session !== null &&
+            !equalModelHostBinding(session.modelBinding, host.binding()))
+            throw new Error("No compatible saved model connection matches this authoring conversation");
+        const { bootstrap } = await this.#compileCurrent(worldId, host.binding());
+        return bootstrap;
+    }
+    async #compileCurrent(worldId, modelBinding) {
+        const epoch = await this.#workspace.active(worldId);
+        const worlds = await this.#worlds.listWorlds();
+        const playPreset = await this.#bindPlayPreset();
+        const locale = this.#locale();
+        const bootstrap = this.#compiler.compileWorldRevision({
+            ...(epoch === null
+                ? {}
+                : { epoch: { id: epoch.epochId, baseHead: epoch.baseHead } }),
+            worldTitle: worlds.find((world) => world.worldId === worldId)?.title ?? worldId,
+            runtimeContract: worldRevisionRuntimeContract(locale),
+            authorPrompt: settingImprovementPromptForBinding(playPreset, locale),
+            playPreset,
+            modelBinding: modelBinding,
+            tools: worldRevisionToolDefinitions(locale),
+        });
+        return { bootstrap, playPreset };
+    }
+    async cancel(sessionId) {
+        const running = this.#conversation.cancel(sessionId);
+        if (running !== null)
+            return running;
+        return this.#mutate(async () => this.#view(await this.#recoverIfNeeded(await this.#store.readSession(sessionId))));
+    }
+    async #create(worldId, epoch, creationRequestId) {
+        const [host, playPreset, worlds] = await Promise.all([
+            this.#bindModelHost(),
+            this.#bindPlayPreset(),
+            this.#worlds.listWorlds(),
+        ]);
+        const worldTitle = worlds.find((world) => world.worldId === worldId)?.title ?? worldId;
+        const locale = this.#locale();
+        const modelBinding = host.binding();
+        const tools = worldRevisionToolDefinitions(locale);
+        const bootstrap = this.#compiler.compileWorldRevision({
+            epoch: { id: epoch.epochId, baseHead: epoch.baseHead },
+            worldTitle,
+            runtimeContract: worldRevisionRuntimeContract(locale),
+            authorPrompt: settingImprovementPromptForBinding(playPreset, locale),
+            playPreset,
+            modelBinding,
+            tools,
+        });
+        const now = Date.now();
+        const session = {
+            schemaVersion: 1,
+            sessionId: this.#store.createSessionId(),
+            worldId,
+            worldTitle,
+            epochId: epoch.epochId,
+            locale,
+            runStatus: "ready",
+            createdAt: now,
+            updatedAt: now,
+            creationRequestId,
+            bootstrap,
+            modelBinding,
+            playPreset: structuredClone(playPreset),
+            modelItems: [],
+            messages: [],
+            usage: emptyAggregatedModelUsage(),
+            exchange: 0,
+            toolCalls: 0,
+            activeRequestId: null,
+            completedRequestIds: [],
+            lastFailure: null,
+            authorization: null,
+            pendingSettlement: null,
+        };
+        await this.#store.saveSession(session);
+        return session;
+    }
+    #startRun(session, host, requestId) {
+        let activeTransaction = null;
+        return this.#conversation.run({
+            changed: (durable) => this.#changed(session.worldId, durable),
+            session,
+            host,
+            requestId,
+            save: (next) => this.#store.saveSession(next),
+            settleToolResponse: async (next, assistantItemIndex, calls) => {
+                activeTransaction = await this.#settleToolResponse(next, assistantItemIndex, calls, activeTransaction);
+            },
+            view: (next) => this.#view(next),
+            failure: {
+                exchangeLimit: "World revision exceeded 64 model exchanges for one user message",
+                cancelled: "The world-revision response was cancelled. Settled worktree changes were retained.",
+                interrupted: "The world-revision response was interrupted",
+            },
+        });
+    }
+    async #settleToolResponse(session, assistantItemIndex, calls, active) {
+        const epoch = await this.#requiredActiveEpoch(session);
+        const beforeRevision = epoch.revision;
+        session.pendingSettlement = {
+            phase: "response_confirmed",
+            assistantItemIndex,
+            epochId: epoch.epochId,
+            beforeRevision,
+        };
+        session.updatedAt = Date.now();
+        await this.#store.saveSession(session);
+        const binding = await this.#worlds.bindWorldRevision({
+            worldId: epoch.worldId,
+            epochId: epoch.epochId,
+        });
+        const transaction = active?.revision === beforeRevision
+            ? active.transaction
+            : await this.#openTransaction(session, epoch, binding);
+        const rawResults = transaction.execute(calls);
+        const files = transaction.files();
+        const afterRevision = contentTreeFingerprint(files);
+        const toolResults = rawResults.map((result) => ({
+            ...structuredClone(result),
+            changeSetId: result.isError || result.changes.length === 0
+                ? null
+                : this.#store.createChangeSetId(),
+        }));
+        const prepared = {
+            phase: "publication_prepared",
+            assistantItemIndex,
+            epochId: epoch.epochId,
+            beforeRevision,
+            afterRevision,
+            afterFiles: files,
+            toolResults,
+            authorization: transaction.authorization(afterRevision),
+        };
+        session.pendingSettlement = prepared;
+        session.updatedAt = Date.now();
+        await this.#store.saveSession(session);
+        await this.#workspace.publishAi({
+            worldId: epoch.worldId,
+            epochId: epoch.epochId,
+            expectedRevision: beforeRevision,
+            afterRevision,
+            files,
+            toolResults,
+        });
+        finalizeSettlement(session, prepared);
+        session.updatedAt = Date.now();
+        await this.#store.saveSession(session);
+        return { revision: afterRevision, transaction };
+    }
+    async #openTransaction(session, epoch, binding) {
+        const maintenance = await this.#worlds.inspectDocumentMaintenance(epoch.worldId, epoch.baseHead);
+        return new WorldRevisionAuthoringTransaction({
+            baseFiles: epoch.files,
+            immutableBaseFiles: epoch.baseFiles,
+            locale: session.locale,
+            revision: epoch.revision,
+            authorization: session.authorization,
+            preview: (snapshot) => this.#preview({
+                snapshot,
+                modelBinding: session.modelBinding,
+                playPreset: session.requests?.at(-1)?.playPreset ?? session.playPreset,
+                binding,
+                epoch,
+                maintenance,
+            }),
+        });
+    }
+    async #validateApply(epoch) {
+        const [host, playPreset, binding, maintenance] = await Promise.all([
+            this.#bindModelHost(),
+            this.#bindPlayPreset(),
+            this.#worlds.bindWorldRevision({
+                worldId: epoch.worldId,
+                epochId: epoch.epochId,
+            }),
+            this.#worlds.inspectDocumentMaintenance(epoch.worldId, epoch.baseHead),
+        ]);
+        const snapshot = WorldDocumentStore.open({
+            layout: "world_state",
+            files: epoch.files,
+        });
+        if (snapshot.status !== "usable")
+            throw new WorldRevisionWorkspaceError("Only a usable world-revision worktree can be applied");
+        try {
+            this.#preview({
+                snapshot,
+                modelBinding: host.binding(),
+                playPreset,
+                binding,
+                epoch,
+                maintenance,
+            });
+        }
+        catch (error) {
+            throw new WorldRevisionWorkspaceError(`World-revision Prompt Preview failed: ${error instanceof Error ? error.message : "unknown preview failure"}`, error instanceof Error ? { cause: error } : undefined);
+        }
+    }
+    async #recoverIfNeeded(session) {
+        if (this.#conversation.isRunning(session.sessionId))
+            return session;
+        if (session.pendingSettlement !== null) {
+            const pending = session.pendingSettlement;
+            if (pending.phase === "publication_prepared") {
+                const active = await this.#workspace.active(session.worldId);
+                if (active?.epochId === pending.epochId) {
+                    try {
+                        await this.#workspace.publishAi({
+                            worldId: session.worldId,
+                            epochId: pending.epochId,
+                            expectedRevision: pending.beforeRevision,
+                            afterRevision: pending.afterRevision,
+                            files: pending.afterFiles,
+                            toolResults: pending.toolResults,
+                        });
+                        finalizeSettlement(session, pending);
+                    }
+                    catch (error) {
+                        finalizeUnconfirmed(session, pending.assistantItemIndex, error);
+                    }
+                }
+                else
+                    finalizeUnconfirmed(session, pending.assistantItemIndex, new Error("The revision epoch ended before tool publication recovered"));
+            }
+            else
+                finalizeUnconfirmed(session, pending.assistantItemIndex, new Error("Runtime restarted before the complete tool response was prepared"));
+        }
+        if (session.runStatus !== "running" && session.pendingSettlement === null)
+            return session;
+        const requestId = session.activeRequestId;
+        session.runStatus = "interrupted";
+        session.activeRequestId = null;
+        if (requestId !== null)
+            session.completedRequestIds = rememberAuthoringRequest(session.completedRequestIds, requestId);
+        session.lastFailure =
+            "The previous model request stopped after its last settled worktree change. Continue this conversation when ready.";
+        session.updatedAt = Date.now();
+        await this.#store.saveSession(session);
+        return session;
+    }
+    async #requiredActiveEpoch(session) {
+        const epoch = await this.#workspace.active(session.worldId);
+        if (epoch?.epochId !== session.epochId)
+            throw new WorldRevisionWorkspaceError("The conversation's revision epoch is no longer active");
+        return epoch;
+    }
+    async #recoverWorldSessions(worldId) {
+        const sessions = [];
+        for (const stored of await this.#store.listSessions(worldId))
+            sessions.push(await this.#recoverIfNeeded(stored));
+        return sessions;
+    }
+    async #assertNoRunningConversation(worldId, exceptSessionId) {
+        const sessions = await this.#recoverWorldSessions(worldId);
+        if (sessions.some(({ sessionId }) => sessionId !== exceptSessionId &&
+            this.#conversation.isRunning(sessionId)))
+            throw new WorldRevisionWorkspaceError("Wait for or cancel the running AI response before changing the revision");
+    }
+    #view(session) {
+        const streaming = session.runStatus === "running"
+            ? this.#conversation.streaming(session.sessionId)
+            : null;
+        return {
+            requestPreviews: authoringRequestPreviews(session),
+            sessionId: session.sessionId,
+            worldId: session.worldId,
+            epochId: session.epochId,
+            runStatus: streaming === null ? session.runStatus : "running",
+            messages: structuredClone(session.messages),
+            turns: conversationTurns(session),
+            usage: structuredClone(session.usage),
+            progress: {
+                exchange: session.exchange,
+                toolCalls: session.toolCalls,
+                streaming,
+                updatedAt: session.updatedAt,
+            },
+            lastFailure: session.lastFailure,
+        };
+    }
+    #statusView(session) {
+        const streaming = session.runStatus === "running"
+            ? this.#conversation.streaming(session.sessionId)
+            : null;
+        return {
+            sessionId: session.sessionId,
+            runStatus: streaming === null ? session.runStatus : "running",
+            progress: {
+                exchange: session.exchange,
+                toolCalls: session.toolCalls,
+                streaming,
+                updatedAt: session.updatedAt,
+            },
+        };
+    }
+    async #mutate(operation) {
+        const previous = this.#mutationTail;
+        let release = () => undefined;
+        this.#mutationTail = new Promise((resolveMutation) => {
+            release = resolveMutation;
+        });
+        await previous;
+        try {
+            return await operation();
+        }
+        finally {
+            release();
+        }
+    }
+}
+function retargetSession(session, epoch, locale) {
+    const markdown = locale === "zh-CN"
+        ? `# 新的世界修订 epoch\n\n上一轮修订已经应用或放弃。当前工作树是 ${epoch.epochId}，从世界端点 ${epoch.baseHead} 重新建立。此前全部 list/search cursor 和 read 写授权已失效；修改前必须重新读取。`
+        : `# New world-revision epoch\n\nThe previous revision was applied or discarded. Worktree ${epoch.epochId} was rebuilt from world endpoint ${epoch.baseHead}. Every prior list/search cursor and read authorization is invalid; re-read before writing.`;
+    session.modelItems.push({
+        kind: "prompt_delta",
+        logicalMessages: [
+            {
+                role: "runtime_system",
+                markdown,
+                blocks: [
+                    {
+                        source: `runtime:world-revision-epoch:${epoch.epochId}`,
+                        markdown,
+                    },
+                ],
+            },
+        ],
+    });
+    session.epochId = epoch.epochId;
+    session.authorization = null;
+    session.pendingSettlement = null;
+    session.lastFailure = null;
+    session.updatedAt = Date.now();
+}
+function finalizeSettlement(session, pending) {
+    for (const result of pending.toolResults)
+        session.modelItems.push({
+            kind: "tool",
+            toolCallId: result.toolCallId,
+            markdown: result.markdown,
+            ...(result.isError ? { isError: true } : {}),
+            changes: structuredClone(result.changes),
+            changeSetId: result.changeSetId,
+        });
+    session.authorization = structuredClone(pending.authorization);
+    session.toolCalls += pending.toolResults.length;
+    session.pendingSettlement = null;
+}
+function finalizeUnconfirmed(session, assistantItemIndex, error) {
+    const assistant = assistantAt(session, assistantItemIndex);
+    const message = error instanceof Error ? error.message : "unknown failure";
+    for (const call of assistant.toolCalls)
+        session.modelItems.push({
+            kind: "tool",
+            toolCallId: call.id,
+            markdown: `# Revision settlement could not be confirmed\n\n${message}. Re-read the active worktree before editing.`,
+            isError: true,
+            changes: [],
+            changeSetId: null,
+        });
+    session.authorization = null;
+    session.toolCalls += assistant.toolCalls.length;
+    session.pendingSettlement = null;
+}
+function assistantAt(session, itemIndex) {
+    const item = session.modelItems[itemIndex];
+    if (item?.kind !== "assistant" || item.toolCalls.length === 0)
+        throw new Error("Pending world-revision settlement is damaged");
+    return item;
+}
+function conversationTurns(session) {
+    const userMessages = session.messages.filter(({ role }) => role === "user");
+    const turns = [];
+    let userIndex = 0;
+    let exchange = 0;
+    let current = null;
+    let pending = new Map();
+    for (const [itemIndex, item] of session.modelItems.entries()) {
+        if (item.kind === "user") {
+            const persisted = userMessages[userIndex++];
+            current = {
+                id: persisted?.id ?? `${session.sessionId}:turn:${itemIndex}`,
+                user: persisted ??
+                    {
+                        id: `${session.sessionId}:user:${itemIndex}`,
+                        role: "user",
+                        text: item.text,
+                        createdAt: session.createdAt,
+                    },
+                exchanges: [],
+            };
+            turns.push(current);
+            pending = new Map();
+        }
+        else if (item.kind === "assistant" && current !== null) {
+            exchange += 1;
+            const toolCalls = item.toolCalls.map((call) => ({
+                callId: call.id,
+                name: call.name,
+                arguments: structuredClone(call.arguments),
+                result: null,
+            }));
+            current.exchanges.push({
+                id: `${session.sessionId}:exchange:${itemIndex}`,
+                exchange,
+                text: item.text,
+                ...(item.reasoningContent === undefined
+                    ? {}
+                    : { reasoning: item.reasoningContent }),
+                toolCalls,
+            });
+            pending = new Map(toolCalls.map((call) => [call.callId, call]));
+        }
+        else if (item.kind === "tool") {
+            const call = pending.get(item.toolCallId);
+            if (call?.result === null)
+                call.result = {
+                    markdown: item.markdown,
+                    isError: item.isError === true,
+                    changes: structuredClone(item.changes),
+                    changeSetId: item.changeSetId,
+                };
+        }
+    }
+    return turns;
+}
+function historyItem(session) {
+    const assistants = session.modelItems.filter((item) => item.kind === "assistant");
+    const changed = new Set(session.modelItems.flatMap((item) => item.kind === "tool" ? item.changes.map(({ path }) => path) : []));
+    return {
+        sessionId: session.sessionId,
+        epochId: session.epochId,
+        runStatus: session.runStatus,
+        createdAt: session.createdAt,
+        updatedAt: session.updatedAt,
+        excerpt: Array.from((session.messages.find(({ role }) => role === "user")?.text ?? "")
+            .replace(/\s+/gu, " ")
+            .trim())
+            .slice(0, 120)
+            .join(""),
+        turnCount: session.modelItems.filter((item) => item.kind === "user").length,
+        exchangeCount: assistants.length,
+        toolCallCount: assistants.reduce((count, item) => count + item.toolCalls.length, 0),
+        changedFileCount: changed.size,
+    };
+}
+function statusFingerprint(epoch, sessions) {
+    return createHash("sha256")
+        .update(JSON.stringify({
+        epoch: epoch === null
+            ? null
+            : {
+                epochId: epoch.epochId,
+                lifecycle: epoch.lifecycle,
+                revision: epoch.revision,
+                updatedAt: epoch.updatedAt,
+            },
+        sessions: sessions.map((session) => ({
+            sessionId: session.sessionId,
+            epochId: session.epochId,
+            runStatus: session.runStatus,
+            updatedAt: session.updatedAt,
+            exchange: session.exchange,
+            toolCalls: session.toolCalls,
+        })),
+    }))
+        .digest("hex");
+}
+function assertWorld(session, worldId) {
+    if (session.worldId !== worldId)
+        throw new WorldRevisionWorkspaceError("World-revision conversation belongs to another world");
+}
+function requiredMessage(message) {
+    if (message.trim().length === 0)
+        throw new WorldRevisionWorkspaceError("A world-revision message cannot be empty");
+    if (message.length > 64 * 1024)
+        throw new WorldRevisionWorkspaceError("World-revision message is too large");
+    return message;
+}
+function requiredRequestId(requestId) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,159}$/u.test(requestId))
+        throw new WorldRevisionWorkspaceError("Invalid world-revision request ID");
+    return requestId;
+}