cojson 0.19.22 → 0.20.1

package/dist/tests/OutgoingLoadQueue.test.js

@@ -0,0 +1,814 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { CO_VALUE_LOADING_CONFIG, setMaxInFlightLoadsPerPeer, } from "../config.js";
+import { OutgoingLoadQueue } from "../queue/OutgoingLoadQueue.js";
+import { createTestNode } from "./testUtils.js";
+const TEST_PEER_ID = "test-peer";
+// Store original config values
+let originalMaxInFlightLoads;
+let originalTimeout;
+beforeEach(() => {
+    originalMaxInFlightLoads =
+        CO_VALUE_LOADING_CONFIG.MAX_IN_FLIGHT_LOADS_PER_PEER;
+    originalTimeout = CO_VALUE_LOADING_CONFIG.TIMEOUT;
+});
+afterEach(() => {
+    // Restore original config
+    setMaxInFlightLoadsPerPeer(originalMaxInFlightLoads);
+    CO_VALUE_LOADING_CONFIG.TIMEOUT = originalTimeout;
+    vi.useRealTimers();
+});
+describe("OutgoingLoadQueue", () => {
+    describe("basic enqueue behavior", () => {
+        test("should call sendCallback immediately when queue has capacity", () => {
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            const map = group.createMap();
+            let callbackCalled = false;
+            queue.enqueue(map.core, () => {
+                callbackCalled = true;
+            });
+            expect(callbackCalled).toBe(true);
+            expect(queue.inFlightCount).toBe(1);
+        });
+        test("should track sent request in inFlightLoads", () => {
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            const map = group.createMap();
+            queue.enqueue(map.core, () => { });
+            expect(queue.inFlightCount).toBe(1);
+        });
+    });
+    describe("FIFO ordering", () => {
+        test("should maintain FIFO order for pending requests", () => {
+            setMaxInFlightLoadsPerPeer(1);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            // Block the queue first
+            const blockerMap = group.createMap();
+            queue.enqueue(blockerMap.core, () => { });
+            // Enqueue multiple CoValues
+            const map1 = group.createMap();
+            const map2 = group.createMap();
+            const map3 = group.createMap();
+            const order = [];
+            queue.enqueue(map1.core, () => order.push("map1"));
+            queue.enqueue(map2.core, () => order.push("map2"));
+            queue.enqueue(map3.core, () => order.push("map3"));
+            // Complete requests one by one
+            queue.trackComplete(blockerMap.core);
+            queue.trackComplete(map1.core);
+            queue.trackComplete(map2.core);
+            expect(order).toEqual(["map1", "map2", "map3"]);
+        });
+    });
+    describe("throttling", () => {
+        test("should queue requests when at capacity limit", () => {
+            setMaxInFlightLoadsPerPeer(2);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            const map1 = group.createMap();
+            const map2 = group.createMap();
+            const map3 = group.createMap();
+            let callback3Called = false;
+            queue.enqueue(map1.core, () => { });
+            queue.enqueue(map2.core, () => { });
+            queue.enqueue(map3.core, () => {
+                callback3Called = true;
+            });
+            // First two should be in flight
+            expect(queue.inFlightCount).toBe(2);
+            // Third should be pending
+            expect(queue.pendingCount).toBe(1);
+            expect(callback3Called).toBe(false);
+        });
+        test("should process queued requests when a slot becomes available", () => {
+            setMaxInFlightLoadsPerPeer(2);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            const map1 = group.createMap();
+            const map2 = group.createMap();
+            const map3 = group.createMap();
+            let callback3Called = false;
+            queue.enqueue(map1.core, () => { });
+            queue.enqueue(map2.core, () => { });
+            queue.enqueue(map3.core, () => {
+                callback3Called = true;
+            });
+            expect(callback3Called).toBe(false);
+            // Complete one request
+            queue.trackComplete(map1.core);
+            // Third should now be processed
+            expect(callback3Called).toBe(true);
+            expect(queue.inFlightCount).toBe(2);
+            expect(queue.pendingCount).toBe(0);
+        });
+    });
+    describe("request deduplication", () => {
+        test("should skip duplicate enqueue while pending", () => {
+            setMaxInFlightLoadsPerPeer(1);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            const blockerMap = group.createMap();
+            const targetMap = group.createMap();
+            let targetCallbackCount = 0;
+            let duplicateCallbackCount = 0;
+            queue.enqueue(blockerMap.core, () => { });
+            queue.enqueue(targetMap.core, () => {
+                targetCallbackCount += 1;
+            });
+            queue.enqueue(targetMap.core, () => {
+                duplicateCallbackCount += 1;
+            });
+            expect(queue.pendingCount).toBe(1);
+            expect(targetCallbackCount).toBe(0);
+            expect(duplicateCallbackCount).toBe(0);
+            queue.trackComplete(blockerMap.core);
+            expect(targetCallbackCount).toBe(1);
+            expect(duplicateCallbackCount).toBe(0);
+        });
+        test("should skip duplicate enqueue while in-flight", () => {
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            const map = group.createMap();
+            let duplicateCallbackCount = 0;
+            queue.enqueue(map.core, () => { });
+            queue.enqueue(map.core, () => {
+                duplicateCallbackCount += 1;
+            });
+            expect(queue.inFlightCount).toBe(1);
+            expect(duplicateCallbackCount).toBe(0);
+        });
+        test("should skip duplicate enqueue for same CoValue ID", () => {
+            setMaxInFlightLoadsPerPeer(1);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const otherNode = createTestNode();
+            const group = node.createGroup();
+            const availableMap = group.createMap();
+            const sameIdCoValue = otherNode.getCoValue(availableMap.id);
+            queue.enqueue(availableMap.core, () => { });
+            queue.trackComplete(availableMap.core);
+            // Block capacity so the next enqueue stays pending
+            const blockerMap = group.createMap();
+            queue.enqueue(blockerMap.core, () => { });
+            let duplicateCallbackCount = 0;
+            queue.enqueue(availableMap.core, () => { });
+            queue.enqueue(sameIdCoValue, () => {
+                duplicateCallbackCount += 1;
+            });
+            expect(queue.pendingCount).toBe(1);
+            expect(duplicateCallbackCount).toBe(0);
+        });
+    });
+    describe("timeout behavior", () => {
+        test("should mark CoValue as not found in peer after timeout", async () => {
+            vi.useFakeTimers();
+            CO_VALUE_LOADING_CONFIG.TIMEOUT = 1000;
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            // Get an unavailable CoValue
+            const coValue = node.getCoValue("co_zTestTimeoutCoValue0001");
+            queue.enqueue(coValue, () => { });
+            expect(queue.inFlightCount).toBe(1);
+            // Advance time past the timeout
+            await vi.advanceTimersByTimeAsync(1001);
+            // Should be removed from in-flight
+            expect(queue.inFlightCount).toBe(0);
+            // Should be marked as not found
+            expect(coValue.getLoadingStateForPeer(TEST_PEER_ID)).toBe("unavailable");
+        });
+        test("should free the queue slot and process pending requests on timeout", async () => {
+            vi.useFakeTimers();
+            CO_VALUE_LOADING_CONFIG.TIMEOUT = 1000;
+            setMaxInFlightLoadsPerPeer(1);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            const coValue1 = node.getCoValue("co_zTestTimeoutFree00000001");
+            const map2 = group.createMap();
+            let callback2Called = false;
+            queue.enqueue(coValue1, () => { });
+            queue.enqueue(map2.core, () => {
+                callback2Called = true;
+            });
+            expect(queue.inFlightCount).toBe(1);
+            expect(callback2Called).toBe(false);
+            // Advance time past the timeout
+            await vi.advanceTimersByTimeAsync(1001);
+            // First should have timed out, second should be processed
+            expect(callback2Called).toBe(true);
+            expect(queue.inFlightCount).toBe(1);
+        });
+        test("should timeout each in-flight load independently", async () => {
+            vi.useFakeTimers();
+            CO_VALUE_LOADING_CONFIG.TIMEOUT = 1000;
+            setMaxInFlightLoadsPerPeer(3);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const coValue1 = node.getCoValue("co_zTestSingleTimer000001");
+            const coValue2 = node.getCoValue("co_zTestSingleTimer000002");
+            const coValue3 = node.getCoValue("co_zTestSingleTimer000003");
+            queue.enqueue(coValue1, () => { });
+            await vi.advanceTimersByTimeAsync(100);
+            queue.enqueue(coValue2, () => { });
+            await vi.advanceTimersByTimeAsync(100);
+            queue.enqueue(coValue3, () => { });
+            expect(queue.inFlightCount).toBe(3);
+            // Advance time past the timeout
+            await vi.advanceTimersByTimeAsync(801);
+            // All three should have timed out
+            expect(queue.inFlightCount).toBe(2);
+            await vi.advanceTimersByTimeAsync(101);
+            expect(coValue1.getLoadingStateForPeer(TEST_PEER_ID)).toBe("unavailable");
+            expect(queue.inFlightCount).toBe(1);
+            await vi.advanceTimersByTimeAsync(101);
+            expect(coValue2.getLoadingStateForPeer(TEST_PEER_ID)).toBe("unavailable");
+            expect(queue.inFlightCount).toBe(0);
+            await vi.advanceTimersByTimeAsync(101);
+            expect(coValue3.getLoadingStateForPeer(TEST_PEER_ID)).toBe("unavailable");
+            expect(queue.inFlightCount).toBe(0);
+        });
+        test("should allow re-enqueue after timeout", async () => {
+            vi.useFakeTimers();
+            CO_VALUE_LOADING_CONFIG.TIMEOUT = 1000;
+            setMaxInFlightLoadsPerPeer(1);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const coValue = node.getCoValue("co_zTestTimeoutReenqueue0001");
+            let secondCallbackCount = 0;
+            queue.enqueue(coValue, () => { });
+            await vi.advanceTimersByTimeAsync(1001);
+            expect(queue.inFlightCount).toBe(0);
+            expect(coValue.getLoadingStateForPeer(TEST_PEER_ID)).toBe("unavailable");
+            queue.enqueue(coValue, () => {
+                secondCallbackCount += 1;
+            });
+            expect(queue.inFlightCount).toBe(1);
+            expect(secondCallbackCount).toBe(1);
+        });
+        test("should warn but not mark as unavailable when streaming CoValue times out", async () => {
+            vi.useFakeTimers();
+            CO_VALUE_LOADING_CONFIG.TIMEOUT = 1000;
+            setMaxInFlightLoadsPerPeer(1);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            const map = group.createMap();
+            map.set("key", "value");
+            // Mock isStreaming to return true (CoValue is available but still streaming)
+            vi.spyOn(map.core, "isStreaming").mockReturnValue(true);
+            queue.enqueue(map.core, () => { });
+            expect(queue.inFlightCount).toBe(1);
+            // Advance time past the timeout
+            await vi.advanceTimersByTimeAsync(1001);
+            // Should be removed from in-flight (timeout clears the slot)
+            expect(queue.inFlightCount).toBe(0);
+            // But should NOT be marked as unavailable since it's available (just streaming)
+            expect(map.core.isAvailable()).toBe(true);
+        });
+    });
+    describe("trackComplete", () => {
+        test("should remove from inFlightLoads and allow next request to process", () => {
+            setMaxInFlightLoadsPerPeer(1);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            const map1 = group.createMap();
+            const map2 = group.createMap();
+            let callback2Called = false;
+            queue.enqueue(map1.core, () => { });
+            queue.enqueue(map2.core, () => {
+                callback2Called = true;
+            });
+            expect(queue.inFlightCount).toBe(1);
+            expect(callback2Called).toBe(false);
+            queue.trackComplete(map1.core);
+            expect(callback2Called).toBe(true);
+            expect(queue.inFlightCount).toBe(1);
+        });
+        test("should be a no-op for unknown CoValues", () => {
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            const map1 = group.createMap();
+            const unknownCoValue = node.getCoValue("co_zTestUnknownCoValue001");
+            queue.enqueue(map1.core, () => { });
+            expect(queue.inFlightCount).toBe(1);
+            // trackComplete on unknown CoValue should be a no-op
+            queue.trackComplete(unknownCoValue);
+            expect(queue.inFlightCount).toBe(1);
+        });
+        test("should allow re-enqueue after completion", () => {
+            setMaxInFlightLoadsPerPeer(1);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            const map = group.createMap();
+            let firstCallbackCount = 0;
+            let secondCallbackCount = 0;
+            queue.enqueue(map.core, () => {
+                firstCallbackCount += 1;
+            });
+            expect(queue.inFlightCount).toBe(1);
+            expect(firstCallbackCount).toBe(1);
+            queue.trackComplete(map.core);
+            queue.enqueue(map.core, () => {
+                secondCallbackCount += 1;
+            });
+            expect(queue.inFlightCount).toBe(1);
+            expect(secondCallbackCount).toBe(1);
+        });
+        test("should not complete if CoValue is streaming", () => {
+            setMaxInFlightLoadsPerPeer(1);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            const map1 = group.createMap();
+            const map2 = group.createMap();
+            // Mock isStreaming to return true
+            vi.spyOn(map1.core, "isStreaming").mockReturnValue(true);
+            let callback2Called = false;
+            queue.enqueue(map1.core, () => { });
+            queue.enqueue(map2.core, () => {
+                callback2Called = true;
+            });
+            expect(queue.inFlightCount).toBe(1);
+            expect(callback2Called).toBe(false);
+            // trackComplete should not complete because map1 is streaming
+            queue.trackComplete(map1.core);
+            // Should still be in-flight and pending should not be processed
+            expect(queue.inFlightCount).toBe(1);
+            expect(callback2Called).toBe(false);
+            expect(queue.pendingCount).toBe(1);
+            // Stop streaming
+            vi.spyOn(map1.core, "isStreaming").mockReturnValue(false);
+            // Now trackComplete should work
+            queue.trackComplete(map1.core);
+            expect(queue.inFlightCount).toBe(1); // map2 is now in-flight
+            expect(callback2Called).toBe(true);
+            expect(queue.pendingCount).toBe(0);
+        });
+    });
+    describe("trackUpdate", () => {
+        test("should refresh timeout for in-flight streaming CoValue", async () => {
+            vi.useFakeTimers();
+            CO_VALUE_LOADING_CONFIG.TIMEOUT = 1000;
+            setMaxInFlightLoadsPerPeer(1);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            const map = group.createMap();
+            map.set("key", "value");
+            // Mock isStreaming to return true
+            vi.spyOn(map.core, "isStreaming").mockReturnValue(true);
+            queue.enqueue(map.core, () => { });
+            expect(queue.inFlightCount).toBe(1);
+            // Advance time to just before timeout
+            await vi.advanceTimersByTimeAsync(900);
+            // Refresh the timeout (simulating receiving a chunk)
+            queue.trackUpdate(map.core);
+            // Advance another 200ms - would have timed out without the refresh
+            await vi.advanceTimersByTimeAsync(200);
+            // Should still be in-flight because timeout was refreshed
+            expect(queue.inFlightCount).toBe(1);
+            // Now advance past the new timeout
+            await vi.advanceTimersByTimeAsync(900);
+            // Should have timed out now
+            expect(queue.inFlightCount).toBe(0);
+        });
+        test("should be a no-op for unknown CoValues", () => {
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            const map = group.createMap();
+            const unknownCoValue = node.getCoValue("co_zTestTrackUpdateUnknown01");
+            queue.enqueue(map.core, () => { });
+            expect(queue.inFlightCount).toBe(1);
+            // trackUpdate on unknown CoValue should be a no-op
+            queue.trackUpdate(unknownCoValue);
+            // Should still have the same in-flight count
+            expect(queue.inFlightCount).toBe(1);
+        });
+    });
+    describe("immediate mode", () => {
+        test("should send immediately when mode is immediate even at capacity", () => {
+            setMaxInFlightLoadsPerPeer(1);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            const map1 = group.createMap();
+            const map2 = group.createMap();
+            let callback1Called = false;
+            let callback2Called = false;
+            // Fill the queue to capacity
+            queue.enqueue(map1.core, () => {
+                callback1Called = true;
+            });
+            expect(callback1Called).toBe(true);
+            expect(queue.inFlightCount).toBe(1);
+            // This should bypass the capacity limit with immediate mode
+            queue.enqueue(map2.core, () => {
+                callback2Called = true;
+            }, "immediate");
+            // Both should have been called even though capacity is 1
+            expect(callback2Called).toBe(true);
+            expect(queue.inFlightCount).toBe(2);
+        });
+        test("should still track immediate requests for timeout handling", async () => {
+            vi.useFakeTimers();
+            CO_VALUE_LOADING_CONFIG.TIMEOUT = 1000;
+            setMaxInFlightLoadsPerPeer(1);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const coValue = node.getCoValue("co_zTestOverflowTimeout01");
+            queue.enqueue(coValue, () => { }, "immediate");
+            expect(queue.inFlightCount).toBe(1);
+            // Advance time past the timeout
+            await vi.advanceTimersByTimeAsync(1001);
+            // Should be removed from in-flight and marked as not found
+            expect(queue.inFlightCount).toBe(0);
+            expect(coValue.getLoadingStateForPeer(TEST_PEER_ID)).toBe("unavailable");
+        });
+        test("should still deduplicate immediate requests", () => {
+            setMaxInFlightLoadsPerPeer(1);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            const map = group.createMap();
+            let callbackCount = 0;
+            queue.enqueue(map.core, () => {
+                callbackCount++;
+            }, "immediate");
+            queue.enqueue(map.core, () => {
+                callbackCount++;
+            }, "immediate");
+            // Should only be called once due to deduplication
+            expect(callbackCount).toBe(1);
+            expect(queue.inFlightCount).toBe(1);
+        });
+        test("should process pending requests when immediate request completes", () => {
+            setMaxInFlightLoadsPerPeer(1);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            const map1 = group.createMap();
+            const immediateMap = group.createMap();
+            const map2 = group.createMap();
+            let callback2Called = false;
+            // Fill the queue
+            queue.enqueue(map1.core, () => { });
+            // Add pending request
+            queue.enqueue(map2.core, () => {
+                callback2Called = true;
+            });
+            expect(callback2Called).toBe(false);
+            expect(queue.pendingCount).toBe(1);
+            // Add immediate request - this bypasses the queue but still counts as in-flight
+            queue.enqueue(immediateMap.core, () => { }, "immediate");
+            expect(queue.inFlightCount).toBe(2);
+            // Complete the immediate request
+            queue.trackComplete(immediateMap.core);
+            // Still at capacity because map1 is still in-flight
+            expect(callback2Called).toBe(false);
+            expect(queue.inFlightCount).toBe(1);
+            // Complete the regular request - now pending can be processed
+            queue.trackComplete(map1.core);
+            expect(callback2Called).toBe(true);
+            expect(queue.inFlightCount).toBe(1); // map2 is now in-flight
+        });
+    });
+    describe("clear", () => {
+        test("should clear all in-flight loads and pending queues", () => {
+            setMaxInFlightLoadsPerPeer(2);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            const map1 = group.createMap();
+            const map2 = group.createMap();
+            const map3 = group.createMap();
+            queue.enqueue(map1.core, () => { });
+            queue.enqueue(map2.core, () => { });
+            queue.enqueue(map3.core, () => { });
+            expect(queue.inFlightCount).toBe(2);
+            expect(queue.pendingCount).toBe(1);
+            queue.clear();
+            expect(queue.inFlightCount).toBe(0);
+            expect(queue.pendingCount).toBe(0);
+        });
+        test("should cancel any pending timeout", async () => {
+            vi.useFakeTimers();
+            CO_VALUE_LOADING_CONFIG.TIMEOUT = 1000;
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const coValue = node.getCoValue("co_zTestClearTimeout00001");
+            queue.enqueue(coValue, () => { });
+            expect(queue.inFlightCount).toBe(1);
+            // Clear before timeout
+            queue.clear();
+            expect(queue.inFlightCount).toBe(0);
+            // Advance time past the timeout
+            await vi.advanceTimersByTimeAsync(1001);
+            // Should not have marked as not found since we cleared
+            expect(coValue.getLoadingStateForPeer(TEST_PEER_ID)).not.toBe("unavailable");
+        });
+    });
+    describe("priority queue", () => {
+        test("should process high-priority requests before low-priority", () => {
+            setMaxInFlightLoadsPerPeer(1);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            // Block the queue first
+            const blockerMap = group.createMap();
+            queue.enqueue(blockerMap.core, () => { });
+            // Enqueue low-priority requests
+            const lowMap1 = group.createMap();
+            const lowMap2 = group.createMap();
+            // Enqueue high-priority request
+            const highMap = group.createMap();
+            const order = [];
+            // Add low-priority first
+            queue.enqueue(lowMap1.core, () => order.push("low1"), "low-priority");
+            queue.enqueue(lowMap2.core, () => order.push("low2"), "low-priority");
+            // Add high-priority after
+            queue.enqueue(highMap.core, () => order.push("high"));
+            expect(queue.pendingCount).toBe(3);
+            expect(queue.highPriorityPendingCount).toBe(1);
+            expect(queue.lowPriorityPendingCount).toBe(2);
+            // Complete the blocker and process requests one by one
+            queue.trackComplete(blockerMap.core);
+            expect(order).toEqual(["high"]);
+            queue.trackComplete(highMap.core);
+            expect(order).toEqual(["high", "low1"]);
+            queue.trackComplete(lowMap1.core);
+            expect(order).toEqual(["high", "low1", "low2"]);
+        });
+        test("should add low-priority request to low-priority queue", () => {
+            setMaxInFlightLoadsPerPeer(1);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            // Block the queue
+            const blockerMap = group.createMap();
+            queue.enqueue(blockerMap.core, () => { });
+            const lowMap = group.createMap();
+            queue.enqueue(lowMap.core, () => { }, "low-priority");
+            expect(queue.pendingCount).toBe(1);
+            expect(queue.lowPriorityPendingCount).toBe(1);
+            expect(queue.highPriorityPendingCount).toBe(0);
+        });
+        test("should upgrade low-priority to high-priority when requested with normal priority", () => {
+            setMaxInFlightLoadsPerPeer(1);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            // Block the queue
+            const blockerMap = group.createMap();
+            queue.enqueue(blockerMap.core, () => { });
+            const targetMap = group.createMap();
+            let callbackCount = 0;
+            // First enqueue as low-priority
+            queue.enqueue(targetMap.core, () => {
+                callbackCount++;
+            }, "low-priority");
+            expect(queue.lowPriorityPendingCount).toBe(1);
+            expect(queue.highPriorityPendingCount).toBe(0);
+            // Upgrade by requesting with normal priority
+            queue.enqueue(targetMap.core, () => {
+                callbackCount += 10;
+            });
+            // Should have moved to high-priority queue
+            expect(queue.lowPriorityPendingCount).toBe(0);
+            expect(queue.highPriorityPendingCount).toBe(1);
+            // Complete blocker and verify upgraded callback is used
+            queue.trackComplete(blockerMap.core);
+            expect(callbackCount).toBe(10); // Upgraded callback should be called
+        });
+        test("should not downgrade high-priority to low-priority", () => {
+            setMaxInFlightLoadsPerPeer(1);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            // Block the queue
+            const blockerMap = group.createMap();
+            queue.enqueue(blockerMap.core, () => { });
+            const targetMap = group.createMap();
+            // First enqueue as high-priority
+            queue.enqueue(targetMap.core, () => { });
+            expect(queue.highPriorityPendingCount).toBe(1);
+            expect(queue.lowPriorityPendingCount).toBe(0);
+            // Try to enqueue as low-priority
+            queue.enqueue(targetMap.core, () => { }, "low-priority");
+            // Should still be in high-priority queue (no change)
+            expect(queue.highPriorityPendingCount).toBe(1);
+            expect(queue.lowPriorityPendingCount).toBe(0);
+        });
+        test("should process mixed priority requests in correct order", () => {
+            setMaxInFlightLoadsPerPeer(1);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            // Block the queue first
+            const blockerMap = group.createMap();
+            queue.enqueue(blockerMap.core, () => { });
+            const order = [];
+            // Interleave low and high priority
+            const low1 = group.createMap();
+            const high1 = group.createMap();
+            const low2 = group.createMap();
+            const high2 = group.createMap();
+            const low3 = group.createMap();
+            queue.enqueue(low1.core, () => order.push("low1"), "low-priority");
+            queue.enqueue(high1.core, () => order.push("high1"));
+            queue.enqueue(low2.core, () => order.push("low2"), "low-priority");
+            queue.enqueue(high2.core, () => order.push("high2"));
+            queue.enqueue(low3.core, () => order.push("low3"), "low-priority");
+            expect(queue.highPriorityPendingCount).toBe(2);
+            expect(queue.lowPriorityPendingCount).toBe(3);
+            // Process all
+            queue.trackComplete(blockerMap.core);
+            queue.trackComplete(high1.core);
+            queue.trackComplete(high2.core);
+            queue.trackComplete(low1.core);
+            queue.trackComplete(low2.core);
+            // High priority should come first, then low priority
+            expect(order).toEqual(["high1", "high2", "low1", "low2", "low3"]);
+        });
+        test("should handle upgrade when item is the only one in low-priority queue", () => {
+            setMaxInFlightLoadsPerPeer(1);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            // Block the queue
+            const blockerMap = group.createMap();
+            queue.enqueue(blockerMap.core, () => { });
+            const targetMap = group.createMap();
+            // Add single low-priority item
+            queue.enqueue(targetMap.core, () => { }, "low-priority");
+            expect(queue.lowPriorityPendingCount).toBe(1);
+            // Upgrade it
+            queue.enqueue(targetMap.core, () => { });
+            expect(queue.lowPriorityPendingCount).toBe(0);
+            expect(queue.highPriorityPendingCount).toBe(1);
+        });
+        test("should handle upgrade when item is in the middle of low-priority queue", () => {
+            setMaxInFlightLoadsPerPeer(1);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            // Block the queue
+            const blockerMap = group.createMap();
+            queue.enqueue(blockerMap.core, () => { });
+            const order = [];
+            const low1 = group.createMap();
+            const low2 = group.createMap();
+            const low3 = group.createMap();
+            // Add three low-priority items
+            queue.enqueue(low1.core, () => order.push("low1"), "low-priority");
+            queue.enqueue(low2.core, () => order.push("low2"), "low-priority");
+            queue.enqueue(low3.core, () => order.push("low3"), "low-priority");
+            expect(queue.lowPriorityPendingCount).toBe(3);
+            // Upgrade the middle one (uses new callback)
+            queue.enqueue(low2.core, () => order.push("upgraded"));
+            expect(queue.lowPriorityPendingCount).toBe(2);
+            expect(queue.highPriorityPendingCount).toBe(1);
+            // Process all
+            queue.trackComplete(blockerMap.core);
+            queue.trackComplete(low2.core);
+            queue.trackComplete(low1.core);
+            // upgraded should be first (high priority with new callback), then low1 and low3
+            expect(order).toEqual(["upgraded", "low1", "low3"]);
+        });
+        test("should execute immediately when upgrading low-priority with immediate mode", () => {
+            setMaxInFlightLoadsPerPeer(1);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            // Block the queue
+            const blockerMap = group.createMap();
+            queue.enqueue(blockerMap.core, () => { });
+            const targetMap = group.createMap();
+            let originalCallbackCalled = false;
+            let immediateCallbackCalled = false;
+            // Add low-priority item
+            queue.enqueue(targetMap.core, () => {
+                originalCallbackCalled = true;
+            }, "low-priority");
+            expect(queue.lowPriorityPendingCount).toBe(1);
+            expect(originalCallbackCalled).toBe(false);
+            // Upgrade with immediate mode - should execute immediately with new callback
+            queue.enqueue(targetMap.core, () => {
+                immediateCallbackCalled = true;
+            }, "immediate");
+            // Should have been executed immediately, not moved to high-priority queue
+            expect(queue.lowPriorityPendingCount).toBe(0);
+            expect(queue.highPriorityPendingCount).toBe(0);
+            expect(originalCallbackCalled).toBe(false); // Original callback not called
+            expect(immediateCallbackCalled).toBe(true); // New callback called
+            // Should be in-flight now (2 because blocker is also in-flight)
+            expect(queue.inFlightCount).toBe(2);
+        });
+        test("should execute immediately when upgrading high-priority with immediate mode", () => {
+            setMaxInFlightLoadsPerPeer(1);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            // Block the queue
+            const blockerMap = group.createMap();
+            queue.enqueue(blockerMap.core, () => { });
+            const targetMap = group.createMap();
+            let originalCallbackCalled = false;
+            let immediateCallbackCalled = false;
+            // Add high-priority item (it will be queued since blocker is in-flight)
+            queue.enqueue(targetMap.core, () => {
+                originalCallbackCalled = true;
+            });
+            expect(queue.highPriorityPendingCount).toBe(1);
+            expect(originalCallbackCalled).toBe(false);
+            // Request with immediate mode - should execute immediately with new callback
+            queue.enqueue(targetMap.core, () => {
+                immediateCallbackCalled = true;
+            }, "immediate");
+            // Should have been executed immediately, removed from high-priority queue
+            expect(queue.highPriorityPendingCount).toBe(0);
+            expect(originalCallbackCalled).toBe(false); // Original callback not called
+            expect(immediateCallbackCalled).toBe(true); // New callback called
+            // Should be in-flight now (2 because blocker is also in-flight)
+            expect(queue.inFlightCount).toBe(2);
+        });
+        test("should skip immediate request on an in-flight value", () => {
+            setMaxInFlightLoadsPerPeer(10);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            const targetMap = group.createMap();
+            let firstCallbackCount = 0;
+            let secondCallbackCount = 0;
+            // First enqueue - should go in-flight immediately
+            queue.enqueue(targetMap.core, () => {
+                firstCallbackCount++;
+            });
+            expect(queue.inFlightCount).toBe(1);
+            expect(firstCallbackCount).toBe(1);
+            // Immediate request on in-flight value - should be skipped
+            queue.enqueue(targetMap.core, () => {
+                secondCallbackCount++;
+            }, "immediate");
+            // Should not have sent again
+            expect(queue.inFlightCount).toBe(1);
+            expect(firstCallbackCount).toBe(1);
+            expect(secondCallbackCount).toBe(0);
+        });
+        test("should skip low-priority request on an in-flight value", () => {
+            setMaxInFlightLoadsPerPeer(10);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            const targetMap = group.createMap();
+            let firstCallbackCount = 0;
+            let secondCallbackCount = 0;
+            // First enqueue - should go in-flight immediately
+            queue.enqueue(targetMap.core, () => {
+                firstCallbackCount++;
+            });
+            expect(queue.inFlightCount).toBe(1);
+            expect(firstCallbackCount).toBe(1);
+            // Low-priority request on in-flight value - should be skipped
+            queue.enqueue(targetMap.core, () => {
+                secondCallbackCount++;
+            }, "low-priority");
+            // Should not have sent again or queued
+            expect(queue.inFlightCount).toBe(1);
+            expect(queue.lowPriorityPendingCount).toBe(0);
+            expect(firstCallbackCount).toBe(1);
+            expect(secondCallbackCount).toBe(0);
+        });
+        test("should clear both priority queues on clear()", () => {
+            setMaxInFlightLoadsPerPeer(1);
+            const queue = new OutgoingLoadQueue(TEST_PEER_ID);
+            const node = createTestNode();
+            const group = node.createGroup();
+            // Block the queue
+            const blockerMap = group.createMap();
+            queue.enqueue(blockerMap.core, () => { });
+            const highMap = group.createMap();
+            const lowMap = group.createMap();
+            queue.enqueue(highMap.core, () => { });
+            queue.enqueue(lowMap.core, () => { }, "low-priority");
+            expect(queue.highPriorityPendingCount).toBe(1);
+            expect(queue.lowPriorityPendingCount).toBe(1);
+            queue.clear();
+            expect(queue.highPriorityPendingCount).toBe(0);
+            expect(queue.lowPriorityPendingCount).toBe(0);
+            expect(queue.pendingCount).toBe(0);
+        });
+    });
+});
+//# sourceMappingURL=OutgoingLoadQueue.test.js.map