it("keeps later same-key work behind a timer-backed flush that already started", async () => {

const started: string[] = [];

const finished: string[] = [];

let releaseFirst!: () => void;

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

const firstGate = new Promise<void>((resolve) => {

releaseFirst = resolve;

});

expect(started).toEqual(["1"]);

expect(finished).toEqual([]);

if (!releaseFirst) {

throw new Error("Expected first inbound debounce release callback to be initialized");

}

releaseFirst();

await Promise.all([firstFlush, secondEnqueue]);

it("keeps fire-and-forget keyed work ahead of a later buffered item", async () => {

const started: string[] = [];

const finished: string[] = [];

let releaseFirst!: () => void;

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

const firstGate = new Promise<void>((resolve) => {

releaseFirst = resolve;

});

expect(started).toEqual(["1"]);

expect(finished).toEqual([]);

if (!releaseFirst) {

throw new Error("Expected first inbound debounce release callback to be initialized");

}

releaseFirst();

await Promise.all([firstFlush, secondEnqueue, thirdFlush, thirdEnqueue]);

it("does not serialize keyed turns when debounce is disabled and no keyed chain exists", async () => {

const started: string[] = [];

let releaseFirst!: () => void;

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

const firstGate = new Promise<void>((resolve) => {

releaseFirst = resolve;

});

expect(started).toEqual(["1", "2"]);

if (!releaseFirst) {

throw new Error("Expected first inbound debounce release callback to be initialized");

}

releaseFirst();

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

});

it("keeps same-key overflow work ordered after falling back to immediate flushes", async () => {

const started: string[] = [];

const finished: string[] = [];

let releaseOverflow!: () => void;

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

const overflowGate = new Promise<void>((resolve) => {

releaseOverflow = resolve;

});

expect(started).toEqual(["2"]);

expect(finished).toEqual([]);

if (!releaseOverflow) {

throw new Error("Expected inbound overflow release callback to be initialized");

}

releaseOverflow();

await Promise.all([overflowEnqueue, bufferedEnqueue, bufferedFlush]);

it("counts tracked debounce keys by union of buffers and active chains", async () => {

const started: string[] = [];

const finished: string[] = [];

let releaseChainOnly!: () => void;

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

const chainOnlyGate = new Promise<void>((resolve) => {

releaseChainOnly = resolve;

});

expect(finished).toEqual(["4"]);

});

if (!releaseChainOnly) {

throw new Error("Expected inbound chain-only release callback to be initialized");

}

releaseChainOnly();

await Promise.all([secondFlush, overflowEnqueue]);

expect(finished).toEqual(["4", "2"]);