function yieldEventLoop(): Promise<void> {

return new Promise<void>((resolve) => setImmediate(resolve));

}

// A payload-less lock can be left behind if shutdown lands between open("wx")

// and the owner metadata write. Keep the grace short so 10s callers recover.

const ORPHAN_LOCK_PAYLOAD_GRACE_MS = 5_000;

// A payload-less lock can be left behind during the window between open("wx")

// and the owner metadata write if the owner is suspended (CPU pressure,

// container freeze, I/O stall, GC pause). 30 s covers realistic system

// pauses while staying well below DEFAULT_TIMEOUT_GRACE_MS (120 s).

const ORPHAN_LOCK_PAYLOAD_GRACE_MS = 30_000;

const SHORT_TIMEOUT_ORPHAN_LOCK_PAYLOAD_GRACE_MS = 5_000;

type CleanupState = {

registered: boolean;

details: LockInspectionDetails,

staleMs: number,

nowMs: number,

orphanPayloadGraceMs = ORPHAN_LOCK_PAYLOAD_GRACE_MS,

): Promise<boolean> {

if (!details.stale) {

return false;

try {

const stat = await fs.stat(lockPath);

const ageMs = Math.max(0, nowMs - stat.mtimeMs);

return ageMs > Math.min(staleMs, ORPHAN_LOCK_PAYLOAD_GRACE_MS);

return ageMs > Math.min(staleMs, orphanPayloadGraceMs);

} catch (error) {

const code = (error as { code?: string } | null)?.code;

return code !== "ENOENT";

}

}

function resolveOrphanLockPayloadGraceMs(timeoutMs: number): number {

if (timeoutMs < ORPHAN_LOCK_PAYLOAD_GRACE_MS) {

return SHORT_TIMEOUT_ORPHAN_LOCK_PAYLOAD_GRACE_MS;

}

return ORPHAN_LOCK_PAYLOAD_GRACE_MS;

}

async function shouldRemoveLockDuringCleanup(

lockPath: string,

details: LockInspectionDetails,

});

const staleMs = resolvePositiveMs(params.staleMs, defaultOptions.staleMs);

const maxHoldMs = resolvePositiveMs(params.maxHoldMs, defaultOptions.maxHoldMs);

const orphanPayloadGraceMs = resolveOrphanLockPayloadGraceMs(timeoutMs);

const sessionFile = path.resolve(params.sessionFile);

const sessionDir = path.dirname(sessionFile);

const normalizedSessionFile = await resolveNormalizedSessionFile(sessionFile);

readOwnerProcessArgs: readProcessArgsSync,

respectMaxHold: !heldByThisProcess,

});

return await shouldReclaimContendedLockFile(lockPath, inspected, staleMs, nowMs);

return await shouldReclaimContendedLockFile(

lockPath,

inspected,

staleMs,

nowMs,

orphanPayloadGraceMs,

);

},

shouldRemoveStaleLock: async ({ lockPath, normalizedTargetPath, payload }) => {

await yieldEventLoop();

readOwnerProcessArgs: readProcessArgsSync,

respectMaxHold: !heldByThisProcess,

});

return await shouldReclaimContendedLockFile(lockPath, inspected, staleMs, nowMs);

return await shouldReclaimContendedLockFile(

lockPath,

inspected,

staleMs,

nowMs,

orphanPayloadGraceMs,

);

},

});

return { release: lock.release };