acrylblends 0.6.2 → 0.6.4

package/plugins/acryl-router/tests/service.spec.ts

@@ -1,426 +0,0 @@
-/**
- * The router as a Cordis service: mounts owned by the plugin that made them, and the lifecycle mechanics the repo protocol requires -
- * PENDING while the provider is missing, reactivation when it appears, provider replacement without duplicate registrations, disposal,
- * repeated mount and reload, in-flight abort, and streams that end with the router or with the plugin that serves them. Routing itself is covered by the core's own suite.
- */
-
-import { Context, type FiberState } from '@deepseek-ai/cordis'
-import { afterEach, describe, expect, it } from 'vitest'
-import { streamSSE } from '../src/helpers/index.ts'
-import { apply, Acryl, Config, connectionOf, HTTPException, name, type Router } from '../src/index.ts'
-
-const PENDING = 0 as FiberState.PENDING
-const ACTIVE = 2 as FiberState.ACTIVE
-const DISPOSED = 4 as FiberState.DISPOSED
-
-const contexts: Context[] = []
-const settle = (): Promise<void> => new Promise(resolve => setTimeout(resolve, 0))
-
-function root(): Context {
-  const ctx = new Context()
-  contexts.push(ctx)
-  return ctx
-}
-
-const provider = { name, apply }
-const config: Config = { trailingSlash: 'strict', disposeGraceMs: 2000 }
-
-async function mountRouter(): Promise<{ ctx: Context, router: Router }> {
-  const ctx = root()
-  ctx.plugin(provider, config)
-  await settle()
-  return { ctx, router: ctx.router }
-}
-
-afterEach(async () => {
-  while (contexts.length > 0) await contexts.pop()?.fiber.dispose()
-})
-
-/** A consumer plugin that needs `router` and mounts one route, the way the Market does. */
-function consumer(path: string, label: string) {
-  return {
-    name: `consumer${label}`,
-    inject: ['router'],
-    apply(ctx: Context): void {
-      ctx.router.route('/', new Acryl().get(path, c => c.text(label)))
-    },
-  }
-}
-
-const get = (router: Router, path: string): Promise<Response> => router.fetch(new Request(`http://acryl.test${path}`))
-
-describe('acryl-router mounts', () => {
-  it('serves a mounted app under its path, with the app\'s own routes, middleware and error handler', async () => {
-    const { router } = await mountRouter()
-    const api = new Acryl()
-      .use(async (c, next) => { await next(); c.header('x-api', 'yes') })
-      .get('/items/:id', c => c.json({ id: c.req.param('id') }))
-      .get('/boom', () => { throw new Error('boom') })
-      .onError((error, c) => c.json({ handled: error instanceof Error ? error.message : 'unknown' }, 418))
-    router.route('/api', api)
-
-    const item = await get(router, '/api/items/a%20b')
-    expect(await item.json()).toEqual({ id: 'a b' })
-    expect(item.headers.get('x-api')).toBe('yes')
-    const boom = await get(router, '/api/boom')
-    expect(boom.status).toBe(418)
-    expect(await boom.json()).toEqual({ handled: 'boom' })
-    expect((await get(router, '/items/a')).status).toBe(404)
-  })
-
-  it('removes a mount with its remover, idempotently, and keeps the others', async () => {
-    const { router } = await mountRouter()
-    const removeA = router.route('/', new Acryl().get('/a', c => c.text('a')))
-    router.route('/', new Acryl().get('/b', c => c.text('b')))
-    expect((await get(router, '/a')).status).toBe(200)
-    removeA()
-    removeA()
-    expect((await get(router, '/a')).status).toBe(404)
-    expect(await (await get(router, '/b')).text()).toBe('b')
-    router.route('/', new Acryl().get('/a', c => c.text('a2')))
-    expect(await (await get(router, '/a')).text()).toBe('a2')
-  })
-
-  it('runs mounts in the order they were made, so an earlier mount\'s middleware wraps a later mount\'s routes', async () => {
-    const { router } = await mountRouter()
-    router.route('/', new Acryl().use('/guarded/*', async c => c.text('denied', 401)))
-    router.route('/', new Acryl().get('/guarded/x', c => c.text('secret')).get('/open', c => c.text('open')))
-    expect((await get(router, '/guarded/x')).status).toBe(401)
-    expect(await (await get(router, '/open')).text()).toBe('open')
-  })
-
-  it('takes one router-wide error handler and one not-found handler, owned by the caller', async () => {
-    const { router } = await mountRouter()
-    router.route('/', new Acryl().get('/boom', () => { throw new Error('boom') }).get('/teapot', () => { throw new HTTPException(418, { message: 'short' }) }))
-    expect((await get(router, '/boom')).status).toBe(500)
-    expect((await get(router, '/teapot')).status).toBe(418)
-
-    const removeError = router.onError((_error, c) => c.text('custom', 503))
-    const removeNotFound = router.notFound(c => c.text('nothing here', 404))
-    expect(() => router.onError((_error, c) => c.text('second'))).toThrow(/already registered/)
-    expect((await get(router, '/boom')).status).toBe(503)
-    expect(await (await get(router, '/missing')).text()).toBe('nothing here')
-    removeError()
-    removeNotFound()
-    expect((await get(router, '/boom')).status).toBe(500)
-  })
-
-  it('treats /a and /a/ as one path when trailingSlash is ignore', async () => {
-    const ctx = root()
-    ctx.plugin(provider, { trailingSlash: 'ignore', disposeGraceMs: 2000 })
-    await settle()
-    ctx.router.route('/', new Acryl().get('/a', c => c.text('a')))
-    expect((await get(ctx.router, '/a/')).status).toBe(200)
-  })
-
-  it('hands the transport\'s connection info to the handler and gives an in-process call an empty one', async () => {
-    const { router } = await mountRouter()
-    router.route('/', new Acryl().get('/who', c => c.json({ remote: connectionOf(c).remoteAddress ?? null, port: connectionOf(c).localPort ?? null })))
-    const over = await router.fetch(new Request('http://acryl.test/who'), { remoteAddress: '127.0.0.1', localPort: 4000 })
-    expect(await over.json()).toEqual({ remote: '127.0.0.1', port: 4000 })
-    const inProcess = await router.request('/who')
-    expect(await inProcess.json()).toEqual({ remote: null, port: null })
-  })
-})
-
-describe('acryl-router lifecycle through Cordis', () => {
-  it('leaves a consumer PENDING while router is missing and activates it when router appears', async () => {
-    const ctx = root()
-    const fiber = ctx.plugin(consumer('/c', 'A'))
-    await settle()
-    expect(fiber.state).toBe(PENDING)
-
-    ctx.plugin(provider, config)
-    await settle()
-    expect(fiber.state).toBe(ACTIVE)
-    expect(await (await get(ctx.router, '/c')).text()).toBe('A')
-    expect(ctx.router.size).toBe(1)
-  })
-
-  it('removes a consumer\'s mounts when the consumer unloads and leaves other consumers alone', async () => {
-    const { ctx, router } = await mountRouter()
-    const a = ctx.plugin(consumer('/a', 'A'))
-    ctx.plugin(consumer('/b', 'B'))
-    await settle()
-    expect(router.size).toBe(2)
-
-    await a.dispose()
-    await settle()
-    expect(a.state).toBe(DISPOSED)
-    expect((await get(router, '/a')).status).toBe(404)
-    expect(await (await get(router, '/b')).text()).toBe('B')
-    expect(router.size).toBe(1)
-  })
-
-  it('labels a mount by its path with one child per route, so no label grows with the app (an inspector caps label length)', async () => {
-    const { ctx, router } = await mountRouter()
-    const big = new Acryl().use('/api/*', async (_c, next) => { await next() })
-    for (let i = 0; i < 60; i += 1) big.get(`/api/a-fairly-long-resource-name-${String(i)}`, c => c.text('ok'))
-    const fiber = ctx.plugin({ name: 'big', inject: ['router'], apply: (inner: Context) => { inner.router.route('/', big) } })
-    await settle()
-    const [mount, ...rest] = fiber.getEffects()
-    expect(rest).toEqual([])
-    expect(mount?.label).toBe('acryl-router: route /')
-    expect(mount?.children).toHaveLength(61)
-    expect(mount?.children[0]?.label).toBe('acryl-router: serves ALL /api/*')
-    expect(mount?.children.every(child => child.label.length < 100 && child.children.length === 0)).toBe(true)
-    expect(router.size).toBe(1)
-    await fiber.dispose()
-    expect(router.size).toBe(0)
-  })
-
-  it('replaces the provider without leaving doubled registrations: consumers re-register exactly once', async () => {
-    const ctx = root()
-    const first = ctx.plugin(provider, config)
-    const fiber = ctx.plugin(consumer('/c', 'A'))
-    await settle()
-    const oldRouter = ctx.router
-    expect(fiber.state).toBe(ACTIVE)
-
-    await first.dispose()
-    await settle()
-    expect(fiber.state).toBe(PENDING)
-    expect(oldRouter.size).toBe(0)
-
-    ctx.plugin(provider, config)
-    await settle()
-    expect(fiber.state).toBe(ACTIVE)
-    expect(ctx.router).not.toBe(oldRouter)
-    expect(ctx.router.size).toBe(1)
-    expect(await (await get(ctx.router, '/c')).text()).toBe('A')
-  })
-
-  it('serves the routes an app had when it was mounted, whatever else changes later', async () => {
-    const { ctx, router } = await mountRouter()
-    const app = new Acryl().get('/early', c => c.text('early'))
-    router.route('/', app)
-    app.get('/late', c => c.text('late'))
-    expect((await get(router, '/early')).status).toBe(200)
-    expect((await get(router, '/late')).status).toBe(404)
-    // Another plugin's mount recomposes the router; the late route still is not served.
-    ctx.plugin(consumer('/other', 'other'))
-    await settle()
-    expect((await get(router, '/other')).status).toBe(200)
-    expect((await get(router, '/late')).status).toBe(404)
-  })
-
-  it('serves two plugins on the same path in mount order, and hands the path to the other when the first unloads', async () => {
-    const { ctx, router } = await mountRouter()
-    const first = ctx.plugin(consumer('/same', 'first'))
-    await settle()
-    ctx.plugin(consumer('/same', 'second'))
-    await settle()
-    expect(await (await get(router, '/same')).text()).toBe('first')
-    await first.dispose()
-    await settle()
-    expect(await (await get(router, '/same')).text()).toBe('second')
-  })
-
-  it('runs a reloaded plugin\'s handler once per request: reloading leaves no duplicate route behind, ten times', async () => {
-    const { ctx, router } = await mountRouter()
-    let calls = 0
-    const counting = {
-      name: 'counting',
-      inject: ['router'],
-      apply(inner: Context): void {
-        inner.router.route('/', new Acryl().use(async (_c, next) => { calls += 1; await next() }).get('/count', c => c.text(String(calls))))
-      },
-    }
-    for (let round = 0; round < 10; round += 1) {
-      const fiber = ctx.plugin(counting)
-      await settle()
-      expect(router.size).toBe(1)
-      calls = 0
-      expect(await (await get(router, '/count')).text()).toBe('1')
-      await fiber.dispose()
-      await settle()
-      expect(router.size).toBe(0)
-    }
-  })
-
-  it('returns to its baseline after fifty consumer mount and unload cycles', async () => {
-    const { ctx, router } = await mountRouter()
-    ctx.plugin(consumer('/stay', 'S'))
-    await settle()
-    const baseline = router.size
-    for (let i = 0; i < 50; i += 1) {
-      const fiber = ctx.plugin(consumer(`/cycle/${String(i)}`, `C${String(i)}`))
-      await settle()
-      expect(router.size).toBe(baseline + 1)
-      expect(await (await get(router, `/cycle/${String(i)}`)).text()).toBe(`C${String(i)}`)
-      await fiber.dispose()
-      await settle()
-    }
-    expect(router.size).toBe(baseline)
-    expect((await get(router, '/cycle/0')).status).toBe(404)
-  })
-
-  it('aborts an in-flight request and waits for it when the router is disposed, then answers 503', async () => {
-    const ctx = root()
-    const fiber = ctx.plugin(provider, config)
-    await settle()
-    const router = ctx.router
-    let aborted = false
-    router.route('/', new Acryl().get('/slow', async c => {
-      await new Promise<void>((_resolve, reject) => { c.req.raw.signal.addEventListener('abort', () => { aborted = true; reject(new Error('aborted')) }, { once: true }) })
-      return c.text('late')
-    }))
-    const pending = get(router, '/slow')
-    await settle()
-
-    await fiber.dispose()
-    await settle()
-    expect(aborted).toBe(true)
-    expect((await pending).status).toBe(499)
-    expect((await get(router, '/slow')).status).toBe(503)
-  })
-
-  it('forwards the caller\'s own abort to the handler signal', async () => {
-    const { router } = await mountRouter()
-    let seen = false
-    router.route('/', new Acryl().get('/slow', async c => {
-      await new Promise<void>((_resolve, reject) => { c.req.raw.signal.addEventListener('abort', () => { seen = true; reject(new Error('aborted')) }, { once: true }) })
-      return c.text('x')
-    }))
-    const controller = new AbortController()
-    const pending = router.fetch(new Request('http://acryl.test/slow', { signal: controller.signal }))
-    await settle()
-    controller.abort()
-    expect((await pending).status).toBe(499)
-    expect(seen).toBe(true)
-  })
-
-  it('ends a server-sent-event stream when the router is disposed: the stream\'s abort cleanup runs and the reader sees the end', async () => {
-    const ctx = root()
-    const fiber = ctx.plugin(provider, config)
-    await settle()
-    let cleaned = false
-    ctx.router.route('/', new Acryl().get('/events', c => streamSSE(c, async stream => {
-      stream.onAbort(() => { cleaned = true })
-      await stream.writeSSE({ data: 'first' })
-      while (!stream.aborted) await stream.sleep(10)
-    })))
-    const response = await get(ctx.router, '/events')
-    expect(response.headers.get('content-type')).toBe('text/event-stream')
-    const reader = response.body!.getReader()
-    expect(new TextDecoder().decode((await reader.read()).value)).toBe('data: first\n\n')
-
-    await fiber.dispose()
-    expect(cleaned).toBe(true)
-    await expect(reader.read()).resolves.toMatchObject({ done: true })
-  })
-
-  it('ends the stream a plugin opened when that plugin unloads, and leaves another plugin\'s request running', async () => {
-    const { ctx, router } = await mountRouter()
-    let cleaned = false
-    let otherAborted = false
-    let release!: () => void
-    const streaming = ctx.plugin({
-      name: 'streaming',
-      inject: ['router'],
-      apply(inner: Context): void {
-        inner.router.route('/', new Acryl().get('/events', c => streamSSE(c, async stream => {
-          stream.onAbort(() => { cleaned = true })
-          await stream.writeSSE({ data: 'first' })
-          while (!stream.aborted) await stream.sleep(10)
-        })))
-      },
-    })
-    ctx.plugin({
-      name: 'other',
-      inject: ['router'],
-      apply(inner: Context): void {
-        inner.router.route('/', new Acryl().get('/slow', async c => {
-          c.req.raw.signal.addEventListener('abort', () => { otherAborted = true }, { once: true })
-          await new Promise<void>(resolve => { release = resolve })
-          return c.text('done')
-        }))
-      },
-    })
-    await settle()
-    const response = await get(router, '/events')
-    const reader = response.body!.getReader()
-    expect(new TextDecoder().decode((await reader.read()).value)).toBe('data: first\n\n')
-    const slow = get(router, '/slow')
-    await settle()
-
-    await streaming.dispose()
-    expect(cleaned).toBe(true)
-    await expect(reader.read()).resolves.toMatchObject({ done: true })
-    expect(otherAborted).toBe(false)
-    release()
-    expect(await (await slow).text()).toBe('done')
-  })
-
-  it('aborts a request still inside an unloading plugin\'s middleware, but not one that middleware already passed on', async () => {
-    const { ctx, router } = await mountRouter()
-    let guardAborted = false
-    let handlerAborted = false
-    let release!: () => void
-    const guard = ctx.plugin({
-      name: 'guard',
-      inject: ['router'],
-      apply(inner: Context): void {
-        inner.router.route('/', new Acryl()
-          .use('/held/*', async (c, next) => {
-            c.req.raw.signal.addEventListener('abort', () => { guardAborted = true }, { once: true })
-            await new Promise<void>((_resolve, reject) => { c.req.raw.signal.addEventListener('abort', () => { reject(new Error('aborted')) }, { once: true }) })
-            await next()
-          })
-          .use('/passed/*', async (_c, next) => { await next() }))
-      },
-    })
-    ctx.plugin({
-      name: 'handler',
-      inject: ['router'],
-      apply(inner: Context): void {
-        inner.router.route('/', new Acryl()
-          .get('/held/x', c => c.text('held'))
-          .get('/passed/x', c => streamSSE(c, async stream => {
-            stream.onAbort(() => { handlerAborted = true })
-            await stream.writeSSE({ data: 'open' })
-            await new Promise<void>(resolve => { release = resolve })
-          })))
-      },
-    })
-    await settle()
-    const held = get(router, '/held/x')
-    const passed = await get(router, '/passed/x')
-    const reader = passed.body!.getReader()
-    await reader.read()
-
-    await guard.dispose()
-    expect(guardAborted).toBe(true)
-    expect((await held).status).toBe(499)
-    expect(handlerAborted).toBe(false)
-    release()
-    await expect(reader.read()).resolves.toMatchObject({ done: true })
-  })
-
-  it('keeps a request in flight through waitUntil until its task settles', async () => {
-    const ctx = root()
-    const fiber = ctx.plugin(provider, config)
-    await settle()
-    let finished = false
-    ctx.router.route('/', new Acryl().get('/later', c => {
-      c.executionCtx.waitUntil(new Promise<void>(resolve => { setTimeout(() => { finished = true; resolve() }, 30) }))
-      return c.text('now')
-    }))
-    expect(await (await get(ctx.router, '/later')).text()).toBe('now')
-    expect(finished).toBe(false)
-    await fiber.dispose()
-    expect(finished).toBe(true)
-  })
-
-  it('gives up on a request that ignores the abort after the grace period instead of hanging disposal', async () => {
-    const ctx = root()
-    const fiber = ctx.plugin(provider, { trailingSlash: 'strict', disposeGraceMs: 30 })
-    await settle()
-    ctx.router.route('/', new Acryl().get('/stuck', c => { c.executionCtx.waitUntil(new Promise(() => undefined)); return c.text('x') }))
-    await get(ctx.router, '/stuck')
-    const started = Date.now()
-    await fiber.dispose()
-    expect(Date.now() - started).toBeLessThan(1000)
-    expect(fiber.state).toBe(DISPOSED)
-  })
-})

package/plugins/acryl-router/tests/shadow-state.spec.ts

@@ -1,79 +0,0 @@
-/**
- * What a Service's fields look like to the plugins that call it. A plugin reaches a service through its own shadow of the instance
- * (`ctx.counter` in plugin A and in plugin B are two different objects over one service), but reads and writes of fields pass through to
- * the one instance: a field assigned in a method is seen by every caller, as is state kept in an object that is only mutated. What the
- * shadow does change is `this.ctx` inside a method, which `live-install.spec.ts` covers.
- */
-import { Context, Service } from '@deepseek-ai/cordis'
-import { afterEach, describe, expect, it } from 'vitest'
-
-declare module '@deepseek-ai/cordis' {
-  interface Context {
-    counter: Counter
-  }
-}
-
-const contexts: Context[] = []
-const settle = (): Promise<void> => new Promise(resolve => setTimeout(resolve, 0))
-afterEach(async () => {
-  while (contexts.length > 0) await contexts.pop()?.fiber.dispose()
-})
-
-class Counter extends Service {
-  /** Reassigned by `assign`. */
-  assigned = 0
-  /** Created once, only mutated. */
-  private readonly state = { count: 0 }
-
-  constructor(ctx: Context) {
-    super(ctx, 'counter')
-  }
-
-  assign(): void {
-    this.assigned += 1
-  }
-
-  mutate(): void {
-    this.state.count += 1
-  }
-
-  get count(): number {
-    return this.state.count
-  }
-}
-
-async function twoCallers(): Promise<{ a: Context, b: Context }> {
-  const root = new Context()
-  contexts.push(root)
-  root.plugin({ name: 'counter', apply: (ctx: Context) => { new Counter(ctx) } })
-  const callers: Context[] = []
-  for (const name of ['a', 'b']) root.plugin({ name, inject: ['counter'], apply: (ctx: Context) => { callers.push(ctx) } })
-  await settle()
-  const [a, b] = callers
-  if (a === undefined || b === undefined) throw new Error('both callers should be active')
-  return { a, b }
-}
-
-describe('service state and the shadow context', () => {
-  it('shows a field assigned in a method through one caller to every caller', async () => {
-    const { a, b } = await twoCallers()
-    a.counter.assign()
-    b.counter.assign()
-    expect(a.counter.assigned).toBe(2)
-    expect(b.counter.assigned).toBe(2)
-  })
-
-  it('shows a field assigned from outside through one caller to every caller', async () => {
-    const { a, b } = await twoCallers()
-    a.counter.assigned = 5
-    expect(b.counter.assigned).toBe(5)
-  })
-
-  it('shares state kept in one object that is only mutated', async () => {
-    const { a, b } = await twoCallers()
-    a.counter.mutate()
-    b.counter.mutate()
-    expect(a.counter.count).toBe(2)
-    expect(b.counter.count).toBe(2)
-  })
-})

package/plugins/acryl-router-http/tests/adapter.spec.ts

@@ -1,174 +0,0 @@
-/**
- * The Web adapter against the real DSH `webServer` listening on a loopback port: a plugin mounts a prefix, requests
- * travel over real HTTP into `router.fetch`, and the lifecycle (PENDING, unload, reload) is observed the way a browser
- * would see it. The router is the built `acryl-router` entry, as production loads it.
- */
-
-import { Context, type FiberState } from '@deepseek-ai/cordis'
-import WebServer from '@deepseek-ai/dsh-host-webserver'
-import { apply as routerApply, name as routerName } from '../../acryl-router/src/index.ts'
-import { afterEach, describe, expect, it } from 'vitest'
-import { Acryl, connectionOf, type RouterHttpService } from '../../acryl-router/src/index.ts'
-import { methodNotAllowed } from '../../acryl-router/src/middleware/index.ts'
-import { apply, inject, name } from '../src/index.ts'
-
-const PENDING = 0 as FiberState.PENDING
-const ACTIVE = 2 as FiberState.ACTIVE
-
-const contexts: Context[] = []
-const settle = (ms = 0): Promise<void> => new Promise(resolve => setTimeout(resolve, ms))
-afterEach(async () => {
-  while (contexts.length > 0) await contexts.pop()?.fiber.dispose()
-})
-
-async function until(check: () => boolean, label: string): Promise<void> {
-  for (let i = 0; i < 300; i += 1) { if (check()) return; await settle(10) }
-  throw new Error(`timed out waiting for: ${label}`)
-}
-
-const adapter = { name, inject, apply }
-const router = { name: routerName, apply: routerApply }
-
-/** A whole stack on one root context: webServer on an OS-assigned port, the router, and the adapter. */
-async function stack(): Promise<{ ctx: Context, base: () => string }> {
-  const ctx = new Context()
-  contexts.push(ctx)
-  ctx.plugin(WebServer, { host: '127.0.0.1', port: 0 } as never)
-  ctx.plugin(router, { trailingSlash: 'strict' })
-  ctx.plugin(adapter)
-  await until(() => (ctx as unknown as { webServer?: { port: number } }).webServer?.port !== undefined && ctx.routerHttp !== undefined, 'the stack to start')
-  return { ctx, base: () => `http://127.0.0.1:${String((ctx as unknown as { webServer: { port: number } }).webServer.port)}` }
-}
-
-function demo(prefix: string, extra?: (app: Acryl) => void) {
-  return {
-    name: `demo${prefix.replaceAll('/', '-')}`,
-    inject: ['router', 'routerHttp'],
-    apply(ctx: Context): void {
-      ctx.routerHttp.mount(prefix)
-      const app = new Acryl()
-      app.use(methodNotAllowed({ app }))
-      app.get('/hello/:who', c => c.json({ hello: c.req.param('who'), q: c.req.query('q') ?? null, host: c.req.header('host') !== undefined }))
-      app.post('/echo', async c => c.json({ got: await c.req.text(), type: c.req.header('content-type') ?? null }, 201))
-      app.get('/cookies', () => {
-        const headers = new Headers()
-        headers.append('set-cookie', 'a=1; Path=/')
-        headers.append('set-cookie', 'b=2; Path=/')
-        return new Response('ok', { headers })
-      })
-      app.get('/stream', () => new Response(new ReadableStream({
-        start(controller) { controller.enqueue(new TextEncoder().encode('one,')); controller.enqueue(new TextEncoder().encode('two')); controller.close() },
-      })))
-      app.get('/peer', c => c.json({ remote: connectionOf(c).remoteAddress ?? null, localPort: connectionOf(c).localPort ?? null }))
-      extra?.(app)
-      ctx.router.route(prefix, app)
-    },
-  }
-}
-
-describe('acryl-router-http against a real webServer', () => {
-  it('serves a mounted prefix over HTTP: params, query, JSON, status', async () => {
-    const { ctx, base } = await stack()
-    ctx.plugin(demo('/api/demo'))
-    await settle(20)
-    const response = await fetch(`${base()}/api/demo/hello/zed%20x?q=1`)
-    expect(response.status).toBe(200)
-    expect(response.headers.get('content-type')).toContain('application/json')
-    expect(await response.json()).toEqual({ hello: 'zed x', q: '1', host: true })
-  })
-
-  it('passes the socket peer address as connection info, not as part of the request', async () => {
-    const { ctx, base } = await stack()
-    ctx.plugin(demo('/api/demo'))
-    await settle(20)
-    const body = await (await fetch(`${base()}/api/demo/peer`)).json() as { remote: string | null, localPort: number | null }
-    expect(['127.0.0.1', '::ffff:127.0.0.1']).toContain(body.remote)
-    expect(body.localPort).toBe(Number(new URL(base()).port))
-  })
-
-  it('streams a request body into the handler and keeps status and headers on the way out', async () => {
-    const { ctx, base } = await stack()
-    ctx.plugin(demo('/api/demo'))
-    await settle(20)
-    const response = await fetch(`${base()}/api/demo/echo`, { method: 'POST', body: 'payload', headers: { 'content-type': 'text/plain' } })
-    expect(response.status).toBe(201)
-    expect(await response.json()).toEqual({ got: 'payload', type: 'text/plain' })
-  })
-
-  it('keeps repeated set-cookie headers separate and streams a response body', async () => {
-    const { ctx, base } = await stack()
-    ctx.plugin(demo('/api/demo'))
-    await settle(20)
-    const cookies = await fetch(`${base()}/api/demo/cookies`)
-    expect(cookies.headers.getSetCookie()).toEqual(['a=1; Path=/', 'b=2; Path=/'])
-    expect(await (await fetch(`${base()}/api/demo/stream`)).text()).toBe('one,two')
-  })
-
-  it('answers the router\'s 404 and 405 below the mount, and answers HEAD without a body', async () => {
-    const { ctx, base } = await stack()
-    ctx.plugin(demo('/api/demo'))
-    await settle(20)
-    const missing = await fetch(`${base()}/api/demo/none`)
-    expect(missing.status).toBe(404)
-    expect(await missing.text()).toBe('404 Not Found')
-    expect((await fetch(`${base()}/api/demo/echo`)).status).toBe(405)
-    const head = await fetch(`${base()}/api/demo/hello/a`, { method: 'HEAD' })
-    expect(head.status).toBe(200)
-    expect(head.headers.get('content-type')).toContain('application/json')
-    expect(await head.text()).toBe('')
-  })
-
-  it('aborts the handler signal when the HTTP client disconnects', async () => {
-    const { ctx, base } = await stack()
-    let aborted = false
-    ctx.plugin(demo('/api/demo', app => {
-      app.get('/slow', async r => {
-        await new Promise<void>((_resolve, reject) => { r.req.raw.signal.addEventListener('abort', () => { aborted = true; reject(new Error('aborted')) }, { once: true }) })
-        return r.text('never')
-      })
-    }))
-    await settle(20)
-    const controller = new AbortController()
-    const pending = fetch(`${base()}/api/demo/slow`, { signal: controller.signal }).catch(() => undefined)
-    await settle(50)
-    controller.abort()
-    await pending
-    await until(() => aborted, 'the handler to see the disconnect')
-  })
-
-  it('stops serving the prefix when the owning plugin unloads, and serves it again on reload, fifty times', async () => {
-    const { ctx, base } = await stack()
-    for (let i = 0; i < 50; i += 1) {
-      const fiber = ctx.plugin(demo('/api/demo'))
-      await settle(5)
-      expect((await fetch(`${base()}/api/demo/hello/a`)).status).toBe(200)
-      await fiber.dispose()
-      await settle(5)
-      // Unmounted: the webServer has no fallback in this stack, so it answers its own empty 404, not the router's body.
-      const gone = await fetch(`${base()}/api/demo/hello/a`)
-      expect(gone.status).toBe(404)
-      expect(await gone.text()).toBe('')
-    }
-    expect(ctx.router.size).toBe(0)
-  })
-
-  it('stays PENDING while webServer is missing and activates when it appears', async () => {
-    const ctx = new Context()
-    contexts.push(ctx)
-    ctx.plugin(router, { trailingSlash: 'strict' })
-    const fiber = ctx.plugin(adapter)
-    await settle(20)
-    expect(fiber.state).toBe(PENDING)
-    ctx.plugin(WebServer, { host: '127.0.0.1', port: 0 } as never)
-    await until(() => fiber.state === ACTIVE, 'the adapter to activate')
-  })
-
-  it('refuses a prefix that is not a clean path and a prefix another plugin already mounted', async () => {
-    const { ctx } = await stack()
-    const http: RouterHttpService = ctx.routerHttp
-    expect(() => http.mount('no-slash')).toThrow(/mountable/)
-    expect(() => http.mount('/trailing/')).toThrow(/mountable/)
-    http.mount('/api/once')
-    expect(() => http.mount('/api/once')).toThrow(/duplicate/)
-  })
-})