@playcraft/cli 0.1.24 → 0.1.25

package/dist/workspace-runtime/codex/model-broker.js

@@ -0,0 +1,239 @@
+import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
+import { createServer } from 'node:http';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { basename, dirname } from 'node:path';
+import { z } from 'zod';
+import { workspaceContextFromRoot } from '../workspaces/registry.js';
+import { PLATFORM_ROUTES, modelResponsesPath, platformEndpoint } from '@playcraft/common/cloud-workspace/runtime';
+const credentialSchema = z.object({
+    token: z.string().min(1), expiresAt: z.string().datetime(),
+    configId: z.string().uuid(), model: z.string().min(1).max(128),
+    claims: z.object({
+        environment: z.string(), userId: z.string(), workspaceId: z.string(), runtimeId: z.string(),
+        generation: z.number().int(), runtimeEpoch: z.number().int(),
+    }),
+});
+/** Keeps renewable execution credentials in control memory, outside Codex and project files. */
+export class WorkspaceModelBroker {
+    state;
+    server;
+    baseUrl = '';
+    entries = new Map();
+    routes = new Map();
+    pending = new Map();
+    requests = new Set();
+    sessionRequests = new Map();
+    constructor(state) {
+        this.state = state;
+    }
+    async start() {
+        if (this.server)
+            return;
+        const server = createServer({ maxHeaderSize: 8192 }, (request, response) => {
+            void this.forward(request, response);
+        });
+        await new Promise((resolve, reject) => {
+            server.once('error', reject);
+            server.listen(0, '127.0.0.1', resolve);
+        });
+        this.server = server;
+        const address = server.address();
+        if (!address || typeof address === 'string')
+            throw new Error('model_broker_unavailable');
+        this.baseUrl = `http://127.0.0.1:${address.port}`;
+    }
+    async threadConfig(cwd, modelConfigId, sessionId) {
+        const { activate, ...settings } = await this.prepareThreadConfig(cwd, modelConfigId, sessionId);
+        activate();
+        return settings;
+    }
+    async prepareThreadConfig(cwd, modelConfigId, sessionId) {
+        if (!this.server)
+            throw new Error('workspace_not_registered');
+        const { workspaceId } = await workspaceContextFromRoot(this.state, cwd);
+        if (modelConfigId !== undefined && !z.string().uuid().safeParse(modelConfigId).success)
+            throw new Error('model_config_denied');
+        const routeKey = sessionId ? `${workspaceId}/${createHash('sha256').update(sessionId).digest('hex').slice(0, 32)}` : workspaceId;
+        let route = this.routes.get(routeKey);
+        const selected = modelConfigId ?? (route?.epoch === this.state.runtimeEpoch ? route.selected?.entry.modelConfigId : undefined);
+        const cacheKey = `${workspaceId}:${selected ?? 'default'}`;
+        let entry = this.entries.get(cacheKey) ?? [...this.entries.values()].find(item => item.workspaceId === workspaceId && item.epoch === this.state.runtimeEpoch && item.modelConfigId === selected);
+        if (!entry || entry.epoch !== this.state.runtimeEpoch) {
+            entry = { workspaceId, epoch: this.state.runtimeEpoch, cacheKey, modelConfigId: selected };
+            this.entries.set(cacheKey, entry);
+        }
+        // Resolve current model metadata and permission at every native turn boundary.
+        const credential = await this.credential(entry, true);
+        if (!route || route.epoch !== this.state.runtimeEpoch) {
+            route = { workspaceId, epoch: this.state.runtimeEpoch, capability: randomBytes(32).toString('base64url') };
+            this.routes.set(routeKey, route);
+        }
+        // Each session pins its prepared model; shared credential renewal cannot change an active turn.
+        return {
+            activate: () => {
+                if (!this.valid(entry) || this.routes.get(routeKey) !== route)
+                    throw new Error('model_access_denied');
+                route.selected = { entry, model: credential.model };
+            },
+            model: credential.model,
+            modelConfigId: credential.configId,
+            modelProvider: 'playcraft_workspace',
+            config: {
+                'model_providers.playcraft_workspace': {
+                    name: 'PlayCraft Workspace', base_url: `${this.baseUrl}/${routeKey}`,
+                    wire_api: 'responses', requires_openai_auth: false,
+                    http_headers: { Authorization: `Bearer ${route.capability}` },
+                },
+            },
+        };
+    }
+    valid(entry) {
+        return Boolean(this.server && !this.state.journal.destroyed()
+            && this.state.runtimeEpoch === entry.epoch && this.state.journal.getWorkspace(entry.workspaceId)
+            && this.entries.get(entry.cacheKey) === entry);
+    }
+    async credential(entry, refresh = false) {
+        if (!this.valid(entry))
+            throw new Error('model_access_denied');
+        if (!refresh && entry.credential && Date.parse(entry.credential.expiresAt) > Date.now() + 60_000)
+            return entry.credential;
+        let pending = this.pending.get(entry);
+        if (!pending) {
+            pending = this.renew(entry).finally(() => this.pending.delete(entry));
+            this.pending.set(entry, pending);
+        }
+        return pending;
+    }
+    async renew(entry) {
+        const config = this.state.config;
+        const endpoint = platformEndpoint(config.publicBaseUrl, PLATFORM_ROUTES.modelCredentials);
+        const response = await fetch(endpoint, {
+            method: 'POST', redirect: 'error', signal: AbortSignal.timeout(10_000),
+            headers: { authorization: `Bearer ${config.controlToken}`, 'content-type': 'application/json', 'playcraft-env': config.environment },
+            body: JSON.stringify({ runtimeId: config.runtimeId, generation: config.generation,
+                runtimeEpoch: entry.epoch, workspaceId: entry.workspaceId,
+                ...(entry.modelConfigId ? { modelConfigId: entry.modelConfigId } : {}) }),
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({}));
+            throw new Error(['model_config_required', 'model_config_denied'].includes(error.reason ?? '') ? error.reason : 'model_credential_unavailable');
+        }
+        const credential = credentialSchema.parse(await response.json());
+        const claims = credential.claims;
+        if (!this.valid(entry) || claims.workspaceId !== entry.workspaceId || claims.runtimeId !== config.runtimeId
+            || claims.userId !== config.userId || claims.environment !== config.environment
+            || claims.generation !== config.generation || claims.runtimeEpoch !== entry.epoch
+            || (entry.modelConfigId !== undefined && credential.configId !== entry.modelConfigId)
+            || Date.parse(credential.expiresAt) <= Date.now() + 1000)
+            throw new Error('model_credential_scope_mismatch');
+        entry.modelConfigId = credential.configId;
+        entry.credential = credential;
+        return credential;
+    }
+    async forward(request, response) {
+        const abort = new AbortController();
+        this.requests.add(abort);
+        let activeRoute;
+        const cancel = () => abort.abort();
+        response.once('close', cancel);
+        try {
+            const match = /^\/([0-9a-f-]{36}(?:\/[0-9a-f]{32})?)\/responses$/.exec(request.url ?? '');
+            const route = match ? this.routes.get(match[1]) : undefined;
+            const selected = route?.selected;
+            const entry = selected?.entry;
+            const presented = Buffer.from(request.headers.authorization ?? '');
+            const expected = Buffer.from(route ? `Bearer ${route.capability}` : '');
+            if (request.method !== 'POST' || !entry || !expected.length || presented.length !== expected.length
+                || !timingSafeEqual(presented, expected) || !this.valid(entry)) {
+                response.writeHead(403);
+                response.end();
+                return;
+            }
+            activeRoute = route;
+            const active = this.sessionRequests.get(route) ?? new Set();
+            active.add(abort);
+            this.sessionRequests.set(route, active);
+            const credential = await this.credential(entry);
+            const chunks = [];
+            let size = 0;
+            for await (const chunk of request) {
+                size += chunk.length;
+                if (size > 16 * 1024 * 1024) {
+                    response.writeHead(413);
+                    response.end();
+                    return;
+                }
+                chunks.push(Buffer.from(chunk));
+            }
+            if (!this.valid(entry))
+                throw new Error('model_access_denied');
+            const body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+            if (!body || typeof body !== 'object' || Array.isArray(body)) {
+                response.writeHead(400);
+                response.end();
+                return;
+            }
+            // The browser selects a configuration, never an arbitrary billable upstream model.
+            body.model = selected.model;
+            const expires = setTimeout(cancel, Math.max(0, Date.parse(credential.expiresAt) - Date.now()));
+            try {
+                const upstream = await fetch(platformEndpoint(this.state.config.publicBaseUrl, modelResponsesPath(credential.configId)), {
+                    method: 'POST', redirect: 'error', signal: abort.signal,
+                    headers: { authorization: `Bearer ${credential.token}`, 'content-type': 'application/json' },
+                    body: JSON.stringify(body),
+                });
+                if (upstream.status === 401 || upstream.status === 403)
+                    entry.credential = undefined;
+                response.writeHead(upstream.status, {
+                    'content-type': upstream.headers.get('content-type') ?? 'application/json', 'cache-control': 'no-store',
+                });
+                if (upstream.body)
+                    await pipeline(Readable.fromWeb(upstream.body), response);
+                else
+                    response.end();
+            }
+            finally {
+                clearTimeout(expires);
+            }
+        }
+        catch {
+            if (!response.headersSent) {
+                response.writeHead(503, { 'content-type': 'application/json', 'cache-control': 'no-store' });
+                response.end(JSON.stringify({ error: { message: 'model_credential_unavailable', type: 'server_error' } }));
+            }
+            else
+                response.destroy();
+        }
+        finally {
+            response.off('close', cancel);
+            this.requests.delete(abort);
+            if (activeRoute) {
+                const active = this.sessionRequests.get(activeRoute);
+                active?.delete(abort);
+                if (!active?.size)
+                    this.sessionRequests.delete(activeRoute);
+            }
+        }
+    }
+    cancelSession(cwd, sessionId) {
+        const routeKey = `${/^(basic|remix-)/.test(basename(cwd)) ? basename(dirname(cwd)) : basename(cwd)}/${createHash('sha256').update(sessionId).digest('hex').slice(0, 32)}`;
+        const route = this.routes.get(routeKey);
+        if (route)
+            for (const request of this.sessionRequests.get(route) ?? [])
+                request.abort();
+    }
+    async close() {
+        const server = this.server;
+        this.server = undefined;
+        this.entries.clear();
+        this.routes.clear();
+        this.sessionRequests.clear();
+        for (const request of this.requests)
+            request.abort();
+        if (server) {
+            server.closeAllConnections();
+            await new Promise(resolve => server.close(() => resolve()));
+        }
+    }
+}

package/dist/workspace-runtime/codex/native-adapter.js

@@ -0,0 +1,9 @@
+/** Failure before a native request was sent; safe to report as failed instead of uncertain. */
+export class NativePreparationError extends Error {
+}
+export function nativeEvent(type, payload) {
+    return { type, payload, occurredAt: new Date().toISOString() };
+}
+export function collectedEvent(kind, method, params) {
+    return { kind, method, params, occurredAt: new Date().toISOString() };
+}

package/dist/workspace-runtime/main.js

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,355 @@
+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 };
+    }
+    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;
+        this.snapshot = {
+            ...emptySnapshot(),
+            ...dump.snapshot,
+            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,
+    };
+}