@abide/abide 0.110.4 → 0.111.0

package/src/server/answerWorker.ts

@@ -0,0 +1,195 @@
+// SECTION 45 — THE SERVICE WORKER, written by the server rather than bundled: what it saves is the
+// build's own file list, which the server holds (38.5), and a script whose bytes change with the
+// build is how a browser learns there is a new one to install.
+//
+// WRITTEN AS TEXT, NOT AS A FUNCTION'S SOURCE: an executable `abide compile` writes carries its code
+// as bytecode (38.93), where a function has no source to read back.
+
+import { CLIENT_ADDRESS } from '#shared/ADDRESSES.ts'
+import { MOUNT, mounted } from '#shared/mount.ts'
+import { NAVIGATION_HEADER } from '#shared/NAVIGATION_HEADER.ts'
+import {
+    OFFLINE_BUNDLE,
+    OFFLINE_CACHE_PREFIX,
+    OFFLINE_SAVED,
+} from '#shared/OFFLINE_CACHES.ts'
+import { PRINCIPAL_HEADER } from '#shared/PRINCIPAL_HEADER.ts'
+import type { Manifest } from './manifestOf.ts'
+
+// What `framingOf` reads as a framed stream (16.32), and a binary's bytes (16.34), which may be one —
+// spelled again as a list because `framingOf`, in every page's client closure, reads them as branches.
+const STREAMED_TYPES = [
+    'text/event-stream',
+    'application/jsonl',
+    'application/x-ndjson',
+    'application/octet-stream',
+]
+
+const CACHES = `const OURS = ${JSON.stringify(OFFLINE_CACHE_PREFIX)}
+const SAVED = ${JSON.stringify(OFFLINE_SAVED)}
+const BUNDLE = ${JSON.stringify(OFFLINE_BUNDLE)}
+
+async function dropOurs(keeping) {
+    for (const name of await caches.keys())
+        if (name.startsWith(OURS) && name !== keeping) await caches.delete(name)
+}
+`
+
+// 45.3 through 45.8, and 45.13.
+const SAVING = `
+self.addEventListener('install', (event) => {
+    event.waitUntil(
+        caches
+            .open(BUNDLE)
+            .then((cache) => cache.addAll([...FILES]))
+            .then(() => self.skipWaiting()),
+    )
+})
+
+self.addEventListener('activate', (event) => {
+    event.waitUntil(
+        (async () => {
+            await dropOurs(BUNDLE)
+            const cache = await caches.open(BUNDLE)
+            for (const request of await cache.keys())
+                if (!FILES.has(request.url)) await cache.delete(request)
+            await self.registration.navigationPreload?.enable()
+            await self.clients.claim()
+            for (const client of await self.clients.matchAll({ type: 'window' }))
+                await fetch(client.url).then(
+                    (response) =>
+                        kept(response)
+                            ? keep(new Request(client.url), response)
+                            : response.body?.cancel(),
+                    () => {},
+                )
+        })(),
+    )
+})
+
+self.addEventListener('message', (event) => {
+    if (event.data === 'rotated') event.waitUntil(caches.delete(SAVED))
+})
+
+self.addEventListener('fetch', (event) => {
+    const request = event.request
+    if (request.mode === 'navigate') {
+        if (request.method === 'GET') event.respondWith(answer(event, true))
+        else event.waitUntil(caches.delete(SAVED))
+        return
+    }
+    if (request.method !== 'GET') return
+    if (FILES.has(request.url)) {
+        event.respondWith(
+            caches
+                .match(request, { cacheName: BUNDLE })
+                .then((saved) => saved ?? fetch(request)),
+        )
+        return
+    }
+    if (new URL(request.url).origin !== self.location.origin) return
+    if (request.headers.has(NAVIGATION) || request.headers.has('range')) return
+    if ((request.headers.get('accept') ?? '').includes('text/event-stream'))
+        return
+    event.respondWith(answer(event, false))
+})
+
+async function answer(event, page) {
+    let response
+    try {
+        response =
+            (page ? await event.preloadResponse : undefined) ??
+            (await fetch(event.request))
+    } catch {
+        const saved = await caches.match(event.request, {
+            cacheName: SAVED,
+            ignoreVary: true,
+        })
+        return saved ?? (page ? offline() : Response.error())
+    }
+    // A copy nothing reads is a tee holding every chunk, so one is cloned only to be saved.
+    const copy = kept(response) ? response.clone() : undefined
+    const rotated = response.headers.has(PRINCIPAL)
+    event.waitUntil(
+        (rotated ? caches.delete(SAVED) : Promise.resolve()).then(() =>
+            copy === undefined ? undefined : keep(event.request, copy),
+        ),
+    )
+    return response
+}
+
+function kept(response) {
+    if (response.status !== 200) return false
+    const type = response.headers.get('content-type') ?? ''
+    return !STREAMED.some((streamed) => type.startsWith(streamed))
+}
+
+async function keep(request, response) {
+    const cache = await caches.open(SAVED)
+    await cache.put(request, response)
+}
+
+function offline() {
+    return new Response(OFFLINE, {
+        status: 503,
+        headers: { 'content-type': 'text/html; charset=utf-8' },
+    })
+}
+`
+
+// 45.11 — the page a navigation with no network and no saved copy is answered with.
+const OFFLINE = `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>Offline</title></head><body><p>You're offline, and this page wasn't saved on this device. It loads once you're back online.</p></body></html>`
+
+// 45.9 — THE WORKER THAT REMOVES ITSELF, for a browser still holding one an earlier build registered.
+const REMOVING = `${CACHES}
+self.addEventListener('install', () => self.skipWaiting())
+
+self.addEventListener('activate', (event) => {
+    event.waitUntil(
+        (async () => {
+            await dropOurs(undefined)
+            await self.registration.unregister()
+        })(),
+    )
+})
+`
+
+/** Every file of the build's bundle, by name: the entry, its stylesheet and each route's chunks. */
+function bundleFiles(manifest: Manifest): Set<string> {
+    const files = new Set<string>()
+    if (manifest.entry !== undefined) files.add(manifest.entry)
+    if (manifest.stylesheet !== undefined) files.add(manifest.stylesheet)
+    for (const chunks of Object.values(manifest.chunks))
+        for (const chunk of chunks) files.add(chunk)
+    return files
+}
+
+/**
+ * The service worker's script: the one saving the build `manifest` names, or, with none, the one that
+ * removes itself.
+ *
+ * 45.2 — ALLOWED THE MOUNT'S WHOLE SCOPE from below `/__abide`, where a worker's own directory would
+ * be all it could reach.
+ */
+export function answerWorker(manifest: Manifest | undefined): Response {
+    let script = REMOVING
+    if (manifest !== undefined) {
+        const paths: string[] = []
+        for (const name of bundleFiles(manifest))
+            paths.push(mounted(`${CLIENT_ADDRESS}/${name}`))
+        script = `${CACHES}const PRINCIPAL = ${JSON.stringify(PRINCIPAL_HEADER)}
+const NAVIGATION = ${JSON.stringify(NAVIGATION_HEADER)}
+// 45.4 — the types a stream 16.32 frames, which has no end to save.
+const STREAMED = ${JSON.stringify(STREAMED_TYPES)}
+const OFFLINE = ${JSON.stringify(OFFLINE)}
+const FILES = new Set(${JSON.stringify(paths)}.map((path) => new URL(path, self.location).href))
+${SAVING}`
+    }
+    return new Response(script, {
+        headers: {
+            'content-type': 'text/javascript; charset=utf-8',
+            'cache-control': 'no-cache',
+            'service-worker-allowed': `${MOUNT.current()}/`,
+        },
+    })
+}

package/src/server/appManifest.ts

@@ -0,0 +1,48 @@
+// 45.15 — THE WEB APP MANIFEST, which makes the app one a phone can put on its home screen: where the
+// browser keeps what the service worker saved for as long as the app stays installed, rather than
+// clearing it after a spell unvisited.
+
+import { APP_MANIFEST_ADDRESS } from '#shared/ADDRESSES.ts'
+import { ICON_ADDRESSES } from '#shared/LAUNCHER_FILES.ts'
+import { appName } from '#shared/log.ts'
+import { MOUNT, mounted } from '#shared/mount.ts'
+
+const PNG_SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]
+
+/**
+ * The tags a document links the manifest for the icon at `iconPath` by, and the manifest itself, or
+ * `undefined` where it is not a PNG.
+ *
+ * DECLARED AT ITS OWN SIZE, read off the PNG's header: nothing on a server draws it at another
+ * (`abide bundle` has `sips`, and a Linux host does not).
+ */
+export async function appManifest(
+    iconPath: string,
+): Promise<{ tags: string; body: string } | undefined> {
+    const head = await Bun.file(iconPath).slice(0, 24).bytes()
+    // A file cut off before the header's width and height is no PNG to size.
+    if (head.length < 24) return undefined
+    for (let at = 0; at < PNG_SIGNATURE.length; at += 1)
+        if (head[at] !== PNG_SIGNATURE[at]) return undefined
+    const header = new DataView(head.buffer, head.byteOffset, head.byteLength)
+    const icon = mounted(ICON_ADDRESSES.png)
+    const scope = `${MOUNT.current()}/`
+    const name = appName()
+    return {
+        tags: `<link rel="manifest" href="${mounted(APP_MANIFEST_ADDRESS)}"><link rel="apple-touch-icon" href="${icon}">`,
+        body: JSON.stringify({
+            name,
+            short_name: name,
+            start_url: scope,
+            scope,
+            display: 'standalone',
+            icons: [
+                {
+                    src: icon,
+                    sizes: `${header.getUint32(16)}x${header.getUint32(20)}`,
+                    type: 'image/png',
+                },
+            ],
+        }),
+    }
+}

package/src/server/assistant.ts

@@ -93,7 +93,7 @@ export async function* assistant(
     yield* ASSISTANT_LOG.enabled() ? traced(events, messages.length) : events
 }
 
-/** `events`, and one line on `abide:assistant` once they end, however they end. 44.32. */
+/** `events`, and one line on `abide:assistant` once they end, however they end. 44.31. */
 async function* traced(
     events: AsyncGenerator<AssistantEvent>,
     messageCount: number,

package/src/server/bridgeRelay.ts

@@ -15,11 +15,10 @@
 import { isFailed } from '#shared/Failed.ts'
 import { refuse } from '#shared/refuse.ts'
 import { answered } from './answerFailure.ts'
-import { bodyWithin, raiseTimeout } from './answerRpc.ts'
+import { bodyWithin } from './answerRpc.ts'
 import { framed } from './answerValue.ts'
 import { Inbox } from './Inbox.ts'
 import { randomToken } from './randomToken.ts'
-import { EVENT_STREAM_OPENER } from './streamEvent.ts'
 
 /**
  * What a turn hears from the bridge, in the order the bridge posted it: an event, an MCP request, the
@@ -53,9 +52,6 @@ const CODE_LIFETIME = 10 * 60_000
 const IDLE_GRACE = 30_000
 /** How long a pairing whose stream dropped waits to be resumed. 44.26. */
 export const RESUME_MILLISECONDS = 60_000
-/** How often a pairing's stream carries a comment while it has nothing else to send. 44.27. */
-export const HEARTBEAT_MILLISECONDS = 15_000
-const HEARTBEAT = new TextEncoder().encode(EVENT_STREAM_OPENER)
 
 const CODES = new Map<string, { caller: string; expires: number }>()
 const BY_CALLER = new Map<string, Bridge>()
@@ -246,56 +242,14 @@ function resume(request: Request): Response {
 /** `bridge`'s frames as this request's stream, held for `RESUME_MILLISECONDS` once it drops. */
 function attach(bridge: Bridge, request: Request): Response {
     const frames = bridge.frames
-    // 16.57 — a pairing stays open for as long as the bridge holds it.
-    raiseTimeout(Number.POSITIVE_INFINITY)
     request.signal.addEventListener('abort', () => {
         if (bridge.frames !== frames || !BY_TOKEN.has(bridge.token)) return
         bridge.frames = frames.handOff()
         bridge.held = setTimeout(() => dropBridge(bridge), RESUME_MILLISECONDS)
     })
-    const answer = framed(
-        frames[Symbol.asyncIterator](),
-        'sse',
-        new Headers(),
-        200,
-    )
-    return new Response(
-        withHeartbeat(answer.body as ReadableStream<Uint8Array>),
-        answer,
-    )
-}
-
-// 44.27 — A COMMENT EVERY HEARTBEAT, so a bridge can tell a connection that went silent without
-// ending from a quiet one. A comment rather than a frame: a bridge reads only `data:` lines, and a
-// frame would sit in the pairing's inbox through a drop.
-function withHeartbeat(
-    body: ReadableStream<Uint8Array>,
-): ReadableStream<Uint8Array> {
-    const reader = body.getReader()
-    let beat: ReturnType<typeof setInterval> | undefined
-    return new ReadableStream<Uint8Array>({
-        start(controller) {
-            beat = setInterval(
-                () => controller.enqueue(HEARTBEAT),
-                HEARTBEAT_MILLISECONDS,
-            )
-        },
-        async pull(controller) {
-            try {
-                const next = await reader.read()
-                if (!next.done) return controller.enqueue(next.value)
-                clearInterval(beat)
-                controller.close()
-            } catch (thrown) {
-                clearInterval(beat)
-                controller.error(thrown)
-            }
-        },
-        cancel(reason) {
-            clearInterval(beat)
-            return reader.cancel(reason)
-        },
-    })
+    // 16.57 — `App.fetch` beats it, which is how a bridge tells a connection
+    // gone silent from a quiet one (44.27).
+    return framed(frames[Symbol.asyncIterator](), 'sse', new Headers(), 200)
 }
 
 type BridgeReport = {

package/src/server/claudeApi.ts

@@ -122,7 +122,7 @@ export function claudeApi(config: ClaudeApiConfig): Provider {
                             const block = event.content_block
                             blocks[event.index] = block
                             partials[event.index] = ''
-                            // 44.29 — announced as the model starts writing it.
+                            // 44.28 — announced as the model starts writing it.
                             if (block.type === 'tool_use')
                                 yield {
                                     type: 'tool',

package/src/server/claudeCode.ts

@@ -6,7 +6,7 @@
 // CONFIGURED BY CLAUDE CODE'S OWN OPTION NAMES, which the bridge lays on as their flags, and only the ones
 // that shape the answer. What would give a site power over the visitor's machine — permissions,
 // directory, settings — is not an option here at all, and its built-in `tools` are a request the visitor
-// grants or does not: the bridge decides (44.15, 44.16, 44.30).
+// grants or does not: the bridge decides (44.15, 44.16, 44.29).
 
 import { mounted } from '#shared/mount.ts'
 import { refuse } from '#shared/refuse.ts'
@@ -42,7 +42,7 @@ export type ClaudeCodeConfig = {
     tools?: string[]
 }
 
-/** The built-in tools a pairing command grants, as the visitor would after its `--`. 44.33. */
+/** The built-in tools a pairing command grants, as the visitor would after its `--`. 44.32. */
 type PairingOptions = Pick<ClaudeCodeConfig, 'tools'>
 
 /** Whether this browser's bridge is connected, and the command that pairs one where it is not. */
@@ -128,7 +128,7 @@ function askingCaller(): string {
 
 /**
  * The command that pairs a bridge with this browser, and when its code stops standing. 44.14. The
- * `tools` it is given are written after its `--`, so the visitor running it grants them (44.30, 44.33).
+ * `tools` it is given are written after its `--`, so the visitor running it grants them (44.29, 44.32).
  */
 function bridgeCommand({ tools }: PairingOptions = {}): {
     command: string

package/src/server/clientBundle.ts

@@ -71,6 +71,13 @@ export async function clientBundle(
         // app serves is still worth a build error.
         external: [...published.values()],
         throw: false,
+        // 36.16 — THE MODE, NOT THE ENVIRONMENT: the bundler writes in the `NODE_ENV` this process
+        // STARTED under, so the `production` `abide build` assigns once running never reached it.
+        define: {
+            'process.env.NODE_ENV': JSON.stringify(
+                mode === 'build' ? 'production' : 'development',
+            ),
+        },
         ...(mode === 'build'
             ? {
                   // 38.5 — MINIFIED, and EVERY NAME HASHED, the entry's included: chunks and assets are

package/src/server/config.ts

@@ -156,6 +156,20 @@ export function positiveSetting<Fallback extends number | undefined>(
     return Number.isFinite(declared) && declared > 0 ? declared : fallback
 }
 
+/**
+ * Whether the switch `name` is on: `true` or `false`, or text reading `true` or `1`, `false` or `0`
+ * in any case, as 27.8 coerces one over a boolean default — and `fallback` where it is unset or reads
+ * as neither.
+ *
+ * 45.14.
+ */
+export function settingOn(name: string, fallback: boolean): boolean {
+    const declared = config.peek()?.[name]
+    if (typeof declared === 'boolean') return declared
+    if (typeof declared !== 'string') return fallback
+    return (coerce(declared, fallback) as boolean | undefined) ?? fallback
+}
+
 // 36.2 — `APP_URL`, parsed once per text it holds, and `undefined` where there is none or it will not
 // parse. Read through the configuration, so an environment that moves it moves every address.
 let appUrlFor: string | undefined

package/src/server/createApp.ts

@@ -6,6 +6,8 @@
 import { existsSync } from 'node:fs' // bun exposes no sync existence check of its own
 import { resolve } from 'node:path' // bun exposes no path helpers of its own
 import { FAILURE_STATUS_TEXT } from '#shared/FAILURE_STATUS_TEXT.ts'
+import { framingOf } from '#shared/framing.ts'
+import { LONGEST_DELAY } from '#shared/LONGEST_DELAY.ts'
 import { namedLogger } from '#shared/log.ts'
 import { compose } from '#shared/Middleware.ts'
 import { MOUNT, unmounted } from '#shared/mount.ts'
@@ -26,6 +28,7 @@ import {
 } from './config.ts'
 import { McpSurface } from './generatedSurfaces.ts'
 import { HOOKS, inOrder, reportUnexpected, rootRungs } from './hooks.ts'
+import { IDLE_TIMEOUT_SECONDS } from './IDLE_TIMEOUT_SECONDS.ts'
 import { installServer } from './installServer.ts'
 import { admitsMux, muxSocketOptions, upgraded } from './muxUpgrade.ts'
 import { plainAnswer } from './plainAnswer.ts'
@@ -34,11 +37,13 @@ import {
     type AnsweringApp,
     applyWritten,
     currentRequestScope,
+    holdScope,
     inReleasedScope,
     LISTENING,
     rungsTook,
     serverTiming,
 } from './requestScope.ts'
+import { heldBody } from './streamEvent.ts'
 import { testBuild } from './testBuild.ts'
 import { traceResponse } from './trace.ts'
 
@@ -299,7 +304,7 @@ export async function bootEntered(
         try {
             // 42.6 — `run`, with dispatch over it — and the headers every answer carries stamped
             // inside it, where the trace the request was answered under is still the current one.
-            // 16.22 — the scope keeps `given` too, the one request bun will raise a timeout on.
+            // 16.23 — the scope keeps `given` too, the one request bun will set a timeout on.
             return await inReleasedScope(
                 request,
                 async () => {
@@ -312,7 +317,7 @@ export async function bootEntered(
                         reportUnexpected(thrown)
                         answered = plainAnswer('internal server error', 500)
                     }
-                    const stamped = stamp(answered)
+                    const stamped = beating(stamp(answered))
                     // 28.7 — a closed namespace does not pay for the line it would have written.
                     if (REQUEST_LOG.enabled())
                         REQUEST_LOG.debug(
@@ -388,10 +393,9 @@ export async function bootEntered(
             new Promise<false>((done) => {
                 deadline = setTimeout(
                     () => done(false),
-                    // setTimeout reads anything past a signed 32-bit count as 1 ms.
                     Math.min(
                         positiveSetting('ABIDE_STOP_TIMEOUT', STOP_TIMEOUT),
-                        2 ** 31 - 1,
+                        LONGEST_DELAY,
                     ),
                 )
             }),
@@ -423,6 +427,9 @@ export async function bootEntered(
                 ...(options?.unix !== undefined
                     ? { unix: options.unix }
                     : {
+                          // 16.56 — the bound a request received whole lifts and its answer puts
+                          // back (16.23). A unix socket takes bun's own.
+                          idleTimeout: IDLE_TIMEOUT_SECONDS,
                           ...(port === undefined ? {} : { port }),
                           ...(options?.hostname === undefined
                               ? {}
@@ -505,6 +512,23 @@ function stamp(answered: Response): Response {
     return stamped
 }
 
+/**
+ * `answered`, beating where it is an event stream, and holding its request's scope until it ends.
+ *
+ * 16.57 — EVERY `text/event-stream`, whoever wrote it: an sse body, a followed value, a pairing's
+ * stream, a `Response` a handler built itself. 16.23 — and the hold is what keeps the last of those
+ * from being reaped once `fetch` returns, where nothing else outlives it.
+ */
+function beating(answered: Response): Response {
+    // The type first: reading `body` turns a string answer into a stream.
+    if (
+        framingOf(answered.headers.get('content-type')) !== 'sse' ||
+        answered.body === null
+    )
+        return answered
+    return new Response(heldBody(answered.body, holdScope(), true), answered)
+}
+
 /**
  * The request with the mount taken off its address, where it is under the mount — or the redirect
  * to the mount's root, where it asked for the mount with a `/` after it.

package/src/server/devWorker.ts

@@ -128,7 +128,7 @@ const relay = serveOver(
     },
 )
 
-// 16.22 — THE LISTENER HOLDS THE CONNECTION, so the idle timeout a call raises is raised there, on
+// 16.23 — THE LISTENER HOLDS THE CONNECTION, so a request's idle timeout is set there, on
 // the request bun handed it.
 LISTENING.timeout = relay.timeout
 
@@ -239,6 +239,9 @@ async function open(
                 client: bundling.then((bundle) => ({
                     manifest: bundle.manifest,
                     head: `<script type="module" src="${RELOAD_CLIENT_ADDRESS}"></script>`,
+                    // 45.9 — a worker `abide start` registered on this origin is removed rather than
+                    // left answering a dev server from what it saved.
+                    offline: false,
                     framework: (pathname, request) =>
                         pathname === RELOAD_CLIENT_ADDRESS
                             ? new Response(RELOAD_CLIENT, {

package/src/server/requestScope.ts

@@ -17,6 +17,7 @@ import type { Principal } from '#shared/principal.ts'
 import { SCOPING, type Scope } from '#shared/reactive/scoping.ts'
 import type { RpcRequest } from '#shared/rpcRequest.ts'
 import type { McpSurface } from './generatedSurfaces.ts'
+import { IDLE_TIMEOUT_SECONDS } from './IDLE_TIMEOUT_SECONDS.ts'
 
 /** The three framings a stream is answered in. 17.6. */
 export type Framing = Framed | 'bytes'
@@ -37,12 +38,8 @@ export type RequestScope = Scope & {
     caller: string | undefined
     /** This request's one resolve of the principal. 26.14. */
     principal: Promise<Principal> | undefined
-    /**
-     * The longest `timeout` any handler that ran in this request asked for, in seconds.
-     *
-     * 16.23 — and `Infinity` for one that is never reaped (16.57).
-     */
-    timeout: number
+    /** 16.23 — whether the received request's idle timeout is off until the answer is sent. */
+    unreaped: boolean
     /** This response's nonce, minted by the `csp` rung or on the first ask. 29.3. */
     nonce: string | undefined
     /** This request's cookie jar, built on the first ask. 22.2. */
@@ -71,7 +68,7 @@ export type RequestScope = Scope & {
     /**
      * The request the listener was handed, before a mount or a rung made another.
      *
-     * 16.22 — bun raises the idle timeout only on the one it received itself.
+     * 16.23 — bun sets the idle timeout only on the one it received itself.
      */
     received: Request | undefined
     /** What a write through `response` is collected onto, for whoever answers to apply. 22.9. */
@@ -168,7 +165,7 @@ export function scopeFor(
         cookies: undefined,
         nonce: undefined,
         framing: undefined,
-        timeout: 0,
+        unreaped: false,
         caller: undefined,
         principal: undefined,
         applied: false,
@@ -216,6 +213,8 @@ export function inReleasedScope<Result>(
     received: Request | undefined = given,
 ): Promise<Result> {
     const scope = scopeFor(given, received, app)
+    // 16.23 — a request with no body is received whole as it arrives.
+    if (received?.body === null) unreap(scope)
     return STORAGE.run(scope, async () => {
         try {
             return await body()
@@ -269,6 +268,12 @@ export function heldByApp(end: () => void): () => void {
 export function releaseScope(scope: RequestScope): void {
     scope.holds -= 1
     if (scope.holds > 0) return
+    // 16.56 — answered, the connection is reaped once idle again: set before bun writes an answer
+    // that was not streamed, and as the last chunk of one that was goes out.
+    if (scope.unreaped) {
+        scope.unreaped = false
+        LISTENING.timeout(scope.received as Request, IDLE_TIMEOUT_SECONDS)
+    }
     const stops = scope.stops
     for (let at = 0; at < stops.length; at += 1) (stops[at] as () => void)()
     stops.length = 0
@@ -285,10 +290,25 @@ export function adoptRequest(given: Request): void {
 }
 
 /**
- * What `App.listen` bound, and how a call raises the idle timeout on the received request.
+ * Turns the received request's idle timeout off until its answer is sent (16.23), for a request
+ * received whole. Where no request was received there is no connection to keep.
+ *
+ * WHOLE, NOT ARRIVED: a body still arriving is reaped as any idle connection is (16.56), so a caller
+ * that stops sending partway is not held open for good.
+ */
+export function unreap(scope: RequestScope | undefined): void {
+    if (scope === undefined || scope.received === undefined || scope.unreaped)
+        return
+    scope.unreaped = true
+    // bun spells "never reaped" 0.
+    LISTENING.timeout(scope.received, 0)
+}
+
+/**
+ * What `App.listen` bound, and how the idle timeout is set on the received request.
  *
- * 42.9 — the server is for `server` to hand back. 16.22 — the timeout is raised on the server
- * bound here, or where the listener is in another process (`abide dev`), by a message to it.
+ * 42.9 — the server is for `server` to hand back. 16.23 — the timeout is set on the server bound
+ * here, or where the listener is in another process (`abide dev`), by a message to it.
  */
 export const LISTENING: {
     server: Bun.Server<unknown> | undefined

package/src/server/responseRelay.ts

@@ -25,7 +25,7 @@ export type ToRelay =
     | { kind: 'pull'; id: number }
     | { kind: 'cancel'; id: number }
 
-/** What the worker's half sends: a request's idle timeout raised, and its head, each chunk, and its end. */
+/** What the worker's half sends: a request's idle timeout set, and its head, each chunk, and its end. */
 export type FromRelay =
     | { kind: 'timeout'; id: number; seconds: number }
     | {
@@ -56,8 +56,8 @@ export function describe(thrown: unknown): string {
 
 /**
  * The worker's half: answers each request the listener sends with `fetch`, and its body a chunk per
- * pull. `take` is handed every `ToRelay` message; `timeout` raises a request's idle timeout where the
- * listener holds its connection (16.22); `hangUpAll` aborts every request still being answered.
+ * pull. `take` is handed every `ToRelay` message; `timeout` sets a request's idle timeout where the
+ * listener holds its connection (16.23); `hangUpAll` aborts every request still being answered.
  */
 export function serveOver(
     channel: Channel<FromRelay>,
@@ -80,7 +80,7 @@ export function serveOver(
         number,
         { reader: ReadableStreamDefaultReader<Uint8Array>; html: boolean }
     >()
-    // 16.22 — each request built here, known by the ask it was built from.
+    // 16.23 — each request built here, known by the ask it was built from.
     const asks = new WeakMap<Request, number>()
 
     const ended = (id: number): void => {
@@ -203,7 +203,7 @@ export function serveOver(
 // and, once its head has come back, the stream the body is fed into and the pull waiting on the
 // worker's next chunk (38.35).
 type InFlight = {
-    // 16.22 — the request bun handed the listener, which is the one its idle timeout is raised on.
+    // 16.23 — the request bun handed the listener, which is the one its idle timeout is set on.
     request: Request
     headers: [string, string][]
     body: ArrayBuffer | null
@@ -223,7 +223,7 @@ type InFlight = {
  * compiles; `endAll` ends what the worker that is gone was answering.
  */
 export function askOver(
-    raiseTimeout: (request: Request, seconds: number) => void,
+    setIdleTimeout: (request: Request, seconds: number) => void,
 ) {
     let channel: Channel<ToRelay> | undefined
     const inFlight = new Map<number, InFlight>()
@@ -334,7 +334,7 @@ export function askOver(
             const waiting = inFlight.get(message.id)
             if (waiting === undefined) return
             if (message.kind === 'timeout') {
-                raiseTimeout(waiting.request, message.seconds)
+                setIdleTimeout(waiting.request, message.seconds)
                 return
             }
             if (message.kind === 'head') {