/** Process-local serialization only; this does not exclude another replica. */ const btestNodeLocks = new Map>() const MAX_TICKETS = 1024 let liveTickets = 0 export interface BtestNodeLockOptions { signal?: AbortSignal; deadlineAt?: number } export class BtestNodeLockError extends Error { constructor(readonly code: "BTEST_NODE_LOCK_INVALID_INPUT" | "BTEST_NODE_LOCK_QUEUE_FULL" | "BTEST_NODE_LOCK_DEADLINE_EXPIRED") { super(code) } } function check(options: BtestNodeLockOptions): void { options.signal?.throwIfAborted() if (options.deadlineAt !== undefined && Date.now() >= options.deadlineAt) throw new BtestNodeLockError("BTEST_NODE_LOCK_DEADLINE_EXPIRED") } function waitFor(predecessor: Promise, options: BtestNodeLockOptions): Promise { return new Promise((resolve, reject) => { let settled = false let timer: ReturnType | undefined const finish = (error?: unknown, failed = false) => { if (settled) return settled = true if (timer) clearTimeout(timer) options.signal?.removeEventListener("abort", aborted) if (failed) reject(error) else resolve() } const aborted = () => finish(options.signal!.reason, true) const expiry = () => { if (settled || options.deadlineAt === undefined) return const remaining = options.deadlineAt - Date.now() if (remaining <= 0) finish(new BtestNodeLockError("BTEST_NODE_LOCK_DEADLINE_EXPIRED"), true) else timer = setTimeout(expiry, Math.min(remaining, 2147483647)) } options.signal?.addEventListener("abort", aborted, { once: true }) if (options.signal?.aborted) aborted() expiry() void predecessor.then(() => finish(), error => finish(error, true)) }) } export async function withBtestNodeLocks(nodeIds: number[], fn: () => Promise, options: BtestNodeLockOptions = {}): Promise { if (!Array.isArray(nodeIds) || nodeIds.length > MAX_TICKETS || Array.from(nodeIds).some(id => !Number.isSafeInteger(id) || id <= 0)) throw new BtestNodeLockError("BTEST_NODE_LOCK_INVALID_INPUT") if (options.deadlineAt !== undefined && (!Number.isSafeInteger(options.deadlineAt) || options.deadlineAt < 0)) throw new BtestNodeLockError("BTEST_NODE_LOCK_INVALID_INPUT") const scope = { signal: options.signal, deadlineAt: options.deadlineAt } const ids = [...new Set(nodeIds)].sort((a, b) => a - b) check(scope) // Reserve the entire scope before enqueueing anything, including partial pairs. if (liveTickets + ids.length > MAX_TICKETS) throw new BtestNodeLockError("BTEST_NODE_LOCK_QUEUE_FULL") liveTickets += ids.length let registered = 0 const releases: Array<() => void> = [] try { for (const id of ids) { check(scope) const predecessor = btestNodeLocks.get(id) ?? Promise.resolve() let resolveCurrent!: () => void const current = new Promise(resolve => { resolveCurrent = resolve }) btestNodeLocks.set(id, current) registered++ let released = false const release = () => { if (released) return released = true if (btestNodeLocks.get(id) === current) btestNodeLocks.delete(id) liveTickets-- resolveCurrent() } try { await waitFor(predecessor, scope) check(scope) releases.push(release) } catch (error) { // Keep a cancelled ticket behind its predecessor; never release another holder. void predecessor.then(release, release) throw error } } check(scope) // Running callbacks retain ownership until settlement, including after abort. return await fn() } finally { liveTickets -= ids.length - registered for (let index = releases.length - 1; index >= 0; index--) releases[index]() } }