performance-helpers 1.0.0 → 1.0.1

package/test/umd.bundle.branches.test.js

@@ -1,100 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { existsSync, readFileSync } from 'fs';
-import { execSync } from 'child_process';
-import vm from 'vm';
-import path from 'path';
-
-describe('UMD bundle - branches', () => {
-  it('loads under CommonJS (module.exports) branch and encodes/decodes via Buffer when TextEncoder missing', () => {
-    const distFile = path.resolve(process.cwd(), 'dist', 'performance-helpers.js');
-    if (!existsSync(distFile)) execSync('npm run build', { stdio: 'inherit' });
-    const code = readFileSync(distFile, 'utf8');
-
-    const sandbox = { console, setTimeout, clearTimeout, setInterval, clearInterval };
-    // Provide Buffer and Uint8Array but intentionally omit TextEncoder/TextDecoder
-    sandbox.Buffer = Buffer;
-    sandbox.Uint8Array = Uint8Array;
-    // Provide CommonJS globals
-    sandbox.module = { exports: {} };
-    sandbox.exports = sandbox.module.exports;
-
-    const ctx = vm.createContext(sandbox);
-    vm.runInContext(code, ctx, { filename: distFile });
-
-    const lib = sandbox.module.exports;
-    expect(lib).toBeDefined();
-    expect(typeof lib.PowerCache).toBe('function');
-
-    // Check encode/decode using Buffer path (since TextEncoder undefined)
-    const encoded = lib.o2u8({ foo: 'bar' });
-    expect(encoded).toBeInstanceOf(Uint8Array);
-    const decoded = lib.u82o(encoded);
-    expect(decoded).toEqual({ foo: 'bar' });
-  });
-
-  it('loads under AMD (define.amd) branch', () => {
-    const distFile = path.resolve(process.cwd(), 'dist', 'performance-helpers.js');
-    if (!existsSync(distFile)) execSync('npm run build', { stdio: 'inherit' });
-    const code = readFileSync(distFile, 'utf8');
-
-    const sandbox = {
-      console,
-      setTimeout,
-      clearTimeout,
-      setInterval,
-      clearInterval,
-      globalThis: {},
-    };
-    // implement AMD define
-    sandbox.__amd = null;
-    sandbox.define = function (deps, factory) {
-      const exports = {};
-      factory(exports);
-      sandbox.__amd = exports;
-    };
-    sandbox.define.amd = true;
-
-    const ctx = vm.createContext(sandbox);
-    vm.runInContext(code, ctx, { filename: distFile });
-
-    const lib = sandbox.__amd;
-    expect(lib).toBeDefined();
-    expect(typeof lib.PowerPool).toBe('function');
-  });
-
-  it('throws when no TextEncoder or Buffer is available for o2u8', () => {
-    const distFile = path.resolve(process.cwd(), 'dist', 'performance-helpers.js');
-    if (!existsSync(distFile)) execSync('npm run build', { stdio: 'inherit' });
-    const code = readFileSync(distFile, 'utf8');
-
-    const sandbox = {
-      console,
-      setTimeout,
-      clearTimeout,
-      setInterval,
-      clearInterval,
-      globalThis: {},
-    };
-    // ensure no TextEncoder and no Buffer
-    sandbox.TextEncoder = undefined;
-    sandbox.TextDecoder = undefined;
-    sandbox.Buffer = undefined;
-    sandbox.module = { exports: {} };
-    sandbox.exports = sandbox.module.exports;
-
-    const ctx = vm.createContext(sandbox);
-    vm.runInContext(code, ctx, { filename: distFile });
-
-    const lib = sandbox.module.exports;
-    expect(lib).toBeDefined();
-
-    // calling o2u8 should throw due to missing encoders
-    let threw = false;
-    try {
-      lib.o2u8({ x: 1 });
-    } catch (e) {
-      threw = true;
-    }
-    expect(threw).toBe(true);
-  });
-});

package/test/umd.bundle.cache-timers.test.js

@@ -1,48 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { existsSync, readFileSync } from 'fs';
-import { execSync } from 'child_process';
-import vm from 'vm';
-import path from 'path';
-
-const distFile = path.resolve(process.cwd(), 'dist', 'performance-helpers.js');
-if (!existsSync(distFile)) execSync('npm run build', { stdio: 'inherit' });
-const code = readFileSync(distFile, 'utf8');
-
-describe('UMD bundle PowerCache timer branches', () => {
-  it('startCleanup accepts numeric interval and options object', () => {
-    const sandbox = {
-      console,
-      setTimeout,
-      clearTimeout,
-      setInterval,
-      clearInterval,
-      TextEncoder,
-      TextDecoder,
-      globalThis: {},
-    };
-    sandbox.window = sandbox.globalThis;
-    sandbox.self = sandbox.globalThis;
-    sandbox.global = sandbox.globalThis;
-
-    const ctx = vm.createContext(sandbox);
-    vm.runInContext(code, ctx, { filename: distFile });
-
-    const res = vm.runInContext(
-      `(function(){
-      const lib = (typeof globalThis !== 'undefined' && (globalThis.PerformanceHelpers || globalThis.performanceHelpers)) || (typeof PerformanceHelpers !== 'undefined' && (PerformanceHelpers || performanceHelpers)) || this.PerformanceHelpers || this.performanceHelpers
-      const cache = new lib.PowerCache({ maxEntries: 5, defaultTTL: 10 })
-      // numeric interval
-      cache.startCleanup(1)
-      cache.stopCleanup()
-      // options object
-      cache.startCleanup({ interval: 1, maxCleanupPerTick: 2 })
-      cache.stopCleanup()
-      return true
-    })()`,
-      ctx,
-      { filename: distFile }
-    );
-
-    expect(res).toBe(true);
-  });
-});

package/test/umd.bundle.exhaustive.test.js

@@ -1,158 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { existsSync, readFileSync } from 'fs';
-import { execSync } from 'child_process';
-import vm from 'vm';
-import path from 'path';
-
-const distFile = path.resolve(process.cwd(), 'dist', 'performance-helpers.js');
-if (!existsSync(distFile)) execSync('npm run build', { stdio: 'inherit' });
-const code = readFileSync(distFile, 'utf8');
-
-describe('UMD bundle exhaustive branches', () => {
-  it('global context with TextEncoder/TextDecoder exercises many APIs', async () => {
-    const sandbox = {
-      console,
-      setTimeout,
-      clearTimeout,
-      setInterval,
-      clearInterval,
-      TextEncoder,
-      TextDecoder,
-      globalThis: {},
-    };
-    sandbox.window = sandbox.globalThis;
-    sandbox.self = sandbox.globalThis;
-    sandbox.global = sandbox.globalThis;
-
-    const ctx = vm.createContext(sandbox);
-    vm.runInContext(code, ctx, { filename: distFile });
-
-    const lib =
-      sandbox.globalThis.PerformanceHelpers ||
-      sandbox.globalThis.performanceHelpers ||
-      sandbox.PerformanceHelpers ||
-      sandbox.performanceHelpers;
-    expect(lib).toBeDefined();
-
-    // Buffer/encoding paths (TextEncoder present) -> o2u8/u82o roundtrip (do full roundtrip inside VM)
-    const obj = { hello: 'world' };
-    const round = vm.runInContext(
-      `(function(){ const lib = (typeof globalThis !== 'undefined' && (globalThis.PerformanceHelpers || globalThis.performanceHelpers)) || (typeof PerformanceHelpers !== 'undefined' && (PerformanceHelpers || performanceHelpers)) || this.PerformanceHelpers || this.performanceHelpers; const u8 = lib.o2u8(${JSON.stringify(obj)}); return lib.u82o(u8); })()`,
-      ctx,
-      { filename: distFile }
-    );
-    expect(round).toEqual(obj);
-
-    // b2o/o2b conversions
-    // perform ArrayBuffer roundtrip inside the VM to avoid cross-realm checks
-    vm.runInContext(
-      `(function(){ const lib = (typeof globalThis !== 'undefined' && (globalThis.PerformanceHelpers || globalThis.performanceHelpers)) || (typeof PerformanceHelpers !== 'undefined' && (PerformanceHelpers || performanceHelpers)) || this.PerformanceHelpers || this.performanceHelpers; lib.o2b(${JSON.stringify(obj)}); return true })()`,
-      ctx,
-      { filename: distFile }
-    );
-
-    // PowerLogger: enable verbose and call with lazy-throwing functions
-    const logger = new lib.PowerLogger(3);
-    expect(typeof logger.setDebugLevel).toBe('function');
-    // call with a lazy function that throws; should not propagate
-    logger.info(
-      () => 'ok',
-      () => {
-        throw new Error('boom-in-lazy');
-      }
-    );
-    logger.warn('plain', () => 'value');
-
-    // PowerCache basic ops
-    const cache = new lib.PowerCache({ maxEntries: 3 });
-    cache.set('a', 1);
-    expect(cache.get('a')).toBe(1);
-    cache.set('b', 2);
-    expect(cache.has('b')).toBe(true);
-    cache.delete('b');
-    expect(cache.has('b')).toBe(false);
-
-    // PowerMemoizer: sync and async caching behavior
-    const syncFn = (x) => x * 2;
-    const memoSync = new lib.PowerMemoizer(syncFn, { cacheOptions: { maxEntries: 10 } });
-    const callSync = typeof memoSync === 'function' ? memoSync : (...args) => memoSync.run(...args);
-    expect(callSync(2)).toBe(4);
-    expect(callSync(2)).toBe(4);
-
-    const asyncFn = async (n) => n + 1;
-    const memoAsync = new lib.PowerMemoizer(asyncFn, { cacheOptions: { maxEntries: 10 } });
-    const callAsync =
-      typeof memoAsync === 'function' ? memoAsync : (...args) => memoAsync.run(...args);
-    const p1 = callAsync(3);
-    const p2 = callAsync(3);
-    expect(p1).toBe(p2);
-    const res = await p1;
-    expect(res).toBe(4);
-
-    // PowerPool: use mock underlying to exercise encode path
-    vm.runInContext(
-      `(function(){
-      class MockUnderlying {
-        constructor(){ this.onmessage=null; this.postMessageCalls=[] }
-        postMessage(msg, transfer){ this.postMessageCalls.push(msg); setTimeout(()=>{ if(this.onmessage) this.onmessage({ data: msg }) }, 0) }
-        addEventListener(t, cb){ if(t==='message') this.onmessage = cb }
-        terminate(){ this.__terminated = true }
-      }
-      const lib = (typeof globalThis !== 'undefined' && (globalThis.PerformanceHelpers || globalThis.performanceHelpers)) || (typeof PerformanceHelpers !== 'undefined' && (PerformanceHelpers || performanceHelpers)) || this.PerformanceHelpers || this.performanceHelpers
-      const pool = new lib.PowerPool(MockUnderlying, { size: 1, idleTimeout: 1000, maxTasksPerWorker: 1, taskQueue: true })
-      this.__p = pool
-      this.__r = []
-      pool.onmessage = (e) => { this.__r.push(e.data) }
-      pool.postMessage({ ping: 'pong' })
-      return true
-    })()`,
-      ctx,
-      { filename: distFile }
-    );
-
-    // allow async replies
-    await new Promise((r) => setTimeout(r, 50));
-    const summary = vm.runInContext(
-      `(function(){
-      const count = (this.__r && this.__r.length) || 0
-      const underlying = (this.__p && this.__p.workers && this.__p.workers[0] && this.__p.workers[0]._underlying) || (this.__p && this.__p.workers && this.__p.workers[0] && this.__p.workers[0].worker && this.__p.workers[0].worker._underlying)
-      const postArg = underlying && underlying.postMessageCalls && underlying.postMessageCalls[0]
-      return { count, postArg }
-    })()`,
-      ctx,
-      { filename: distFile }
-    );
-    expect(summary.count).toBeGreaterThanOrEqual(1);
-    expect(summary.postArg).not.toBeNull();
-  });
-
-  it('CommonJS/module.exports path with Buffer fallback exercises Buffer encoder path', () => {
-    const sandbox = { console, setTimeout, clearTimeout, setInterval, clearInterval };
-    // remove TextEncoder/TextDecoder to force Buffer fallback
-    sandbox.TextEncoder = undefined;
-    sandbox.TextDecoder = undefined;
-    sandbox.Buffer = Buffer;
-    sandbox.module = { exports: {} };
-    sandbox.exports = sandbox.module.exports;
-
-    const ctx = vm.createContext(sandbox);
-    vm.runInContext(code, ctx, { filename: distFile });
-
-    const lib = sandbox.module.exports;
-    expect(lib).toBeDefined();
-
-    // Buffer-based encoding should work when TextEncoder absent
-    const obj = { x: 1 };
-    // run encode/decode entirely inside the VM to avoid cross-realm instanceof failures
-    const decoded = vm.runInContext(
-      `(function(){ const lib = module.exports; const u8 = lib.o2u8(${JSON.stringify(obj)}); return lib.u82o(u8); })()`,
-      ctx,
-      { filename: distFile }
-    );
-    expect(decoded).toEqual(obj);
-
-    // logger still functions
-    const logger = new lib.PowerLogger(2);
-    logger.error(() => 'err', 'plain');
-  });
-});

package/test/umd.bundle.fuzz.test.js

@@ -1,86 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { existsSync, readFileSync } from 'fs';
-import { execSync } from 'child_process';
-import vm from 'vm';
-import path from 'path';
-
-const distFile = path.resolve(process.cwd(), 'dist', 'performance-helpers.js');
-if (!existsSync(distFile)) execSync('npm run build', { stdio: 'inherit' });
-const code = readFileSync(distFile, 'utf8');
-
-describe('UMD bundle broader exercise', () => {
-  it('runs a wide set of operations to exercise branches', () => {
-    const sandbox = {
-      console,
-      setTimeout,
-      clearTimeout,
-      setInterval,
-      clearInterval,
-      TextEncoder,
-      TextDecoder,
-      Buffer: global.Buffer,
-      globalThis: {},
-    };
-    sandbox.window = sandbox.globalThis;
-    sandbox.self = sandbox.globalThis;
-    sandbox.global = sandbox.globalThis;
-
-    const ctx = vm.createContext(sandbox);
-    vm.runInContext(code, ctx, { filename: distFile });
-
-    const res = vm.runInContext(
-      `(function(){
-      const lib = (typeof globalThis !== 'undefined' && (globalThis.PerformanceHelpers || globalThis.performanceHelpers)) || (typeof PerformanceHelpers !== 'undefined' && (PerformanceHelpers || performanceHelpers)) || this.PerformanceHelpers || this.performanceHelpers
-      const cache = new lib.PowerCache({ maxEntries: 50, maxWeight: 1000 })
-
-      // circular object to make JSON.stringify throw
-      const a = { }
-      a.self = a
-      try { cache.set('circ', a) } catch(e){}
-
-      // object with toJSON throwing
-      const bad = { toJSON(){ throw new Error('bad') } }
-      try { cache.set('bad', bad) } catch(e){}
-
-      // DataView
-      const buf = new ArrayBuffer(8);
-      const dv = new DataView(buf);
-      dv.setUint8(0, 42);
-      cache.set('dv', dv);
-      const dvOk = cache.hasEqual('dv', new DataView(buf));
-
-      // Buffer (Node)
-      const bufNode = Buffer.from([1,2,3]);
-      cache.set('nodebuf', bufNode);
-      const bufOk = cache.hasEqual('nodebuf', Buffer.from([1,2,3]));
-
-      // Map/Set edgecases
-      const m = new Map([[{k:1}, 2]]);
-      cache.set('m2', m);
-      const s = new Set([1,2,3]);
-      cache.set('s2', s);
-
-      // Pool interactions: create a mock worker factory
-      const WorkerCtor = function(){
-        this.postMessage = (msg, transfer)=>{}
-        this.addEventListener = ()=>{}
-        this.removeEventListener = ()=>{}
-        this.terminate = ()=>{}
-        this.onmessage = null
-        this.onerror = null
-        this.onmessageerror = null
-      }
-      const pool = new lib.PowerPool(WorkerCtor)
-      const posted = pool.postMessage({a:1})
-
-      return { dvOk, bufOk, posted }
-    })()`,
-      ctx,
-      { filename: distFile }
-    );
-
-    expect(res.dvOk).toBe(true);
-    expect(res.bufOk).toBe(true);
-    expect(res.posted).toBe(true);
-  });
-});

package/test/umd.bundle.hasEqual.more.test.js

@@ -1,68 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { existsSync, readFileSync } from 'fs';
-import { execSync } from 'child_process';
-import vm from 'vm';
-import path from 'path';
-
-const distFile = path.resolve(process.cwd(), 'dist', 'performance-helpers.js');
-if (!existsSync(distFile)) execSync('npm run build', { stdio: 'inherit' });
-const code = readFileSync(distFile, 'utf8');
-
-describe('UMD bundle additional deep-equality branches', () => {
-  it('handles prototype mismatches and primitive set fast-path', () => {
-    const sandbox = {
-      console,
-      setTimeout,
-      clearTimeout,
-      setInterval,
-      clearInterval,
-      TextEncoder,
-      TextDecoder,
-      globalThis: {},
-    };
-    sandbox.window = sandbox.globalThis;
-    sandbox.self = sandbox.globalThis;
-    sandbox.global = sandbox.globalThis;
-
-    const ctx = vm.createContext(sandbox);
-    vm.runInContext(code, ctx, { filename: distFile });
-
-    const result = vm.runInContext(
-      `(function(){
-      const lib = (typeof globalThis !== 'undefined' && (globalThis.PerformanceHelpers || globalThis.performanceHelpers)) || (typeof PerformanceHelpers !== 'undefined' && (PerformanceHelpers || performanceHelpers)) || this.PerformanceHelpers || this.performanceHelpers
-      const cache = new lib.PowerCache({ maxEntries: 20 })
-
-      // Prototype mismatch
-      const a = Object.create(null); a.x = 1
-      const b = { x: 1 }
-      cache.set('proto', a)
-      const pmatch = cache.hasEqual('proto', b)
-
-      // Set primitive fast-path
-      const s = new Set([1,2,3])
-      cache.set('primset', s)
-      const primOk = cache.hasEqual('primset', new Set([1,2,3]))
-
-      // Array mismatch
-      const arr = [1, {x:2}, 3]
-      cache.set('arr', arr)
-      const arrOk = cache.hasEqual('arr', [1, {x:2}, 3])
-
-      // TypedArray view with offset should cause slice branch in o2b/buffer helpers when used elsewhere
-      const buf = new ArrayBuffer(10)
-      const view = new Uint8Array(buf, 2, 4)
-      cache.set('view', view)
-      const viewOk = cache.hasEqual('view', new Uint8Array(buf, 2, 4))
-
-      return { pmatch, primOk, arrOk, viewOk }
-    })()`,
-      ctx,
-      { filename: distFile }
-    );
-
-    expect(result.pmatch).toBe(false);
-    expect(result.primOk).toBe(true);
-    expect(result.arrOk).toBe(true);
-    expect(result.viewOk).toBe(true);
-  });
-});

package/test/umd.bundle.hasEqual.test.js

@@ -1,104 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { existsSync, readFileSync } from 'fs';
-import { execSync } from 'child_process';
-import vm from 'vm';
-import path from 'path';
-
-const distFile = path.resolve(process.cwd(), 'dist', 'performance-helpers.js');
-if (!existsSync(distFile)) execSync('npm run build', { stdio: 'inherit' });
-const code = readFileSync(distFile, 'utf8');
-
-describe('UMD bundle deep-equality and logger edge branches', () => {
-  it('PowerCache.hasEqual exercises many deep-equality branches', () => {
-    const sandbox = {
-      console,
-      setTimeout,
-      clearTimeout,
-      setInterval,
-      clearInterval,
-      TextEncoder,
-      TextDecoder,
-      globalThis: {},
-    };
-    sandbox.window = sandbox.globalThis;
-    sandbox.self = sandbox.globalThis;
-    sandbox.global = sandbox.globalThis;
-
-    const ctx = vm.createContext(sandbox);
-    vm.runInContext(code, ctx, { filename: distFile });
-
-    // Run several hasEqual scenarios inside VM to exercise many branches
-    const result = vm.runInContext(
-      `(function(){
-      const lib = (typeof globalThis !== 'undefined' && (globalThis.PerformanceHelpers || globalThis.performanceHelpers)) || (typeof PerformanceHelpers !== 'undefined' && (PerformanceHelpers || performanceHelpers)) || this.PerformanceHelpers || this.performanceHelpers
-      const cache = new lib.PowerCache({ maxEntries: 20 })
-
-      // TypedArray / ArrayBuffer
-      const buf = new ArrayBuffer(8)
-      const ua = new Uint8Array(buf)
-      ua[0] = 1
-      cache.set('ta', ua)
-      const ok1 = cache.hasEqual('ta', new Uint8Array(buf))
-
-      // Date
-      const d = new Date(123456)
-      cache.set('date', d)
-      const ok2 = cache.hasEqual('date', new Date(123456))
-
-      // RegExp
-      const re = /abc/g
-      cache.set('re', re)
-      const ok3 = cache.hasEqual('re', /abc/g)
-
-      // Map of nested objects
-      const m = new Map(); m.set('x', { a: [1,2,3] })
-      cache.set('map', m)
-      const m2 = new Map(); m2.set('x', { a: [1,2,3] })
-      const ok4 = cache.hasEqual('map', m2)
-
-      // Set with object requiring O(n^2) fallback
-      const s = new Set(); s.add({ k: 1 })
-      cache.set('set', s)
-      const s2 = new Set(); s2.add({ k: 1 })
-      const ok5 = cache.hasEqual('set', s2)
-
-      return { ok1, ok2, ok3, ok4, ok5 }
-    })()`,
-      ctx,
-      { filename: distFile }
-    );
-
-    expect(result.ok1).toBe(true);
-    expect(result.ok2).toBe(true);
-    expect(result.ok3).toBe(true);
-    expect(result.ok4).toBe(true);
-    expect(result.ok5).toBe(true);
-  });
-
-  it('PowerLogger handles missing console methods and lazy args safely', () => {
-    const sandbox = { setTimeout, clearTimeout, setInterval, clearInterval, globalThis: {} };
-    sandbox.window = sandbox.globalThis;
-    sandbox.self = sandbox.globalThis;
-    sandbox.global = sandbox.globalThis;
-    // Provide a console with missing methods
-    sandbox.console = { log: () => {}, warn: () => {} };
-
-    const ctx = vm.createContext(sandbox);
-    vm.runInContext(code, ctx, { filename: distFile });
-
-    const res = vm.runInContext(
-      `(function(){
-      const lib = (typeof globalThis !== 'undefined' && (globalThis.PerformanceHelpers || globalThis.performanceHelpers)) || (typeof PerformanceHelpers !== 'undefined' && (PerformanceHelpers || performanceHelpers)) || this.PerformanceHelpers || this.performanceHelpers
-      const logger = new lib.PowerLogger(3)
-      // these calls should not throw even if console.info/error are missing
-      try { logger.info(() => 'a', () => { throw new Error('boom') }); } catch (e) { return false }
-      try { logger.error('x', () => 'y'); } catch (e) { return false }
-      return true
-    })()`,
-      ctx,
-      { filename: distFile }
-    );
-
-    expect(res).toBe(true);
-  });
-});

package/test/umd.bundle.logger-extra.test.js

@@ -1,48 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { existsSync, readFileSync } from 'fs';
-import { execSync } from 'child_process';
-import vm from 'vm';
-import path from 'path';
-
-const distFile = path.resolve(process.cwd(), 'dist', 'performance-helpers.js');
-if (!existsSync(distFile)) execSync('npm run build', { stdio: 'inherit' });
-const code = readFileSync(distFile, 'utf8');
-
-describe('UMD bundle logger extra branches', () => {
-  it('invokes counter APIs and handles odd inputs', () => {
-    const sandbox = {
-      console,
-      setTimeout,
-      clearTimeout,
-      setInterval,
-      clearInterval,
-      TextEncoder,
-      TextDecoder,
-      globalThis: {},
-    };
-    sandbox.window = sandbox.globalThis;
-    sandbox.self = sandbox.globalThis;
-    sandbox.global = sandbox.globalThis;
-
-    const ctx = vm.createContext(sandbox);
-    vm.runInContext(code, ctx, { filename: distFile });
-
-    const ok = vm.runInContext(
-      `(function(){
-      const lib = (typeof globalThis !== 'undefined' && (globalThis.PerformanceHelpers || globalThis.performanceHelpers)) || (typeof PerformanceHelpers !== 'undefined' && (PerformanceHelpers || performanceHelpers)) || this.PerformanceHelpers || this.performanceHelpers
-      const logger = new lib.PowerLogger(2)
-      logger.incrementCounter('k')
-      const before = logger.getDebugCounters()
-      logger.resetDebugCounters()
-      const after = logger.getDebugCounters()
-      // weird setDebugLevel input
-      logger.setDebugLevel({ toString: () => { throw new Error('boom') } })
-      return before && typeof after === 'object'
-    })()`,
-      ctx,
-      { filename: distFile }
-    );
-
-    expect(ok).toBe(true);
-  });
-});

package/test/umd.bundle.more-coverage-2.test.js

@@ -1,67 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { existsSync, readFileSync } from 'fs';
-import { execSync } from 'child_process';
-import vm from 'vm';
-import path from 'path';
-
-const distFile = path.resolve(process.cwd(), 'dist', 'performance-helpers.js');
-if (!existsSync(distFile)) execSync('npm run build', { stdio: 'inherit' });
-const code = readFileSync(distFile, 'utf8');
-
-describe('UMD bundle more coverage permutations', () => {
-  it('exercises map/set/typed-array key cases and buffer decode errors', () => {
-    const sandbox = {
-      console,
-      setTimeout,
-      clearTimeout,
-      setInterval,
-      clearInterval,
-      TextEncoder,
-      TextDecoder,
-      Buffer: global.Buffer,
-      globalThis: {},
-    };
-    sandbox.window = sandbox.globalThis;
-    sandbox.self = sandbox.globalThis;
-    sandbox.global = sandbox.globalThis;
-
-    const ctx = vm.createContext(sandbox);
-    vm.runInContext(code, ctx, { filename: distFile });
-
-    const res = vm.runInContext(
-      `(function(){
-      const lib = (typeof globalThis !== 'undefined' && (globalThis.PerformanceHelpers || globalThis.performanceHelpers)) || (typeof PerformanceHelpers !== 'undefined' && (PerformanceHelpers || performanceHelpers)) || this.PerformanceHelpers || this.performanceHelpers
-      const cache = new lib.PowerCache({ maxEntries: 50 })
-
-      // Map with typed-array key
-      const key = new Uint8Array([1,2,3])
-      const m = new Map(); m.set(key, 'v')
-      cache.set('mapt', m)
-      const mapRes = cache.hasEqual('mapt', new Map([[new Uint8Array([1,2,3]), 'v']]))
-
-      // Set primitive vs complex
-      const s1 = new Set([1,2,3])
-      cache.set('s1', s1)
-      const s1ok = cache.hasEqual('s1', new Set([1,2,3]))
-
-      const s2 = new Set([{a:1}])
-      cache.set('s2', s2)
-      const s2ok = cache.hasEqual('s2', new Set([{a:1}]))
-
-      // u82o error for unsupported value (simulate by passing number)
-      let threw = false
-      try { lib.u82o(123) } catch(e){ threw = true }
-
-      return { mapRes, s1ok, s2ok, threw }
-    })()`,
-      ctx,
-      { filename: distFile }
-    );
-
-    // mapRes should be false (different key references)
-    expect(res.mapRes).toBe(false);
-    expect(res.s1ok).toBe(true);
-    expect(res.s2ok).toBe(true);
-    expect(res.threw).toBe(true);
-  });
-});