@astrale-os/cli 1.0.0-beta.32 → 1.0.0-beta.43

package/src/lib/__tests__/admin-target.test.ts

@@ -1,184 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import type { InstanceStore } from '../instance'
-
-import {
-  DEFAULT_ADMIN_TARGET_NAME,
-  DEFAULT_ADMIN_DOMAIN_ISSUER,
-  DEFAULT_ADMIN_TARGET_URL,
-  defaultAdminTargetForChannel,
-  resolveAdminTargetFromStore,
-} from '../admin-target'
-import { DEFAULT_CONFIG, type AstraleConfig } from '../config'
-
-const instances: InstanceStore = {
-  active: 'primary',
-  instances: {
-    primary: {
-      url: 'https://primary.example.com',
-      issuer: 'https://primary-issuer.example.com',
-    },
-    admin: {
-      url: 'https://bookmarked-admin.example.com',
-      issuer: 'https://bookmarked-issuer.example.com',
-      domainIssuer: 'https://bookmarked-domain.example.com',
-      defaultIdentity: 'admin-workos',
-    },
-    alias: {
-      url: 'https://alias-admin.example.com',
-      domainIssuer: 'https://alias-domain.example.com',
-      name: 'named-admin',
-    },
-  },
-}
-
-describe('resolveAdminTargetFromStore', () => {
-  test('derives hosted Admin defaults from the release channel', () => {
-    expect(defaultAdminTargetForChannel('beta')).toEqual({
-      url: 'https://admin.eu.beta.astrale.ai/api',
-      domainIssuer: 'https://admin.beta.astrale.ai',
-    })
-    expect(defaultAdminTargetForChannel('stable')).toEqual({
-      url: 'https://admin.eu.astrale.ai/api',
-      domainIssuer: 'https://admin.astrale.ai',
-    })
-  })
-
-  test('uses hosted admin default without active instance coupling', () => {
-    expect(resolveAdminTargetFromStore({}, DEFAULT_CONFIG, instances)).toEqual({
-      name: DEFAULT_ADMIN_TARGET_NAME,
-      registrationSlug: DEFAULT_ADMIN_TARGET_NAME,
-      url: DEFAULT_ADMIN_TARGET_URL,
-      kernelIssuer: DEFAULT_ADMIN_TARGET_URL,
-      domainIssuer: DEFAULT_ADMIN_DOMAIN_ISSUER,
-      source: 'default',
-      configured: false,
-    })
-  })
-
-  test('uses configured admin bookmark', () => {
-    const config: AstraleConfig = {
-      ...DEFAULT_CONFIG,
-      admin: { instance: 'admin' },
-    }
-
-    expect(resolveAdminTargetFromStore({}, config, instances)).toEqual({
-      name: 'admin',
-      registrationSlug: 'admin',
-      url: 'https://bookmarked-admin.example.com',
-      kernelIssuer: 'https://bookmarked-issuer.example.com',
-      domainIssuer: 'https://bookmarked-domain.example.com',
-      defaultIdentity: 'admin-workos',
-      source: 'config-instance',
-      configured: true,
-    })
-  })
-
-  test('keeps an exact beta Domain issuer separate from the Admin Kernel target', () => {
-    const config: AstraleConfig = {
-      ...DEFAULT_CONFIG,
-      admin: {
-        url: 'https://admin.eu.beta.astrale.ai/api',
-        kernelIssuer: 'https://admin.eu.beta.astrale.ai/api',
-        domainIssuer: 'https://admin.beta.astrale.ai',
-      },
-    }
-
-    expect(resolveAdminTargetFromStore({}, config, instances)).toMatchObject({
-      url: 'https://admin.eu.beta.astrale.ai/api',
-      kernelIssuer: 'https://admin.eu.beta.astrale.ai/api',
-      domainIssuer: 'https://admin.beta.astrale.ai',
-      source: 'config-url',
-      configured: true,
-    })
-
-    expect(
-      resolveAdminTargetFromStore(
-        { adminUrl: 'https://override.eu.beta.astrale.ai/api' },
-        config,
-        instances,
-      ),
-    ).toMatchObject({
-      url: 'https://override.eu.beta.astrale.ai/api',
-      domainIssuer: 'https://admin.beta.astrale.ai',
-    })
-  })
-
-  test('allows explicit admin bookmark and admin url overrides', () => {
-    expect(
-      resolveAdminTargetFromStore({ admin: 'alias' }, DEFAULT_CONFIG, instances),
-    ).toMatchObject({
-      name: 'alias',
-      url: 'https://alias-admin.example.com',
-      kernelIssuer: 'https://alias-admin.example.com',
-      domainIssuer: 'https://alias-domain.example.com',
-      source: 'admin',
-    })
-
-    expect(
-      resolveAdminTargetFromStore(
-        {
-          adminUrl: 'https://override-admin.example.com',
-          domainIssuer: 'https://override-domain.example.com',
-        },
-        DEFAULT_CONFIG,
-        instances,
-      ),
-    ).toMatchObject({
-      name: 'admin',
-      url: 'https://override-admin.example.com',
-      kernelIssuer: 'https://override-admin.example.com',
-      domainIssuer: 'https://override-domain.example.com',
-      source: 'admin-url',
-    })
-  })
-
-  test('accepts -i and --url as admin target overrides', () => {
-    expect(
-      resolveAdminTargetFromStore({ instance: 'admin' }, DEFAULT_CONFIG, instances),
-    ).toMatchObject({
-      name: 'admin',
-      url: 'https://bookmarked-admin.example.com',
-      source: 'admin',
-    })
-
-    expect(
-      resolveAdminTargetFromStore(
-        {
-          url: 'https://override.example.com',
-          domainIssuer: 'https://override-domain.example.com',
-        },
-        DEFAULT_CONFIG,
-        instances,
-      ),
-    ).toMatchObject({
-      name: 'admin',
-      url: 'https://override.example.com',
-      domainIssuer: 'https://override-domain.example.com',
-      source: 'admin-url',
-    })
-  })
-
-  test('rejects conflicting admin target overrides', () => {
-    expect(() =>
-      resolveAdminTargetFromStore(
-        { admin: 'admin', adminUrl: 'https://override-admin.example.com' },
-        DEFAULT_CONFIG,
-        instances,
-      ),
-    ).toThrow('Choose one admin target override')
-  })
-
-  test('retains configured Domain evidence instead of inferring it from the Kernel issuer', () => {
-    expect(
-      resolveAdminTargetFromStore(
-        { adminUrl: 'https://override-admin.example.com' },
-        DEFAULT_CONFIG,
-        instances,
-      ),
-    ).toMatchObject({
-      kernelIssuer: 'https://override-admin.example.com',
-      domainIssuer: DEFAULT_ADMIN_DOMAIN_ISSUER,
-    })
-  })
-})

package/src/lib/__tests__/binary.test.ts

@@ -1,70 +0,0 @@
-import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
-import { readFile, unlink } from 'node:fs/promises'
-
-import { presentBinary, type BinaryLike } from '../binary'
-
-const png = (): BinaryLike => ({
-  mediaType: 'image/png',
-  body: new Uint8Array([1, 2, 3, 4]),
-})
-
-describe('presentBinary', () => {
-  let chunks: Buffer[] = []
-  let originalWrite: typeof process.stdout.write
-
-  beforeEach(() => {
-    chunks = []
-    originalWrite = process.stdout.write.bind(process.stdout)
-    process.stdout.write = mock((chunk: string | Uint8Array) => {
-      chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : Buffer.from(chunk))
-      return true
-    }) as typeof process.stdout.write
-  })
-
-  afterEach(() => {
-    process.stdout.write = originalWrite
-  })
-
-  test('--raw writes the raw bytes to stdout', async () => {
-    await presentBinary(png(), { raw: true })
-    expect(Array.from(Buffer.concat(chunks))).toEqual([1, 2, 3, 4])
-  })
-
-  test('--json writes a base64-wrapped JSON envelope', async () => {
-    await presentBinary(png(), { json: true })
-    const obj = JSON.parse(Buffer.concat(chunks).toString())
-    expect(obj.contentType).toBe('image/png')
-    expect([...Buffer.from(obj.bodyBase64, 'base64')]).toEqual([1, 2, 3, 4])
-  })
-
-  test('--json inlines text for text-like content types', async () => {
-    await presentBinary(
-      { mediaType: 'text/plain', status: 202, body: new TextEncoder().encode('hi') },
-      { json: true },
-    )
-    const obj = JSON.parse(Buffer.concat(chunks).toString())
-    expect(obj.body).toBe('hi')
-    expect(obj.status).toBe(202)
-  })
-
-  test('--raw drains streaming binary chunks in exact order', async () => {
-    await presentBinary(
-      {
-        mediaType: 'application/octet-stream',
-        body: (async function* () {
-          yield new Uint8Array([1, 2])
-          yield new Uint8Array([3, 4])
-        })(),
-      },
-      { raw: true },
-    )
-    expect(Array.from(Buffer.concat(chunks))).toEqual([1, 2, 3, 4])
-  })
-
-  test('-o writes raw bytes to a file', async () => {
-    const tmp = `${process.env.TMPDIR ?? '/tmp'}/astrale-bin-test-${process.pid}.bin`
-    await presentBinary(png(), {}, { outFile: tmp })
-    expect([...(await readFile(tmp))]).toEqual([1, 2, 3, 4])
-    await unlink(tmp)
-  })
-})

package/src/lib/__tests__/browser-retention.test.ts

@@ -1,212 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
-import {
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  rmSync,
-  symlinkSync,
-  utimesSync,
-  writeFileSync,
-} from 'node:fs'
-import { hostname, tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import type { BrowserRetentionBudget } from '../browser-retention'
-
-import {
-  DEFAULT_MAX_CACHE_BYTES,
-  DEFAULT_MAX_PROFILE_AGE_DAYS,
-  browserRetentionBudget,
-  heldByLiveBrowser,
-  profileCacheBytes,
-  sweepBrowserProfiles,
-} from '../browser-retention'
-
-const DAY = 24 * 60 * 60 * 1000
-const BUDGET: BrowserRetentionBudget = { maxCacheBytes: 10_000, maxProfileAgeMs: 30 * DAY }
-
-let dir: string
-
-beforeEach(() => {
-  dir = mkdtempSync(join(tmpdir(), 'astrale-browser-ret-'))
-  delete process.env.ASTRALE_BROWSER_MAX_CACHE_BYTES
-  delete process.env.ASTRALE_BROWSER_MAX_PROFILE_AGE_DAYS
-})
-
-afterEach(() => {
-  rmSync(dir, { recursive: true, force: true })
-})
-
-type Seed = { idleMs?: number; cacheBytes?: number; lockPid?: number }
-
-/** A profile shaped like Chromium's: session state at the root and in Default/,
- *  cache in the subdirectories retention is allowed to delete. */
-function seedProfile(name: string, { idleMs = 0, cacheBytes = 0, lockPid }: Seed): string {
-  const profile = join(dir, name)
-  mkdirSync(join(profile, 'Default'), { recursive: true })
-  writeFileSync(join(profile, 'Local State'), '{"os_crypt":{"encrypted_key":"x"}}')
-  writeFileSync(join(profile, 'Default', 'Cookies'), 'SQLite format 3\0cookie-data')
-  writeFileSync(join(profile, 'Default', 'Preferences'), '{"profile":{}}')
-  mkdirSync(join(profile, 'Default', 'Local Storage', 'leveldb'), { recursive: true })
-  writeFileSync(join(profile, 'Default', 'Local Storage', 'leveldb', '000003.log'), 'state')
-
-  if (cacheBytes > 0) {
-    mkdirSync(join(profile, 'Default', 'Cache', 'Cache_Data'), { recursive: true })
-    writeFileSync(
-      join(profile, 'Default', 'Cache', 'Cache_Data', 'f_000001'),
-      'x'.repeat(cacheBytes),
-    )
-    mkdirSync(join(profile, 'Default', 'Code Cache', 'js'), { recursive: true })
-    writeFileSync(join(profile, 'Default', 'Code Cache', 'js', 'index'), 'y'.repeat(cacheBytes))
-  }
-  if (lockPid !== undefined) {
-    symlinkSync(`${hostname()}-${lockPid}`, join(profile, 'SingletonLock'))
-  }
-  const when = new Date(Date.now() - idleMs)
-  utimesSync(profile, when, when)
-  return profile
-}
-
-const sessionIntact = (name: string): boolean =>
-  existsSync(join(dir, name, 'Default', 'Cookies')) &&
-  existsSync(join(dir, name, 'Local State')) &&
-  existsSync(join(dir, name, 'Default', 'Preferences')) &&
-  existsSync(join(dir, name, 'Default', 'Local Storage', 'leveldb', '000003.log'))
-
-const cacheGone = (name: string): boolean =>
-  !existsSync(join(dir, name, 'Default', 'Cache')) &&
-  !existsSync(join(dir, name, 'Default', 'Code Cache'))
-
-describe('age rule', () => {
-  test('a dormant profile is removed outright', async () => {
-    seedProfile('dormant', { idleMs: 40 * DAY, cacheBytes: 100 })
-    const r = await sweepBrowserProfiles({ dir, budget: BUDGET })
-    expect(r.removed).toEqual(['dormant'])
-    expect(existsSync(join(dir, 'dormant'))).toBe(false)
-    expect(r.bytesFreed).toBeGreaterThan(0)
-  })
-
-  test('a recently used profile is kept', async () => {
-    seedProfile('fresh', { idleMs: 2 * DAY, cacheBytes: 100 })
-    const r = await sweepBrowserProfiles({ dir, budget: BUDGET })
-    expect(r.removed).toEqual([])
-    expect(sessionIntact('fresh')).toBe(true)
-  })
-
-  test('the age bound is configurable', async () => {
-    seedProfile('two-days', { idleMs: 2 * DAY })
-    const strict = { ...BUDGET, maxProfileAgeMs: DAY }
-    expect((await sweepBrowserProfiles({ dir, budget: strict })).removed).toEqual(['two-days'])
-  })
-})
-
-describe('size rule', () => {
-  test('a profile under budget is left completely alone', async () => {
-    seedProfile('small', { idleMs: DAY, cacheBytes: 1_000 })
-    const r = await sweepBrowserProfiles({ dir, budget: BUDGET })
-    expect(r.purged).toEqual([])
-    expect(cacheGone('small')).toBe(false)
-  })
-
-  test('a profile over budget loses its cache but keeps its session', async () => {
-    seedProfile('bloated', { idleMs: DAY, cacheBytes: 20_000 })
-    const r = await sweepBrowserProfiles({ dir, budget: BUDGET })
-    expect(r.purged).toEqual(['bloated'])
-    expect(cacheGone('bloated')).toBe(true)
-    // The entire point: the cookie survives, so the user stays signed in.
-    expect(sessionIntact('bloated')).toBe(true)
-    expect(existsSync(join(dir, 'bloated'))).toBe(true)
-    expect(r.bytesFreed).toBeGreaterThanOrEqual(40_000)
-  })
-
-  test('the size bound counts only cache directories, not the whole profile', async () => {
-    const profile = seedProfile('measured', { idleMs: DAY, cacheBytes: 3_000 })
-    writeFileSync(join(profile, 'Default', 'History'), 'z'.repeat(50_000))
-    // 2 cache files of 3 KB each; History is not cache and must not count.
-    expect(await profileCacheBytes(profile)).toBe(6_000)
-    expect((await sweepBrowserProfiles({ dir, budget: BUDGET })).purged).toEqual([])
-  })
-})
-
-describe('live-browser guard', () => {
-  test('a profile locked by a live process is never touched', async () => {
-    // Our own pid is unambiguously alive.
-    seedProfile('in-use', { idleMs: 40 * DAY, cacheBytes: 20_000, lockPid: process.pid })
-    const r = await sweepBrowserProfiles({ dir, budget: BUDGET })
-    expect(r.skipped).toEqual(['in-use'])
-    expect(r.removed).toEqual([])
-    expect(r.purged).toEqual([])
-    expect(existsSync(join(dir, 'in-use'))).toBe(true)
-    expect(cacheGone('in-use')).toBe(false)
-  })
-
-  test('a stale lock from a dead process does not protect anything', async () => {
-    // Chromium leaves these behind after a crash; they must not pin disk forever.
-    seedProfile('crashed', { idleMs: 40 * DAY, lockPid: 999_999 })
-    const r = await sweepBrowserProfiles({ dir, budget: BUDGET })
-    expect(r.removed).toEqual(['crashed'])
-  })
-
-  test('heldByLiveBrowser reads the symlink without resolving it', () => {
-    // The target names a file that does not exist — statting it would throw.
-    const live = seedProfile('live', { lockPid: process.pid })
-    const dead = seedProfile('dead', { lockPid: 999_999 })
-    const none = seedProfile('none', {})
-    expect(heldByLiveBrowser(live)).toBe(true)
-    expect(heldByLiveBrowser(dead)).toBe(false)
-    expect(heldByLiveBrowser(none)).toBe(false)
-  })
-})
-
-describe('sweep resilience', () => {
-  test('a missing browser directory is a no-op, not an error', async () => {
-    const gone = join(dir, 'does-not-exist')
-    const r = await sweepBrowserProfiles({ dir: gone, budget: BUDGET })
-    expect(r).toEqual({ removed: [], purged: [], skipped: [], bytesFreed: 0 })
-  })
-
-  test('stray files beside the profiles are ignored', async () => {
-    writeFileSync(join(dir, 'browser.json'), '{}')
-    seedProfile('real', { idleMs: 40 * DAY })
-    expect((await sweepBrowserProfiles({ dir, budget: BUDGET })).removed).toEqual(['real'])
-  })
-
-  test('several profiles are handled independently in one pass', async () => {
-    seedProfile('a-dormant', { idleMs: 40 * DAY })
-    seedProfile('b-bloated', { idleMs: DAY, cacheBytes: 20_000 })
-    seedProfile('c-fine', { idleMs: DAY, cacheBytes: 100 })
-    seedProfile('d-locked', { idleMs: 40 * DAY, lockPid: process.pid })
-    const r = await sweepBrowserProfiles({ dir, budget: BUDGET })
-    expect(r.removed).toEqual(['a-dormant'])
-    expect(r.purged).toEqual(['b-bloated'])
-    expect(r.skipped).toEqual(['d-locked'])
-    expect(sessionIntact('c-fine')).toBe(true)
-  })
-})
-
-describe('browserRetentionBudget', () => {
-  test('defaults when nothing is configured', async () => {
-    expect(await browserRetentionBudget()).toEqual({
-      maxCacheBytes: DEFAULT_MAX_CACHE_BYTES,
-      maxProfileAgeMs: DEFAULT_MAX_PROFILE_AGE_DAYS * DAY,
-    })
-  })
-
-  test('env overrides both bounds', async () => {
-    process.env.ASTRALE_BROWSER_MAX_CACHE_BYTES = '4096'
-    process.env.ASTRALE_BROWSER_MAX_PROFILE_AGE_DAYS = '3'
-    expect(await browserRetentionBudget()).toEqual({
-      maxCacheBytes: 4096,
-      maxProfileAgeMs: 3 * DAY,
-    })
-  })
-
-  test.each([
-    ['zero', '0'],
-    ['negative', '-1'],
-    ['not a number', 'lots'],
-  ])('a %s env value falls back to the default rather than removing the cap', async (_l, value) => {
-    process.env.ASTRALE_BROWSER_MAX_CACHE_BYTES = value
-    expect((await browserRetentionBudget()).maxCacheBytes).toBe(DEFAULT_MAX_CACHE_BYTES)
-  })
-})

package/src/lib/__tests__/command-dx.test.ts

@@ -1,102 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { CommanderError } from 'commander'
-
-import { buildProgram } from '../../program/index'
-import { collectCommandCatalog, renderCommanderError } from '../command-dx'
-
-// `renderCommanderError` styles commands with `chalk.bold`, which emits ANSI
-// codes only when chalk detects a color-capable stdout (TTY). Strip them so the
-// assertions are deterministic whether the suite runs under a TTY or in CI.
-// (Built from a char code so the regex source carries no literal control char.)
-const ANSI_RE = new RegExp(String.fromCharCode(27) + '\\[[0-9;]*m', 'g')
-const stripAnsi = (s: string): string => s.replace(ANSI_RE, '')
-
-function dx(
-  program: Awaited<ReturnType<typeof buildProgram>>,
-  error: CommanderError,
-  argv: string[],
-) {
-  const rendered = JSON.parse(stripAnsi(renderCommanderError(program, error, argv, true))) as {
-    error: string
-    message: string
-    detail: string
-  }
-  expect(rendered.error).toBe('USAGE_ERROR')
-  return rendered
-}
-
-describe('command DX suggestions', () => {
-  test('collects command paths from the registered program tree', async () => {
-    const program = await buildProgram()
-    const usages = collectCommandCatalog(program).map((entry) => entry.usage)
-
-    expect(usages).toContain('identity use <name>')
-    expect(usages).toContain('instance use [name]')
-    expect(usages).toContain('admin status')
-    expect(usages).toContain('admin use [bookmark]')
-    expect(usages).toContain('use <name>')
-    expect(usages).toContain('update')
-    expect(usages).toContain('query [sources...]')
-    expect(usages).toContain('get <target>')
-    expect(usages).toContain('introspect <target>')
-    expect(usages).toContain('status')
-    expect(usages).not.toContain('ls <source>')
-    expect(usages).not.toContain('describe <target>')
-  })
-
-  test('explains shared verbs as namespaced commands, not arity errors', async () => {
-    const program = await buildProgram()
-    const error = new CommanderError(
-      1,
-      'commander.excessArguments',
-      'error: too many arguments. Expected 0 arguments but got 2.',
-    )
-    const rendered = dx(program, error, ['delete', 'demo-system'])
-
-    expect(rendered.message).toContain('Unknown command: astrale delete demo-system')
-    expect(rendered.detail).toContain('"delete" is available under:')
-    expect(rendered.detail).toContain('astrale identity delete <name>')
-    expect(rendered.detail).toContain('astrale instance delete <id>')
-    expect(rendered.detail).not.toContain('too many arguments')
-  })
-
-  test('points retired describe at get', async () => {
-    const program = await buildProgram()
-    const error = new CommanderError(
-      1,
-      'commander.unknownCommand',
-      "error: unknown command 'describe'",
-    )
-    const rendered = dx(program, error, ['describe', '@note'])
-
-    expect(rendered.message).toContain('Unknown command: astrale describe @note')
-    expect(rendered.detail).toContain('astrale describe` was removed')
-    expect(rendered.detail).toContain('astrale get <target>')
-    expect(rendered.detail).not.toContain('Did you mean:')
-  })
-
-  test('points retired ls at query', async () => {
-    const program = await buildProgram()
-    const error = new CommanderError(1, 'commander.unknownCommand', "error: unknown command 'ls'")
-    const rendered = dx(program, error, ['ls', '@note'])
-
-    expect(rendered.message).toContain('Unknown command: astrale ls @note')
-    expect(rendered.detail).toContain('astrale ls` was removed')
-    expect(rendered.detail).toContain('astrale query <source> --edge <class>')
-    expect(rendered.detail).not.toContain('Did you mean:')
-  })
-
-  test('suggests nearest command for typo paths', async () => {
-    const program = await buildProgram()
-    const error = new CommanderError(
-      1,
-      'commander.excessArguments',
-      'error: too many arguments. Expected 0 arguments but got 2.',
-    )
-    const rendered = dx(program, error, ['indetityl', 'ist'])
-
-    expect(rendered.message).toContain('Unknown command: astrale indetityl ist')
-    expect(rendered.detail).toContain('Did you mean:')
-    expect(rendered.detail).toContain('astrale identity list')
-  })
-})

package/src/lib/__tests__/concurrency.test.ts

@@ -1,62 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { mapBounded } from '../concurrency'
-
-const tick = (ms: number) => new Promise((r) => setTimeout(r, ms))
-
-describe('mapBounded', () => {
-  test('preserves input order regardless of completion order', async () => {
-    const out = await mapBounded([30, 10, 20, 0], 4, async (ms, i) => {
-      await tick(ms)
-      return i
-    })
-    expect(out).toEqual([0, 1, 2, 3])
-  })
-
-  test('never exceeds the concurrency bound', async () => {
-    let inFlight = 0
-    let peak = 0
-    await mapBounded(
-      Array.from({ length: 12 }, (_, i) => i),
-      3,
-      async () => {
-        inFlight++
-        peak = Math.max(peak, inFlight)
-        await tick(5)
-        inFlight--
-      },
-    )
-    expect(peak).toBeLessThanOrEqual(3)
-  })
-
-  test('processes every item exactly once', async () => {
-    const seen: number[] = []
-    await mapBounded([1, 2, 3, 4, 5], 2, async (n) => {
-      seen.push(n)
-    })
-    expect(seen.sort((a, b) => a - b)).toEqual([1, 2, 3, 4, 5])
-  })
-
-  test('empty input → empty output, fn never called', async () => {
-    let called = false
-    const out = await mapBounded([], 4, async () => {
-      called = true
-    })
-    expect(out).toEqual([])
-    expect(called).toBe(false)
-  })
-
-  test('limit below 1 is clamped (still makes progress)', async () => {
-    const out = await mapBounded([1, 2, 3], 0, async (n) => n * 2)
-    expect(out).toEqual([2, 4, 6])
-  })
-
-  test('a rejection propagates', async () => {
-    await expect(
-      mapBounded([1, 2, 3], 2, async (n) => {
-        if (n === 2) throw new Error('boom')
-        return n
-      }),
-    ).rejects.toThrow('boom')
-  })
-})