@pyreon/vite-plugin 0.24.5 → 0.24.6

package/src/tests/islands-registry.test.ts

@@ -1,236 +0,0 @@
-/**
- * Auto-discovered island-registry tests for @pyreon/vite-plugin.
- *
- * Exercises the `pyreon({ islands: true })` path:
- *   1. Materialize synthetic source files containing `island()` calls
- *   2. Drive plugin.config() + plugin.buildStart() to populate the registry
- *   3. Drive plugin.load('\0pyreon/islands-registry') + assert the emitted
- *      source contains the expected loader entries (and excludes
- *      hydrate: 'never' islands)
- *
- * Companion to `cross-module-signals.test.ts` — same harness shape.
- */
-
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest'
-import pyreonPlugin, { type PyreonPluginOptions } from '../index'
-
-type ConfigHook = (
-  userConfig: Record<string, unknown>,
-  env: { command: string; isSsrBuild?: boolean },
-) => Record<string, unknown>
-
-type BuildStartHook = (this: unknown) => Promise<void>
-type LoadHook = (id: string) => string | undefined
-type ResolveIdHook = (
-  this: unknown,
-  id: string,
-  importer?: string,
-) => Promise<string | null | undefined>
-
-let root: string
-
-beforeAll(() => {
-  root = mkdtempSync(join(tmpdir(), 'pyreon-islands-registry-'))
-})
-afterAll(() => {
-  rmSync(root, { recursive: true, force: true })
-})
-beforeEach(() => {
-  rmSync(root, { recursive: true, force: true })
-  mkdirSync(root, { recursive: true })
-})
-
-function writeFile(rel: string, contents: string): string {
-  const full = join(root, rel)
-  const dir = full.slice(0, full.lastIndexOf('/'))
-  mkdirSync(dir, { recursive: true })
-  writeFileSync(full, contents)
-  return full
-}
-
-function bootstrap(opts?: PyreonPluginOptions) {
-  const plugin = pyreonPlugin(opts)
-  ;(plugin.config as unknown as ConfigHook)({ root }, { command: 'build' })
-  return plugin
-}
-
-async function runBuildStart(plugin: ReturnType<typeof pyreonPlugin>) {
-  const buildStart = plugin.buildStart as BuildStartHook
-  await buildStart.call({})
-}
-
-function runLoad(plugin: ReturnType<typeof pyreonPlugin>, id: string): string {
-  const result = (plugin.load as LoadHook)(id)
-  if (typeof result !== 'string') {
-    throw new Error(`load('${id}') returned ${typeof result}, expected string`)
-  }
-  return result
-}
-
-async function runResolveId(
-  plugin: ReturnType<typeof pyreonPlugin>,
-  id: string,
-): Promise<string | null | undefined> {
-  return (plugin.resolveId as ResolveIdHook).call({}, id)
-}
-
-const ISLANDS_REGISTRY_IMPORT = 'virtual:pyreon/islands-registry'
-const ISLANDS_REGISTRY_ID = '\0pyreon/islands-registry'
-
-describe('vite-plugin — islands virtual module', () => {
-  it('resolveId redirects virtual:pyreon/islands-registry to the \\0-prefixed id', async () => {
-    const plugin = bootstrap()
-    expect(await runResolveId(plugin, ISLANDS_REGISTRY_IMPORT)).toBe(ISLANDS_REGISTRY_ID)
-  })
-
-  it('emits an empty registry when no island() calls exist', async () => {
-    writeFile('src/App.tsx', `export const App = () => null`)
-    const plugin = bootstrap()
-    await runBuildStart(plugin)
-    const source = runLoad(plugin, ISLANDS_REGISTRY_ID)
-    expect(source).toContain('__pyreonIslandsEnabled = true')
-    expect(source).toContain('__pyreonIslandRegistry = {')
-    // No entries beyond the opening and closing braces
-    expect(source).not.toMatch(/import\(.+\)/)
-  })
-
-  it('discovers `island(() => import("./X"), { name, hydrate: "load" })` calls', async () => {
-    writeFile(
-      'src/islands.ts',
-      `import { island } from '@pyreon/server'
-export const Counter = island(() => import('./components/Counter'), {
-  name: 'Counter',
-  hydrate: 'load',
-})`,
-    )
-    const plugin = bootstrap()
-    await runBuildStart(plugin)
-    const source = runLoad(plugin, ISLANDS_REGISTRY_ID)
-    expect(source).toContain('"Counter":')
-    // Loader path was resolved relative to the file where the call lives
-    expect(source).toContain(`/components/Counter`)
-  })
-
-  it('omits hydrate: "never" islands from the registry', async () => {
-    writeFile(
-      'src/islands.ts',
-      `import { island } from '@pyreon/server'
-export const Counter = island(() => import('./Counter'), { name: 'Counter', hydrate: 'load' })
-export const StaticBadge = island(() => import('./StaticBadge'), { name: 'StaticBadge', hydrate: 'never' })`,
-    )
-    const plugin = bootstrap()
-    await runBuildStart(plugin)
-    const source = runLoad(plugin, ISLANDS_REGISTRY_ID)
-    expect(source).toContain('"Counter":')
-    expect(source).not.toContain('"StaticBadge":')
-    expect(source).not.toContain('StaticBadge')
-  })
-
-  it('handles `media(...)` and `interaction` strategy strings without omitting them', async () => {
-    writeFile(
-      'src/islands.ts',
-      `import { island } from '@pyreon/server'
-export const Mobile = island(() => import('./Mobile'), { name: 'Mobile', hydrate: 'media((max-width: 768px))' })
-export const Idle = island(() => import('./Idle'), { name: 'Idle', hydrate: 'idle' })
-export const Visible = island(() => import('./Visible'), { name: 'Visible', hydrate: 'visible' })`,
-    )
-    const plugin = bootstrap()
-    await runBuildStart(plugin)
-    const source = runLoad(plugin, ISLANDS_REGISTRY_ID)
-    expect(source).toContain('"Mobile":')
-    expect(source).toContain('"Idle":')
-    expect(source).toContain('"Visible":')
-  })
-
-  it('discovers island() calls across multiple source files', async () => {
-    writeFile(
-      'src/foo/A.ts',
-      `import { island } from '@pyreon/server'
-export const A = island(() => import('./component'), { name: 'A', hydrate: 'load' })`,
-    )
-    writeFile(
-      'src/bar/B.ts',
-      `import { island } from '@pyreon/server'
-export const B = island(() => import('./component'), { name: 'B', hydrate: 'idle' })`,
-    )
-    const plugin = bootstrap()
-    await runBuildStart(plugin)
-    const source = runLoad(plugin, ISLANDS_REGISTRY_ID)
-    expect(source).toContain('"A":')
-    expect(source).toContain('"B":')
-  })
-
-  it('skips node_modules / dist / lib / build during the prescan walk', async () => {
-    writeFile(
-      'node_modules/some-pkg/island.ts',
-      `island(() => import('./X'), { name: 'IgnoreMe', hydrate: 'load' })`,
-    )
-    writeFile(
-      'dist/build-output.ts',
-      `island(() => import('./X'), { name: 'AlsoIgnoreMe', hydrate: 'load' })`,
-    )
-    writeFile(
-      'src/Real.ts',
-      `import { island } from '@pyreon/server'
-export const Real = island(() => import('./X'), { name: 'Real', hydrate: 'load' })`,
-    )
-    const plugin = bootstrap()
-    await runBuildStart(plugin)
-    const source = runLoad(plugin, ISLANDS_REGISTRY_ID)
-    expect(source).toContain('"Real":')
-    expect(source).not.toContain('"IgnoreMe":')
-    expect(source).not.toContain('"AlsoIgnoreMe":')
-  })
-
-  it('emits a stub registry when islands: false is set', async () => {
-    writeFile(
-      'src/islands.ts',
-      `import { island } from '@pyreon/server'
-export const Counter = island(() => import('./Counter'), { name: 'Counter', hydrate: 'load' })`,
-    )
-    const plugin = bootstrap({ islands: false })
-    await runBuildStart(plugin)
-    const source = runLoad(plugin, ISLANDS_REGISTRY_ID)
-    // Stub flips the enabled flag so hydrateIslandsAuto() throws at runtime
-    // with a clear message — better than a silent empty registry.
-    expect(source).toContain('__pyreonIslandsEnabled = false')
-    expect(source).not.toContain('"Counter":')
-  })
-
-  it('deduplicates duplicate names (last-wins order)', async () => {
-    writeFile(
-      'src/a.ts',
-      `import { island } from '@pyreon/server'
-export const A = island(() => import('./a-comp'), { name: 'Same', hydrate: 'load' })`,
-    )
-    writeFile(
-      'src/b.ts',
-      `import { island } from '@pyreon/server'
-export const B = island(() => import('./b-comp'), { name: 'Same', hydrate: 'load' })`,
-    )
-    const plugin = bootstrap()
-    await runBuildStart(plugin)
-    const source = runLoad(plugin, ISLANDS_REGISTRY_ID)
-    // Only one entry for "Same" emitted — registry can't have duplicate keys.
-    const matches = source.match(/"Same":/g) ?? []
-    expect(matches).toHaveLength(1)
-  })
-
-  it('skips island() calls without a name field (auto-registry has nothing to key on)', async () => {
-    writeFile(
-      'src/islands.ts',
-      `import { island } from '@pyreon/server'
-// Anomaly: island() without a name option. Auto-registry can't include this.
-export const Bad = island(() => import('./X'), { hydrate: 'load' } as any)
-export const Good = island(() => import('./Y'), { name: 'Good', hydrate: 'load' })`,
-    )
-    const plugin = bootstrap()
-    await runBuildStart(plugin)
-    const source = runLoad(plugin, ISLANDS_REGISTRY_ID)
-    expect(source).toContain('"Good":')
-    expect(source).not.toContain('"Bad":')
-  })
-})

package/src/tests/lpih-auto-bridge.test.ts

@@ -1,408 +0,0 @@
-/**
- * R1 — LPIH auto-bridge.
- *
- * The plugin auto-wires Live Program Inlay Hints in dev:
- *   1. `configureServer` registers a POST /__pyreon_lpih__ middleware
- *      that atomically writes the cache file the LSP auto-discovers.
- *   2. `transformIndexHtml` injects a client-side `<script type="module">`
- *      that activates devtools + polls `getFireSummaries()` every
- *      `intervalMs` and POSTs to the endpoint.
- *
- * Bisect-verified-with-restore:
- *   - Disabling the lpihEnabled gate in configureServer → "no LPIH
- *     middleware registered when lpih:true" fails.
- *   - Disabling the lpihEnabled gate in transformIndexHtml → "injects
- *     the LPIH client script into <head> when lpih:true" fails.
- *   - Reverting writeLpihCacheFile to bare `JSON.parse` → "rejects
- *     malformed body" fails (would silently corrupt the file).
- */
-import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import pyreonPlugin, {
-  type PyreonPluginOptions,
-  buildLpihClientScript,
-  resolveLpihCachePath,
-  writeLpihCacheFile,
-} from '../index'
-
-type ConfigHook = (
-  userConfig: Record<string, unknown>,
-  env: { command: string; isSsrBuild?: boolean },
-) => Record<string, unknown>
-
-type TransformIndexHtmlHook = (html: string) => string | undefined
-
-interface MockServer {
-  watcher: { on: ReturnType<typeof vi.fn>; emit?: (event: string, file: string) => void }
-  middlewares: { use: ReturnType<typeof vi.fn> }
-  ssrFixStacktrace: (e: Error) => void
-  ssrLoadModule: ReturnType<typeof vi.fn>
-  transformIndexHtml: ReturnType<typeof vi.fn>
-}
-
-function createMockServer(): MockServer {
-  const handlers: Record<string, (file: string) => void> = {}
-  return {
-    watcher: {
-      on: vi.fn((event: string, cb: (file: string) => void) => {
-        handlers[event] = cb
-      }),
-      emit: (event: string, file: string) => handlers[event]?.(file),
-    },
-    middlewares: { use: vi.fn() },
-    ssrFixStacktrace: () => {},
-    ssrLoadModule: vi.fn(),
-    transformIndexHtml: vi.fn(async (_url: string, html: string) => html),
-  }
-}
-
-let root: string
-
-beforeEach(() => {
-  root = mkdtempSync(join(tmpdir(), 'pyreon-lpih-bridge-'))
-})
-afterEach(() => {
-  rmSync(root, { recursive: true, force: true })
-})
-
-function bootstrap(
-  opts?: PyreonPluginOptions,
-  env: { command: 'serve' | 'build' } = { command: 'serve' },
-) {
-  const plugin = pyreonPlugin(opts)
-  ;(plugin.config as unknown as ConfigHook)({ root }, env)
-  return plugin
-}
-
-describe('resolveLpihCachePath', () => {
-  it('returns <projectRoot>/.pyreon-lpih.json', () => {
-    expect(resolveLpihCachePath('/abs/proj')).toBe('/abs/proj/.pyreon-lpih.json')
-  })
-
-  it('handles paths without trailing slash', () => {
-    expect(resolveLpihCachePath('/abs/proj/')).toBe('/abs/proj/.pyreon-lpih.json')
-  })
-})
-
-describe('writeLpihCacheFile', () => {
-  it('writes JSON payload at the target path', async () => {
-    const path = join(root, '.pyreon-lpih.json')
-    const payload = JSON.stringify({
-      fires: [{ file: '/a.tsx', line: 1, count: 1, kind: 'signal' }],
-    })
-    await writeLpihCacheFile(path, payload)
-    expect(existsSync(path)).toBe(true)
-    const parsed = JSON.parse(readFileSync(path, 'utf8')) as { fires: unknown[] }
-    expect(parsed.fires).toHaveLength(1)
-  })
-
-  it('overwrites existing file (atomic rename)', async () => {
-    const path = join(root, '.pyreon-lpih.json')
-    await writeLpihCacheFile(path, JSON.stringify({ fires: [{ file: 'a', line: 1, count: 1 }] }))
-    await writeLpihCacheFile(path, JSON.stringify({ fires: [{ file: 'b', line: 2, count: 2 }] }))
-    const parsed = JSON.parse(readFileSync(path, 'utf8')) as {
-      fires: Array<{ file: string }>
-    }
-    expect(parsed.fires[0]?.file).toBe('b')
-  })
-
-  it('rejects malformed JSON body', async () => {
-    const path = join(root, '.pyreon-lpih.json')
-    await expect(writeLpihCacheFile(path, 'not json')).rejects.toThrow(/not valid JSON/)
-    expect(existsSync(path)).toBe(false)
-  })
-
-  it('rejects body without `fires` array', async () => {
-    const path = join(root, '.pyreon-lpih.json')
-    await expect(writeLpihCacheFile(path, JSON.stringify({}))).rejects.toThrow(/missing `fires`/)
-    await expect(
-      writeLpihCacheFile(path, JSON.stringify({ fires: 'not array' })),
-    ).rejects.toThrow(/missing `fires`/)
-    await expect(writeLpihCacheFile(path, JSON.stringify(null))).rejects.toThrow(
-      /missing `fires`/,
-    )
-    expect(existsSync(path)).toBe(false)
-  })
-
-  it('leaves no tmp files after successful write', async () => {
-    const path = join(root, '.pyreon-lpih.json')
-    await writeLpihCacheFile(path, JSON.stringify({ fires: [] }))
-    const fs = await import('node:fs/promises')
-    const files = await fs.readdir(root)
-    const tmpFiles = files.filter((f) => f.includes('.tmp.'))
-    expect(tmpFiles).toEqual([])
-  })
-
-  it('cleans up tmp file when rename fails (rename onto a directory)', async () => {
-    // The pre-existing case the original try-around-rename ALREADY handled:
-    // writeFile succeeds (writes a tmp file in root/), rename onto a path
-    // that is a directory fails (EISDIR / EPERM), the catch unlinks tmp.
-    // This test locks in that branch — bisect-verified by the existing
-    // 'as-dir' rename-failure handling in writeLpihCacheFile.
-    const targetDir = join(root, 'as-dir')
-    const fs = await import('node:fs/promises')
-    await fs.mkdir(targetDir, { recursive: true })
-    await expect(
-      writeLpihCacheFile(targetDir, JSON.stringify({ fires: [] })),
-    ).rejects.toBeDefined()
-    const files = await fs.readdir(root)
-    const tmpFiles = files.filter(
-      (f) => f.startsWith('as-dir.tmp.') || f.includes('.tmp.'),
-    )
-    expect(tmpFiles).toEqual([])
-  })
-})
-
-describe('buildLpihClientScript', () => {
-  it('returns a <script type="module"> block', () => {
-    const script = buildLpihClientScript(250)
-    expect(script).toContain('<script type="module">')
-    expect(script).toContain('</script>')
-  })
-
-  it('embeds the interval as a JSON literal', () => {
-    const script = buildLpihClientScript(500)
-    expect(script).toContain('const __pxInterval = 500')
-  })
-
-  it('imports activateReactiveDevtools + getFireSummaries from @pyreon/reactivity', () => {
-    const script = buildLpihClientScript(250)
-    expect(script).toContain("import('@pyreon/reactivity')")
-    expect(script).toContain('activateReactiveDevtools')
-    expect(script).toContain('getFireSummaries')
-  })
-
-  it('uses top-level await on the dynamic import — activation BEFORE app modules', () => {
-    // Critical for tracking module-scope signals. `<script type="module">`
-    // tags defer + run in document order; top-level await blocks subsequent
-    // modules. Dynamic import via `.then()` does NOT — the module body
-    // completes immediately, the app's entry runs, module-scope signals
-    // get created with `_active = false`, and `_rdRegister` skips them.
-    const script = buildLpihClientScript(250)
-    expect(script).toMatch(/await import\(['"]@pyreon\/reactivity['"]\)/)
-    // The catch path returns null (silent fallback for missing-dep apps).
-    expect(script).toMatch(/\.catch\(\(\) => null\)/)
-    // Activation MUST appear AFTER the await (synchronous after the import resolves).
-    const awaitIdx = script.indexOf('await import')
-    const activateIdx = script.indexOf('activateReactiveDevtools()')
-    expect(awaitIdx).toBeGreaterThan(0)
-    expect(activateIdx).toBeGreaterThan(awaitIdx)
-  })
-
-  it('POSTs to /__pyreon_lpih__ with JSON content-type', () => {
-    const script = buildLpihClientScript(250)
-    expect(script).toContain("fetch('/__pyreon_lpih__'")
-    expect(script).toContain("method: 'POST'")
-    expect(script).toContain("'content-type': 'application/json'")
-  })
-
-  it('cleans up the interval on beforeunload', () => {
-    const script = buildLpihClientScript(250)
-    expect(script).toContain("addEventListener('beforeunload'")
-    expect(script).toContain('clearInterval')
-  })
-
-  it('serializes the `fires` shape that the dev-server expects', () => {
-    const script = buildLpihClientScript(250)
-    // The browser-side must produce { fires: [{ file, line, count, kind, lastFire, rate1s }] }
-    expect(script).toContain('fires: summaries.map')
-    expect(script).toContain('file: s.loc.file')
-    expect(script).toContain('line: s.loc.line')
-    expect(script).toContain('count: s.count')
-    expect(script).toContain('kind: s.kind')
-    expect(script).toContain('rate1s: s.rate1s')
-  })
-})
-
-describe('LPIH transformIndexHtml — injection gating', () => {
-  it('injects the LPIH client script into <head> when lpih:true (default)', () => {
-    const plugin = bootstrap()
-    const transform = plugin.transformIndexHtml as unknown as TransformIndexHtmlHook
-    const out = transform('<html><head><title>X</title></head><body></body></html>')
-    expect(out).toBeDefined()
-    expect(out).toContain('/__pyreon_lpih__')
-    expect(out).toContain('@pyreon/reactivity')
-    // Injected BEFORE the closing </head>, not after.
-    const headEnd = out!.indexOf('</head>')
-    const scriptStart = out!.indexOf('<script type="module">')
-    expect(scriptStart).toBeGreaterThan(0)
-    expect(scriptStart).toBeLessThan(headEnd)
-  })
-
-  it('does NOT inject when lpih:false', () => {
-    const plugin = bootstrap({ lpih: false })
-    const transform = plugin.transformIndexHtml as unknown as TransformIndexHtmlHook
-    const out = transform('<html><head></head><body></body></html>')
-    // Plugin returns undefined → Vite uses the original HTML.
-    expect(out).toBeUndefined()
-  })
-
-  it('does NOT inject in build mode (lpih is dev-only)', () => {
-    const plugin = bootstrap({ lpih: true }, { command: 'build' })
-    const transform = plugin.transformIndexHtml as unknown as TransformIndexHtmlHook
-    const out = transform('<html><head></head><body></body></html>')
-    expect(out).toBeUndefined()
-  })
-
-  it('respects custom intervalMs via object-form option', () => {
-    const plugin = bootstrap({ lpih: { intervalMs: 1000 } })
-    const transform = plugin.transformIndexHtml as unknown as TransformIndexHtmlHook
-    const out = transform('<html><head></head><body></body></html>')
-    expect(out).toContain('const __pxInterval = 1000')
-  })
-
-  it('uses default 250ms interval when lpih:true with no override', () => {
-    const plugin = bootstrap({ lpih: true })
-    const transform = plugin.transformIndexHtml as unknown as TransformIndexHtmlHook
-    const out = transform('<html><head></head><body></body></html>')
-    expect(out).toContain('const __pxInterval = 250')
-  })
-})
-
-describe('LPIH configureServer — middleware registration', () => {
-  it('registers a /__pyreon_lpih__ middleware when lpih:true (default)', () => {
-    const plugin = bootstrap()
-    const server = createMockServer()
-    ;(plugin.configureServer as unknown as (s: MockServer) => unknown)(server)
-
-    // Find the LPIH middleware in the call list — first arg is the path.
-    const lpihCall = server.middlewares.use.mock.calls.find(
-      (c: unknown[]) => c[0] === '/__pyreon_lpih__',
-    )
-    expect(lpihCall).toBeDefined()
-    expect(typeof lpihCall![1]).toBe('function')
-  })
-
-  it('does NOT register the LPIH middleware when lpih:false', () => {
-    const plugin = bootstrap({ lpih: false })
-    const server = createMockServer()
-    ;(plugin.configureServer as unknown as (s: MockServer) => unknown)(server)
-
-    const lpihCall = server.middlewares.use.mock.calls.find(
-      (c: unknown[]) => c[0] === '/__pyreon_lpih__',
-    )
-    expect(lpihCall).toBeUndefined()
-  })
-
-  it('LPIH middleware rejects non-POST with 405', () => {
-    const plugin = bootstrap()
-    const server = createMockServer()
-    ;(plugin.configureServer as unknown as (s: MockServer) => unknown)(server)
-
-    const lpihCall = server.middlewares.use.mock.calls.find(
-      (c: unknown[]) => c[0] === '/__pyreon_lpih__',
-    )
-    const handler = lpihCall![1] as (
-      req: { method: string },
-      res: { statusCode: number; end: (msg?: string) => void },
-    ) => void
-
-    let statusCode = 0
-    let ended = false
-    handler(
-      { method: 'GET' },
-      {
-        statusCode: 0,
-        end(_msg?: string) {
-          ended = true
-          // capture
-          statusCode = (this as { statusCode: number }).statusCode
-        },
-      },
-    )
-    expect(ended).toBe(true)
-    expect(statusCode).toBe(405)
-  })
-
-  it('LPIH middleware writes valid POST payload to the cache file', async () => {
-    const plugin = bootstrap()
-    const server = createMockServer()
-    ;(plugin.configureServer as unknown as (s: MockServer) => unknown)(server)
-
-    const lpihCall = server.middlewares.use.mock.calls.find(
-      (c: unknown[]) => c[0] === '/__pyreon_lpih__',
-    )
-    const handler = lpihCall![1] as (
-      req: { method: string; on: (ev: string, cb: (chunk: string) => void) => void; destroy: () => void },
-      res: { statusCode: number; end: () => void },
-    ) => void
-
-    type DataCb = (chunk: string) => void
-    type EndCb = () => void
-    const handlers: { data?: DataCb; end?: EndCb } = {}
-    const req = {
-      method: 'POST',
-      on: (ev: string, cb: (chunk: string) => void) => {
-        if (ev === 'data') handlers.data = cb as DataCb
-        if (ev === 'end') handlers.end = cb as unknown as EndCb
-      },
-      destroy: () => {},
-    }
-    const resultPromise = new Promise<number>((resolve) => {
-      const res = {
-        statusCode: 0,
-        end() {
-          resolve(res.statusCode)
-        },
-      }
-      handler(req, res)
-    })
-
-    const payload = JSON.stringify({
-      fires: [
-        { file: '/a.tsx', line: 5, count: 3, kind: 'signal', lastFire: 100, rate1s: 1.5 },
-      ],
-    })
-    handlers.data!(payload)
-    handlers.end!()
-
-    const status = await resultPromise
-    expect(status).toBe(204)
-    const cachePath = join(root, '.pyreon-lpih.json')
-    expect(existsSync(cachePath)).toBe(true)
-    const parsed = JSON.parse(readFileSync(cachePath, 'utf8')) as { fires: unknown[] }
-    expect(parsed.fires).toHaveLength(1)
-  })
-
-  it('LPIH middleware honours custom cachePath via object-form option', async () => {
-    const customPath = join(root, 'custom-lpih.json')
-    const plugin = bootstrap({ lpih: { cachePath: customPath } })
-    const server = createMockServer()
-    ;(plugin.configureServer as unknown as (s: MockServer) => unknown)(server)
-
-    const lpihCall = server.middlewares.use.mock.calls.find(
-      (c: unknown[]) => c[0] === '/__pyreon_lpih__',
-    )
-    const handler = lpihCall![1] as (
-      req: { method: string; on: (ev: string, cb: (chunk: string) => void) => void; destroy: () => void },
-      res: { statusCode: number; end: () => void },
-    ) => void
-
-    type DataCb = (chunk: string) => void
-    type EndCb = () => void
-    const handlers: { data?: DataCb; end?: EndCb } = {}
-    const req = {
-      method: 'POST',
-      on: (ev: string, cb: (chunk: string) => void) => {
-        if (ev === 'data') handlers.data = cb as DataCb
-        if (ev === 'end') handlers.end = cb as unknown as EndCb
-      },
-      destroy: () => {},
-    }
-    const done = new Promise<void>((resolve) => {
-      handler(req, {
-        statusCode: 0,
-        end: () => resolve(),
-      })
-    })
-    handlers.data!(JSON.stringify({ fires: [] }))
-    handlers.end!()
-    await done
-
-    // Default cache path NOT written; custom path IS.
-    expect(existsSync(join(root, '.pyreon-lpih.json'))).toBe(false)
-    expect(existsSync(customPath)).toBe(true)
-  })
-})