@playcraft/cli 0.1.50-beta → 0.1.51

package/dist/workspace-runtime/codex/ui-tools.js

@@ -1,203 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { workspaceUiCommandSchema, workspaceUiResultSchema, WORKSPACE_UI_COMMAND_EVENT, WORKSPACE_UI_RESULT_EVENT, } from '@playcraft/common/cloud-workspace/runtime';
-import { rejectTool } from './tool-response.js';
-export const WORKSPACE_UI_TOOLS = [
-    { type: 'function', name: 'playcraft_get_ui_context',
-        description: 'Read the PlayCraft browser view captured when the user sent this turn. This is a turn-start snapshot, not a live browser observation or visual verification. Only the visible panel target is returned by default; request open tabs only when needed.',
-        inputSchema: { type: 'object', properties: { includeOpenTabs: { type: 'boolean' } }, additionalProperties: false } },
-    { type: 'function', name: 'playcraft_open_file',
-        description: 'Open a file in the current PlayCraft workspace browser view. Use a workspace-relative path and an optional line range. The result confirms selection, not visual verification.',
-        inputSchema: { type: 'object', properties: { path: { type: 'string' }, range: { type: 'object',
-                    properties: { startLine: { type: 'integer', minimum: 1 }, endLine: { type: 'integer', minimum: 1 } },
-                    required: ['startLine', 'endLine'], additionalProperties: false } }, required: ['path'], additionalProperties: false } },
-    { type: 'function', name: 'playcraft_open_preview',
-        description: 'Open an existing preview in the current PlayCraft workspace browser view. Omit identifiers for the latest available preview. Opening does not start a build or verify the rendered appearance.',
-        inputSchema: { type: 'object', properties: { artifactId: { type: 'string' }, versionId: { type: 'string' },
-                previewId: { type: 'string' } }, additionalProperties: false } },
-    { type: 'function', name: 'playcraft_open_delivery',
-        description: 'Open the delivery panel in the current PlayCraft workspace browser view. Opening does not start or verify a build.',
-        inputSchema: { type: 'object', properties: { channel: { type: 'string' }, buildId: { type: 'string' } },
-            additionalProperties: false } },
-    { type: 'function', name: 'playcraft_open_task',
-        description: 'Open the task panel in the current PlayCraft workspace browser view. Opening does not change task state.',
-        inputSchema: { type: 'object', properties: { taskId: { type: 'string' } }, additionalProperties: false } },
-];
-/** Read the saved view locally; browser commands have a separate receipt lifecycle. */
-export class WorkspaceUiTools {
-    emit;
-    timeoutMs;
-    pending = new Map();
-    settled = new Map();
-    constructor(emit, timeoutMs = 20_000) {
-        this.emit = emit;
-        this.timeoutMs = timeoutMs;
-    }
-    request(requestId, params, client, snapshot) {
-        const threadId = typeof params.threadId === 'string' ? params.threadId : '';
-        const turnId = typeof params.turnId === 'string' ? params.turnId : '';
-        if (!snapshot || !threadId || !turnId) {
-            void this.reject(client, requestId, 'ui_view_unavailable');
-            return;
-        }
-        const args = params.arguments;
-        if (params.namespace || !args || typeof args !== 'object' || Array.isArray(args)) {
-            void this.reject(client, requestId, 'invalid_ui_tool_arguments');
-            return;
-        }
-        if (params.tool === 'playcraft_get_ui_context') {
-            const input = args;
-            if (Object.keys(input).some(key => key !== 'includeOpenTabs')
-                || (input.includeOpenTabs !== undefined && typeof input.includeOpenTabs !== 'boolean')) {
-                void this.reject(client, requestId, 'invalid_ui_tool_arguments');
-                return;
-            }
-            void client.respond(requestId, { success: true, contentItems: [{ type: 'inputText',
-                        text: JSON.stringify(viewContext(snapshot, input.includeOpenTabs === true)) }] }).catch(() => undefined);
-            return;
-        }
-        const kind = params.tool === 'playcraft_open_file' ? 'open_file'
-            : params.tool === 'playcraft_open_preview' ? 'open_preview'
-                : params.tool === 'playcraft_open_delivery' ? 'open_delivery'
-                    : params.tool === 'playcraft_open_task' ? 'open_task' : undefined;
-        const allowed = kind === 'open_file' ? ['path', 'range']
-            : kind === 'open_preview' ? ['artifactId', 'versionId', 'previewId']
-                : kind === 'open_delivery' ? ['channel', 'buildId'] : ['taskId'];
-        if (!kind || Object.keys(args).some(key => !allowed.includes(key))) {
-            void this.reject(client, requestId, 'invalid_ui_tool_arguments');
-            return;
-        }
-        if (this.pending.size >= 32) {
-            void this.reject(client, requestId, 'ui_commands_busy');
-            return;
-        }
-        const commandId = randomUUID();
-        const envelope = { commandId, viewId: snapshot.viewId, workspaceId: snapshot.workspaceId,
-            directoryName: snapshot.directoryName, sessionId: snapshot.sessionId,
-            expiresAt: new Date(Date.now() + this.timeoutMs).toISOString() };
-        const parsed = workspaceUiCommandSchema.safeParse({ ...args, ...envelope, kind });
-        if (!parsed.success) {
-            void this.reject(client, requestId, 'invalid_ui_tool_arguments');
-            return;
-        }
-        const command = parsed.data;
-        const timer = setTimeout(() => {
-            void this.finish(commandId, { commandId, viewId: command.viewId, status: 'failed', reason: 'ui_command_timeout' });
-        }, this.timeoutMs);
-        timer.unref?.();
-        this.pending.set(commandId, { requestId, threadId, turnId, command, client, timer });
-        this.emit({ kind: 'notification', method: WORKSPACE_UI_COMMAND_EVENT, occurredAt: new Date().toISOString(),
-            params: { ...command, threadId, turnId } });
-    }
-    async respond(sessionId, value) {
-        const parsed = workspaceUiResultSchema.safeParse(value);
-        if (!parsed.success)
-            return { outcome: 'failed', error: 'invalid_ui_result' };
-        const result = parsed.data;
-        const fingerprint = JSON.stringify(result);
-        const done = this.settled.get(result.commandId);
-        if (done)
-            return done.sessionId === sessionId && done.viewId === result.viewId && done.fingerprint === fingerprint
-                ? done.result : { outcome: 'failed', error: 'ui_command_expired' };
-        const pending = this.pending.get(result.commandId);
-        if (!pending || pending.command.sessionId !== sessionId || pending.command.viewId !== result.viewId)
-            return { outcome: 'failed', error: 'ui_command_unavailable' };
-        if (Date.now() >= Date.parse(pending.command.expiresAt)) {
-            await this.finish(result.commandId, { commandId: result.commandId, viewId: result.viewId, status: 'failed', reason: 'ui_command_timeout' });
-            return { outcome: 'failed', error: 'ui_command_expired' };
-        }
-        const snapshot = result.snapshot;
-        const command = pending.command;
-        if (snapshot && (snapshot.viewId !== command.viewId || snapshot.sessionId !== command.sessionId
-            || snapshot.workspaceId !== command.workspaceId || snapshot.directoryName !== command.directoryName))
-            return { outcome: 'failed', error: 'ui_result_scope_mismatch' };
-        const targetTab = command.kind === 'open_file' ? 'files'
-            : command.kind === 'open_preview' ? 'preview' : command.kind;
-        if (result.status === 'opened' && (!snapshot?.panelOpen
-            || (command.kind === 'open_file' && (!isAssetTab(snapshot.activeTab) || snapshot.activeFile?.path !== command.path
-                || (command.range && (snapshot.activeFile.range?.startLine !== command.range.startLine
-                    || snapshot.activeFile.range?.endLine !== command.range.endLine))))
-            || (command.kind === 'open_preview' && (snapshot.activeTab !== 'preview' || !snapshot.activePreview
-                || (command.artifactId && snapshot.activePreview.artifactId !== command.artifactId)
-                || (command.versionId && snapshot.activePreview.versionId !== command.versionId)
-                || (command.previewId && snapshot.activePreview.previewId !== command.previewId)))
-            || (command.kind !== 'open_file' && command.kind !== 'open_preview' && snapshot.activeTab !== targetTab)
-            || (command.kind === 'open_delivery' && ((command.channel !== undefined && snapshot.activeDelivery?.channel !== command.channel)
-                || (command.buildId !== undefined && snapshot.activeDelivery?.buildId !== command.buildId)))
-            || (command.kind === 'open_task' && command.taskId !== undefined && snapshot.activeTask?.taskId !== command.taskId)))
-            return { outcome: 'failed', error: 'ui_result_target_mismatch' };
-        return this.finish(result.commandId, result, fingerprint);
-    }
-    async cancel(threadId, reason = 'ui_command_cancelled') {
-        await Promise.all([...this.pending].filter(([, pending]) => !threadId || pending.threadId === threadId)
-            .map(([commandId, pending]) => this.finish(commandId, { commandId, viewId: pending.command.viewId, status: 'failed', reason })));
-    }
-    async reject(client, requestId, reason) {
-        await rejectTool(client, requestId, reason);
-    }
-    async finish(commandId, result, fingerprint) {
-        const pending = this.pending.get(commandId);
-        if (!pending)
-            return { outcome: 'failed', error: 'ui_command_expired' };
-        this.pending.delete(commandId);
-        clearTimeout(pending.timer);
-        const saved = { sessionId: pending.command.sessionId, viewId: pending.command.viewId,
-            fingerprint, result: { outcome: 'uncertain', turnId: pending.turnId } };
-        this.settled.set(commandId, saved);
-        if (this.settled.size > 256)
-            this.settled.delete(this.settled.keys().next().value);
-        try {
-            await pending.client.respond(pending.requestId, { success: result.status === 'opened',
-                contentItems: [{ type: 'inputText', text: JSON.stringify(openedContext(pending.command, result)) }] });
-            saved.result = { outcome: 'accepted', turnId: pending.turnId };
-        }
-        catch { /* A closed transport cannot confirm delivery. */ }
-        this.emit({ kind: 'notification', method: WORKSPACE_UI_RESULT_EVENT, occurredAt: new Date().toISOString(),
-            params: { ...result, sessionId: pending.command.sessionId, threadId: pending.threadId, turnId: pending.turnId } });
-        return saved.result;
-    }
-}
-function isAssetTab(tab) {
-    return tab === 'files' || Boolean(tab?.startsWith('files:'));
-}
-function viewContext(snapshot, includeOpenTabs) {
-    const file = snapshot.panelOpen && isAssetTab(snapshot.activeTab) ? snapshot.activeFile : undefined;
-    const preview = snapshot.panelOpen && snapshot.activeTab === 'preview' ? snapshot.activePreview : undefined;
-    return {
-        source: 'turn_start',
-        panelOpen: snapshot.panelOpen,
-        activeTab: snapshot.activeTab,
-        ...(file ? { activeFile: { path: file.path, ...(file.range ? { range: file.range } : {}),
-                dirty: file.dirty, loadState: file.loadState } } : {}),
-        ...(preview ? { activePreview: previewContext(preview) } : {}),
-        ...(includeOpenTabs ? { openTabs: snapshot.openTabs.slice(0, 32) } : {}),
-    };
-}
-function previewContext(preview) {
-    return {
-        ...(preview.artifactId ? { artifactId: preview.artifactId } : {}),
-        ...(preview.versionId ? { versionId: preview.versionId } : {}),
-        ...(preview.previewId ? { previewId: preview.previewId } : {}),
-        ...(preview.name ? { name: preview.name } : {}),
-        ...(preview.path ? { path: preview.path } : {}),
-        ...(preview.kind ? { kind: preview.kind } : {}),
-        ...(preview.versionCreatedAt ? { versionCreatedAt: preview.versionCreatedAt } : {}),
-        ...(preview.isCurrentVersion !== undefined ? { isCurrentVersion: preview.isCurrentVersion } : {}),
-        loadState: preview.loadState,
-        ...(preview.viewport ? { viewport: preview.viewport } : {}),
-    };
-}
-function openedContext(command, result) {
-    const file = result.status === 'opened' && command.kind === 'open_file' ? result.snapshot?.activeFile : undefined;
-    const preview = result.status === 'opened' && command.kind === 'open_preview' ? result.snapshot?.activePreview : undefined;
-    return {
-        status: result.status,
-        ...(result.reason ? { reason: result.reason } : {}),
-        ...(file ? { file: { path: file.path, ...(file.range ? { range: file.range } : {}), loadState: file.loadState } } : {}),
-        ...(preview ? { preview: {
-                ...(preview.artifactId ? { artifactId: preview.artifactId } : {}),
-                ...(preview.versionId ? { versionId: preview.versionId } : {}),
-                ...(preview.previewId ? { previewId: preview.previewId } : {}),
-                loadState: preview.loadState,
-            } } : {}),
-    };
-}

package/dist/workspace-runtime/codex/work-mode.js

@@ -1,15 +0,0 @@
-export function workModeExecution(execution, workMode) {
-    return workMode === 'plan' ? {
-        ...execution, approvalPolicy: 'never', sandboxPolicy: { type: 'readOnly', networkAccess: false },
-    } : execution;
-}
-export function nativeCollaborationMode(model, effort, workMode) {
-    return {
-        mode: workMode === 'plan' ? 'plan' : 'default',
-        settings: {
-            model,
-            reasoning_effort: effort === 'max' ? 'xhigh' : effort ?? null,
-            developer_instructions: null,
-        },
-    };
-}

package/dist/workspace-runtime/main.js

@@ -1,10 +0,0 @@
-import { runWorkspaceRuntimeServe } from '../commands/workspace-runtime.js';
-const flag = process.argv.indexOf('--config');
-const configPath = flag >= 0 ? process.argv[flag + 1] : undefined;
-if (!configPath) {
-    console.error('workspace-runtime: missing --config');
-    process.exitCode = 2;
-}
-else {
-    await runWorkspaceRuntimeServe(configPath);
-}

package/dist/workspace-runtime/persistence/journal.js

@@ -1,365 +0,0 @@
-import { copyFile, mkdir, readFile, writeFile } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { workspaceRegistrationSchema, operationRecordSchema, pendingSourceEventSchema, replayPinResultSchema, retainedRangeHasGap, sourceAckSchema, sourceEventKey, sourceEventReceiptSchema, terminalRecordSchema, } from '@playcraft/common/cloud-workspace/runtime';
-import { SqliteWorkerClient } from './sqlite-client.js';
-export const RUNTIME_STATE_FILE = 'runtime-state.sqlite';
-export const LEGACY_JOURNAL_FILE = 'journal.json';
-export const LEGACY_JOURNAL_SENTINEL = 'PLAYCRAFT_RUNTIME_STATE_SQLITE\n';
-export class RuntimeJournal {
-    filePath;
-    legacyPath;
-    client;
-    listeners = new Set();
-    maintenance;
-    engineInfo;
-    epochs = [];
-    readToken = '';
-    inboxPending = 0;
-    locks = new Map();
-    snapshot = emptySnapshot();
-    constructor(stateDir) {
-        this.filePath = join(stateDir, RUNTIME_STATE_FILE);
-        this.legacyPath = join(stateDir, LEGACY_JOURNAL_FILE);
-    }
-    async exclusive(key, action) {
-        const previous = this.locks.get(key) ?? Promise.resolve();
-        let release;
-        const current = new Promise((resolve) => {
-            release = resolve;
-        });
-        this.locks.set(key, current);
-        await previous;
-        try {
-            return await action();
-        }
-        finally {
-            release();
-            if (this.locks.get(key) === current)
-                this.locks.delete(key);
-        }
-    }
-    async load() {
-        await mkdir(dirname(this.filePath), { recursive: true, mode: 0o700 });
-        const legacy = await readLegacy(this.legacyPath, this.filePath);
-        const started = await SqliteWorkerClient.open(this.filePath, legacy?.value ?? null);
-        this.client = started.client;
-        this.apply(started.opened);
-        if (legacy?.readable)
-            await writeFile(this.legacyPath, LEGACY_JOURNAL_SENTINEL, { mode: 0o600 });
-        this.maintenance = setInterval(() => {
-            void this.client?.request('maintain').catch(() => undefined);
-        }, 30_000);
-        this.maintenance.unref?.();
-    }
-    async close() {
-        if (this.maintenance)
-            clearInterval(this.maintenance);
-        await this.client?.close();
-        this.client = undefined;
-    }
-    engine() {
-        if (!this.engineInfo)
-            throw new Error('sqlite_engine_unavailable');
-        return this.engineInfo;
-    }
-    sourceReadToken() {
-        return this.readToken;
-    }
-    pendingInbox() {
-        return this.inboxPending;
-    }
-    epochsSnapshot() {
-        return this.epochs.map((epoch) => ({ ...epoch }));
-    }
-    onSourceEvent(listener) {
-        this.listeners.add(listener);
-        return () => this.listeners.delete(listener);
-    }
-    getWorkspace(workspaceId) {
-        return this.snapshot.workspaces[workspaceId];
-    }
-    async putWorkspace(binding) {
-        const parsed = workspaceRegistrationSchema.parse(binding);
-        await this.run('upsertRecord', { bucket: 'workspaces', key: parsed.workspaceId, body: parsed });
-    }
-    async forgetWorkspaces() {
-        await this.run('forgetWorkspaces', {});
-    }
-    findSessionCreation(sessionId) {
-        return Object.values(this.snapshot.operations).find((item) => item.kind === 'session.create' && item.sessionId === sessionId);
-    }
-    findTerminalCreation(terminalId) {
-        return Object.values(this.snapshot.operations).find((item) => item.kind === 'terminal.create' && item.terminalId === terminalId);
-    }
-    getOperation(scopeKey) {
-        return this.snapshot.operations[scopeKey];
-    }
-    getOperationById(operationId) {
-        return Object.values(this.snapshot.operations).find((operation) => operation.operationId === operationId);
-    }
-    listOperations() {
-        return Object.entries(this.snapshot.operations).map(([scopeKey, operation]) => ({ scopeKey, operation }));
-    }
-    getReceipt(key) {
-        return this.snapshot.receipts[key];
-    }
-    getSession(sessionId) {
-        return this.snapshot.sessions[sessionId];
-    }
-    listSessions() {
-        return Object.values(this.snapshot.sessions);
-    }
-    getTerminal(terminalId) {
-        return this.snapshot.terminals[terminalId];
-    }
-    listTerminals(workspaceId) {
-        return Object.values(this.snapshot.terminals).filter((item) => !workspaceId || item.workspaceId === workspaceId);
-    }
-    listManagedWrites(workspaceId) {
-        return Object.values(this.snapshot.managedWrites).filter((item) => !workspaceId || item.workspaceId === workspaceId);
-    }
-    getManagedWrite(writeId) {
-        return this.snapshot.managedWrites[writeId];
-    }
-    async putManagedWrite(record) {
-        await this.run('upsertRecord', { bucket: 'managed_writes', key: record.writeId, body: record });
-    }
-    getWorkspaceDependencies(workspaceId) {
-        return this.snapshot.workspaceDependencies[workspaceId];
-    }
-    listWorkspaceDependencies() {
-        return Object.values(this.snapshot.workspaceDependencies);
-    }
-    async putWorkspaceDependencies(record) {
-        await this.run('upsertRecord', {
-            bucket: 'workspace_dependencies',
-            key: record.workspaceId,
-            body: record,
-        });
-    }
-    fileRevisions(workspaceId) {
-        return { ...(workspaceId ? this.snapshot.workspaceFileRevisions[workspaceId] ?? {} : this.snapshot.fileRevisions) };
-    }
-    fileRevision(path, workspaceId) {
-        return this.fileRevisions(workspaceId)[path]?.revision ?? 0;
-    }
-    destroyed() {
-        return this.snapshot.destroyed;
-    }
-    lastSourceSequence() {
-        return this.snapshot.lastSourceSequence;
-    }
-    acceptedLeaseFence() {
-        return this.snapshot.acceptedLeaseFence;
-    }
-    storedRuntimeEpoch() {
-        return this.snapshot.runtimeEpoch;
-    }
-    executionGroup() {
-        return { ...this.snapshot.executionGroup };
-    }
-    stoppedRuntimeEpochs() {
-        return [...(this.snapshot.stoppedRuntimeEpochs ?? [])];
-    }
-    getApproval(sessionId, approvalId) {
-        return this.snapshot.approvals[`${sessionId}:${approvalId}`];
-    }
-    listApprovals() {
-        return Object.values(this.snapshot.approvals);
-    }
-    async putApproval(approval) {
-        await this.run('upsertRecord', { bucket: 'approvals', key: `${approval.sessionId}:${approval.approvalId}`, body: approval });
-    }
-    async noteExecutionGroup(group) {
-        await this.run('noteExecutionGroup', { group });
-    }
-    async writeExecutionEpoch(input) {
-        await this.run('writeExecutionEpoch', input);
-    }
-    async setExecutionStopConfirmed(stopConfirmed) {
-        await this.run('setStopConfirmed', { stopConfirmed });
-    }
-    async bindRuntime(input) {
-        await this.run('bindRuntime', input);
-    }
-    listEvents(afterSequence = 0) {
-        return Object.values(this.snapshot.events)
-            .filter((event) => event.source.sourceSequence > afterSequence)
-            .sort((left, right) => left.source.sourceSequence - right.source.sourceSequence || left.source.runtimeEpoch - right.source.runtimeEpoch);
-    }
-    readSourcePage(input) {
-        const epoch = this.epochs.find((item) => item.runtime_id === input.runtimeId && item.generation === input.generation && item.runtime_epoch === input.runtimeEpoch);
-        const retainedFrom = epoch?.retained_from ?? 1;
-        const highWater = epoch?.local_durable_through ?? 0;
-        const coveredThrough = input.after;
-        if (retainedRangeHasGap(retainedFrom, coveredThrough)) {
-            return { ok: false, code: 'source_gap', retainedFrom, highWater, coveredThrough, ...identity(input) };
-        }
-        const matched = Object.values(this.snapshot.events)
-            .filter((event) => event.source.runtimeId === input.runtimeId &&
-            event.source.generation === input.generation &&
-            event.source.runtimeEpoch === input.runtimeEpoch &&
-            event.source.sourceSequence > input.after)
-            .sort((left, right) => left.source.sourceSequence - right.source.sourceSequence);
-        const first = matched[0];
-        if (first && first.source.sourceSequence > input.after + 1) {
-            return { ok: false, code: 'source_gap', retainedFrom, highWater, coveredThrough, ...identity(input) };
-        }
-        const events = matched.slice(0, input.limit ?? 100);
-        const nextAfter = events.at(-1)?.source.sourceSequence ?? input.after;
-        return { ok: true, events, retainedFrom, highWater, nextAfter, ...identity(input) };
-    }
-    async allocateSourceEvent(input) {
-        const result = await this.run('allocateEvent', input);
-        const event = result.committedEvents?.[0];
-        if (!event)
-            throw new Error('source_event_missing');
-        return event;
-    }
-    async commitSourceIdentity(event) {
-        await this.run('commitIdentity', { event: pendingSourceEventSchema.parse(event) });
-    }
-    async ingestNative(input) {
-        const result = await this.run('ingest', input);
-        return result.committedEvents ?? [];
-    }
-    async bindTurn(input) {
-        const result = await this.run('bindTurn', input);
-        return result.committedEvents ?? [];
-    }
-    async acknowledgeSource(ack) {
-        await this.run('ack', sourceAckSchema.parse(ack));
-    }
-    async createReplayPin(input) {
-        const result = await this.run('createPin', { identity: input, ttlMs: input.ttlMs });
-        return replayPinResultSchema.parse(result.pin);
-    }
-    async deleteReplayPin(pinId) {
-        await this.run('deletePin', { pinId });
-    }
-    async reclaimSourceEvents(minRetainMs = 0) {
-        await this.run('reclaim', { minRetainMs });
-    }
-    async putOperation(scopeKey, operation) {
-        const parsed = operationRecordSchema.parse(operation);
-        await this.run('putOperation', { scopeKey, operation: parsed });
-        return this.snapshot.operations[scopeKey] ?? parsed;
-    }
-    async putSession(binding) {
-        await this.run('upsertRecord', { bucket: 'sessions', key: binding.sessionId, body: binding });
-    }
-    async putTerminal(record) {
-        const parsed = terminalRecordSchema.parse(record);
-        await this.run('upsertRecord', { bucket: 'terminals', key: parsed.terminalId, body: parsed });
-        return parsed;
-    }
-    async putFileRevision(path, record, workspaceId) {
-        if (workspaceId) {
-            await this.run('upsertRecord', { bucket: `workspace_files:${workspaceId}`, key: path, body: record });
-            return;
-        }
-        await this.run('upsertRecord', { bucket: 'file_revisions', key: path, body: record });
-    }
-    async markDestroyed() {
-        await this.run('setDestroyed', {});
-    }
-    async replaceSessions(sessions) {
-        await this.run('replaceBucket', {
-            bucket: 'sessions',
-            entries: sessions.map((session) => ({ key: session.sessionId, body: session })),
-        });
-    }
-    async setAcceptedLeaseFence(value) {
-        await this.run('setAcceptedFence', { value });
-    }
-    async putReceipt(receipt, sourceSequence) {
-        const parsed = sourceEventReceiptSchema.parse(receipt);
-        await this.run('upsertRecord', { bucket: 'receipts', key: sourceEventKey(parsed.source), body: parsed });
-        void sourceSequence;
-    }
-    async appendEvent(event) {
-        const parsed = pendingSourceEventSchema.parse(event);
-        await this.commitSourceIdentity(parsed);
-        return this.snapshot.events[sourceEventKey(parsed.source)] ?? parsed;
-    }
-    async run(type, payload) {
-        if (!this.client)
-            throw new Error('sqlite_not_open');
-        const result = await this.client.request(type, payload);
-        this.apply(result);
-        for (const event of result.committedEvents ?? []) {
-            for (const listener of this.listeners)
-                listener(event);
-        }
-        return result;
-    }
-    apply(dump) {
-        const group = dump.snapshot.executionGroup;
-        const events = dump.snapshot.events ?? this.snapshot.events;
-        // Keep history in place: copying it on every streamed delta grows quadratically.
-        for (const event of dump.committedEvents ?? [])
-            events[sourceEventKey(event.source)] = event;
-        for (const event of dump.eventChanges ?? [])
-            events[sourceEventKey(event.source)] = event;
-        this.snapshot = {
-            ...emptySnapshot(),
-            ...dump.snapshot,
-            events,
-            executionGroup: {
-                stopConfirmed: group?.stopConfirmed === true,
-                replaced: group?.replaced === true,
-                pid: group?.pid,
-                startedAt: group?.startedAt,
-                previousPid: group?.previousPid,
-            },
-        };
-        this.epochs = dump.epochs ?? [];
-        this.readToken = dump.sourceReadToken ?? this.readToken;
-        this.inboxPending = dump.pendingInbox ?? 0;
-        if (dump.engine)
-            this.engineInfo = dump.engine;
-    }
-}
-async function readLegacy(legacyPath, sqlitePath) {
-    if (!existsSync(legacyPath))
-        return null;
-    const text = await readFile(legacyPath, 'utf8');
-    if (text.startsWith(LEGACY_JOURNAL_SENTINEL.trim())) {
-        if (!existsSync(sqlitePath))
-            throw new Error('runtime_state_missing');
-        return null;
-    }
-    let value;
-    try {
-        value = JSON.parse(text);
-    }
-    catch {
-        throw new Error('legacy_journal_unreadable');
-    }
-    if (!existsSync(`${legacyPath}.bak`))
-        await copyFile(legacyPath, `${legacyPath}.bak`);
-    return { value, readable: true };
-}
-function identity(input) {
-    return { runtimeId: input.runtimeId, generation: input.generation, runtimeEpoch: input.runtimeEpoch };
-}
-function emptySnapshot() {
-    return {
-        workspaces: {},
-        workspaceFileRevisions: {},
-        operations: {},
-        receipts: {},
-        events: {},
-        sessions: {},
-        terminals: {},
-        fileRevisions: {},
-        approvals: {},
-        managedWrites: {},
-        workspaceDependencies: {},
-        executionGroup: { stopConfirmed: false, replaced: false },
-        lastSourceSequence: 0,
-        acceptedLeaseFence: 0,
-        destroyed: false,
-    };
-}