@nurix/nustack 0.10.0-dev.18 → 0.10.0-dev.20

package/dist/lib/logs/lifecycle.js

@@ -0,0 +1,159 @@
+import { printJsonSuccess } from "../json_output.js";
+import { loadLogscope } from "./library.js";
+import { LogsNotFound, LogsRefused, progress, resolveRoot } from "./answer.js";
+function reportPruneToStderr(library) {
+    for (const record of library.prune()) {
+        progress(`pruned ${record.id} (retention ${library.retentionOf(record)} days, indexed ${record.indexedAt ?? "unknown"})`);
+    }
+}
+export async function indexLogs(targets, options, cwd) {
+    const library = await loadLogscope();
+    const root = resolveRoot(options.root, cwd);
+    const retentionDays = Number(options.retain ?? String(library.DEFAULT_RETENTION_DAYS));
+    if (!Number.isInteger(retentionDays) || retentionDays < 0) {
+        throw new LogsRefused("--retain takes a non-negative whole number of days");
+    }
+    reportPruneToStderr(library);
+    const outcome = await library.indexCorpus({
+        targets,
+        root,
+        since: options.since,
+        until: options.until,
+        revision: options.revision,
+        redact: options.redact !== false,
+        keepExamples: options.examples === true,
+        retentionDays,
+    });
+    if (!outcome.ok)
+        throw new LogsRefused(outcome.message);
+    if (options.json === true) {
+        printJsonSuccess("logscope index", {
+            id: outcome.id,
+            sources: outcome.sources,
+            events: outcome.events,
+            templates: outcome.templates,
+            ratio: outcome.ratio,
+            resumes: outcome.resumes,
+            retentionDays: outcome.retentionDays,
+            hasExamples: outcome.hasExamples,
+            expiresAt: outcome.expiresAt ?? null,
+            warning: outcome.warning ?? null,
+        });
+        return;
+    }
+    console.log([
+        `indexed ${outcome.id}`,
+        `  ${outcome.events} events -> ${outcome.templates} templates (ratio ${outcome.ratio.toFixed(4)})`,
+        `  sources      ${Object.entries(outcome.resumes).map(([path, resume]) => `${path} [${resume}]`).join(", ")}`,
+        `  retention    ${outcome.retentionDays === 0 ? "off (kept until forgotten)" : `${outcome.retentionDays} days (expires ${outcome.expiresAt ?? "unknown"})`}`,
+        `  examples     ${outcome.hasExamples ? "kept" : "not kept — drill and trace <id> cannot answer on this corpus"}`,
+        ...(outcome.warning === undefined ? [] : [`  WARNING: ${outcome.warning}`]),
+    ].join("\n"));
+}
+export async function listCorpora(options) {
+    const library = await loadLogscope();
+    reportPruneToStderr(library);
+    const corpora = library.readRegistry().map((record) => ({
+        id: record.id,
+        sources: record.sources,
+        events: record.events ?? 0,
+        templates: record.templates ?? 0,
+        indexedAt: record.indexedAt ?? null,
+        retentionDays: library.retentionOf(record),
+        expiresAt: library.expiresAt(record) ?? null,
+        hasExamples: record.hasExamples === true,
+    }));
+    if (options.json === true) {
+        printJsonSuccess("logscope corpora", { corpora });
+        return;
+    }
+    if (corpora.length === 0) {
+        console.log("no corpus has been indexed on this machine — run: nustack logscope index <sources...>");
+        return;
+    }
+    console.log(corpora
+        .map((corpus) => `${corpus.id}  ${corpus.events} events, ${corpus.templates} templates  (${corpus.sources.length} sources)  ` +
+        (corpus.retentionDays === 0
+            ? "retention off"
+            : `retention ${corpus.retentionDays} days, expires ${corpus.expiresAt ?? "unknown"}`))
+        .join("\n"));
+}
+export async function allowSources(targets, options, cwd) {
+    const library = await loadLogscope();
+    const root = resolveRoot(options.root, cwd);
+    const allowed = library.allow(root, targets, options.note).map((grant) => grant.path);
+    if (options.json === true) {
+        printJsonSuccess("logscope allow", { root, allowed });
+        return;
+    }
+    console.log(allowed.map((path) => `allowed ${path}`).join("\n"));
+}
+export async function listAllowed(options, cwd) {
+    const library = await loadLogscope();
+    const root = resolveRoot(options.root, cwd);
+    const grants = library.allowedFor(root);
+    if (options.json === true) {
+        printJsonSuccess("logscope allowed", { root, grants });
+        return;
+    }
+    if (grants.length === 0) {
+        console.log(`no source is allowed for ${root} — run: nustack logscope allow <path...>`);
+        return;
+    }
+    console.log(grants
+        .map((grant) => `${grant.path}  granted ${grant.grantedAt}${grant.note === undefined ? "" : `  ${grant.note}`}`)
+        .join("\n"));
+}
+export async function revokeSources(targets, options, cwd) {
+    const library = await loadLogscope();
+    const root = resolveRoot(options.root, cwd);
+    const revoked = library.revoke(root, targets);
+    if (revoked === 0)
+        throw new LogsNotFound(`no grant under ${root} names ${targets.join(", ")}`);
+    if (options.json === true) {
+        printJsonSuccess("logscope revoke", { root, revoked });
+        return;
+    }
+    console.log(`revoked ${revoked} grant(s)`);
+}
+export async function pruneCorpora(options, cwd) {
+    const library = await loadLogscope();
+    resolveRoot(options.root, cwd);
+    const dryRun = options.dryRun === true;
+    const now = new Date();
+    const candidates = dryRun
+        ? library.readRegistry().filter((record) => {
+            const at = library.expiresAt(record);
+            return at !== null && at !== undefined && new Date(at).getTime() <= now.getTime();
+        })
+        : library.prune();
+    const pruned = candidates.map((record) => ({
+        id: record.id,
+        retentionDays: library.retentionOf(record),
+        indexedAt: record.indexedAt ?? null,
+    }));
+    if (options.json === true) {
+        printJsonSuccess("logscope prune", { dryRun, pruned });
+        return;
+    }
+    if (pruned.length === 0) {
+        console.log("nothing to prune");
+        return;
+    }
+    console.log(pruned
+        .map((record) => `${dryRun ? "would prune" : "pruned"} ${record.id} (retention ${record.retentionDays} days, indexed ${record.indexedAt ?? "unknown"})`)
+        .join("\n"));
+}
+export async function forgetCorpusCommand(ref, options) {
+    const library = await loadLogscope();
+    if (ref === undefined)
+        throw new LogsNotFound("name the corpus to forget — run: nustack logscope corpora");
+    const forgot = library.forgetCorpus(ref);
+    if (forgot === undefined)
+        throw new LogsNotFound(`no corpus matches ${ref}`);
+    if (options.json === true) {
+        printJsonSuccess("logscope forget", { forgot });
+        return;
+    }
+    console.log(`forgot ${forgot}`);
+}

package/dist/lib/{lanes → session-engine}/claudeAdapter.js

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { createInterface } from "node:readline";
-export function claudeLaneArgs(permissionMode, resumeSessionId) {
+export function claudeSessionArgs(permissionMode, resumeSessionId) {
     const args = [
         "-p",
         "--input-format",
@@ -20,7 +20,7 @@ export function claudeLaneArgs(permissionMode, resumeSessionId) {
 }
 const DENY_MESSAGE = "Denied by the user in NuStack desktop.";
 const STOP_KILL_GRACE_MS = 3_000;
-export class ClaudeLane {
+export class ClaudeSession {
     child;
     pendingApprovals = new Map();
     interruptSeq = 0;
@@ -30,7 +30,7 @@ export class ClaudeLane {
     constructor(options) {
         this.options = options;
         const spawnImpl = options.spawnImpl ?? spawn;
-        this.child = spawnImpl(options.claudeBin ?? "claude", claudeLaneArgs(options.permissionMode, options.resumeSessionId), {
+        this.child = spawnImpl(options.claudeBin ?? "claude", claudeSessionArgs(options.permissionMode, options.resumeSessionId), {
             cwd: options.cwd,
             env: options.env ?? process.env,
             stdio: ["pipe", "pipe", "pipe"],

package/dist/lib/{lanes → session-engine}/frames.js

@@ -1,10 +1,12 @@
-export const FRAME_VERSION = 1;
+export const FRAME_VERSION = 2;
 const INBOUND_TYPES = new Set([
-    "lane.open",
-    "lane.turn",
-    "lane.approval",
-    "lane.interrupt",
-    "lane.close",
+    "session.open",
+    "session.turn",
+    "session.approval",
+    "session.interrupt",
+    "session.close",
+    "session.list",
+    "session.reclaim",
     "engine.shutdown",
 ]);
 export function parseInboundFrame(line) {
@@ -31,38 +33,40 @@ export function parseInboundFrame(line) {
     const requireString = (key) => (typeof frame[key] === "string" && frame[key] !== "" ? frame[key] : null);
     switch (type) {
         case "engine.shutdown":
+        case "session.list":
             return { ok: true, frame: { v: FRAME_VERSION, type } };
-        case "lane.open": {
-            const laneId = requireString("laneId");
+        case "session.open": {
+            const sessionId = requireString("sessionId");
             const projectPath = requireString("projectPath");
-            if (!laneId || !projectPath)
-                return { ok: false, error: { code: "BAD_FRAME", name: type, message: "lane.open requires laneId and projectPath" } };
+            if (!sessionId || !projectPath)
+                return { ok: false, error: { code: "BAD_FRAME", name: type, message: "session.open requires sessionId and projectPath" } };
             const permissionMode = typeof frame.permissionMode === "string" ? frame.permissionMode : undefined;
             const isolated = frame.isolated === true ? true : undefined;
             const resumeSessionId = typeof frame.resumeSessionId === "string" && frame.resumeSessionId !== "" ? frame.resumeSessionId : undefined;
-            return { ok: true, frame: { v: FRAME_VERSION, type, laneId, projectPath, permissionMode, isolated, resumeSessionId } };
+            return { ok: true, frame: { v: FRAME_VERSION, type, sessionId, projectPath, permissionMode, isolated, resumeSessionId } };
         }
-        case "lane.turn": {
-            const laneId = requireString("laneId");
+        case "session.turn": {
+            const sessionId = requireString("sessionId");
             const text = typeof frame.text === "string" ? frame.text : null;
-            if (!laneId || text === null)
-                return { ok: false, error: { code: "BAD_FRAME", name: type, message: "lane.turn requires laneId and text" } };
-            return { ok: true, frame: { v: FRAME_VERSION, type, laneId, text } };
+            if (!sessionId || text === null)
+                return { ok: false, error: { code: "BAD_FRAME", name: type, message: "session.turn requires sessionId and text" } };
+            return { ok: true, frame: { v: FRAME_VERSION, type, sessionId, text } };
         }
-        case "lane.approval": {
-            const laneId = requireString("laneId");
+        case "session.approval": {
+            const sessionId = requireString("sessionId");
             const requestId = requireString("requestId");
             const verdict = frame.verdict === "allow" || frame.verdict === "deny" ? frame.verdict : null;
-            if (!laneId || !requestId || !verdict)
-                return { ok: false, error: { code: "BAD_FRAME", name: type, message: "lane.approval requires laneId, requestId, verdict" } };
-            return { ok: true, frame: { v: FRAME_VERSION, type, laneId, requestId, verdict } };
+            if (!sessionId || !requestId || !verdict)
+                return { ok: false, error: { code: "BAD_FRAME", name: type, message: "session.approval requires sessionId, requestId, verdict" } };
+            return { ok: true, frame: { v: FRAME_VERSION, type, sessionId, requestId, verdict } };
         }
-        case "lane.interrupt":
-        case "lane.close": {
-            const laneId = requireString("laneId");
-            if (!laneId)
-                return { ok: false, error: { code: "BAD_FRAME", name: type, message: `${type} requires laneId` } };
-            return { ok: true, frame: { v: FRAME_VERSION, type, laneId } };
+        case "session.interrupt":
+        case "session.close":
+        case "session.reclaim": {
+            const sessionId = requireString("sessionId");
+            if (!sessionId)
+                return { ok: false, error: { code: "BAD_FRAME", name: type, message: `${type} requires sessionId` } };
+            return { ok: true, frame: { v: FRAME_VERSION, type, sessionId } };
         }
         default:
             return { ok: false, error: { code: "UNKNOWN_FRAME", name: type, message: `unknown frame type: ${type}` } };

package/dist/lib/session-engine/prune.js

@@ -0,0 +1,233 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { updateSessionRegistry } from "./registry.js";
+import { ENGINE_SESSION_BRANCH_PREFIX, LEGACY_ENGINE_BRANCH_PREFIX, gitOutcome, legacyEngineHome, sessionsHome, } from "./worktree.js";
+const NOT_ISOLATED = "the session ran in the checkout itself — there is nothing of its own to reclaim";
+const FOREIGN_BRANCH = "its branch is not an engine session branch — this row is not the engine's to reclaim";
+const FOREIGN_WORKTREE = "its worktree is outside the engine's worktrees directory — this row is not the engine's to reclaim";
+function insideAnEngineHome(worktreePath, env) {
+    const live = path.join(sessionsHome(env), "worktrees") + path.sep;
+    const legacy = path.join(legacyEngineHome(env), "worktrees") + path.sep;
+    return worktreePath.startsWith(live) || worktreePath.startsWith(legacy);
+}
+function isEngineBranch(branch) {
+    return branch !== null && (branch.startsWith(ENGINE_SESSION_BRANCH_PREFIX) || branch.startsWith(LEGACY_ENGINE_BRANCH_PREFIX));
+}
+async function isDirectory(target) {
+    try {
+        return (await stat(target)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function refuse(record, facts, reason) {
+    return {
+        sessionId: record.sessionId,
+        isolated: false,
+        checkoutPresent: false,
+        worktreePresent: false,
+        branchExists: false,
+        reading: "unknown",
+        dirty: false,
+        stale: false,
+        orphaned: false,
+        reclaimable: false,
+        ...facts,
+        reason,
+    };
+}
+function processIsGone(pid) {
+    try {
+        process.kill(pid, 0);
+        return false;
+    }
+    catch (error) {
+        return error.code === "ESRCH";
+    }
+}
+export async function inspectSession(record, env = process.env) {
+    const orphaned = record.worktreePath.startsWith(path.join(legacyEngineHome(env), "worktrees") + path.sep);
+    const checkoutPresent = await isDirectory(record.projectPath);
+    const worktreePresent = await isDirectory(record.worktreePath);
+    const isolated = record.branch !== null && record.worktreePath !== record.projectPath;
+    if (!isolated)
+        return refuse(record, { checkoutPresent, orphaned }, NOT_ISOLATED);
+    if (!isEngineBranch(record.branch))
+        return refuse(record, { isolated, checkoutPresent, orphaned }, FOREIGN_BRANCH);
+    if (!insideAnEngineHome(record.worktreePath, env)) {
+        return refuse(record, { isolated, checkoutPresent, orphaned }, FOREIGN_WORKTREE);
+    }
+    if (!checkoutPresent) {
+        return refuse(record, { isolated, worktreePresent, orphaned }, `its checkout is gone — remove ${record.worktreePath} and the branch by hand`);
+    }
+    const branch = record.branch;
+    const branchExists = (await gitOutcome(["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`], record.projectPath)).ok;
+    const dirty = worktreePresent && (await gitOutcome(["status", "--porcelain"], record.worktreePath)).stdout !== "";
+    const stale = record.status === "open" && typeof record.enginePid === "number" && processIsGone(record.enginePid);
+    const reading = await readMerge(record, branch, branchExists, dirty);
+    const reclaimable = checkoutPresent &&
+        !dirty &&
+        (record.status === "closed" || stale) &&
+        (reading === "untouched" || reading === "merged" || reading === "merged-into-head" || !branchExists);
+    return {
+        sessionId: record.sessionId,
+        isolated,
+        checkoutPresent,
+        worktreePresent,
+        branchExists,
+        reading,
+        dirty,
+        stale,
+        orphaned,
+        reclaimable,
+        reason: explain({ reading, dirty, stale, branchExists, reclaimable, status: record.status, baseBranch: record.baseBranch ?? null }),
+    };
+}
+async function readMerge(record, branch, branchExists, dirty) {
+    if (!branchExists)
+        return "unknown";
+    const cwd = record.projectPath;
+    if (record.baseCommit) {
+        const tip = await gitOutcome(["rev-parse", branch], cwd);
+        if (tip.ok && tip.stdout === record.baseCommit && !dirty)
+            return "untouched";
+    }
+    if (record.baseBranch) {
+        const againstBase = await gitOutcome(["merge-base", "--is-ancestor", branch, record.baseBranch], cwd);
+        if (againstBase.code === 0)
+            return "merged";
+        if (againstBase.code === 1)
+            return "unmerged";
+    }
+    const againstHead = await gitOutcome(["merge-base", "--is-ancestor", branch, "HEAD"], cwd);
+    if (againstHead.code === 0)
+        return "merged-into-head";
+    if (againstHead.code === 1)
+        return "unmerged";
+    return "unknown";
+}
+function explain(facts) {
+    if (facts.dirty)
+        return "its worktree has uncommitted changes — commit or discard them first";
+    if (facts.status === "open" && !facts.stale)
+        return "it is still open — close the session first";
+    if (facts.reading === "unmerged")
+        return "unmerged — its branch has work nothing has taken";
+    if (facts.reading === "unknown" && facts.branchExists)
+        return "its branch could not be read against any base";
+    if (!facts.reclaimable)
+        return "it cannot be reclaimed yet";
+    if (!facts.branchExists)
+        return "its branch is already gone — only the worktree is left";
+    if (facts.reading === "untouched")
+        return "nothing was ever done in this session, and its worktree is clean";
+    if (facts.reading === "merged")
+        return `merged into ${facts.baseBranch ?? "its base"} and its worktree is clean`;
+    return "merged into the checkout's current HEAD and its worktree is clean";
+}
+export async function readOrphanedWorktrees(env = process.env) {
+    const root = path.join(legacyEngineHome(env), "worktrees");
+    let entries;
+    try {
+        entries = (await readdir(root, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    }
+    catch {
+        return { records: [], undecipherable: [] };
+    }
+    const records = [];
+    const undecipherable = [];
+    for (const id of entries) {
+        const worktreePath = path.join(root, id);
+        const projectPath = await checkoutOfLinkedWorktree(worktreePath, id);
+        if (!projectPath) {
+            undecipherable.push(worktreePath);
+            continue;
+        }
+        records.push({
+            sessionId: id,
+            projectPath,
+            worktreePath,
+            branch: `${LEGACY_ENGINE_BRANCH_PREFIX}${id}`,
+            provider: "claude-code",
+            providerSessionId: null,
+            createdAt: await directoryCreatedAt(worktreePath),
+            status: "closed",
+            nustack: 1,
+            projectId: null,
+            permissionMode: null,
+            baseBranch: null,
+            baseCommit: null,
+            enginePid: null,
+            closedAt: null,
+        });
+    }
+    return { records, undecipherable };
+}
+async function checkoutOfLinkedWorktree(worktreePath, id) {
+    let body;
+    try {
+        body = await readFile(path.join(worktreePath, ".git"), "utf8");
+    }
+    catch {
+        return null;
+    }
+    const match = /^gitdir:\s*(.+)$/m.exec(body.trim());
+    if (!match?.[1])
+        return null;
+    const tail = path.join(".git", "worktrees", id);
+    const gitdir = match[1].trim();
+    if (!gitdir.endsWith(tail))
+        return null;
+    const checkout = gitdir.slice(0, gitdir.length - tail.length).replace(new RegExp(`${path.sep}+$`), "");
+    return checkout === "" ? null : checkout;
+}
+async function directoryCreatedAt(target) {
+    try {
+        return (await stat(target)).mtime.toISOString();
+    }
+    catch {
+        return new Date(0).toISOString();
+    }
+}
+export async function reclaimSession(record, options, env = process.env) {
+    const refused = (reason) => ({
+        sessionId: record.sessionId,
+        removedWorktree: false,
+        deletedBranch: false,
+        droppedRow: false,
+        reason,
+    });
+    if (!isEngineBranch(record.branch))
+        return refused(record.branch === null ? NOT_ISOLATED : FOREIGN_BRANCH);
+    if (record.worktreePath === record.projectPath)
+        return refused(NOT_ISOLATED);
+    if (!insideAnEngineHome(record.worktreePath, env))
+        return refused(FOREIGN_WORKTREE);
+    const facts = await inspectSession(record, env);
+    if (!facts.checkoutPresent)
+        return refused(facts.reason);
+    if (record.status === "open" && !facts.stale) {
+        return refused(`its engine is still running (pid ${String(record.enginePid ?? "unknown")}) — close the session first`);
+    }
+    const force = options.force === true;
+    if (!force && !facts.reclaimable)
+        return refused(facts.reason);
+    const branch = record.branch;
+    const removal = await gitOutcome(force ? ["worktree", "remove", "--force", record.worktreePath] : ["worktree", "remove", record.worktreePath], record.projectPath);
+    await gitOutcome(["worktree", "prune"], record.projectPath);
+    const deletion = await gitOutcome([...(force ? ["branch", "-D"] : ["branch", "-d"]), branch], record.projectPath);
+    const worktreeLeft = await isDirectory(record.worktreePath);
+    const branchLeft = (await gitOutcome(["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`], record.projectPath)).ok;
+    const cleared = !worktreeLeft && !branchLeft;
+    const droppedRow = cleared && !facts.orphaned
+        ? await updateSessionRegistry(env, (sessions) => sessions.filter((row) => row.sessionId !== record.sessionId)).then(() => true)
+        : false;
+    return {
+        sessionId: record.sessionId,
+        removedWorktree: !worktreeLeft,
+        deletedBranch: !branchLeft,
+        droppedRow,
+        reason: cleared ? null : (deletion.stderr || removal.stderr || "the worktree or the branch could not be removed"),
+    };
+}

package/dist/lib/session-engine/registry.js

@@ -0,0 +1,83 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { sessionsHome } from "./worktree.js";
+export const SESSION_REGISTRY_VERSION = 2;
+export function sessionRegistryPath(env = process.env) {
+    return path.join(sessionsHome(env), "registry.json");
+}
+function asText(value) {
+    return typeof value === "string" && value.trim() !== "" ? value : null;
+}
+function asNullableText(value) {
+    return typeof value === "string" ? value : null;
+}
+function narrowRecord(value) {
+    if (typeof value !== "object" || value === null)
+        return null;
+    const row = value;
+    const sessionId = asText(row.sessionId);
+    const projectPath = asText(row.projectPath);
+    const worktreePath = asText(row.worktreePath);
+    const createdAt = asText(row.createdAt);
+    if (!sessionId || !projectPath || !worktreePath || !createdAt)
+        return null;
+    if (row.status !== "open" && row.status !== "closed")
+        return null;
+    if (row.provider !== "claude-code")
+        return null;
+    const enginePid = typeof row.enginePid === "number" && Number.isSafeInteger(row.enginePid) && row.enginePid > 0 ? row.enginePid : null;
+    return {
+        sessionId,
+        projectPath,
+        worktreePath,
+        branch: asNullableText(row.branch),
+        provider: "claude-code",
+        providerSessionId: asNullableText(row.providerSessionId),
+        createdAt,
+        status: row.status,
+        nustack: row.nustack === 0 ? 0 : 1,
+        projectId: asNullableText(row.projectId),
+        permissionMode: asNullableText(row.permissionMode),
+        baseBranch: asNullableText(row.baseBranch),
+        baseCommit: asNullableText(row.baseCommit),
+        enginePid,
+        closedAt: asNullableText(row.closedAt),
+    };
+}
+export async function readSessionRegistry(env = process.env) {
+    let parsed;
+    try {
+        parsed = JSON.parse(await readFile(sessionRegistryPath(env), "utf8"));
+    }
+    catch {
+        return { records: [], dropped: 0 };
+    }
+    const rows = parsed?.sessions;
+    if (!Array.isArray(rows))
+        return { records: [], dropped: 0 };
+    const records = [];
+    let dropped = 0;
+    for (const row of rows) {
+        const record = narrowRecord(row);
+        if (record)
+            records.push(record);
+        else
+            dropped += 1;
+    }
+    return { records, dropped };
+}
+let registryWrites = Promise.resolve();
+export function updateSessionRegistry(env, mutate) {
+    const run = async () => {
+        const file = sessionRegistryPath(env);
+        const { records } = await readSessionRegistry(env);
+        const body = JSON.stringify({ v: SESSION_REGISTRY_VERSION, sessions: mutate(records) }, null, 2) + "\n";
+        await mkdir(path.dirname(file), { recursive: true });
+        const temp = `${file}.${process.pid}.tmp`;
+        await writeFile(temp, body, "utf8");
+        await rename(temp, file);
+    };
+    const landed = registryWrites.then(run, run);
+    registryWrites = landed.then(() => undefined, () => undefined);
+    return landed;
+}