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"];

release: () => void;

} {

const deferred = createDeferred();

const task = enqueueCommand(async () => {

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

await deferred.promise;

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

});

clearCommandLane,

CommandLaneClearedError,

CommandLaneTaskTimeoutError,

enqueueCommand,

enqueueCommandInLane,

GatewayDrainingError,

getActiveTaskCount,

};

const results = await Promise.all([

enqueueCommand(makeTask(1)),

enqueueCommand(makeTask(2)),

enqueueCommand(makeTask(3)),

enqueueCommandInLane(CommandLane.Main, makeTask(1)),

enqueueCommandInLane(CommandLane.Main, makeTask(2)),

enqueueCommandInLane(CommandLane.Main, makeTask(3)),

]);

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

});

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

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

const task = enqueueCommandInLane(CommandLane.Main, async () => {});

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

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

vi.useFakeTimers();

try {

const blocker = createDeferred();

const first = enqueueCommand(async () => {

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

await blocker.promise;

});

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

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

warnAfterMs: 5,

onWait: (ms, ahead) => {

waited = ms;

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

// Second task is queued behind the first.

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

const second = enqueueCommandInLane(CommandLane.Main, async () => "second");

const removed = clearCommandLane();

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

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

markGatewayDraining();

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

GatewayDrainingError,

);

await expect(

enqueueCommandInLane(CommandLane.Main, async () => "blocked"),

).rejects.toBeInstanceOf(GatewayDrainingError);

});

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

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

markGatewayDraining();

resetAllLanes();

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

await expect(enqueueCommandInLane(CommandLane.Main, async () => "ok")).resolves.toBe("ok");

});

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