performance-helpers 1.0.0 → 1.0.1

package/test/powerPool.uncovered.test.js

@@ -1,407 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { PowerPool } from '../src/helpers/powerPool.js';
-
-describe('PowerPool uncovered branches', () => {
-  it('onidle setter swallows thrown handlers and logs error', () => {
-    // Use a minimal stub underlying to avoid actual worker behavior
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 0, lazy: true });
-    pool._logger = { error: vi.fn(), log: () => {} };
-    pool.onidle = () => {
-      throw new Error('boom onidle');
-    };
-    // setting when pool is already idle should invoke handler immediately
-    expect(pool._logger.error).toHaveBeenCalled();
-  });
-
-  it('onidle setter swallows thrown handlers when pool has workers', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 1, lazy: false });
-    pool._logger = { error: vi.fn(), log: () => {} };
-    // pool has workers but no active tasks -> considered idle
-    pool.onidle = () => {
-      throw new Error('boom onidle2');
-    };
-    expect(pool._logger.error).toHaveBeenCalled();
-  });
-
-  it('getters for onmessage/onerror/onidle return underlying handlers', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 0, lazy: true });
-    const m = () => {};
-    const e = () => {};
-    const i = () => {};
-    pool._onmessage = m;
-    pool._onerror = e;
-    pool._onidle = i;
-    expect(pool.onmessage).toBe(m);
-    expect(pool.onerror).toBe(e);
-    expect(pool.onidle).toBe(i);
-  });
-
-  it('getter for onresize returns underlying handler', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 0, lazy: true });
-    const r = () => {};
-    pool._onresize = r;
-    expect(pool.onresize).toBe(r);
-  });
-
-  it('logs when bus.emit("idle") throws during _emitIdle', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 0, lazy: true });
-    pool._logger = { error: vi.fn(), log: () => {} };
-    // make bus.emit throw when emitting 'idle'
-    const origEmit = pool._bus.emit.bind(pool._bus);
-    pool._bus.emit = (type, ev) => {
-      if (type === 'idle') throw new Error('boom idle emit');
-      return origEmit(type, ev);
-    };
-    // call internal emitter directly
-    pool._emitIdle();
-    expect(pool._logger.error).toHaveBeenCalled();
-  });
-
-  it('logs when bus.emit("message") throws during _emitIdle', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 0, lazy: true });
-    pool._logger = { error: vi.fn(), log: () => {} };
-    // make bus.emit throw when emitting 'message'
-    const origEmit = pool._bus.emit.bind(pool._bus);
-    pool._bus.emit = (type, ev) => {
-      if (type === 'message') throw new Error('boom message emit');
-      return origEmit(type, ev);
-    };
-    pool._emitIdle();
-    expect(pool._logger.error).toHaveBeenCalled();
-  });
-
-  it('setters for onmessage/onerror/onresize assign via property', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 0, lazy: true });
-    const m = () => {};
-    const e = () => {};
-    const r = () => {};
-    pool.onmessage = m;
-    pool.onerror = e;
-    pool.onresize = r;
-    expect(pool._onmessage).toBe(m);
-    expect(pool._onerror).toBe(e);
-    expect(pool._onresize).toBe(r);
-  });
-
-  it('_emitIdle catches thrown _onmessage and _onidle handlers and logs errors', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 0, lazy: true });
-    pool._logger = { error: vi.fn(), log: () => {} };
-    pool._onmessage = () => {
-      throw new Error('boom onmessage internal');
-    };
-    pool._onidle = () => {
-      throw new Error('boom onidle internal');
-    };
-    pool._emitIdle();
-    expect(pool._logger.error).toHaveBeenCalled();
-  });
-
-  it('_reapIdleWorkers removes a single non-last worker via swap-and-pop without throwing', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 0, lazy: true, idleTimeout: 1 });
-    // create multiple workers
-    const w = pool.addWorker();
-    // ensure underlying wrapper has a working postMessage
-    w.worker.postMessage = vi.fn();
-    pool.addWorker();
-    pool.addWorker();
-    const now = Date.now();
-    // make only the middle worker idle beyond idleTimeout
-    for (let i = 0; i < pool.workers.length; i++) {
-      const w = pool.workers[i];
-      if (i === 1) {
-        w.tasks = 0;
-        w.lastActive = now - 10000;
-      } else {
-        w.tasks = 1; // busy
-        w.lastActive = now;
-      }
-    }
-    expect(() => pool._reapIdleWorkers()).not.toThrow();
-    expect(pool.workers.length).toBeLessThan(3);
-  });
-
-  it('stopThePressBatch clears reaper interval when recreateWorkers is false', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 0, lazy: true });
-    pool._reaperInterval = setInterval(() => {}, 10000);
-    pool.stopThePressBatch([], { recreateWorkers: false });
-    expect(pool._reaperInterval).toBeNull();
-  });
-
-  it('stopThePressBatch logs when terminating workers throws unexpectedly', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 0, lazy: true });
-    pool._logger = { error: vi.fn(), log: () => {} };
-    // make workers.length readable but accessing an index throws inside the try
-    const proxy = new Proxy(
-      { length: 1, 0: { worker: { terminate: () => {} }, completedTasks: 0 } },
-      {
-        get(target, prop) {
-          if (prop === 'length') return 1;
-          if (String(prop) === '0') throw new Error('boom term');
-          return Reflect.get(target, prop);
-        },
-      }
-    );
-    Object.defineProperty(pool, 'workers', {
-      get: () => proxy,
-      configurable: true,
-    });
-    pool.stopThePressBatch([], { recreateWorkers: false });
-    expect(pool._logger.error).toHaveBeenCalled();
-  });
-
-  it('postMessageBatch logs when queue.pushMany throws', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 0, lazy: true, maxSize: 0 });
-    pool._logger = { error: vi.fn(), log: () => {} };
-    pool.taskQueueEnabled = true;
-    pool.queue = {
-      pushMany: () => {
-        throw new Error('boom pushMany');
-      },
-    };
-    pool.postMessageBatch([{ message: 'x' }]);
-    expect(pool._logger.error).toHaveBeenCalled();
-  });
-
-  it('stopThePressBatch logs when queue.clear throws', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 0, lazy: true });
-    pool._logger = { error: vi.fn(), log: () => {} };
-    pool.queue = {
-      clear: () => {
-        throw new Error('boom clear');
-      },
-    };
-    pool.stopThePressBatch([], { recreateWorkers: false });
-    expect(pool._logger.error).toHaveBeenCalled();
-  });
-
-  it('stopThePressBatch logs when pendingResponses.entries throws', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 0, lazy: true });
-    pool._logger = { error: vi.fn(), log: () => {} };
-    pool._pendingResponses = {
-      entries: () => {
-        throw new Error('boom pending');
-      },
-    };
-    pool.stopThePressBatch([], { recreateWorkers: false });
-    expect(pool._logger.error).toHaveBeenCalled();
-  });
-
-  it('postMessageBatch handles _addWorkerInstance throwing and marks result false', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 0, lazy: true, maxSize: 1 });
-    pool._logger = { error: vi.fn(), log: () => {} };
-    // force worker creation path to throw
-    pool._addWorkerInstance = () => {
-      throw new Error('boom add');
-    };
-    const res = pool.postMessageBatch([{ message: 'x' }]);
-    expect(res[0]).toBe(false);
-  });
-
-  it('postMessageBatch fallback to existing worker logs when fallback.postMessage throws', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 0, lazy: true, maxSize: 1 });
-    pool._logger = { error: vi.fn(), log: () => {} };
-    // ensure one existing worker to trigger fallback path
-    const wobj = pool.addWorker();
-    // make fallback worker.postMessage throw and force fallback path
-    wobj.worker.postMessage = () => {
-      throw new Error('boom fallback');
-    };
-    pool.taskQueueEnabled = false;
-    pool._maxTasksPerWorker = 0;
-    const res = pool.postMessageBatch([{ message: 'x' }]);
-    expect(pool._logger.error).toHaveBeenCalled();
-    expect(res[0]).toBe(false);
-  });
-
-  it('postMessageBatch fallback to existing worker success path updates worker state', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 0, lazy: true, maxSize: 1 });
-    pool._logger = { error: vi.fn(), log: () => {} };
-    const wobj = pool.addWorker();
-    wobj._startTimes = [];
-    // successful postMessage with transfer
-    const pm = vi.fn();
-    wobj.worker.postMessage = pm;
-    pool.taskQueueEnabled = false;
-    pool._maxTasksPerWorker = 0;
-    const transfer = [new ArrayBuffer(1)];
-    const res = pool.postMessageBatch([{ message: 'ok', transfer }]);
-    expect(res[0]).toBe(true);
-    expect(pm).toHaveBeenCalledWith('ok', transfer);
-    expect(Array.isArray(wobj._startTimes) && wobj._startTimes.length).toBeTruthy();
-  });
-
-  it('postMessageBatch creates a new worker when pool can grow and succeeds', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 0, lazy: true, maxSize: 1 });
-    pool._logger = { error: vi.fn(), log: () => {} };
-    // stub _addWorkerInstance to create and register a worker
-    pool._addWorkerInstance = () => {
-      const o = { worker: { postMessage: vi.fn() }, tasks: 0, _startTimes: [], lastActive: 0 };
-      pool.workers.push(o);
-      return o;
-    };
-    const res = pool.postMessageBatch([{ message: 'new' }]);
-    expect(res[0]).toBe(true);
-  });
-
-  it('postMessageBatch least-worker postMessage throwing marks result false', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 0, lazy: true, maxSize: 1 });
-    pool._logger = { error: vi.fn(), log: () => {} };
-    const w = pool.addWorker();
-    // ensure least path is taken
-    pool._maxTasksPerWorker = 1;
-    w.worker.postMessage = () => {
-      throw new Error('boom least');
-    };
-    const res = pool.postMessageBatch([{ message: 'x' }]);
-    expect(res[0]).toBe(false);
-  });
-
-  it('postMessageBatch create-new-worker uses transfer when provided', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 0, lazy: true, maxSize: 1 });
-    pool._logger = { error: vi.fn(), log: () => {} };
-    // stub _addWorkerInstance to create and register a worker
-    pool._addWorkerInstance = () => {
-      const o = { worker: { postMessage: vi.fn() }, tasks: 0, _startTimes: [], lastActive: 0 };
-      pool.workers.push(o);
-      return o;
-    };
-    const transfer = [new ArrayBuffer(1)];
-    const res = pool.postMessageBatch([{ message: 'new', transfer }]);
-    expect(res[0]).toBe(true);
-    // ensure new worker postMessage was called with transfer
-    expect(pool.workers[0].worker.postMessage).toHaveBeenCalledWith('new', transfer);
-  });
-
-  it('postMessageBatch returns false when no workers and cannot grow', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 0, lazy: true, maxSize: 0 });
-    pool._logger = { error: vi.fn(), log: () => {} };
-    pool.taskQueueEnabled = false;
-    const res = pool.postMessageBatch([{ message: 'nope' }]);
-    expect(res[0]).toBe(false);
-  });
-
-  it('stopThePress clears reaper interval when recreateWorkers is false', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 0, lazy: true });
-    pool._reaperInterval = setInterval(() => {}, 10000);
-    pool.stopThePress('x', undefined, { recreateWorkers: false });
-    expect(pool._reaperInterval).toBeNull();
-  });
-
-  it('postMessageBatch throws when items is not an array', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 0, lazy: true });
-    expect(() => pool.postMessageBatch('not-an-array')).toThrow();
-  });
-
-  it('postMessageBatch with awaitResponse defers to postMessage and returns Promises', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 0, lazy: true, maxSize: 1 });
-    pool._logger = { error: vi.fn(), log: () => {} };
-    // ensure a worker exists so postMessage awaitResponse can post
-    const w = pool.addWorker();
-    w.worker.postMessage = vi.fn();
-    // use postMessageBatch with awaitResponse option; it should call postMessage per item
-    const res = pool.postMessageBatch([{ message: { hello: 'p' } }], { awaitResponse: true });
-    expect(res).toBeInstanceOf(Array);
-    expect(typeof res[0].then).toBe('function');
-  });
-
-  it('postMessageBatch with workerId uses targeted worker find path', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 0, lazy: true, maxSize: 1 });
-    pool._logger = { error: vi.fn(), log: () => {} };
-    const w = pool.addWorker();
-    w.id = 'worker-1';
-    const pm = vi.fn();
-    w.worker.postMessage = pm;
-    pool.postMessageBatch([{ message: 't' }], { workerId: 'worker-1' });
-    expect(pm).toHaveBeenCalled();
-  });
-
-  it('postMessageBatch with a fixed correlationId and multiple items throws', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 0, lazy: true, maxSize: 1 });
-    pool._logger = { error: vi.fn(), log: () => {} };
-    expect(() =>
-      pool.postMessageBatch([{ message: { hello: 'a' } }, { message: { hello: 'b' } }], {
-        awaitResponse: true,
-        correlationId: 'shared-id',
-      })
-    ).toThrow(
-      'postMessageBatch cannot use a fixed correlationId for multiple items; provide options.correlationIdFactory or omit correlationId'
-    );
-  });
-
-  it('prepareBuffers supports raw ArrayBuffer transfer optimization', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 0, lazy: true });
-    const buffer = new ArrayBuffer(16);
-    const result = pool.prepareBuffers([buffer]);
-    expect(result).toEqual([{ message: buffer, transfer: [buffer] }]);
-  });
-
-  it('prepareBuffers supports typed array transfer optimization', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 0, lazy: true });
-    const view = new Uint8Array(new ArrayBuffer(16));
-    const result = pool.prepareBuffers([view]);
-    expect(result).toEqual([{ message: view, transfer: [view.buffer] }]);
-  });
-
-  it('prepareBuffers supports DataView transfer optimization', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 0, lazy: true });
-    const buffer = new ArrayBuffer(16);
-    const view = new DataView(buffer);
-    const result = pool.prepareBuffers([view]);
-    expect(result).toEqual([{ message: view, transfer: [buffer] }]);
-  });
-
-  it('postMessageBatch with unknown targeted worker fails immediately', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, { minSize: 0, lazy: true, maxSize: 1 });
-    pool._logger = { error: vi.fn(), log: () => {} };
-    const res = pool.postMessageBatch([{ message: 't' }], { workerId: 'missing' });
-    expect(res).toEqual([false]);
-  });
-
-  it('postMessageBatch with a busy targeted worker fails instead of queueing', () => {
-    function Stub() {}
-    const pool = new PowerPool(Stub, {
-      minSize: 0,
-      lazy: true,
-      maxSize: 1,
-      maxTasksPerWorker: 1,
-      taskQueueEnabled: true,
-    });
-    pool._logger = { error: vi.fn(), log: () => {} };
-    const w = pool.addWorker();
-    w.id = 'worker-1';
-    w.tasks = 1;
-    const res = pool.postMessageBatch([{ message: 't' }], { workerId: 'worker-1' });
-    expect(res).toEqual([false]);
-    expect(pool.queue.length).toBe(0);
-  });
-});

package/test/powerPool.workerId.test.js

@@ -1,47 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { PowerPool } from '../src/helpers/powerPool.js';
-
-describe('PowerPool per-worker targeting', () => {
-  it('routes a message to the specified workerId when available', () => {
-    class MockUnderlying {
-      constructor() {
-        this.onmessage = null;
-        this.postMessage = vi.fn();
-        this.terminate = vi.fn();
-      }
-    }
-
-    const pool = new PowerPool(MockUnderlying, { size: 2, minSize: 2, idleTimeout: 1000 });
-    try {
-      expect(pool.workers.length).toBeGreaterThanOrEqual(2);
-      const target = pool.workers[0];
-      const other = pool.workers[1];
-      // ensure spies are on the underlying implementations
-      const underlyingTarget = target.worker._underlying || target.worker._underlying;
-      const underlyingOther = other.worker._underlying || other.worker._underlying;
-      pool.postMessage({ hello: 'targeted' }, null, { workerId: target.id });
-      expect(underlyingTarget.postMessage).toHaveBeenCalled();
-      // other worker should not have been called for this targeted message
-      expect(underlyingOther.postMessage).not.toHaveBeenCalled();
-    } finally {
-      pool.terminate();
-    }
-  });
-
-  it('returns false when targeted worker does not exist', () => {
-    class MockUnderlying {
-      constructor() {
-        this.onmessage = null;
-        this.postMessage = vi.fn();
-        this.terminate = vi.fn();
-      }
-    }
-    const pool = new PowerPool(MockUnderlying, { size: 1, minSize: 1 });
-    try {
-      const res = pool.postMessage({ x: 1 }, null, { workerId: 9999 });
-      expect(res).toBe(false);
-    } finally {
-      pool.terminate();
-    }
-  });
-});

package/test/powerQueue.iterators.test.js

@@ -1,67 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { PowerQueue } from '../src/helpers/powerQueue.js';
-
-describe('PowerQueue iterators and helpers', () => {
-  it('values() and Symbol.iterator yield values in FIFO order without consuming', () => {
-    const q = new PowerQueue(4);
-    q.push(1);
-    q.push(2);
-    q.push(3);
-
-    // values()
-    expect(Array.from(q.values())).toEqual([1, 2, 3]);
-
-    // default iterator (for...of / spread)
-    expect([...q]).toEqual([1, 2, 3]);
-
-    // original queue must be intact
-    expect(q.length).toBe(3);
-  });
-
-  it('keys() yields zero-based indexes corresponding to positions', () => {
-    const q = new PowerQueue(4);
-    q.push('a');
-    q.push('b');
-    q.push('c');
-    expect(Array.from(q.keys())).toEqual([0, 1, 2]);
-  });
-
-  it('entries() yields [index, value] pairs non-destructively', () => {
-    const q = new PowerQueue(4);
-    q.push('x');
-    q.push('y');
-    expect(Array.from(q.entries())).toEqual([
-      [0, 'x'],
-      [1, 'y'],
-    ]);
-    // still intact
-    expect(q.length).toBe(2);
-  });
-
-  it('toArray() returns a shallow FIFO snapshot without consuming', () => {
-    const q = new PowerQueue(4);
-    q.push(10);
-    q.push(20);
-    expect(q.toArray()).toEqual([10, 20]);
-    expect(q.length).toBe(2);
-  });
-
-  it('drain() consumes the queue and yields items in FIFO order', () => {
-    const q = new PowerQueue(4);
-    q.push(7);
-    q.push(8);
-    const result = [];
-    for (const v of q.drain()) result.push(v);
-    expect(result).toEqual([7, 8]);
-    expect(q.length).toBe(0);
-  });
-
-  it('iterators behave correctly on empty queue', () => {
-    const q = new PowerQueue(4);
-    expect(Array.from(q.values())).toEqual([]);
-    expect(Array.from(q.keys())).toEqual([]);
-    expect(Array.from(q.entries())).toEqual([]);
-    expect(q.toArray()).toEqual([]);
-    expect(Array.from(q.drain())).toEqual([]);
-  });
-});

package/test/powerQueue.saturation.test.js

@@ -1,18 +0,0 @@
-import { it, expect } from 'vitest';
-import { PowerQueue } from '../src/helpers/powerQueue.js';
-
-it('grows and preserves FIFO order under heavy pushMany usage', () => {
-  const q = new PowerQueue(4);
-  const N = 1000;
-  const arr = new Array(N);
-  for (let i = 0; i < N; i++) arr[i] = i;
-  q.pushMany(arr);
-  expect(q.length).toBe(N);
-  // ensure capacity grew at least once
-  expect(q.capacity).toBeGreaterThanOrEqual(4);
-  for (let i = 0; i < N; i++) {
-    const v = q.shift();
-    expect(v).toBe(i);
-  }
-  expect(q.length).toBe(0);
-});

package/test/powerQueue.test.js

@@ -1,48 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { PowerQueue } from '../src/helpers/powerQueue.js';
-
-describe('PowerQueue', () => {
-  it('push/shift preserves order and length updates', () => {
-    const q = new PowerQueue(4);
-    expect(q.length).toBe(0);
-    q.push(1);
-    q.push(2);
-    q.push(3);
-    expect(q.length).toBe(3);
-    expect(q.shift()).toBe(1);
-    expect(q.shift()).toBe(2);
-    expect(q.shift()).toBe(3);
-    expect(q.shift()).toBeUndefined();
-    expect(q.length).toBe(0);
-  });
-
-  it('grows capacity when full and preserves order', () => {
-    const q = new PowerQueue(2);
-    const pushed = [];
-    for (let i = 0; i < 10; i++) {
-      q.push(i);
-      pushed.push(i);
-    }
-    expect(q.capacity).toBeGreaterThanOrEqual(10);
-    const got = [];
-    while (!q.isEmpty) got.push(q.shift());
-    expect(got).toEqual(pushed);
-  });
-
-  it('peek returns next item without removing it', () => {
-    const q = new PowerQueue(4);
-    q.push('a');
-    expect(q.peek()).toBe('a');
-    expect(q.length).toBe(1);
-    expect(q.shift()).toBe('a');
-  });
-
-  it('clear empties the queue', () => {
-    const q = new PowerQueue(4);
-    q.push(1);
-    q.push(2);
-    q.clear();
-    expect(q.length).toBe(0);
-    expect(q.shift()).toBeUndefined();
-  });
-});

package/test/powerQueue.unshiftMany.test.js

@@ -1,49 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { PowerQueue } from '../src/helpers/powerQueue.js';
-
-describe('PowerQueue.unshiftMany', () => {
-  it('prepends items to an empty queue and grows as needed', () => {
-    const q = new PowerQueue(2);
-    const items = [0, 1, 2, 3, 4, 5];
-    q.unshiftMany(items);
-    expect(q.length).toBe(items.length);
-    expect(q.capacity).toBeGreaterThanOrEqual(items.length);
-    const got = [];
-    while (!q.isEmpty) got.push(q.shift());
-    expect(got).toEqual(items);
-  });
-
-  it('preserves order when prepending to a wrapped buffer', () => {
-    const q = new PowerQueue(4);
-    // fill then consume to cause head/tail to wrap
-    q.push(0);
-    q.push(1);
-    q.push(2);
-    q.push(3);
-    expect(q.shift()).toBe(0);
-    expect(q.shift()).toBe(1);
-    // now head points to 2, tail wrapped
-    q.unshiftMany(['a', 'b', 'c']);
-    expect(q.length).toBe(5);
-    const got = [];
-    while (!q.isEmpty) got.push(q.shift());
-    expect(got).toEqual(['a', 'b', 'c', 2, 3]);
-  });
-
-  it('handles large prepend that forces multiple resizes and keeps order', () => {
-    const q = new PowerQueue(4);
-    // create some existing items
-    q.push('x');
-    q.push('y');
-    const many = Array.from({ length: 50 }, (_, i) => `p${i}`);
-    q.unshiftMany(many);
-    expect(q.length).toBe(52);
-    const first = q.shift();
-    expect(first).toBe('p0');
-    // consume some and ensure tail data preserved
-    const tail = [];
-    while (!q.isEmpty) tail.push(q.shift());
-    expect(tail.slice(0, many.length - 1)).toEqual(many.slice(1));
-    expect(tail.slice(-2)).toEqual(['x', 'y']);
-  });
-});