// Command queue tests cover bounded command execution and queue ordering.

import { importFreshModule } from "openclaw/plugin-sdk/test-fixtures";

import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";

import { CommandLane } from "./lanes.js";

const diagnosticMocks = vi.hoisted(() => ({

logLaneEnqueue: vi.fn(),

logLaneDequeue: vi.fn(),

diag: {

debug: vi.fn(),

warn: vi.fn(),

error: vi.fn(),

},

}));

vi.mock("../logging/diagnostic-runtime.js", () => ({

logLaneEnqueue: diagnosticMocks.logLaneEnqueue,

logLaneDequeue: diagnosticMocks.logLaneDequeue,

diagnosticLogger: diagnosticMocks.diag,

}));

type CommandQueueModule = typeof import("./command-queue.js");

let clearCommandLane: CommandQueueModule["clearCommandLane"];

let CommandLaneClearedError: CommandQueueModule["CommandLaneClearedError"];

let CommandLaneTaskTimeoutError: CommandQueueModule["CommandLaneTaskTimeoutError"];

let enqueueCommand: CommandQueueModule["enqueueCommand"];

let enqueueCommandInLane: CommandQueueModule["enqueueCommandInLane"];

let GatewayDrainingError: CommandQueueModule["GatewayDrainingError"];

let getActiveTaskCount: CommandQueueModule["getActiveTaskCount"];

let getCommandLaneSnapshot: CommandQueueModule["getCommandLaneSnapshot"];

let getCommandLaneSnapshots: CommandQueueModule["getCommandLaneSnapshots"];

let getQueueSize: CommandQueueModule["getQueueSize"];

let markGatewayDraining: CommandQueueModule["markGatewayDraining"];

let resetAllLanes: CommandQueueModule["resetAllLanes"];

let resetCommandLane: CommandQueueModule["resetCommandLane"];

let resetCommandQueueStateForTest: CommandQueueModule["resetCommandQueueStateForTest"];

let setCommandLaneConcurrency: CommandQueueModule["setCommandLaneConcurrency"];

let waitForActiveTasks: CommandQueueModule["waitForActiveTasks"];

function createDeferred(): { promise: Promise<void>; resolve: () => void } {

let resolve: (() => void) | undefined;

const promise = new Promise<void>((r) => {

resolve = r;

});

if (!resolve) {

throw new Error("Expected deferred resolver to be initialized");

}

return { promise, resolve };

}

function mockCallArg(

mock: { mock: { calls: readonly unknown[][] } },

label: string,

argIndex: number,

): unknown {

const [call] = mock.mock.calls;

if (!call) {

throw new Error(`expected ${label} call`);

}

return call[argIndex];

}

function enqueueBlockedMainTask<T = void>(

onRelease?: () => Promise<T> | T,

): {

task: Promise<T>;

release: () => void;

} {

const deferred = createDeferred();

const task = enqueueCommand(async () => {

await deferred.promise;

return (await onRelease?.()) as T;

});

return { task, release: deferred.resolve };

}

function expectLaneSnapshotFields(

lane: string,

fields: Partial<ReturnType<CommandQueueModule["getCommandLaneSnapshot"]>>,

): void {

const snapshot = getCommandLaneSnapshot(lane);

for (const [key, value] of Object.entries(fields)) {

expect(snapshot[key as keyof typeof snapshot]).toBe(value);

}

}

function diagnosticDebugMessages(): string[] {

return diagnosticMocks.diag.debug.mock.calls

.map(([message]) => message)

.filter((message): message is string => typeof message === "string");

}

describe("command queue", () => {

beforeAll(async () => {

({

clearCommandLane,

CommandLaneClearedError,

CommandLaneTaskTimeoutError,

enqueueCommand,

enqueueCommandInLane,

GatewayDrainingError,

getActiveTaskCount,

getCommandLaneSnapshot,

getCommandLaneSnapshots,

getQueueSize,

markGatewayDraining,

resetAllLanes,

resetCommandLane,

resetCommandQueueStateForTest,

setCommandLaneConcurrency,

waitForActiveTasks,

} = await import("./command-queue.js"));

});

beforeEach(() => {

vi.useRealTimers();

resetCommandQueueStateForTest();

// Queue state is global across module instances, so reset main lane

// concurrency explicitly to avoid cross-file leakage.

setCommandLaneConcurrency(CommandLane.Main, 1);

diagnosticMocks.logLaneEnqueue.mockClear();

diagnosticMocks.logLaneDequeue.mockClear();

diagnosticMocks.diag.debug.mockClear();

diagnosticMocks.diag.warn.mockClear();

diagnosticMocks.diag.error.mockClear();

});

afterEach(() => {

vi.useRealTimers();

});

it("resetAllLanes is safe when no lanes have been created", () => {

expect(getActiveTaskCount()).toBe(0);

resetAllLanes();

expect(getActiveTaskCount()).toBe(0);

});

it("runs tasks one at a time in order", async () => {

let active = 0;

let maxActive = 0;

const calls: number[] = [];

const makeTask = (id: number) => async () => {

active += 1;

maxActive = Math.max(maxActive, active);

calls.push(id);

await Promise.resolve();

active -= 1;

return id;

};

const results = await Promise.all([

enqueueCommand(makeTask(1)),

enqueueCommand(makeTask(2)),

enqueueCommand(makeTask(3)),

]);

expect(results).toEqual([1, 2, 3]);

expect(calls).toEqual([1, 2, 3]);

expect(maxActive).toBe(1);

expect(getQueueSize()).toBe(0);

});

it("runs foreground work before already queued background work", async () => {

const { task: blocker, release } = enqueueBlockedMainTask(async () => "blocker");

const calls: string[] = [];

const background = enqueueCommandInLane(

CommandLane.Main,

async () => {

calls.push("background");

return "background";

},

{ priority: "background" },

);

const normal = enqueueCommandInLane(CommandLane.Main, async () => {

calls.push("normal");

return "normal";

});

const foreground = enqueueCommandInLane(

CommandLane.Main,

async () => {

calls.push("foreground");

return "foreground";

},

{ priority: "foreground" },

);

release();

await expect(blocker).resolves.toBe("blocker");

await expect(foreground).resolves.toBe("foreground");

await expect(normal).resolves.toBe("normal");

await expect(background).resolves.toBe("background");

expect(calls).toEqual(["foreground", "normal", "background"]);

});

it("preserves FIFO order within each priority", async () => {

const { task: blocker, release } = enqueueBlockedMainTask(async () => "blocker");

const calls: string[] = [];

const first = enqueueCommandInLane(

CommandLane.Main,

async () => {

calls.push("first");

},

{ priority: "foreground" },

);

const second = enqueueCommandInLane(

CommandLane.Main,

async () => {

calls.push("second");

},

{ priority: "foreground" },

);

release();

await blocker;

await Promise.all([first, second]);

expect(calls).toEqual(["first", "second"]);

});

it("reports queueAhead after priority insertion", async () => {

vi.useFakeTimers();

try {

const { task: blocker, release } = enqueueBlockedMainTask(async () => "blocker");

const calls: string[] = [];

let queuedAhead: number | null = null;

const background = enqueueCommandInLane(

CommandLane.Main,

async () => {

calls.push("background");

return "background";

},

{ priority: "background" },

);

const foreground = enqueueCommandInLane(

CommandLane.Main,

async () => {

calls.push("foreground");

return "foreground";

},

{

priority: "foreground",

warnAfterMs: 5,

onWait: (_ms, ahead) => {

queuedAhead = ahead;

},

},

);

await vi.advanceTimersByTimeAsync(6);

release();

await expect(blocker).resolves.toBe("blocker");

await expect(foreground).resolves.toBe("foreground");

await expect(background).resolves.toBe("background");

expect(calls).toEqual(["foreground", "background"]);

expect(queuedAhead).toBe(0);

const waitWarning = diagnosticMocks.diag.warn.mock.calls.find(

([message]) =>

typeof message === "string" && message.includes("lane wait exceeded: lane=main"),

);

expect(waitWarning?.[0]).toContain("queueAhead=0 activeAhead=1");

expect(waitWarning?.[0]).toContain("queueBehind=1");

} finally {

vi.useRealTimers();

}

});

it("logs enqueue depth after push", async () => {

const task = enqueueCommand(async () => {});

expect(diagnosticMocks.logLaneEnqueue).toHaveBeenCalledTimes(1);

expect(mockCallArg(diagnosticMocks.logLaneEnqueue, "logLaneEnqueue", 1)).toBe(1);

await task;

});

it("invokes onWait callback when a task waits past the threshold", async () => {

let waited: number | null = null;

let queuedAhead: number | null = null;

vi.useFakeTimers();

try {

const blocker = createDeferred();

const first = enqueueCommand(async () => {

await blocker.promise;

});

const second = enqueueCommand(async () => {}, {

warnAfterMs: 5,

onWait: (ms, ahead) => {

waited = ms;

queuedAhead = ahead;

},

});

await vi.advanceTimersByTimeAsync(6);

blocker.resolve();

await Promise.all([first, second]);

expect(typeof waited).toBe("number");

expect(waited).toBeGreaterThanOrEqual(5);

expect(queuedAhead).toBe(0);

const waitWarning = diagnosticMocks.diag.warn.mock.calls.find(

([message]) =>

typeof message === "string" && message.includes("lane wait exceeded: lane=main"),

);

expect(waitWarning?.[0]).toContain("queueAhead=0 activeAhead=1");

} finally {

vi.useRealTimers();

}

});

it("demotes live model switch lane failures to debug noise", async () => {

const error = new Error("Live session model switch requested: anthropic/claude-opus-4-6");

error.name = "LiveSessionModelSwitchError";

await expect(

enqueueCommandInLane("nested", async () => {

throw error;

}),

).rejects.toBe(error);

expect(diagnosticMocks.diag.error).not.toHaveBeenCalled();

expect(

diagnosticDebugMessages().some((message) =>

message.includes("lane task interrupted: lane=nested"),

),

).toBe(true);

});

it("getActiveTaskCount returns count of currently executing tasks", async () => {

const { task, release } = enqueueBlockedMainTask();

expect(getActiveTaskCount()).toBe(1);

release();

await task;

expect(getActiveTaskCount()).toBe(0);

});

it("waitForActiveTasks resolves immediately when no tasks are active", async () => {

const { drained } = await waitForActiveTasks(1000);

expect(drained).toBe(true);

});

it("waitForActiveTasks waits for active tasks to finish", async () => {

const { task, release } = enqueueBlockedMainTask();

vi.useFakeTimers();

try {

const drainPromise = waitForActiveTasks(5000);

await vi.advanceTimersByTimeAsync(50);

release();

await vi.advanceTimersByTimeAsync(50);

const { drained } = await drainPromise;

expect(drained).toBe(true);

await task;

} finally {

vi.useRealTimers();

}

});

it("waitForActiveTasks returns drained=false when timeout is zero and tasks are active", async () => {

const { task, release } = enqueueBlockedMainTask();

const { drained } = await waitForActiveTasks(0);

expect(drained).toBe(false);

release();

await task;

});

it("waitForActiveTasks returns drained=false on timeout", async () => {

const { task, release } = enqueueBlockedMainTask();

vi.useFakeTimers();

try {

const waitPromise = waitForActiveTasks(50);

await vi.advanceTimersByTimeAsync(100);

const { drained } = await waitPromise;

expect(drained).toBe(false);

release();

await task;

} finally {

vi.useRealTimers();

}

});

it("resetAllLanes drains queued work immediately after reset", async () => {

const lane = `reset-test-${Date.now()}-${Math.random().toString(16).slice(2)}`;

setCommandLaneConcurrency(lane, 1);

const blocker = createDeferred();

// Start a task that blocks the lane

const task1 = enqueueCommandInLane(lane, async () => {

await blocker.promise;

});

expect(getActiveTaskCount()).toBeGreaterThanOrEqual(1);

// Enqueue another task — it should be stuck behind the blocker

let task2Ran = false;

const task2 = enqueueCommandInLane(lane, async () => {

task2Ran = true;

});

expect(getQueueSize(lane)).toBeGreaterThanOrEqual(2);

expect(task2Ran).toBe(false);

// Simulate SIGUSR1: reset all lanes. Queued work (task2) should be

// drained immediately — no fresh enqueue needed.

resetAllLanes();

// Complete the stale in-flight task; generation mismatch makes its

// completion path a no-op for queue bookkeeping.

blocker.resolve();

await task1;

// task2 should have been pumped by resetAllLanes's drain pass.

await task2;

expect(task2Ran).toBe(true);

});

it("resetCommandLane releases one stuck lane and drains its queued work", async () => {

const lane = `reset-lane-${Date.now()}-${Math.random().toString(16).slice(2)}`;

const otherLane = `reset-lane-other-${Date.now()}-${Math.random().toString(16).slice(2)}`;

setCommandLaneConcurrency(lane, 1);

setCommandLaneConcurrency(otherLane, 1);

const blocker = createDeferred();

const otherBlocker = createDeferred();

const first = enqueueCommandInLane(lane, async () => {

await blocker.promise;

return "first";

});

const other = enqueueCommandInLane(otherLane, async () => {

await otherBlocker.promise;

return "other";

});

let secondRan = false;

const second = enqueueCommandInLane(lane, async () => {

secondRan = true;

return "second";

});

expect(secondRan).toBe(false);

expect(getActiveTaskCount()).toBe(2);

expect(resetCommandLane(lane)).toBe(1);

await expect(second).resolves.toBe("second");

expect(secondRan).toBe(true);

expect(getQueueSize(lane)).toBe(0);

expect(getQueueSize(otherLane)).toBe(1);

blocker.resolve();

otherBlocker.resolve();

await expect(first).resolves.toBe("first");

await expect(other).resolves.toBe("other");

});

it("task timeout releases a stuck lane and drains queued work", async () => {

const lane = `timeout-lane-${Date.now()}-${Math.random().toString(16).slice(2)}`;

setCommandLaneConcurrency(lane, 1);

vi.useFakeTimers();

try {

const first = enqueueCommandInLane(lane, async () => new Promise<never>(() => {}), {

taskTimeoutMs: 25,

});

const firstRejected = expect(first).rejects.toBeInstanceOf(CommandLaneTaskTimeoutError);

let secondRan = false;

const second = enqueueCommandInLane(lane, async () => {

secondRan = true;

return "second";

});

expect(secondRan).toBe(false);

expectLaneSnapshotFields(lane, {

activeCount: 1,

queuedCount: 1,

});

await vi.advanceTimersByTimeAsync(25);

await firstRejected;

await expect(second).resolves.toBe("second");

expect(secondRan).toBe(true);

expectLaneSnapshotFields(lane, {

activeCount: 0,

queuedCount: 0,

});

} finally {

vi.useRealTimers();

}

});

it("task timeout renews from progress timestamps", async () => {

const lane = `timeout-progress-lane-${Date.now()}-${Math.random().toString(16).slice(2)}`;

setCommandLaneConcurrency(lane, 1);

vi.useFakeTimers();

try {

let progressAtMs = Date.now();

const blocker = createDeferred();

const first = enqueueCommandInLane(

lane,

async () => {

await blocker.promise;

return "first";

},

{

taskTimeoutMs: 25,

taskTimeoutProgressAtMs: () => progressAtMs,

},

);

let secondRan = false;

const second = enqueueCommandInLane(lane, async () => {

secondRan = true;

return "second";

});

await vi.advanceTimersByTimeAsync(20);

progressAtMs = Date.now();

await vi.advanceTimersByTimeAsync(20);

expect(secondRan).toBe(false);

blocker.resolve();

await expect(first).resolves.toBe("first");

await expect(second).resolves.toBe("second");

expect(secondRan).toBe(true);

} finally {

vi.useRealTimers();

}

});

it("task timeout falls back when progress timestamp callback throws", async () => {

const lane = `timeout-progress-throw-lane-${Date.now()}-${Math.random().toString(16).slice(2)}`;

setCommandLaneConcurrency(lane, 1);

vi.useFakeTimers();

try {

const first = enqueueCommandInLane(lane, async () => new Promise<never>(() => {}), {

taskTimeoutMs: 25,

taskTimeoutProgressAtMs: () => {

throw new Error("progress failed");

},

});

const firstRejected = expect(first).rejects.toBeInstanceOf(CommandLaneTaskTimeoutError);

await vi.advanceTimersByTimeAsync(25);

await firstRejected;

expect(

diagnosticMocks.diag.warn.mock.calls.some(([message]) =>

String(message).includes("lane task timeout progress callback failed"),

),

).toBe(true);

} finally {

vi.useRealTimers();

}

});

it("keeps work queued while a lane has zero concurrency and drains after resume", async () => {

const lane = `suspended-lane-${Date.now()}-${Math.random().toString(16).slice(2)}`;

setCommandLaneConcurrency(lane, 0);

let ran = false;

const task = enqueueCommandInLane(lane, async () => {

ran = true;

return "resumed";

});

await Promise.resolve();

expect(ran).toBe(false);

expectLaneSnapshotFields(lane, {

activeCount: 0,

queuedCount: 1,

maxConcurrent: 0,

});

setCommandLaneConcurrency(lane, 1);

await expect(task).resolves.toBe("resumed");

expect(ran).toBe(true);

expectLaneSnapshotFields(lane, {

activeCount: 0,

queuedCount: 0,

maxConcurrent: 1,

});

});

it("getCommandLaneSnapshot reports active and queued work for one lane", async () => {

const lane = `snapshot-lane-${Date.now()}-${Math.random().toString(16).slice(2)}`;

setCommandLaneConcurrency(lane, 1);

const blocker = createDeferred();

const first = enqueueCommandInLane(lane, async () => {

await blocker.promise;

return "first";

});

const second = enqueueCommandInLane(lane, async () => "second");

expectLaneSnapshotFields(lane, {

lane,

activeCount: 1,

queuedCount: 1,

maxConcurrent: 1,

draining: false,

generation: 0,

});

blocker.resolve();

await expect(first).resolves.toBe("first");

await expect(second).resolves.toBe("second");

});

it("getCommandLaneSnapshots reports all live lanes in stable order", async () => {

const alphaLane = `snapshot-all-alpha-${Date.now()}-${Math.random().toString(16).slice(2)}`;

const betaLane = `snapshot-all-beta-${Date.now()}-${Math.random().toString(16).slice(2)}`;

setCommandLaneConcurrency(alphaLane, 1);

setCommandLaneConcurrency(betaLane, 1);

const alphaBlocker = createDeferred();

const betaBlocker = createDeferred();

const alpha = enqueueCommandInLane(alphaLane, async () => {

await alphaBlocker.promise;

return "alpha";

});

const beta = enqueueCommandInLane(betaLane, async () => {

await betaBlocker.promise;

return "beta";

});

const snapshots = getCommandLaneSnapshots().filter(

(snapshot) => snapshot.lane === alphaLane || snapshot.lane === betaLane,

);

expect(snapshots.map((snapshot) => snapshot.lane)).toEqual([alphaLane, betaLane]);

expect(snapshots[0]?.lane).toBe(alphaLane);

expect(snapshots[0]?.activeCount).toBe(1);

expect(snapshots[0]?.queuedCount).toBe(0);

expect(snapshots[1]?.lane).toBe(betaLane);

expect(snapshots[1]?.activeCount).toBe(1);

expect(snapshots[1]?.queuedCount).toBe(0);

alphaBlocker.resolve();

betaBlocker.resolve();

await expect(alpha).resolves.toBe("alpha");

await expect(beta).resolves.toBe("beta");

});

it("waitForActiveTasks ignores tasks that start after the call", async () => {

const lane = `drain-snapshot-${Date.now()}-${Math.random().toString(16).slice(2)}`;

setCommandLaneConcurrency(lane, 2);

const blocker1 = createDeferred();

const blocker2 = createDeferred();

const firstStarted = createDeferred();

const first = enqueueCommandInLane(lane, async () => {

firstStarted.resolve();

await blocker1.promise;

});

await firstStarted.promise;

const drainPromise = waitForActiveTasks(2000);

// Starts after waitForActiveTasks snapshot and should not block drain completion.

const second = enqueueCommandInLane(lane, async () => {

await blocker2.promise;

});

expect(getActiveTaskCount()).toBeGreaterThanOrEqual(2);

blocker1.resolve();

const { drained } = await drainPromise;

expect(drained).toBe(true);

blocker2.resolve();

await Promise.all([first, second]);

});

it("clearCommandLane rejects pending promises", async () => {

// First task blocks the lane.

const { task: first, release } = enqueueBlockedMainTask(async () => "first");

// Second task is queued behind the first.

const second = enqueueCommand(async () => "second");

const removed = clearCommandLane();

expect(removed).toBe(1); // only the queued (not active) entry

// The queued promise should reject.

await expect(second).rejects.toBeInstanceOf(CommandLaneClearedError);

// Let the active task finish normally.

release();

await expect(first).resolves.toBe("first");

});

it("keeps draining functional after synchronous onWait failure", async () => {

const lane = `drain-sync-throw-${Date.now()}-${Math.random().toString(16).slice(2)}`;

setCommandLaneConcurrency(lane, 1);

const deferred = createDeferred();

const first = enqueueCommandInLane(lane, async () => {

await deferred.promise;

return "first";

});

const second = enqueueCommandInLane(lane, async () => "second", {

warnAfterMs: 0,

onWait: () => {

throw new Error("onWait exploded");

},

});

await Promise.resolve();

expect(getQueueSize(lane)).toBeGreaterThanOrEqual(2);

deferred.resolve();

await expect(first).resolves.toBe("first");

await expect(second).resolves.toBe("second");

});

it("rejects new enqueues with GatewayDrainingError after markGatewayDraining", async () => {

markGatewayDraining();

await expect(enqueueCommand(async () => "blocked")).rejects.toBeInstanceOf(

GatewayDrainingError,

);

});

it("does not affect already-active tasks after markGatewayDraining", async () => {

const { task, release } = enqueueBlockedMainTask(async () => "ok");

markGatewayDraining();

release();

await expect(task).resolves.toBe("ok");

});

it("resetAllLanes clears gateway draining flag and re-allows enqueue", async () => {

markGatewayDraining();

resetAllLanes();

await expect(enqueueCommand(async () => "ok")).resolves.toBe("ok");

});

it("migrates legacy queue state missing activeTaskWaiters without crashing", async () => {

// Simulate a SIGUSR1 in-process restart where the globalThis singleton was

// created by an older code version (e.g. v2026.4.2) that did not include

// the `activeTaskWaiters` field. The schema migration in getQueueState()

// must patch the missing field so resetAllLanes() and

// notifyActiveTaskWaiters() do not throw.

const key = Symbol.for("openclaw.commandQueueState");

const globalStore = globalThis as Record<PropertyKey, unknown>;

const original = globalStore[key];

try {

// Plant a legacy-shaped state object (no activeTaskWaiters).

globalStore[key] = {

gatewayDraining: false,

lanes: new Map(),

nextTaskId: 1,

};

// resetAllLanes calls notifyActiveTaskWaiters → Array.from(state.activeTaskWaiters).

// Without the migration this would throw:

// TypeError: undefined is not iterable

resetAllLanes();

// waitForActiveTasks also accesses activeTaskWaiters.

await expect(waitForActiveTasks(0)).resolves.toEqual({ drained: true });

} finally {

// Restore original state so subsequent tests are not affected.

if (original !== undefined) {

globalStore[key] = original;

} else {

delete globalStore[key];

}

resetCommandQueueStateForTest();

}

});

it("migrates legacy queued entries missing priority and wait diagnostics", async () => {

const key = Symbol.for("openclaw.commandQueueState");

const globalStore = globalThis as Record<PropertyKey, unknown>;

const original = globalStore[key];

let queuedAhead: number | null = null;

const legacyTask = new Promise<string>((resolve, reject) => {

globalStore[key] = {

gatewayDraining: false,

lanes: new Map([

[

CommandLane.Main,

{

lane: CommandLane.Main,

queue: [

{

task: async () => "done",

resolve,

reject,

enqueuedAt: Date.now() - 10,

warnAfterMs: 0,

onWait: (_ms: number, ahead: number) => {

queuedAhead = ahead;

},

},

],

activeTaskIds: new Set(),

maxConcurrent: 1,

draining: false,

generation: 0,

},

],

]),

activeTaskWaiters: new Set(),

nextTaskId: 1,

nextQueueSequence: 1,

};

});

try {

resetAllLanes();

await expect(legacyTask).resolves.toBe("done");

expect(queuedAhead).toBe(0);

const waitWarning = diagnosticMocks.diag.warn.mock.calls.find(

([message]) =>

typeof message === "string" && message.includes("lane wait exceeded: lane=main"),

);

expect(waitWarning?.[0]).toContain("queueAhead=0 activeAhead=0");

} finally {

if (original !== undefined) {

globalStore[key] = original;

} else {

delete globalStore[key];

}

resetCommandQueueStateForTest();

}

});

it("shares lane state across distinct module instances", async () => {

const commandQueueA = await importFreshModule<typeof import("./command-queue.js")>(

import.meta.url,

"./command-queue.js?scope=shared-a",

);

const commandQueueB = await importFreshModule<typeof import("./command-queue.js")>(

import.meta.url,

"./command-queue.js?scope=shared-b",

);

const lane = `shared-state-${Date.now()}-${Math.random().toString(16).slice(2)}`;

const blocker = createDeferred();

commandQueueA.resetAllLanes();

try {

const task = commandQueueA.enqueueCommandInLane(lane, async () => {

await blocker.promise;

return "done";

});

expect(commandQueueB.getQueueSize(lane)).toBe(1);

expect(commandQueueB.getActiveTaskCount()).toBe(1);

blocker.resolve();

await expect(task).resolves.toBe("done");

expect(commandQueueB.getQueueSize(lane)).toBe(0);

} finally {

blocker.resolve();

commandQueueA.resetAllLanes();

}

});

});