@code-yeongyu/senpi 2026.10.23-1 → 2026.10.24-1

package/dist/core/session-move/extension-state.js

@@ -1,8 +1,8 @@
 import { randomBytes } from "node:crypto";
-import { cpSync, existsSync, mkdirSync, readdirSync, rmSync } from "node:fs";
-import { writeFile } from "node:fs/promises";
+import { cp, mkdir, readdir, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, join } from "node:path";
-import { loadEntriesFromFile } from "../session-manager.js";
+import { loadEntriesFromFileAsync } from "../session-manager.js";
+import { pathExists } from "../tools/path-utils.js";
 import { isPlainId, parseMoveId } from "./bundle.js";
 import { SESSION_MOVED_IN, SESSION_RELEASED } from "./ownership.js";
 /**
@@ -45,36 +45,36 @@ function sealedAttempt(entries, moveId) {
     return isPlainId(attempt) ? attempt : undefined;
 }
 /** The folder of the release attempt that sealed the session for `moveId`, if that release staged one. */
-export function sealedOutgoingStateDir(sessionFile, moveId) {
-    const attempt = sealedAttempt(loadEntriesFromFile(sessionFile), moveId);
+export async function sealedOutgoingStateDir(sessionFile, moveId) {
+    const attempt = sealedAttempt(await loadEntriesFromFileAsync(sessionFile), moveId);
     return attempt === undefined ? undefined : join(outgoingStateDir(sessionFile, moveId), attempt);
 }
 /**
  * Creates a fresh, empty folder for one release attempt. Earlier attempts of the move that never sealed the session
  * are dead and removed (a handler still running for one of them may recreate its own folder, which is never read).
  */
-export function prepareOutgoingState(sessionFile, moveId) {
+export async function prepareOutgoingState(sessionFile, moveId) {
     const root = outgoingStateDir(sessionFile, moveId);
-    const sealed = sealedAttempt(loadEntriesFromFile(sessionFile), moveId);
-    if (existsSync(root)) {
-        for (const name of readdirSync(root)) {
+    const sealed = sealedAttempt(await loadEntriesFromFileAsync(sessionFile), moveId);
+    if (await pathExists(root)) {
+        for (const name of await readdir(root)) {
             if (name !== sealed)
-                rmSync(join(root, name), { recursive: true, force: true });
+                await rm(join(root, name), { recursive: true, force: true });
         }
     }
     const attempt = newAttempt();
     const dir = join(root, attempt);
-    mkdirSync(dir, { recursive: true });
+    await mkdir(dir, { recursive: true });
     return { attempt, dir };
 }
 /**
  * The state the last move into this session left for its extensions, if it has not been handed over yet. Only the
  * newest `session_moved_in` counts, and only until a `session_move_state_restored` for that move is written.
  */
-export function pendingMovedState(sessionFile) {
-    if (!existsSync(sessionFile))
+export async function pendingMovedState(sessionFile) {
+    if (!(await pathExists(sessionFile)))
         return undefined;
-    const entries = loadEntriesFromFile(sessionFile);
+    const entries = await loadEntriesFromFileAsync(sessionFile);
     const movedIn = entries.findLast((entry) => entry.type === "custom" && entry.customType === SESSION_MOVED_IN);
     const moveId = movedIn === undefined ? undefined : moveIdOf(movedIn);
     if (moveId === undefined)
@@ -84,7 +84,7 @@ export function pendingMovedState(sessionFile) {
         return undefined;
     const id = parseMoveId(moveId);
     const dir = movedStateDir(sessionFile, id);
-    return existsSync(dir) ? { moveId: id, dir } : undefined;
+    return (await pathExists(dir)) ? { moveId: id, dir } : undefined;
 }
 /** Delivery bookkeeping for one pending folder: the `delivered` marker and each delivery's own copy. */
 const deliveryDir = (pendingDir) => join(dirname(dirname(pendingDir)), "delivery", basename(pendingDir));
@@ -99,28 +99,28 @@ export async function restoreMovedState(sessionManager, deliver) {
     const sessionFile = sessionManager.getSessionFile();
     if (sessionFile === undefined)
         return;
-    const pending = pendingMovedState(sessionFile);
+    const pending = await pendingMovedState(sessionFile);
     if (pending === undefined)
         return;
     const bookkeeping = deliveryDir(pending.dir);
     const marker = join(bookkeeping, DELIVERED_MARKER);
-    const redelivered = existsSync(marker);
-    if (existsSync(bookkeeping)) {
-        for (const name of readdirSync(bookkeeping)) {
+    const redelivered = await pathExists(marker);
+    if (await pathExists(bookkeeping)) {
+        for (const name of await readdir(bookkeeping)) {
             if (name.startsWith(DELIVERY_COPY))
-                rmSync(join(bookkeeping, name), { recursive: true, force: true });
+                await rm(join(bookkeeping, name), { recursive: true, force: true });
         }
     }
-    mkdirSync(bookkeeping, { recursive: true });
+    await mkdir(bookkeeping, { recursive: true });
     await writeFile(marker, "");
     const copy = join(bookkeeping, `${DELIVERY_COPY}${newAttempt()}`);
-    cpSync(pending.dir, copy, { recursive: true });
+    await cp(pending.dir, copy, { recursive: true });
     let restored;
     try {
         restored = await deliver({ moveId: pending.moveId, dir: copy, redelivered });
     }
     finally {
-        rmSync(copy, { recursive: true, force: true });
+        await rm(copy, { recursive: true, force: true });
     }
     if (!restored)
         return;
@@ -128,7 +128,7 @@ export async function restoreMovedState(sessionManager, deliver) {
         move_id: pending.moveId,
         restored_at: new Date().toISOString(),
     });
-    rmSync(pending.dir, { recursive: true, force: true });
-    rmSync(bookkeeping, { recursive: true, force: true });
+    await rm(pending.dir, { recursive: true, force: true });
+    await rm(bookkeeping, { recursive: true, force: true });
 }
 //# sourceMappingURL=extension-state.js.map

package/dist/core/session-move/finish.d.ts

@@ -9,7 +9,7 @@ export interface FinishMoveOptions {
     /** The receiver's signed answer. `receiving` changes nothing: the move is still open. */
     readonly answer: MoveAnswer;
     /** Runs inside the move lock before anything is read; throw to refuse. */
-    readonly guard?: () => void;
+    readonly guard?: () => void | Promise<void>;
 }
 export declare class MoveMismatchError extends Error {
     readonly code = "move_mismatch";

package/dist/core/session-move/finish.js

@@ -1,5 +1,6 @@
-import { existsSync, rmSync } from "node:fs";
-import { loadEntriesFromFile, SessionManager } from "../session-manager.js";
+import { rm } from "node:fs/promises";
+import { loadEntriesFromFileAsync, SessionManager } from "../session-manager.js";
+import { pathExists } from "../tools/path-utils.js";
 import { readManifest } from "./bundle.js";
 import { outgoingStateDir } from "./extension-state.js";
 import { moveStep } from "./move-steps.js";
@@ -32,17 +33,17 @@ export function finishMove(options) {
 }
 async function settleMove(options) {
     const { sessionFile, bundleDir, moveId, answer } = options;
-    if (existsSync(bundleDir)) {
+    if (await pathExists(bundleDir)) {
         const bundled = (await readManifest(bundleDir)).moveId;
         if (bundled !== moveId)
             throw new MoveMismatchError(moveId, bundled, "the kept bundle");
     }
-    const entries = loadEntriesFromFile(sessionFile);
+    const entries = await loadEntriesFromFileAsync(sessionFile);
     const ownership = sessionOwnership(entries);
     if (ownership.writable) {
         if (reclaimed(entries, moveId))
             await requeueDroppedInput(sessionFile, bundleDir);
-        discardMoveFiles(sessionFile, bundleDir, moveId);
+        await discardMoveFiles(sessionFile, bundleDir, moveId);
         return;
     }
     if (ownership.moveId !== moveId)
@@ -50,7 +51,7 @@ async function settleMove(options) {
     if (ownership.state === "moved") {
         if ("revoked" in answer)
             throw new MoveAlreadyMovedError(moveId);
-        discardMoveFiles(sessionFile, bundleDir, moveId);
+        await discardMoveFiles(sessionFile, bundleDir, moveId);
         return;
     }
     const sessionId = headerSessionId(entries) ?? "";
@@ -62,7 +63,7 @@ async function settleMove(options) {
                 await takeBack(sessionFile, bundleDir, { move_id: moveId, session_id: sessionId, reason: "revoked" });
                 break;
             }
-            SessionManager.open(sessionFile).appendCustomEntry(SESSION_MOVED, {
+            (await SessionManager.openAsync(sessionFile)).appendCustomEntry(SESSION_MOVED, {
                 move_id: moveId,
                 session_id: sessionId,
                 target: ownership.target,
@@ -85,20 +86,20 @@ async function settleMove(options) {
         }
     }
     moveStep("finish:requeued");
-    discardMoveFiles(sessionFile, bundleDir, moveId);
+    await discardMoveFiles(sessionFile, bundleDir, moveId);
 }
 /** `session_reclaimed` makes the file writable again, then the queued input comes back under ids stable per move. */
 async function takeBack(sessionFile, bundleDir, data) {
-    SessionManager.open(sessionFile).appendCustomEntry(SESSION_RECLAIMED, {
+    (await SessionManager.openAsync(sessionFile)).appendCustomEntry(SESSION_RECLAIMED, {
         ...data,
         reclaimed_at: new Date().toISOString(),
     });
     moveStep("finish:recorded");
     await requeueDroppedInput(sessionFile, bundleDir);
 }
-function discardMoveFiles(sessionFile, bundleDir, moveId) {
-    rmSync(bundleDir, { recursive: true, force: true });
-    rmSync(outgoingStateDir(sessionFile, moveId), { recursive: true, force: true });
+async function discardMoveFiles(sessionFile, bundleDir, moveId) {
+    await rm(bundleDir, { recursive: true, force: true });
+    await rm(outgoingStateDir(sessionFile, moveId), { recursive: true, force: true });
 }
 function reclaimed(entries, moveId) {
     return entries.some((entry) => entry.type === "custom" &&
@@ -106,7 +107,7 @@ function reclaimed(entries, moveId) {
         entry.data?.move_id === moveId);
 }
 export async function requeueDroppedInput(sessionFile, bundleDir) {
-    if (!existsSync(bundleDir))
+    if (!(await pathExists(bundleDir)))
         return;
     const manifest = await readManifest(bundleDir);
     await requeueInput(sessionFile, manifest.moveId, manifest.droppedUserMessages);

package/dist/core/session-move/import.js

@@ -1,10 +1,11 @@
-import { copyFileSync, existsSync, mkdirSync, readdirSync, rmSync } from "node:fs";
+import { copyFile, mkdir, readdir, rm } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { normalizePath, resolvePath } from "../../utils/paths.js";
 import { compareRepositoryIdentities, readRepositoryIdentity, } from "../repository-identity.js";
-import { getDefaultSessionDir, loadEntriesFromFile, SessionManager } from "../session-manager.js";
+import { getDefaultSessionDir, loadEntriesFromFileAsync, SessionManager } from "../session-manager.js";
 import { rebindSessionFile } from "../session-rebind.js";
 import { encodedSessionId, serializeByKey } from "../session-sidecar-store.js";
+import { pathExists } from "../tools/path-utils.js";
 import { EXTENSION_STATE_PREFIX, MoveBundleInvalidError, readManifest, sha256File, verifyBundle, } from "./bundle.js";
 import { EXTENSION_STATE_PAYLOAD, movedStateDir } from "./extension-state.js";
 import { MoveFencedError } from "./move-ledger.js";
@@ -27,13 +28,13 @@ export class MoveTargetOccupiedError extends Error {
         this.name = "MoveTargetOccupiedError";
     }
 }
-const movedInFor = (file, moveId) => loadEntriesFromFile(file).some((entry) => entry.type === "custom" &&
+const movedInFor = async (file, moveId) => (await loadEntriesFromFileAsync(file)).some((entry) => entry.type === "custom" &&
     entry.customType === SESSION_MOVED_IN &&
     entry.data?.move_id === moveId);
 /** What the session file records for the move: nothing, its import, or its import and then a revoke. */
-function importOutcome(file, moveId) {
+async function importOutcome(file, moveId) {
     let outcome = "absent";
-    for (const entry of loadEntriesFromFile(file)) {
+    for (const entry of await loadEntriesFromFileAsync(file)) {
         if (entry.type !== "custom")
             continue;
         const data = entry.data;
@@ -59,11 +60,11 @@ export class StatusPathMismatchError extends Error {
  * one revoked), so a file that is not this move's import is refused. A path with no file answers from the ledger.
  */
 export async function answerMoveStatus(ledger, moveId, sessionFile) {
-    const landed = (target) => (existsSync(target) ? importOutcome(target, moveId) : "absent");
-    if (sessionFile === undefined || !existsSync(sessionFile))
+    const landed = async (target) => ((await pathExists(target)) ? importOutcome(target, moveId) : "absent");
+    if (sessionFile === undefined || !(await pathExists(sessionFile)))
         return ledger.answerStatus(moveId, { movedIn: false, landed });
-    return serializeByKey(moveLockKey(sessionFile), async () => {
-        const outcome = importOutcome(sessionFile, moveId);
+    return serializeByKey(await moveLockKey(sessionFile), async () => {
+        const outcome = await importOutcome(sessionFile, moveId);
         if (outcome === "absent")
             throw new StatusPathMismatchError(moveId, sessionFile);
         return ledger.answerStatus(moveId, { movedIn: true, revoked: outcome === "revoked", landed });
@@ -83,10 +84,10 @@ export async function importMovedSession(options) {
     const target = join(sessionDir, manifest.sessionFileName);
     // Once this move's file landed, the move records no failure: only its `accepted` write can have been lost, so it stays
     // receiving and a re-run accepts it. `fail` asks this under the move's lock, where an overlapping commit cannot race it.
-    const landed = () => existsSync(target) && movedInFor(target, manifest.moveId);
-    if (landed()) {
+    const landed = async () => (await pathExists(target)) && (await movedInFor(target, manifest.moveId));
+    if (await landed()) {
         // The rename already committed; a crash or a failed write may have lost `accepted`, and the file is the authority.
-        await options.ledger.confirmLanded(manifest.moveId, target, importOutcome(target, manifest.moveId) === "revoked");
+        await options.ledger.confirmLanded(manifest.moveId, target, (await importOutcome(target, manifest.moveId)) === "revoked");
         return { sessionFile: target };
     }
     try {
@@ -99,7 +100,7 @@ export async function importMovedSession(options) {
     }
     const read = options.readIdentity ?? readRepositoryIdentity;
     if (compareRepositoryIdentities(manifest.repository, await read(targetCwd)) !== "same") {
-        if (!landed())
+        if (!(await landed()))
             await options.ledger.decline(manifest.moveId, "repository");
         throw new MoveRefusedError(targetCwd, manifest.sourceCwd);
     }
@@ -108,13 +109,13 @@ export async function importMovedSession(options) {
     const staging = join(sessionDir, ".move-staging", encodeURIComponent(manifest.moveId));
     try {
         const staged = await stage(options.bundleDir, manifest, staging, options.from ?? "");
-        const sessionFile = await options.ledger.commit(manifest.moveId, target, () => rebindSessionFile(staged, targetCwd, sessionDir), () => {
-            replacePredecessor(target, manifest.sessionId, sessionDir);
+        const sessionFile = await options.ledger.commit(manifest.moveId, target, () => rebindSessionFile(staged, targetCwd, sessionDir), async () => {
+            await replacePredecessor(target, manifest.sessionId, sessionDir);
             // Before the rename: a crash here re-copies on retry, and after it the state is already in place.
-            placeExtensionState(staging, manifest, movedStateDir(target, manifest.moveId));
+            await placeExtensionState(staging, manifest, movedStateDir(target, manifest.moveId));
         });
         moveStep("import:accepted");
-        rmSync(staging, { recursive: true, force: true });
+        await rm(staging, { recursive: true, force: true });
         return { sessionFile };
     }
     catch (error) {
@@ -128,22 +129,22 @@ export async function importMovedSession(options) {
  * It is removed before the rename: if the rename then fails, the move is recorded `import_failed`, the sender takes
  * the session back, and nothing writable was lost here (the removed copy could not be written).
  */
-function replacePredecessor(target, sessionId, sessionDir) {
-    if (!existsSync(target))
+async function replacePredecessor(target, sessionId, sessionDir) {
+    if (!(await pathExists(target)))
         return;
-    const entries = loadEntriesFromFile(target);
+    const entries = await loadEntriesFromFileAsync(target);
     if (headerSessionId(entries) !== sessionId || sessionOwnership(entries).writable) {
         throw new MoveTargetOccupiedError(target);
     }
     const extensions = join(sessionDir, "extensions");
-    if (existsSync(extensions)) {
-        for (const extension of readdirSync(extensions, { withFileTypes: true })) {
+    if (await pathExists(extensions)) {
+        for (const extension of await readdir(extensions, { withFileTypes: true })) {
             if (extension.isDirectory())
-                rmSync(join(extensions, extension.name, `${encodedSessionId(sessionId)}.json`), { force: true });
+                await rm(join(extensions, extension.name, `${encodedSessionId(sessionId)}.json`), { force: true });
         }
     }
-    rmSync(join(sessionDir, "resident-blobs", sessionId), { recursive: true, force: true });
-    rmSync(target, { force: true });
+    await rm(join(sessionDir, "resident-blobs", sessionId), { recursive: true, force: true });
+    await rm(target, { force: true });
 }
 /** Payload files are staged here, next to the staged session file, and placed from this checked copy. */
 const STAGED_PAYLOADS = ".payloads";
@@ -152,34 +153,34 @@ const extensionStateFiles = (manifest) => manifest.payloads.filter((payload) =>
 async function stagePayloads(bundleDir, manifest, staging) {
     for (const file of manifest.payloads.flatMap((payload) => payload.files)) {
         const to = join(staging, STAGED_PAYLOADS, file.path);
-        mkdirSync(dirname(to), { recursive: true });
-        copyFileSync(join(bundleDir, file.path), to);
+        await mkdir(dirname(to), { recursive: true });
+        await copyFile(join(bundleDir, file.path), to);
         if ((await sha256File(to)) !== file.sha256)
             throw new MoveBundleInvalidError(`${file.path} changed in transit`);
     }
 }
-function placeExtensionState(staging, manifest, dir) {
+async function placeExtensionState(staging, manifest, dir) {
     const files = extensionStateFiles(manifest);
     if (files.length === 0)
         return;
-    rmSync(dir, { recursive: true, force: true });
+    await rm(dir, { recursive: true, force: true });
     for (const file of files) {
         const to = join(dir, file.path.slice(EXTENSION_STATE_PREFIX.length));
-        mkdirSync(dirname(to), { recursive: true });
-        copyFileSync(join(staging, STAGED_PAYLOADS, file.path), to);
+        await mkdir(dirname(to), { recursive: true });
+        await copyFile(join(staging, STAGED_PAYLOADS, file.path), to);
     }
 }
 async function stage(bundleDir, manifest, staging, from) {
     const file = join(staging, manifest.sessionFileName);
-    if (!(existsSync(file) && movedInFor(file, manifest.moveId))) {
-        rmSync(staging, { recursive: true, force: true });
+    if (!((await pathExists(file)) && (await movedInFor(file, manifest.moveId)))) {
+        await rm(staging, { recursive: true, force: true });
         for (const item of [manifest.session, ...manifest.sidecars]) {
             const to = item === manifest.session ? file : join(staging, item.path.replace(/^files\//, ""));
-            mkdirSync(dirname(to), { recursive: true });
-            copyFileSync(join(bundleDir, item.path), to);
+            await mkdir(dirname(to), { recursive: true });
+            await copyFile(join(bundleDir, item.path), to);
         }
         await stagePayloads(bundleDir, manifest, staging);
-        SessionManager.open(file, staging).appendCustomEntry(SESSION_MOVED_IN, {
+        (await SessionManager.openAsync(file, staging)).appendCustomEntry(SESSION_MOVED_IN, {
             move_id: manifest.moveId,
             session_id: manifest.sessionId,
             from,

package/dist/core/session-move/move-ledger.d.ts

@@ -73,7 +73,7 @@ export declare class MoveLedger {
     answerStatus(moveId: MoveId, here: {
         readonly movedIn: boolean;
         readonly revoked?: boolean;
-        readonly landed?: (target: string) => LandingOutcome;
+        readonly landed?: (target: string) => LandingOutcome | Promise<LandingOutcome>;
     }): Promise<MoveAnswer>;
     /** Cancel, expiry or a refused chunk: only before the bundle was verified and receiving began, never after. */
     decline(moveId: MoveId, reason: DeclineReason): Promise<MoveRecord>;
@@ -83,7 +83,7 @@ export declare class MoveLedger {
      * commit may land it while this call waits for the lock), nothing is recorded and the current record is returned.
      */
     fail(moveId: MoveId, reason: FailReason, options?: {
-        readonly unlessLanded?: () => boolean;
+        readonly unlessLanded?: () => boolean | Promise<boolean>;
     }): Promise<MoveRecord | undefined>;
     /**
      * Runs the import's commit (the atomic rename into `target`) under the move's lock. The record is stamped
@@ -91,7 +91,7 @@ export declare class MoveLedger {
      * file at the target then decides (`confirmLanded`, `reconcile`). Only the recorded target may be renamed into.
      * `prepare` runs before the stamp: whatever it does or refuses lands nothing, so a refusal there still records failed.
      */
-    commit<T>(moveId: MoveId, target: string, rename: () => T | Promise<T>, prepare?: () => void): Promise<T>;
+    commit<T>(moveId: MoveId, target: string, rename: () => T | Promise<T>, prepare?: () => void | Promise<void>): Promise<T>;
     /**
      * The import found this move's file already landed at `target`: that file proves the commit, so a record a crash
      * left `receiving`, committing or lost becomes accepted there, and revoked when the file is (`revoked`). A target

package/dist/core/session-move/move-ledger.js

@@ -1,5 +1,4 @@
-import { mkdirSync } from "node:fs";
-import { readFile, rename as renameFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile, rename as renameFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { serializeByKey } from "../session-sidecar-store.js";
 import { parseMoveId } from "./bundle.js";
@@ -138,7 +137,9 @@ export class MoveLedger {
      * commit may land it while this call waits for the lock), nothing is recorded and the current record is returned.
      */
     fail(moveId, reason, options = {}) {
-        return this.locked(moveId, () => options.unlessLanded?.() ? this.current(moveId) : this.settleLocked(moveId, { state: "failed", reason }, []));
+        return this.locked(moveId, async () => (await options.unlessLanded?.())
+            ? this.current(moveId)
+            : this.settleLocked(moveId, { state: "failed", reason }, []));
     }
     /**
      * Runs the import's commit (the atomic rename into `target`) under the move's lock. The record is stamped
@@ -152,7 +153,7 @@ export class MoveLedger {
             const landing = await this.landing(moveId);
             if (!landsAt(record, landing, target))
                 throw new MoveFencedError(moveId, record, landedElsewhere(record, landing));
-            prepare?.();
+            await prepare?.();
             await this.write(moveId, { state: "receiving" }, { target, committing: true });
             moveStep("import:stamped");
             const result = await rename();
@@ -188,7 +189,7 @@ export class MoveLedger {
         const { target, committing } = await this.landing(moveId);
         if (landed === undefined || target === undefined)
             return record;
-        const next = settledLanding(record, committing === true, landed(target));
+        const next = settledLanding(record, committing === true, await landed(target));
         if (next === undefined)
             return record;
         await this.write(moveId, next, { target });
@@ -275,7 +276,7 @@ export class MoveLedger {
     locked(moveId, fn) {
         const file = this.path(moveId);
         return serializeByKey(file, async () => {
-            mkdirSync(this.dir, { recursive: true });
+            await mkdir(this.dir, { recursive: true });
             return this.#locks.hold(file, fn);
         });
     }

package/dist/core/session-move/requeue.js

@@ -8,7 +8,7 @@ import { SessionManager } from "../session-manager.js";
 export async function requeueInput(sessionFile, moveId, texts) {
     if (texts.length === 0)
         return;
-    const sessionManager = SessionManager.open(sessionFile);
+    const sessionManager = await SessionManager.openAsync(sessionFile);
     let next = 0;
     const inputs = new SessionPendingInputs({ sessionManager, nextQueuedId: () => `move-${moveId}-${next++}` });
     for (const [index, text] of texts.entries()) {

package/dist/core/session-move/revoke.d.ts

@@ -7,7 +7,7 @@ export interface RevokeMoveOptions {
     /** This device's move record; its accepted record is marked revoked once the copy is sealed. */
     readonly ledger: MoveLedger;
     /** Runs inside the move lock before anything is read; throw to refuse. */
-    readonly guard?: () => void;
+    readonly guard?: () => void | Promise<void>;
 }
 export declare class RevokeMismatchError extends Error {
     readonly code = "move_mismatch";

package/dist/core/session-move/revoke.js

@@ -1,4 +1,4 @@
-import { loadEntriesFromFile, SessionManager } from "../session-manager.js";
+import { loadEntriesFromFileAsync, SessionManager } from "../session-manager.js";
 import { moveStep } from "./move-steps.js";
 import { headerSessionId, ownershipStep, SESSION_MOVED, SESSION_MOVED_IN, } from "./ownership.js";
 import { withSessionMoveLock } from "./session-lock.js";
@@ -19,14 +19,14 @@ export const REVOKED = "revoked";
  */
 export function revokeImportedMove(options) {
     return withSessionMoveLock(options.sessionFile, async () => {
-        seal(options.sessionFile, options.moveId);
+        await seal(options.sessionFile, options.moveId);
         moveStep("revoke:sealed");
         await options.ledger.markRevoked(options.moveId);
         moveStep("revoke:marked");
     }, options.guard);
 }
-function seal(sessionFile, moveId) {
-    const entries = loadEntriesFromFile(sessionFile);
+async function seal(sessionFile, moveId) {
+    const entries = await loadEntriesFromFileAsync(sessionFile);
     const sessionId = headerSessionId(entries);
     let ownership = { writable: true };
     let latest;
@@ -42,7 +42,7 @@ function seal(sessionFile, moveId) {
         return;
     if (!(ownership.writable && ofThisMove && latest?.customType === SESSION_MOVED_IN))
         throw new RevokeMismatchError(moveId);
-    SessionManager.open(sessionFile).appendCustomEntry(SESSION_MOVED, {
+    (await SessionManager.openAsync(sessionFile)).appendCustomEntry(SESSION_MOVED, {
         move_id: moveId,
         session_id: sessionId ?? "",
         target: data(latest, "from") ?? "",

package/dist/core/session-move/session-lock.d.ts

@@ -1,5 +1,6 @@
-export declare function realSessionPath(path: string): string;
-export declare const moveLockKey: (sessionFile: string) => string;
+export declare function realSessionPath(path: string): Promise<string>;
+export declare function orderedRealPath(path: string): Promise<string>;
+export declare const moveLockKey: (sessionFile: string) => Promise<string>;
 /**
  * Runs the sender's steps of a move (export, finish) one at a time per session file, across processes too.
  *
@@ -11,5 +12,5 @@ export declare const moveLockKey: (sessionFile: string) => string;
  * - `guard` runs first inside the queue, so a caller's own check (for example "not open on this host") sees the
  *   state the step will act on.
  */
-export declare function withSessionMoveLock<T>(sessionFile: string, step: () => Promise<T>, guard?: () => void): Promise<T>;
+export declare function withSessionMoveLock<T>(sessionFile: string, step: () => Promise<T>, guard?: () => void | Promise<void>): Promise<T>;
 //# sourceMappingURL=session-lock.d.ts.map

package/dist/core/session-move/session-lock.js

@@ -1,20 +1,34 @@
-import { realpathSync } from "node:fs";
+import { realpath } from "node:fs/promises";
 import { resolve } from "node:path";
 import { withSessionMoveLock as withHolderMoveLock } from "../session-holders.js";
-import { loadEntriesFromFile } from "../session-manager.js";
+import { loadEntriesFromFileAsync } from "../session-manager.js";
 import { serializeByKey } from "../session-sidecar-store.js";
 import { headerSessionId } from "./ownership.js";
-export function realSessionPath(path) {
+export async function realSessionPath(path) {
     const absolute = resolve(path);
     try {
-        return realpathSync(absolute);
+        return await realpath(absolute);
     }
     catch {
         return absolute;
     }
 }
 const lockKey = (resolvedPath) => `session-move:${resolvedPath}`;
-export const moveLockKey = (sessionFile) => lockKey(realSessionPath(sessionFile));
+// Resolutions of one path settle one after another, in call order, so two steps asked for in order enter the
+// per-file queue in that order even though resolving the real path is asynchronous. Each path has its own chain, so
+// one stuck realpath never delays another file's; a chain is dropped once it is idle. `realSessionPath` never rejects.
+const pathChains = new Map();
+export function orderedRealPath(path) {
+    const key = resolve(path);
+    const next = (pathChains.get(key) ?? Promise.resolve("")).then(() => realSessionPath(path));
+    pathChains.set(key, next);
+    void next.then(() => {
+        if (pathChains.get(key) === next)
+            pathChains.delete(key);
+    });
+    return next;
+}
+export const moveLockKey = async (sessionFile) => lockKey(await orderedRealPath(sessionFile));
 /**
  * Runs the sender's steps of a move (export, finish) one at a time per session file, across processes too.
  *
@@ -26,11 +40,11 @@ export const moveLockKey = (sessionFile) => lockKey(realSessionPath(sessionFile)
  * - `guard` runs first inside the queue, so a caller's own check (for example "not open on this host") sees the
  *   state the step will act on.
  */
-export function withSessionMoveLock(sessionFile, step, guard) {
-    const path = realSessionPath(sessionFile);
+export async function withSessionMoveLock(sessionFile, step, guard) {
+    const path = await orderedRealPath(sessionFile);
     return serializeByKey(lockKey(path), async () => {
-        guard?.();
-        const sessionId = headerSessionId(loadEntriesFromFile(path));
+        await guard?.();
+        const sessionId = headerSessionId(await loadEntriesFromFileAsync(path));
         return sessionId === undefined ? step() : withHolderMoveLock(path, sessionId, step);
     });
 }

package/dist/core/session-rebind.d.ts

@@ -1,5 +1,5 @@
 import { type RepositoryIdentity, type RepositoryMatch } from "./repository-identity.ts";
-export declare function readRecordedRepositoryIdentity(sessionFile: string): RepositoryIdentity | undefined;
+export declare function readRecordedRepositoryIdentity(sessionFile: string): Promise<RepositoryIdentity | undefined>;
 /**
  * Whether `cwd` is the git repository a session was recorded in. The session side prefers the live
  * checkout at its recorded cwd and falls back to the identity the session recorded, because a moved