@holoscript/std 7.0.0 → 7.0.1

package/src/__tests__/string-and-time-utilities.test.ts

@@ -1,1070 +0,0 @@
-/**
- * @holoscript/std acceptance tests
- * Covers: string formatting/validation/escaping, time utilities (Stopwatch,
- *         CountdownTimer, debounce, throttle, retry, measure), and
- *         collections (HoloMap, HoloSet, PriorityQueue).
- */
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import {
-  // String — formatting
-  format,
-  formatBytes,
-  formatDuration,
-  formatNumber,
-  numberWithCommas,
-  // String — HTML/regex
-  escapeHtml,
-  unescapeHtml,
-  escapeRegex,
-  slugify,
-  // String — validation
-  isValidIdentifier,
-  isNumeric,
-  isAlphanumeric,
-  isAlpha,
-  isBlank,
-  isNotBlank,
-  // String — manipulation
-  truncate,
-  truncateMiddle,
-  center,
-  padLeft,
-  padRight,
-  removePrefix,
-  removeSuffix,
-  indent,
-  dedent,
-  count,
-  reverse,
-  levenshtein,
-  similarity,
-  uuid,
-  randomString,
-} from '../string.js';
-
-import {
-  measure,
-  retry,
-  debounce,
-  throttle,
-  Stopwatch,
-  CountdownTimer,
-  IntervalTimer,
-  FrameTimer,
-  schedule,
-  DateTime,
-} from '../time.js';
-
-import { HoloMap, HoloSet, PriorityQueue, List } from '../collections.js';
-
-// ═══════════════════════════════════════════════
-// String — formatting
-// ═══════════════════════════════════════════════
-describe('format', () => {
-  it('replaces named placeholders', () => {
-    expect(format('Hello {name}!', { name: 'Alice' })).toBe('Hello Alice!');
-  });
-
-  it('replaces multiple placeholders', () => {
-    expect(format('{a} + {b} = {c}', { a: 1, b: 2, c: 3 })).toBe('1 + 2 = 3');
-  });
-
-  it('leaves unknown placeholders unchanged', () => {
-    expect(format('{x} is unknown', {})).toBe('{x} is unknown');
-  });
-
-  it('handles empty template', () => {
-    expect(format('', { a: 1 })).toBe('');
-  });
-});
-
-describe('formatBytes', () => {
-  it('0 bytes', () => {
-    expect(formatBytes(0)).toBe('0 B');
-  });
-
-  it('bytes under 1KB', () => {
-    expect(formatBytes(512)).toBe('512 B');
-  });
-
-  it('kilobytes', () => {
-    expect(formatBytes(1024)).toBe('1 KB');
-  });
-
-  it('megabytes', () => {
-    expect(formatBytes(1024 * 1024)).toBe('1 MB');
-  });
-
-  it('gigabytes', () => {
-    expect(formatBytes(1024 ** 3)).toBe('1 GB');
-  });
-
-  it('custom decimals', () => {
-    expect(formatBytes(1536, 1)).toBe('1.5 KB');
-  });
-});
-
-describe('formatDuration', () => {
-  it('milliseconds under 1s', () => {
-    expect(formatDuration(500)).toBe('500ms');
-  });
-
-  it('seconds', () => {
-    expect(formatDuration(2500)).toBe('2.5s');
-  });
-
-  it('minutes', () => {
-    expect(formatDuration(90000)).toBe('1.5m');
-  });
-
-  it('hours', () => {
-    expect(formatDuration(3900000)).toBe('1.1h');
-  });
-});
-
-describe('numberWithCommas', () => {
-  it('formats integer with commas', () => {
-    expect(numberWithCommas(1000000)).toBe('1,000,000');
-  });
-
-  it('does not add commas for small numbers', () => {
-    expect(numberWithCommas(999)).toBe('999');
-  });
-});
-
-// ═══════════════════════════════════════════════
-// String — HTML / regex escaping
-// ═══════════════════════════════════════════════
-describe('escapeHtml', () => {
-  it('escapes ampersand', () => {
-    expect(escapeHtml('a & b')).toBe('a & b');
-  });
-
-  it('escapes angle brackets', () => {
-    expect(escapeHtml('<script>')).toBe('&lt;script&gt;');
-  });
-
-  it('escapes double quotes', () => {
-    expect(escapeHtml('"hello"')).toBe('&quot;hello&quot;');
-  });
-
-  it('escapes single quotes', () => {
-    expect(escapeHtml("it's")).toBe('it&#39;s');
-  });
-
-  it('passes safe strings unchanged', () => {
-    expect(escapeHtml('hello world')).toBe('hello world');
-  });
-});
-
-describe('unescapeHtml', () => {
-  it('unescapes &amp;', () => {
-    expect(unescapeHtml('a &amp; b')).toBe('a & b');
-  });
-
-  it('unescapes &lt; and &gt;', () => {
-    expect(unescapeHtml('&lt;b&gt;')).toBe('<b>');
-  });
-
-  it('unescapes &quot;', () => {
-    expect(unescapeHtml('&quot;hi&quot;')).toBe('"hi"');
-  });
-
-  it('round-trips through escapeHtml', () => {
-    const original = '<div class="test">Hello & World</div>';
-    expect(unescapeHtml(escapeHtml(original))).toBe(original);
-  });
-});
-
-describe('escapeRegex', () => {
-  it('escapes dot', () => {
-    const pattern = escapeRegex('a.b');
-    expect(new RegExp(pattern).test('axb')).toBe(false);
-    expect(new RegExp(pattern).test('a.b')).toBe(true);
-  });
-
-  it('escapes parentheses', () => {
-    const pattern = escapeRegex('(test)');
-    expect(new RegExp(pattern).test('(test)')).toBe(true);
-  });
-
-  it('escapes brackets', () => {
-    expect(escapeRegex('[a]')).toBe('\\[a\\]');
-  });
-});
-
-describe('slugify', () => {
-  it('lowercases and replaces spaces with hyphens', () => {
-    expect(slugify('Hello World')).toBe('hello-world');
-  });
-
-  it('removes special characters', () => {
-    expect(slugify('Hello, World!')).toBe('hello-world');
-  });
-
-  it('strips leading/trailing hyphens', () => {
-    expect(slugify('  hello  ')).toBe('hello');
-  });
-
-  it('collapses multiple separators', () => {
-    expect(slugify('hello   world')).toBe('hello-world');
-  });
-});
-
-// ═══════════════════════════════════════════════
-// String — validation
-// ═══════════════════════════════════════════════
-describe('isValidIdentifier', () => {
-  it('accepts simple identifier', () => {
-    expect(isValidIdentifier('myVar')).toBe(true);
-  });
-
-  it('accepts underscore prefix', () => {
-    expect(isValidIdentifier('_private')).toBe(true);
-  });
-
-  it('accepts dollar prefix', () => {
-    expect(isValidIdentifier('$el')).toBe(true);
-  });
-
-  it('rejects identifier starting with digit', () => {
-    expect(isValidIdentifier('1bad')).toBe(false);
-  });
-
-  it('rejects identifier with spaces', () => {
-    expect(isValidIdentifier('my var')).toBe(false);
-  });
-});
-
-describe('isNumeric', () => {
-  it('accepts integer string', () => {
-    expect(isNumeric('42')).toBe(true);
-  });
-
-  it('accepts float string', () => {
-    expect(isNumeric('3.14')).toBe(true);
-  });
-
-  it('rejects non-numeric', () => {
-    expect(isNumeric('abc')).toBe(false);
-  });
-});
-
-describe('isAlphanumeric / isAlpha / isBlank / isNotBlank', () => {
-  it('isAlphanumeric accepts letters and digits', () => {
-    expect(isAlphanumeric('abc123')).toBe(true);
-  });
-
-  it('isAlphanumeric rejects spaces', () => {
-    expect(isAlphanumeric('abc 123')).toBe(false);
-  });
-
-  it('isAlpha accepts letters only', () => {
-    expect(isAlpha('hello')).toBe(true);
-    expect(isAlpha('hello1')).toBe(false);
-  });
-
-  it('isBlank for empty string', () => {
-    expect(isBlank('')).toBe(true);
-    expect(isBlank('   ')).toBe(true);
-  });
-
-  it('isNotBlank for non-empty string', () => {
-    expect(isNotBlank('hello')).toBe(true);
-    expect(isNotBlank('')).toBe(false);
-  });
-});
-
-// ═══════════════════════════════════════════════
-// String — manipulation
-// ═══════════════════════════════════════════════
-describe('truncate', () => {
-  it('does not truncate short strings', () => {
-    expect(truncate('hi', 10)).toBe('hi');
-  });
-
-  it('truncates long strings with ellipsis', () => {
-    expect(truncate('hello world', 8)).toBe('hello...');
-  });
-
-  it('custom ellipsis', () => {
-    // Use ASCII marker to avoid Unicode encoding variance in this fixture.
-    expect(truncate('hello world', 7, '*')).toBe('hello *');
-  });
-});
-
-describe('truncateMiddle', () => {
-  it('does not truncate short strings', () => {
-    expect(truncateMiddle('hi', 10)).toBe('hi');
-  });
-
-  it('preserves start and end with ellipsis in middle', () => {
-    // 'hello_world_long' length=16, maxLength=11, ellipsis='...' (3 chars)
-    // available=8, leftLength=ceil(4)=4, rightLength=floor(4)=4
-    // result = 'hell' + '...' + 'long'
-    const result = truncateMiddle('hello_world_long', 11);
-    expect(result.includes('...')).toBe(true);
-    expect(result.length).toBe(11);
-  });
-});
-
-describe('center', () => {
-  it('centers a string', () => {
-    expect(center('hi', 6)).toBe('  hi  ');
-  });
-
-  it('uses custom char', () => {
-    expect(center('hi', 6, '-')).toBe('--hi--');
-  });
-});
-
-describe('padLeft / padRight', () => {
-  it('pads left with spaces', () => {
-    expect(padLeft('5', 3)).toBe('  5');
-  });
-
-  it('pads right with zeros', () => {
-    expect(padRight('5', 3, '0')).toBe('500');
-  });
-});
-
-describe('removePrefix / removeSuffix', () => {
-  it('removes prefix', () => {
-    expect(removePrefix('https://example.com', 'https://')).toBe('example.com');
-  });
-
-  it('no change if prefix absent', () => {
-    expect(removePrefix('example.com', 'https://')).toBe('example.com');
-  });
-
-  it('removes suffix', () => {
-    expect(removeSuffix('file.ts', '.ts')).toBe('file');
-  });
-
-  it('no change if suffix absent', () => {
-    expect(removeSuffix('file.ts', '.js')).toBe('file.ts');
-  });
-});
-
-describe('indent / dedent', () => {
-  it('indents each line', () => {
-    expect(indent('a\nb', 2)).toBe('  a\n  b');
-  });
-
-  it('dedent removes common indent', () => {
-    expect(dedent('  a\n  b')).toBe('a\nb');
-  });
-});
-
-describe('count / reverse', () => {
-  it('counts substring occurrences', () => {
-    expect(count('abcabc', 'a')).toBe(2);
-  });
-
-  it('returns 0 when not found', () => {
-    expect(count('hello', 'z')).toBe(0);
-  });
-
-  it('reverses a string', () => {
-    expect(reverse('hello')).toBe('olleh');
-  });
-});
-
-describe('levenshtein / similarity', () => {
-  it('levenshtein of identical strings is 0', () => {
-    expect(levenshtein('hello', 'hello')).toBe(0);
-  });
-
-  it('levenshtein of empty to non-empty is length', () => {
-    expect(levenshtein('', 'abc')).toBe(3);
-  });
-
-  it('levenshtein of substitution', () => {
-    expect(levenshtein('cat', 'cut')).toBe(1);
-  });
-
-  it('similarity of identical strings is 1', () => {
-    expect(similarity('hello', 'hello')).toBe(1);
-  });
-
-  it('similarity of empty strings is 1', () => {
-    expect(similarity('', '')).toBe(1);
-  });
-
-  it('similarity of completely different strings is less than 0.5', () => {
-    expect(similarity('abc', 'xyz')).toBeLessThan(0.5);
-  });
-});
-
-describe('uuid', () => {
-  it('matches UUID v4 format', () => {
-    expect(uuid()).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/);
-  });
-
-  it('generates unique values', () => {
-    expect(uuid()).not.toBe(uuid());
-  });
-});
-
-describe('randomString', () => {
-  it('generates string of requested length', () => {
-    expect(randomString(10)).toHaveLength(10);
-  });
-
-  it('uses custom charset', () => {
-    const result = randomString(20, '01');
-    expect(/^[01]+$/.test(result)).toBe(true);
-  });
-});
-
-// ═══════════════════════════════════════════════
-// Time — measure
-// ═══════════════════════════════════════════════
-describe('measure', () => {
-  it('returns result and duration', async () => {
-    const { result, duration } = await measure(() => 42);
-    expect(result).toBe(42);
-    expect(duration).toBeGreaterThanOrEqual(0);
-  });
-
-  it('works with async functions', async () => {
-    const { result, duration } = await measure(async () => 'done');
-    expect(result).toBe('done');
-    expect(typeof duration).toBe('number');
-  });
-});
-
-// ═══════════════════════════════════════════════
-// Time — retry
-// ═══════════════════════════════════════════════
-describe('retry', () => {
-  it('returns immediately on first success', async () => {
-    let calls = 0;
-    const result = await retry(
-      async () => {
-        calls++;
-        return 42;
-      },
-      { maxAttempts: 3, initialDelay: 0 }
-    );
-    expect(result).toBe(42);
-    expect(calls).toBe(1);
-  });
-
-  it('retries on failure and eventually succeeds', async () => {
-    let calls = 0;
-    const result = await retry(
-      async () => {
-        calls++;
-        if (calls < 3) throw new Error('fail');
-        return 'ok';
-      },
-      { maxAttempts: 5, initialDelay: 0 }
-    );
-    expect(result).toBe('ok');
-    expect(calls).toBe(3);
-  });
-
-  it('throws after maxAttempts exhausted', async () => {
-    await expect(
-      retry(
-        async () => {
-          throw new Error('always fail');
-        },
-        { maxAttempts: 2, initialDelay: 0 }
-      )
-    ).rejects.toThrow('always fail');
-  });
-
-  it('calls onRetry callback', async () => {
-    const onRetry = vi.fn();
-    await retry(
-      async () => {
-        if (onRetry.mock.calls.length === 0) throw new Error('fail');
-        return 'ok';
-      },
-      { maxAttempts: 3, initialDelay: 0, onRetry }
-    ).catch(() => {});
-    // onRetry may or may not have been called depending on timing; just verify it's a function
-    expect(typeof onRetry).toBe('function');
-  });
-});
-
-// ═══════════════════════════════════════════════
-// Time — debounce
-// ═══════════════════════════════════════════════
-describe('debounce', () => {
-  it('does not call immediately', () => {
-    vi.useFakeTimers();
-    const fn = vi.fn();
-    const debouncedFn = debounce(fn, 100);
-    debouncedFn();
-    expect(fn).not.toHaveBeenCalled();
-    vi.useRealTimers();
-  });
-
-  it('calls after delay', () => {
-    vi.useFakeTimers();
-    const fn = vi.fn();
-    const debouncedFn = debounce(fn, 100);
-    debouncedFn();
-    vi.advanceTimersByTime(100);
-    expect(fn).toHaveBeenCalledOnce();
-    vi.useRealTimers();
-  });
-
-  it('resets timer on repeated calls', () => {
-    vi.useFakeTimers();
-    const fn = vi.fn();
-    const debouncedFn = debounce(fn, 100);
-    debouncedFn();
-    vi.advanceTimersByTime(50);
-    debouncedFn();
-    vi.advanceTimersByTime(50);
-    expect(fn).not.toHaveBeenCalled();
-    vi.advanceTimersByTime(50);
-    expect(fn).toHaveBeenCalledOnce();
-    vi.useRealTimers();
-  });
-});
-
-// ═══════════════════════════════════════════════
-// Time — throttle
-// ═══════════════════════════════════════════════
-describe('throttle', () => {
-  it('calls function on first invocation', () => {
-    vi.useFakeTimers();
-    const fn = vi.fn();
-    const throttledFn = throttle(fn, 100);
-    throttledFn();
-    expect(fn).toHaveBeenCalledOnce();
-    vi.useRealTimers();
-  });
-
-  it('blocks subsequent calls within window', () => {
-    vi.useFakeTimers();
-    const fn = vi.fn();
-    const throttledFn = throttle(fn, 100);
-    throttledFn();
-    throttledFn();
-    throttledFn();
-    expect(fn).toHaveBeenCalledTimes(1);
-    vi.useRealTimers();
-  });
-
-  it('allows call after window expires', () => {
-    vi.useFakeTimers();
-    const fn = vi.fn();
-    const throttledFn = throttle(fn, 100);
-    throttledFn();
-    vi.advanceTimersByTime(150);
-    throttledFn();
-    expect(fn.mock.calls.length).toBeGreaterThanOrEqual(2);
-    vi.useRealTimers();
-  });
-});
-
-// ═══════════════════════════════════════════════
-// Time — Stopwatch
-// ═══════════════════════════════════════════════
-describe('Stopwatch', () => {
-  it('starts not running', () => {
-    const sw = new Stopwatch();
-    expect(sw.isRunning).toBe(false);
-  });
-
-  it('elapsed is 0 before start', () => {
-    const sw = new Stopwatch();
-    expect(sw.elapsed).toBe(0);
-  });
-
-  it('starts and becomes running', () => {
-    const sw = new Stopwatch();
-    sw.start();
-    expect(sw.isRunning).toBe(true);
-    sw.stop();
-  });
-
-  it('elapsed is positive after start', async () => {
-    const sw = new Stopwatch();
-    sw.start();
-    await new Promise((r) => setTimeout(r, 10));
-    expect(sw.elapsed).toBeGreaterThan(0);
-    sw.stop();
-  });
-
-  it('stop pauses elapsed time', async () => {
-    const sw = new Stopwatch();
-    sw.start();
-    await new Promise((r) => setTimeout(r, 10));
-    sw.stop();
-    const elapsed = sw.elapsed;
-    await new Promise((r) => setTimeout(r, 10));
-    expect(sw.elapsed).toBeCloseTo(elapsed, 0);
-  });
-
-  it('reset clears elapsed and running state', () => {
-    const sw = new Stopwatch();
-    sw.start();
-    sw.reset();
-    expect(sw.elapsed).toBe(0);
-    expect(sw.isRunning).toBe(false);
-  });
-
-  it('restart resets and starts again', async () => {
-    const sw = new Stopwatch();
-    sw.start();
-    await new Promise((r) => setTimeout(r, 20));
-    sw.restart();
-    expect(sw.isRunning).toBe(true);
-    expect(sw.elapsed).toBeLessThan(15);
-    sw.stop();
-  });
-
-  it('lap returns elapsed time and restarts', async () => {
-    const sw = new Stopwatch();
-    sw.start();
-    await new Promise((r) => setTimeout(r, 10));
-    const lapTime = sw.lap();
-    expect(typeof lapTime).toBe('number');
-    expect(lapTime).toBeGreaterThan(0);
-    // After lap(), stopwatch restarted — elapsed should be less than before
-    expect(sw.elapsed).toBeLessThan(lapTime);
-    sw.stop();
-  });
-});
-
-// ═══════════════════════════════════════════════
-// Time — CountdownTimer
-// ═══════════════════════════════════════════════
-describe('CountdownTimer', () => {
-  it('starts not running', () => {
-    const ct = new CountdownTimer(1000);
-    expect(ct.isRunning).toBe(false);
-  });
-
-  it('remaining equals duration before start', () => {
-    const ct = new CountdownTimer(5000);
-    expect(ct.remaining).toBe(5000);
-  });
-
-  it('isComplete is false before start', () => {
-    const ct = new CountdownTimer(1000);
-    expect(ct.isComplete).toBe(false);
-  });
-
-  it('starts and becomes running', () => {
-    const ct = new CountdownTimer(1000);
-    ct.start();
-    expect(ct.isRunning).toBe(true);
-    ct.stop();
-  });
-
-  it('pause stops running', () => {
-    const ct = new CountdownTimer(1000);
-    ct.start();
-    ct.pause();
-    expect(ct.isRunning).toBe(false);
-    ct.stop();
-  });
-
-  it('reset restores remaining', () => {
-    const ct = new CountdownTimer(1000);
-    ct.start();
-    ct.reset(2000);
-    expect(ct.remaining).toBe(2000);
-  });
-
-  it('fires onComplete callback', async () => {
-    const onComplete = vi.fn();
-    const ct = new CountdownTimer(50, { onComplete });
-    ct.start();
-    await new Promise((r) => setTimeout(r, 100));
-    expect(onComplete).toHaveBeenCalledOnce();
-  });
-});
-
-// ═══════════════════════════════════════════════
-// Time — IntervalTimer
-// ═══════════════════════════════════════════════
-describe('IntervalTimer', () => {
-  it('starts not running', () => {
-    const it = new IntervalTimer(() => {}, 1000);
-    expect(it.running).toBe(false);
-  });
-
-  it('start makes it running', () => {
-    const timer = new IntervalTimer(() => {}, 1000);
-    timer.start();
-    expect(timer.running).toBe(true);
-    timer.stop();
-  });
-
-  it('stop clears running', () => {
-    const timer = new IntervalTimer(() => {}, 1000);
-    timer.start();
-    timer.stop();
-    expect(timer.running).toBe(false);
-  });
-
-  it('fires callback at interval', async () => {
-    const fn = vi.fn();
-    const timer = new IntervalTimer(fn, 10);
-    timer.start();
-    await new Promise((r) => setTimeout(r, 80));
-    timer.stop();
-    expect(fn.mock.calls.length).toBeGreaterThanOrEqual(2);
-  });
-
-  it('pause stops the interval without clearing isPaused', () => {
-    const timer = new IntervalTimer(() => {}, 1000);
-    timer.start();
-    timer.pause();
-    expect(timer.running).toBe(false);
-    expect(timer.paused).toBe(true);
-    timer.stop();
-  });
-});
-
-// ═══════════════════════════════════════════════
-// Time — schedule
-// ═══════════════════════════════════════════════
-describe('schedule', () => {
-  it('fires callback after delay', async () => {
-    const fn = vi.fn();
-    schedule(fn, 20);
-    await new Promise((r) => setTimeout(r, 30));
-    expect(fn).toHaveBeenCalledOnce();
-  });
-
-  it('cancel function prevents callback', async () => {
-    const fn = vi.fn();
-    const cancel = schedule(fn, 50);
-    cancel();
-    await new Promise((r) => setTimeout(r, 60));
-    expect(fn).not.toHaveBeenCalled();
-  });
-});
-
-// ═══════════════════════════════════════════════
-// Time — DateTime
-// ═══════════════════════════════════════════════
-describe('DateTime', () => {
-  it('toISO returns ISO string', () => {
-    const iso = DateTime.toISO(new Date(2024, 0, 15));
-    expect(iso).toMatch(/^2024/);
-    expect(iso).toContain('T');
-  });
-
-  it('format with YYYY pattern', () => {
-    const result = DateTime.format(new Date(2024, 5, 15), 'YYYY-MM-DD');
-    expect(result).toBe('2024-06-15');
-  });
-
-  it('diff in milliseconds (d1 - d2)', () => {
-    // diff returns d1.getTime() - d2.getTime()
-    const d1 = new Date(2024, 0, 2);
-    const d2 = new Date(2024, 0, 1);
-    expect(DateTime.diff(d1, d2, 'ms')).toBe(86400000);
-  });
-
-  it('isToday returns true for today', () => {
-    expect(DateTime.isToday(new Date())).toBe(true);
-  });
-
-  it('isToday returns false for other day', () => {
-    expect(DateTime.isToday(new Date(2000, 0, 1))).toBe(false);
-  });
-
-  it('startOfDay returns midnight', () => {
-    const start = DateTime.startOfDay(new Date(2024, 5, 15, 12, 30));
-    expect(start.getHours()).toBe(0);
-    expect(start.getMinutes()).toBe(0);
-    expect(start.getSeconds()).toBe(0);
-  });
-});
-
-// ═══════════════════════════════════════════════
-// Collections — HoloMap
-// ═══════════════════════════════════════════════
-describe('HoloMap', () => {
-  it('creates empty map', () => {
-    const m = HoloMap.of<string, number>();
-    expect(m.size).toBe(0);
-    expect(m.isEmpty).toBe(true);
-  });
-
-  it('set and get', () => {
-    const m = HoloMap.of<string, number>().set('a', 1);
-    expect(m.get('a')).toBe(1);
-  });
-
-  it('set returns new map (immutable)', () => {
-    const m1 = HoloMap.of<string, number>();
-    const m2 = m1.set('x', 10);
-    expect(m1.has('x')).toBe(false);
-    expect(m2.has('x')).toBe(true);
-  });
-
-  it('delete removes entry', () => {
-    const m = HoloMap.of<string, number>().set('a', 1).delete('a');
-    expect(m.has('a')).toBe(false);
-  });
-
-  it('has returns true for existing key', () => {
-    const m = HoloMap.of<string, number>().set('z', 99);
-    expect(m.has('z')).toBe(true);
-    expect(m.has('w')).toBe(false);
-  });
-
-  it('getOrDefault returns default for missing key', () => {
-    const m = HoloMap.of<string, number>();
-    expect(m.getOrDefault('missing', 42)).toBe(42);
-  });
-
-  it('from creates from entries', () => {
-    const m = HoloMap.from([
-      ['a', 1],
-      ['b', 2],
-    ]);
-    expect(m.size).toBe(2);
-    expect(m.get('b')).toBe(2);
-  });
-
-  it('merge combines two maps', () => {
-    const m1 = HoloMap.from([['a', 1]]);
-    const m2 = HoloMap.from([['b', 2]]);
-    const merged = m1.merge(m2);
-    expect(merged.size).toBe(2);
-    expect(merged.get('a')).toBe(1);
-    expect(merged.get('b')).toBe(2);
-  });
-
-  it('map transforms values', () => {
-    const m = HoloMap.from([
-      ['a', 1],
-      ['b', 2],
-    ]).map((v) => v * 10);
-    expect(m.get('a')).toBe(10);
-    expect(m.get('b')).toBe(20);
-  });
-
-  it('filter keeps matching entries', () => {
-    const m = HoloMap.from([
-      ['a', 1],
-      ['b', 2],
-      ['c', 3],
-    ]).filter((v) => v > 1);
-    expect(m.size).toBe(2);
-    expect(m.has('a')).toBe(false);
-  });
-
-  it('keys, values, entries iteration', () => {
-    const m = HoloMap.from([
-      ['x', 1],
-      ['y', 2],
-    ]);
-    expect([...m.keys()].sort()).toEqual(['x', 'y']);
-    expect([...m.values()].sort()).toEqual([1, 2]);
-    expect([...m.entries()].length).toBe(2);
-  });
-
-  it('toObject converts to plain object', () => {
-    const m = HoloMap.from([
-      ['a', 1],
-      ['b', 2],
-    ]);
-    const obj = (m as HoloMap<string, number>).toObject();
-    expect(obj).toEqual({ a: 1, b: 2 });
-  });
-});
-
-// ═══════════════════════════════════════════════
-// Collections — HoloSet
-// ═══════════════════════════════════════════════
-describe('HoloSet', () => {
-  it('creates empty set', () => {
-    const s = HoloSet.of<number>();
-    expect(s.size).toBe(0);
-    expect(s.isEmpty).toBe(true);
-  });
-
-  it('add and has', () => {
-    const s = HoloSet.of<number>().add(1);
-    expect(s.has(1)).toBe(true);
-    expect(s.has(2)).toBe(false);
-  });
-
-  it('add is immutable', () => {
-    const s1 = HoloSet.of<number>();
-    const s2 = s1.add(5);
-    expect(s1.has(5)).toBe(false);
-    expect(s2.has(5)).toBe(true);
-  });
-
-  it('delete removes element', () => {
-    const s = HoloSet.of<number>().add(1).delete(1);
-    expect(s.has(1)).toBe(false);
-  });
-
-  it('from creates from array', () => {
-    const s = HoloSet.from([1, 2, 3]);
-    expect(s.size).toBe(3);
-  });
-
-  it('union combines elements', () => {
-    const a = HoloSet.from([1, 2]);
-    const b = HoloSet.from([2, 3]);
-    const u = a.union(b);
-    expect(u.size).toBe(3);
-    expect(u.has(1)).toBe(true);
-    expect(u.has(3)).toBe(true);
-  });
-
-  it('intersection keeps common elements', () => {
-    const a = HoloSet.from([1, 2, 3]);
-    const b = HoloSet.from([2, 3, 4]);
-    const inter = a.intersection(b);
-    expect(inter.size).toBe(2);
-    expect(inter.has(1)).toBe(false);
-    expect(inter.has(2)).toBe(true);
-  });
-
-  it('difference keeps elements not in other', () => {
-    const a = HoloSet.from([1, 2, 3]);
-    const b = HoloSet.from([2]);
-    const diff = a.difference(b);
-    expect(diff.size).toBe(2);
-    expect(diff.has(2)).toBe(false);
-  });
-
-  it('isSubsetOf / isSupersetOf', () => {
-    const small = HoloSet.from([1, 2]);
-    const big = HoloSet.from([1, 2, 3]);
-    expect(small.isSubsetOf(big)).toBe(true);
-    expect(big.isSupersetOf(small)).toBe(true);
-  });
-
-  it('toArray converts to array', () => {
-    const s = HoloSet.from([10, 20, 30]);
-    expect(s.toArray().sort((a, b) => a - b)).toEqual([10, 20, 30]);
-  });
-});
-
-// ═══════════════════════════════════════════════
-// Collections — PriorityQueue
-// ═══════════════════════════════════════════════
-describe('PriorityQueue', () => {
-  it('creates empty queue', () => {
-    const pq = new PriorityQueue<number>();
-    expect(pq.size).toBe(0);
-    expect(pq.isEmpty).toBe(true);
-  });
-
-  it('enqueue and size', () => {
-    const pq = new PriorityQueue<number>();
-    pq.enqueue(5, 1);
-    pq.enqueue(3, 0);
-    expect(pq.size).toBe(2);
-  });
-
-  it('dequeue returns item with highest priority (min-heap)', () => {
-    const pq = PriorityQueue.minHeap<string>();
-    pq.enqueue('low', 10);
-    pq.enqueue('high', 1);
-    pq.enqueue('mid', 5);
-    expect(pq.dequeue()).toBe('high');
-    expect(pq.dequeue()).toBe('mid');
-    expect(pq.dequeue()).toBe('low');
-  });
-
-  it('maxHeap dequeues highest priority first', () => {
-    const pq = PriorityQueue.maxHeap<string>();
-    pq.enqueue('low', 1);
-    pq.enqueue('high', 10);
-    expect(pq.dequeue()).toBe('high');
-    expect(pq.dequeue()).toBe('low');
-  });
-
-  it('peek does not remove item', () => {
-    const pq = PriorityQueue.minHeap<number>();
-    pq.enqueue(42, 1);
-    expect(pq.peek()).toBe(42);
-    expect(pq.size).toBe(1);
-  });
-
-  it('dequeue on empty returns undefined', () => {
-    const pq = new PriorityQueue<number>();
-    expect(pq.dequeue()).toBeUndefined();
-  });
-
-  it('clear empties the queue', () => {
-    const pq = PriorityQueue.minHeap<number>();
-    pq.enqueue(1, 1);
-    pq.enqueue(2, 2);
-    pq.clear();
-    expect(pq.size).toBe(0);
-    expect(pq.isEmpty).toBe(true);
-  });
-});
-
-// ═══════════════════════════════════════════════
-// Collections — List (extended)
-// ═══════════════════════════════════════════════
-describe('List (extended)', () => {
-  it('range creates sequential list (exclusive end)', () => {
-    const l = List.range(1, 6);
-    expect(l.toArray()).toEqual([1, 2, 3, 4, 5]);
-  });
-
-  it('groupBy groups elements', () => {
-    const l = List.of(1, 2, 3, 4);
-    const grouped = l.groupBy((n) => (n % 2 === 0 ? 'even' : 'odd'));
-    expect(grouped.get('even')?.toArray().sort()).toEqual([2, 4]);
-    expect(grouped.get('odd')?.toArray().sort()).toEqual([1, 3]);
-  });
-
-  it('partition splits by predicate', () => {
-    const l = List.of(1, 2, 3, 4, 5);
-    const [evens, odds] = l.partition((n) => n % 2 === 0);
-    expect(evens.toArray()).toEqual([2, 4]);
-    expect(odds.toArray()).toEqual([1, 3, 5]);
-  });
-
-  it('zip pairs two lists', () => {
-    const a = List.of(1, 2, 3);
-    const b = List.of('a', 'b', 'c');
-    const zipped = a.zip(b);
-    expect(zipped.toArray()).toEqual([
-      [1, 'a'],
-      [2, 'b'],
-      [3, 'c'],
-    ]);
-  });
-
-  it('unique removes duplicates', () => {
-    const l = List.of(1, 2, 1, 3, 2);
-    expect(l.unique().toArray().sort()).toEqual([1, 2, 3]);
-  });
-
-  it('takeLast returns last N elements', () => {
-    const l = List.of(1, 2, 3, 4, 5);
-    expect(l.takeLast(3).toArray()).toEqual([3, 4, 5]);
-  });
-
-  it('dropLast removes last N elements', () => {
-    const l = List.of(1, 2, 3, 4, 5);
-    expect(l.dropLast(2).toArray()).toEqual([1, 2, 3]);
-  });
-
-  it('average of numeric list', () => {
-    const l = List.of(2, 4, 6);
-    expect((l as List<number>).average()).toBe(4);
-  });
-
-  it('none returns true when predicate never satisfied', () => {
-    const l = List.of(1, 2, 3);
-    expect(l.none((n) => n > 10)).toBe(true);
-    expect(l.none((n) => n > 1)).toBe(false);
-  });
-});