@playcraft/cli 0.1.17 → 0.1.19

package/dist/workspace-runtime/server/http.js

@@ -1,12 +1,11 @@
 import { readObservedFile, withObservedFile } from '../workspaces/revisions.js';
 import { registerWorkspace, revisionScope, workspaceRoot, WorkspaceContextError } from '../workspaces/registry.js';
 import { randomUUID } from 'node:crypto';
-import { workspaceRegistrationRequestSchema, HTTP_STATUS_BY_ERROR, assertLeaseFence, buildHandshakeDocument, capability, findUntrustedRuntimeFields, gitFileRefSchema, hashOperationPayload, instanceRebuildRequestSchema, sourceAckSchema, operationAcceptRequestSchema, operationKindSchema, operationScopeKey, resolveIdempotentAccept, nativeHistoryReadSchema, runtimeError, runtimeConnectivityDocumentSchema, unavailableRuntimeCapabilities, } from '@playcraft/common/cloud-workspace/runtime';
+import { workspaceRegistrationRequestSchema, HTTP_STATUS_BY_ERROR, assertLeaseFence, buildHandshakeDocument, capability, findUntrustedRuntimeFields, gitFileRefSchema, hashOperationPayload, sourceAckSchema, operationAcceptRequestSchema, operationKindSchema, operationScopeKey, resolveIdempotentAccept, nativeHistoryReadSchema, runtimeError, runtimeConnectivityDocumentSchema, unavailableRuntimeCapabilities, } from '@playcraft/common/cloud-workspace/runtime';
 import { controlTokenMatches, extractControlToken } from './auth.js';
 import { applyRuntimeEndpointPatch } from './endpoints.js';
 import { canExecuteKind, executeOperation } from './dispatch.js';
 import { InvalidWorkspacePathError, listWorkspaceFiles, } from '../workspaces/files.js';
-import { materializeRemoteSnapshot } from '../workspaces/file-snapshot.js';
 import { GitWorkspaceError, readWorkspaceGitDiff, readWorkspaceGitFile, readWorkspaceGitGraph, readWorkspaceGitStatus, } from '../workspaces/git.js';
 import { readWorkspaceParameters } from '../workspaces/parameters.js';
 import { readDependencies } from '../workspaces/dependencies.js';
@@ -107,24 +106,6 @@ export async function handleRuntimeRequest(state, request, response) {
             writeError(response, runtimeError('capability_unavailable', 'capability_not_implemented'));
             return;
         }
-        if (request.method === 'POST' && url.pathname === '/runtime/instance/rebuild') {
-            await rebuildInstanceFiles(state, request, response);
-            return;
-        }
-        if (request.method === 'GET' && url.pathname === '/runtime/checkpoint') {
-            const checkpointId = url.searchParams.get('checkpointId') ?? '';
-            const checkpoint = state.journal.getCheckpoint(checkpointId);
-            if (!checkpoint) {
-                writeJson(response, 404, { error: 'unknown_checkpoint' });
-                return;
-            }
-            writeJson(response, 200, {
-                checkpoint,
-                fileCheckpointId: state.journal.fileCheckpointId() ?? null,
-                consistentCheckpointId: state.journal.consistentCheckpointId() ?? null,
-            });
-            return;
-        }
         if (url.pathname === '/runtime/events' || url.pathname.startsWith('/runtime/events/')) {
             await handleSourceEvents(state, request, response, url);
             return;
@@ -440,7 +421,9 @@ async function acceptOperation(state, request, response) {
         }
         else if (parsed.data.kind.startsWith('session.') && state.config.workspaceMode === 'multi') {
             const session = state.journal.getSession(parsed.data.sessionId);
-            if (!session || session.workspaceId !== parsed.data.workspaceId) {
+            // A replaced sandbox has no binding yet; the recovering turn creates it.
+            const rebinding = !session && parsed.data.kind === 'session.turn' && parsed.data.sessionRecovery;
+            if (!rebinding && (!session || session.workspaceId !== parsed.data.workspaceId)) {
                 writeJson(response, 409, { error: 'session_workspace_mismatch' });
                 return;
             }
@@ -482,7 +465,7 @@ async function acceptOperation(state, request, response) {
         state.acceptedLeaseFence = Math.max(state.acceptedLeaseFence, incomingFence);
         await state.journal.setAcceptedLeaseFence(state.acceptedLeaseFence);
         const queued = await state.journal.putOperation(scopeKey, operation);
-        const executed = await executeOperation(state, scopeKey, queued, parsed.data.payload);
+        const executed = await executeOperation(state, scopeKey, queued, parsed.data.payload, parsed.data.sessionRecovery);
         if (executed.status === 'uncertain') {
             writeError(response, runtimeError('uncertain_operation', executed.error ?? 'native_receipt_lost', {
                 operationId: executed.operationId,
@@ -524,42 +507,6 @@ async function writeGitRead(state, response, read) {
         writeError(response, runtimeError('capability_unavailable', reason));
     }
 }
-async function rebuildInstanceFiles(state, request, response) {
-    if (writeDestroyed(state, response))
-        return;
-    if (state.journal.fileCheckpointId() || state.journal.listSessions().length > 0) {
-        writeJson(response, 409, { status: 'failed', error: 'instance_still_alive', nativeContinuable: false });
-        return;
-    }
-    const parsed = instanceRebuildRequestSchema.safeParse(await readJson(request));
-    if (!parsed.success) {
-        writeJson(response, 400, { status: 'failed', error: 'snapshot_mismatch', nativeContinuable: false });
-        return;
-    }
-    try {
-        const root = await workspaceRoot(state, parsed.data.workspaceId);
-        const materialized = await materializeRemoteSnapshot(root, parsed.data.entries);
-        state.rebuildGate = {
-            directoryReady: materialized.directoryReady,
-            repositoryReady: materialized.repositoryReady,
-            environmentReady: materialized.environmentReady,
-        };
-        writeJson(response, 200, {
-            status: 'completed',
-            snapshotId: parsed.data.snapshotId,
-            nativeContinuable: false,
-            filesRestored: true,
-            skipped: materialized.skipped,
-            directoryReady: materialized.directoryReady,
-            repositoryReady: materialized.repositoryReady,
-            environmentReady: materialized.environmentReady,
-        });
-    }
-    catch (error) {
-        const reason = error instanceof Error && error.message === 'snapshot_mismatch' ? 'snapshot_mismatch' : 'snapshot_mismatch';
-        writeJson(response, 409, { status: 'failed', error: reason, nativeContinuable: false });
-    }
-}
 async function readJson(request) {
     const chunks = [];
     for await (const chunk of request) {

package/dist/workspace-runtime/workspaces/files.js

@@ -1,6 +1,6 @@
-import { mkdir, readdir, readFile, realpath, rm, writeFile } from 'node:fs/promises';
+import { mkdir, readdir, readFile, realpath, writeFile } from 'node:fs/promises';
 import { dirname, join, relative, resolve, sep } from 'node:path';
-import { hashWorkspaceFileContent, hashSnapshotBytes, isWorkspaceAttachmentPath, workspaceFileContentSchema, workspaceFileListSchema, workspaceRelativePathSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { hashWorkspaceFileContent, workspaceFileContentSchema, workspaceFileListSchema, workspaceRelativePathSchema, } from '@playcraft/common/cloud-workspace/runtime';
 const SKIP_DIRECTORY_NAMES = new Set(['.git', 'node_modules']);
 export class InvalidWorkspacePathError extends Error {
     code = 'invalid_workspace_path';
@@ -66,37 +66,6 @@ export async function listWorkspaceFiles(root, revisions) {
     files.sort((left, right) => left.path.localeCompare(right.path));
     return workspaceFileListSchema.parse({ files });
 }
-export async function snapshotWorkspaceFiles(root, snapshotDir, revisions) {
-    const listed = await listWorkspaceFiles(root, revisions);
-    await rm(snapshotDir, { recursive: true, force: true });
-    const records = [];
-    for (const file of listed.files) {
-        const content = await readFile(await resolveWorkspaceFile(root, file.path));
-        const target = join(snapshotDir, ...file.path.split('/'));
-        await mkdir(dirname(target), { recursive: true, mode: 0o700 });
-        await writeFile(target, content, { mode: 0o600 });
-        records.push({ path: file.path, contentHash: hashSnapshotBytes(content), revision: file.revision });
-    }
-    return records;
-}
-export async function restoreWorkspaceFiles(root, snapshotDir, files) {
-    const rootReal = await ensureWorkspaceRoot(root);
-    const keep = new Set(files.map((item) => item.path));
-    for (const relativePath of await walkWorkspaceFiles(rootReal, rootReal)) {
-        if (!keep.has(relativePath) && !isWorkspaceAttachmentPath(relativePath)) {
-            await rm(join(rootReal, ...relativePath.split('/')), { force: true });
-        }
-    }
-    const next = {};
-    for (const file of files) {
-        const source = join(snapshotDir, ...file.path.split('/'));
-        const content = await readFile(source);
-        const target = await resolveWorkspaceFile(root, file.path);
-        await writeFile(target, content, { mode: isWorkspaceAttachmentPath(file.path) ? 0o644 : 0o600 });
-        next[file.path] = { revision: file.revision, contentHash: hashSnapshotBytes(content) };
-    }
-    return next;
-}
 async function walkWorkspaceFiles(rootReal, current) {
     const entries = await readdir(current, { withFileTypes: true });
     const paths = [];

package/dist/workspace-runtime/workspaces/git.js

@@ -1,6 +1,6 @@
 import { spawn } from 'node:child_process';
 import { excludeFromGit } from './dependencies.js';
-import { lstat, mkdir, readFile, realpath, rename, rm, stat, unlink, writeFile } from 'node:fs/promises';
+import { lstat, readFile, realpath, stat, unlink } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { basename, dirname, join, relative, resolve, sep } from 'node:path';
 import { WORKSPACE_FILE_CONTENT_MAX, gitDiffSchema, gitFileContentSchema, gitGraphSchema, gitStatusSchema, workspaceRelativePathSchema, } from '@playcraft/common/cloud-workspace/runtime';
@@ -246,95 +246,81 @@ export async function pushWorkspaceGit(root, boundBranch) {
     catch { /* Preserve uncertainty; never replay a write automatically. */ }
     throw new GitWorkspaceError('git_push_outcome_unknown', 'git_push_outcome_unknown');
 }
-const UNPUSHED_DIRECTORY = '.git/playcraft';
-export const UNPUSHED_BUNDLE = `${UNPUSHED_DIRECTORY}/unpushed.bundle`;
-const UNPUSHED_TIPS = `${UNPUSHED_DIRECTORY}/unpushed.tips`;
 /**
- * Keeps a bundle of the commits on local branches and the latest stash that no remote-tracking
- * branch holds, so a backup without the packs still has them. It is rewritten only when one of
- * those refs moves, and removed when nothing is unpushed. Without remote-tracking refs there is no
- * baseline, and the whole history is left out rather than bundled.
+ * Credential files a save never commits, even when `.gitignore` misses them: env files (their
+ * `.example` / `.sample` / `.template` stay), SSH keys, netrc and Git credential stores, and key
+ * or certificate bundles.
  */
-export async function bundleUnpushedCommits(root) {
-    const rootReal = await realpath(root);
-    const marker = await lstat(join(rootReal, '.git')).catch(() => undefined);
-    if (!marker?.isDirectory())
-        return;
-    const tips = await git(rootReal, [
-        'for-each-ref', '--format=%(objectname) %(refname)', 'refs/heads', 'refs/remotes', 'refs/stash',
-    ]);
-    const tipsPath = join(rootReal, UNPUSHED_TIPS);
-    if ((await readFile(tipsPath, 'utf8').catch(() => undefined)) === tips)
-        return;
-    const refs = tips.split('\n').map((line) => line.split(' ')[1]).filter((ref) => Boolean(ref));
-    const local = ['--branches', ...(refs.includes('refs/stash') ? ['refs/stash'] : [])];
-    const unpushed = refs.some((ref) => ref.startsWith('refs/remotes/'))
-        ? Number.parseInt((await git(rootReal, ['rev-list', '--count', ...local, '--not', '--remotes'], 60000)).trim(), 10)
-        : 0;
-    const bundlePath = join(rootReal, UNPUSHED_BUNDLE);
-    await mkdir(join(rootReal, UNPUSHED_DIRECTORY), { recursive: true, mode: 0o700 });
-    if (unpushed > 0) {
-        // The `.lock` name keeps a half-written bundle out of any snapshot.
-        const temp = `${bundlePath}.lock`;
-        try {
-            await git(rootReal, ['bundle', 'create', temp, ...local, '--not', '--remotes'], 120000);
-            await rename(temp, bundlePath);
-        }
-        finally {
-            await rm(temp, { force: true });
-        }
-    }
-    else {
-        await rm(bundlePath, { force: true });
-    }
-    await writeFile(tipsPath, tips, { mode: 0o600 });
+const CREDENTIAL_FILE = /^(?:\.env(?:\.(?!(?:example|sample|template)$)[^/]+)?|id_(?:rsa|dsa|ecdsa|ed25519)|\.netrc|\.git-credentials|[^/]*\.(?:pem|key|p12|pfx))$/i;
+export function isCredentialFile(path) {
+    return CREDENTIAL_FILE.test(path.split('/').pop() ?? '');
 }
 /**
- * Adds a bundle's objects to the repository. `unbundle` walks history from the current refs, so this
- * runs on the fresh clone before the snapshot's refs, which point at these very commits, replace its
- * own. It fails when the remote lost the commits the bundle was built on; `repositoryResolves` then
- * reports what is missing.
+ * Commits every change in the work tree (`git add -A`, credential files aside) and, when asked,
+ * pushes the branch. A save with nothing new commits nothing and pushes only what the remote
+ * lacks, so a commit whose push failed goes out with the next save.
  */
-export async function addBundleObjects(root, body) {
-    const rootReal = await realpath(root);
-    const marker = await lstat(join(rootReal, '.git')).catch(() => undefined);
-    if (!marker?.isDirectory())
+export async function saveWorkspaceGit(root, input) {
+    const rootReal = await ensureWorkspaceGit(root);
+    await assertBoundBranch(rootReal, input.boundBranch);
+    await git(rootReal, ['add', '-A'], 60000);
+    const staged = (await git(rootReal, ['diff', '--cached', '--name-only', '-z'], 60000)).split('\0').filter(Boolean);
+    const withheld = staged.filter(isCredentialFile);
+    await unstage(rootReal, withheld);
+    const cached = await gitAllowFail(rootReal, ['diff', '--cached', '--quiet'], 60000);
+    if (cached.code !== 0 && cached.code !== 1) {
+        throw new GitWorkspaceError('git_command_failed', cached.stderr.trim() || 'git_diff_failed');
+    }
+    let commit;
+    if (cached.code === 1) {
+        await git(rootReal, [...(await commitIdentity(rootReal)), 'commit', '-q', '-m', input.message], 60000);
+        commit = (await git(rootReal, ['rev-parse', 'HEAD'])).trim();
+    }
+    if (!input.push || (await remoteHasHead(rootReal)))
+        return { ...(commit ? { commit } : {}), pushed: false, withheld };
+    await pushWorkspaceGit(rootReal, input.boundBranch);
+    await recordPushedHead(rootReal);
+    return { ...(commit ? { commit } : {}), pushed: true, withheld };
+}
+async function unstage(rootReal, paths) {
+    if (paths.length === 0)
         return;
-    const temp = join(rootReal, '.git', 'playcraft-restore.bundle.lock');
-    try {
-        await writeFile(temp, body, { mode: 0o600 });
-        await gitAllowFail(rootReal, ['bundle', 'unbundle', temp], 120000);
-    }
-    catch {
-        /* Reported by repositoryResolves. */
-    }
-    finally {
-        await rm(temp, { force: true });
+    const born = (await gitAllowFail(rootReal, ['rev-parse', '-q', '--verify', 'HEAD'])).code === 0;
+    for (let start = 0; start < paths.length; start += 100) {
+        const chunk = paths.slice(start, start + 100);
+        // Before the first commit there is no HEAD to reset to; dropping the entries does the same.
+        await git(rootReal, born ? ['reset', '-q', '--', ...chunk] : ['rm', '-q', '--cached', '--', ...chunk]);
     }
 }
-/** Whether HEAD and the index resolve to objects the repository holds. */
-export async function repositoryResolves(root) {
-    const rootReal = await realpath(root);
-    const marker = await lstat(join(rootReal, '.git')).catch(() => undefined);
-    if (!marker?.isDirectory())
-        return false;
-    try {
-        // Snapshots hold files only; Git does not recognise a repository whose refs folder is gone.
-        for (const directory of ['refs/heads', 'refs/tags', 'objects']) {
-            await mkdir(join(rootReal, '.git', directory), { recursive: true, mode: 0o755 });
-        }
-        const head = await gitAllowFail(rootReal, ['rev-parse', '-q', '--verify', 'HEAD^{tree}']);
-        if (head.code === 0) {
-            const index = await gitAllowFail(rootReal, ['diff-index', '--cached', '--quiet', 'HEAD'], 60000);
-            return index.code === 0 || index.code === 1;
-        }
-        // Before the first commit there is no branch to resolve.
-        const branches = await gitAllowFail(rootReal, ['for-each-ref', '--count=1', 'refs/heads']);
-        return branches.code === 0 && branches.stdout.trim() === '';
-    }
-    catch {
+/** A clone carries no committer; the sandbox image sets none either. */
+async function commitIdentity(rootReal) {
+    const email = await gitAllowFail(rootReal, ['config', 'user.email']);
+    if (email.code === 0 && email.stdout.trim())
+        return [];
+    return ['-c', 'user.name=PlayCraft Workspace', '-c', 'user.email=workspace@playcraft.local'];
+}
+/**
+ * The remote-tracking ref of the current branch. A fork clone has no fetch refspec for its own
+ * branch, so the ref is written here after a confirmed push.
+ */
+async function trackingRef(rootReal) {
+    const branch = (await gitAllowFail(rootReal, ['symbolic-ref', '--quiet', '--short', 'HEAD'])).stdout.trim();
+    return branch ? `refs/remotes/origin/${branch}` : undefined;
+}
+async function remoteHasHead(rootReal) {
+    const ref = await trackingRef(rootReal);
+    if (!ref)
         return false;
-    }
+    const [head, tracked] = await Promise.all([
+        gitAllowFail(rootReal, ['rev-parse', '-q', '--verify', 'HEAD^{commit}']),
+        gitAllowFail(rootReal, ['rev-parse', '-q', '--verify', `${ref}^{commit}`]),
+    ]);
+    return head.code === 0 && tracked.code === 0 && head.stdout.trim() === tracked.stdout.trim();
+}
+async function recordPushedHead(rootReal) {
+    const ref = await trackingRef(rootReal);
+    if (ref)
+        await gitAllowFail(rootReal, ['update-ref', ref, 'HEAD']);
 }
 export async function ensureWorkspaceGit(root) {
     const rootReal = await realpath(root);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playcraft/cli",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "private": false,
   "type": "module",
   "engines": {
@@ -48,8 +48,8 @@
     "@gltf-transform/core": "^4.3.0",
     "@gltf-transform/extensions": "^4.3.0",
     "@gltf-transform/functions": "^4.3.0",
-    "@playcraft/build": "^0.1.17",
-    "@playcraft/common": "^0.1.17",
+    "@playcraft/build": "^0.1.19",
+    "@playcraft/common": "^0.1.19",
     "better-sqlite3-pinned": "npm:better-sqlite3@13.0.3",
     "chokidar": "^4.0.3",
     "commander": "^13.1.0",

package/dist/workspace-runtime/codex/transcripts.js

@@ -1,94 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { readdir, readFile, stat } from 'node:fs/promises';
-import { join } from 'node:path';
-import { startLauncherProcess } from './launcher-client.js';
-export const TRANSCRIPT_MAX_BYTES = 64 * 1024 * 1024;
-const THREAD_ID = /^[A-Za-z0-9_-]{1,128}$/;
-const TRANSCRIPT_PATH = /^sessions\/\d{4}\/\d{2}\/\d{2}\/rollout-[A-Za-z0-9_.-]{1,200}\.jsonl$/;
-const COMMAND_TIMEOUT_MS = 60_000;
-/**
- * Reads the transcript Codex keeps for one thread. Codex appends to it while a turn runs, so a
- * trailing partial line is dropped; what is returned always parses line by line.
- */
-export async function exportTranscript(home, threadId) {
-    if (!THREAD_ID.test(threadId))
-        return undefined;
-    const found = home.launcher
-        ? await exportAsDeveloper(home.homeDir, home.launcher, threadId)
-        : await exportDirect(home.homeDir, threadId);
-    if (!found || !transcriptPathFor(found.path, threadId))
-        return undefined;
-    const end = found.body.lastIndexOf(0x0a);
-    if (end < 0)
-        return undefined;
-    return { path: found.path, body: found.body.subarray(0, end + 1) };
-}
-function transcriptPathFor(path, threadId) {
-    return TRANSCRIPT_PATH.test(path) && path.endsWith(`-${threadId}.jsonl`);
-}
-async function exportDirect(homeDir, threadId) {
-    const suffix = `-${threadId}.jsonl`;
-    for (const year of await names(join(homeDir, 'sessions'))) {
-        for (const month of await names(join(homeDir, 'sessions', year))) {
-            for (const day of await names(join(homeDir, 'sessions', year, month))) {
-                const directory = join('sessions', year, month, day);
-                const match = (await names(join(homeDir, directory))).find((name) => name.endsWith(suffix));
-                if (!match)
-                    continue;
-                const path = `${directory}/${match}`;
-                const absolute = join(homeDir, path);
-                if ((await stat(absolute)).size > TRANSCRIPT_MAX_BYTES)
-                    return undefined;
-                return { path, body: await readFile(absolute) };
-            }
-        }
-    }
-    return undefined;
-}
-async function exportAsDeveloper(homeDir, launcher, threadId) {
-    const limitKib = TRANSCRIPT_MAX_BYTES / 1024;
-    const outcome = await runAsDeveloper(launcher, [
-        `home=${quote(homeDir)}`,
-        `f=$(find "$home/sessions" -mindepth 4 -maxdepth 4 -type f -name ${quote(`rollout-*-${threadId}.jsonl`)} -size -${limitKib}k 2>/dev/null | head -n 1)`,
-        '[ -n "$f" ] || exit 3',
-        'printf \'%s\\n\' "${f#"$home"/}"',
-        'base64 -w 0 "$f"',
-    ].join('; '));
-    if (outcome.code !== 0)
-        return undefined;
-    const text = outcome.stdout.toString('utf8');
-    const newline = text.indexOf('\n');
-    if (newline < 0)
-        return undefined;
-    return { path: text.slice(0, newline), body: Buffer.from(text.slice(newline + 1).trim(), 'base64') };
-}
-async function runAsDeveloper(launcher, command) {
-    const child = await startLauncherProcess({
-        socketPath: launcher.socketPath,
-        processId: `transcript-${randomUUID()}`,
-        runtimeEpoch: launcher.runtimeEpoch,
-        argv: ['/usr/bin/bash', '-c', `{ ${command}; } </dev/null 2>/dev/null`],
-        cwd: launcher.cwd,
-        env: {},
-    });
-    child.stdin?.end();
-    const chunks = [];
-    child.stdout?.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
-    const code = await new Promise((resolve) => {
-        const timer = setTimeout(() => {
-            void child.stop().catch(() => undefined);
-            resolve(null);
-        }, COMMAND_TIMEOUT_MS);
-        child.onExit((value) => {
-            clearTimeout(timer);
-            resolve(value);
-        });
-    });
-    return { code, stdout: Buffer.concat(chunks) };
-}
-async function names(directory) {
-    return readdir(directory).then((entries) => entries.sort(), () => []);
-}
-function quote(value) {
-    return `'${value.replaceAll("'", "'\\''")}'`;
-}

package/dist/workspace-runtime/workspaces/checkpoint-saves.js

@@ -1,70 +0,0 @@
-import { rm } from 'node:fs/promises';
-import { join } from 'node:path';
-/** Local copies kept per workspace. Older ones are removed; the remote snapshots stay. */
-const LOCAL_COPIES_KEPT = 3;
-const saves = new WeakMap();
-/** Kept in memory: after a restart the first save writes a new checkpoint and uploads again. */
-export function workspaceSaves(state, workspaceId) {
-    let byWorkspace = saves.get(state);
-    if (!byWorkspace) {
-        byWorkspace = new Map();
-        saves.set(state, byWorkspace);
-    }
-    let entry = byWorkspace.get(workspaceId);
-    if (!entry) {
-        entry = { uploaded: new Set(), transcripts: new Map(), local: [], queue: Promise.resolve() };
-        byWorkspace.set(workspaceId, entry);
-    }
-    return entry;
-}
-/**
- * Saves of one workspace run one after another. Overlapping saves (the page's timer, Runtime's
- * save after a change, the Save button) would otherwise finish in any order, and the last to finish
- * becomes the recovery point even when it captured the older tree.
- */
-export function oneSaveAtATime(state, workspaceId, run) {
-    const entry = workspaceSaves(state, workspaceId);
-    const next = entry.queue.then(run, run);
-    entry.queue = next.then(() => undefined, () => undefined);
-    return next;
-}
-export function sessionsKey(sessions) {
-    return JSON.stringify([...sessions]
-        .sort((left, right) => left.sessionId.localeCompare(right.sessionId))
-        .map((item) => [item.sessionId, item.nativeThreadId ?? null, item.nativeDurableTurnId ?? null, item.recoverability]));
-}
-/**
- * The checkpoint a save can answer with instead of writing a new one: same files on disk, same
- * native session state, and the journal still has it.
- */
-export function unchangedCheckpoint(state, workspaceId, digest, sessions) {
-    const last = workspaceSaves(state, workspaceId).last;
-    if (!last || last.digest !== digest || last.sessions !== sessionsKey(sessions))
-        return undefined;
-    const checkpoint = state.journal.getCheckpoint(last.checkpointId);
-    return checkpoint?.workspaceId === workspaceId ? checkpoint : undefined;
-}
-export async function rememberFileCheckpoint(state, workspaceId, saved) {
-    const entry = workspaceSaves(state, workspaceId);
-    entry.last = { checkpointId: saved.checkpointId, digest: saved.digest, sessions: sessionsKey(saved.sessions) };
-    entry.local.push(saved.checkpointId);
-    // The journal's current file and consistent checkpoints keep their copy until they are replaced.
-    const kept = new Set([state.journal.fileCheckpointId(), state.journal.consistentCheckpointId()]);
-    const removable = entry.local
-        .slice(0, Math.max(0, entry.local.length - LOCAL_COPIES_KEPT))
-        .filter((checkpointId) => !kept.has(checkpointId));
-    entry.local = entry.local.filter((checkpointId) => !removable.includes(checkpointId));
-    for (const checkpointId of removable) {
-        await rm(join(state.config.stateDir, 'file-checkpoints', checkpointId), { recursive: true, force: true }).catch(() => undefined);
-    }
-}
-/** Checkpoint uploads always go to this deployment, so they always carry the control credential. */
-export function objectStoreHeaders(state) {
-    return {
-        authorization: `Bearer ${state.config.controlToken}`,
-        'playcraft-env': state.config.environment,
-        'x-playcraft-runtime-id': state.config.runtimeId,
-        'x-playcraft-generation': String(state.config.generation),
-        'x-playcraft-runtime-epoch': String(state.runtimeEpoch),
-    };
-}