@abide/abide 0.103.0 → 0.104.0

package/src/server/abideModules.ts

@@ -123,13 +123,39 @@ let registered = false
  */
 export function serveCompilation(root: string, compilation: Compilation): void {
     const real = realOrAsGiven(root)
-    addCompilation(real, compilation, RUNTIME)
+    const handlerFiles = addCompilation(real, compilation, RUNTIME)
     installSourceMaps(serverMapsOf(compilation, real), real)
+    if (handlerFiles.length !== 0) Bun.plugin(handlerFilesPlugin(handlerFiles))
     if (registered) return
     registered = true
     Bun.plugin(modulesPlugin(RUNTIME))
 }
 
+// 16.2 — A HANDLER FILE LOADED AT ITS OWN PATH RE-EXPORTS ITS FACE, so every spelling of its import
+// is the module the server mounted. The runtime asks `onResolve` only for a specifier with an
+// extension, while `onLoad` is asked by the path the file resolved to, however it was spelled. One
+// plugin per compilation because the filter is fixed at registration, and the runtime's `onLoad`
+// cannot fall through, so the filter names the handler files and nothing else. The face it names
+// is resolved by `modulesPlugin`, registered once.
+function handlerFilesPlugin(paths: string[]): Bun.BunPlugin {
+    return {
+        name: 'abide-handler-files',
+        setup(build) {
+            build.onLoad(
+                {
+                    filter: new RegExp(
+                        `^(?:${paths.map(RegExp.escape).join('|')})$`,
+                    ),
+                },
+                (args) => ({
+                    contents: `export { default } from ${JSON.stringify(`${args.path}${HANDLER_SUFFIX}`)}\n`,
+                    loader: 'js',
+                }),
+            )
+        },
+    }
+}
+
 /** What the server's table exports: its routes and error pages, server blocks and handlers. */
 export type BuiltTable = ServerTable & {
     /** 37.1 — every module a `<script server>` runs in, imported before the app boots. */
@@ -162,18 +188,24 @@ export function serverMapsOf(
     return maps
 }
 
+/** Adds `compilation` to `held`, and answers its handler files' absolute paths. */
 function addCompilation(
     root: string,
     compilation: Compilation,
     held: Held,
-): void {
+): string[] {
     // RESOLVED, not joined: a dependency's file is keyed above the root (`../node_modules/…`).
     for (const [relative, compiled] of Object.entries(compilation.files))
         held.files.set(resolve(root, relative), compiled)
-    for (const [relative, face] of Object.entries(compilation.handlers))
-        held.handlers.set(resolve(root, relative), face)
+    const handlerFiles: string[] = []
+    for (const [relative, face] of Object.entries(compilation.handlers)) {
+        const path = resolve(root, relative)
+        held.handlers.set(path, face)
+        handlerFiles.push(path)
+    }
     for (const [name, text] of Object.entries(compilation.tables))
         held.tables.set(`${root}/${VIRTUAL_DIRECTORY}/${name}`, text)
+    return handlerFiles
 }
 
 // `Bun.resolveSync` asks EVERY abide plugin's `onResolve` again — this one's, and the runtime's, which
@@ -292,46 +324,45 @@ function modulesPlugin(served: Held): Bun.BunPlugin {
 
             // A HANDLER FILE IS FOUND BY WHERE ITS IMPORT RESOLVES, however the import spells it, and
             // only from the app's own modules: a package's never names one, and asking bun again for
-            // each of a package's relative imports is a resolve per module of the bundle. IN A BUNDLE
-            // THE FILTER IS THE HANDLER FILES' NAMES: a hook matching every relative import costs the
-            // bundle abide's own `sideEffects`, and the barrel's rest — the validator, the csp — moved
-            // into the chunk every page loads (38.94). The runtime is told of each compilation after
-            // it registered, so it matches every relative or `#` import and asks.
+            // each of a package's relative imports is a resolve per module of the bundle. THE FILTER
+            // IS THE HANDLER FILES' NAMES: a hook matching every relative import costs the bundle
+            // abide's own `sideEffects`, and the barrel's rest — the validator, the csp — moved into
+            // the chunk every page loads (38.94). ONLY IN A BUNDLE: the runtime finds a handler file
+            // by the path it loads at (`handlerFilesPlugin`), which costs no resolve per import.
             // Each handler file's name without `.ts` — what an import of one ends in.
-            let stems: string[] | undefined
-            if (bundling) {
-                const names = new Set<string>()
+            const stems = new Set<string>()
+            if (bundling)
                 for (const path of served.handlers.keys())
-                    names.add(basename(path, '.ts'))
-                stems = [...names]
-            }
-            const handlerImport =
-                stems === undefined
-                    ? RELATIVE_OR_SUBPATH
-                    : new RegExp(
-                          `(?:^|/)(?:${stems.map(RegExp.escape).join('|')})(?:\\.ts)?$`,
-                      )
-            if (stems?.length !== 0)
-                build.onResolve({ filter: handlerImport }, (args) => {
-                    if (resolving || !RELATIVE_OR_SUBPATH.test(args.path))
-                        return undefined
-                    const importer = pathOf(args.importer)
-                    if (importer.includes('/node_modules/')) return undefined
-                    let path: string
-                    try {
-                        path = resolved(args.path, args.importer)
-                    } catch {
-                        return undefined
-                    }
-                    const face = served.handlers.get(path)
-                    if (face === undefined) return undefined
-                    // 20.4 — a handler the browser is handed no wrapper for is no import of its.
-                    if (inBrowser(args.importer) && face.client === '')
-                        throw new Error(
-                            `abide: ${pathOf(args.importer)} imports ${args.path}, whose handler withholds itself from the browser (\`clients: { ui: false }\`). Call it from a <script server>, or let the browser have it. RULEBOOK 20.4.`,
-                        )
-                    return { path: `${path}${HANDLER_SUFFIX}` }
-                })
+                    stems.add(basename(path, '.ts'))
+            if (stems.size !== 0)
+                build.onResolve(
+                    {
+                        filter: new RegExp(
+                            `(?:^|/)(?:${[...stems].map(RegExp.escape).join('|')})(?:\\.ts)?$`,
+                        ),
+                    },
+                    (args) => {
+                        if (resolving || !RELATIVE_OR_SUBPATH.test(args.path))
+                            return undefined
+                        const importer = pathOf(args.importer)
+                        if (importer.includes('/node_modules/'))
+                            return undefined
+                        let path: string
+                        try {
+                            path = resolved(args.path, args.importer)
+                        } catch {
+                            return undefined
+                        }
+                        const face = served.handlers.get(path)
+                        if (face === undefined) return undefined
+                        // 20.4 — a handler the browser is handed no wrapper for is no import of its.
+                        if (inBrowser(args.importer) && face.client === '')
+                            throw new Error(
+                                `abide: ${pathOf(args.importer)} imports ${args.path}, whose handler withholds itself from the browser (\`clients: { ui: false }\`). Call it from a <script server>, or let the browser have it. RULEBOOK 20.4.`,
+                            )
+                        return { path: `${path}${HANDLER_SUFFIX}` }
+                    },
+                )
 
             // A RELATIVE SPECIFIER A FACE IMPORTS AT RUN TIME is resolved from the file the face
             // stands for: bun's runtime reads one from an importer in a namespace as no path at
@@ -340,12 +371,18 @@ function modulesPlugin(served: Held): Bun.BunPlugin {
             // and where a hook matching every relative import in a package costs the bundle that
             // package's `sideEffects`: a two-page app grew by 12 KB, the validator one page never
             // calls moved into the chunk both pages load.
-            if (!bundling)
+            if (!bundling) {
+                // A face `handlerFilesPlugin` re-exports, named by its absolute path, which no file
+                // is at.
+                build.onResolve({ filter: HANDLER_FACE }, (args) => ({
+                    path: args.path,
+                }))
                 build.onResolve({ filter: /^\.\.?\// }, (args) =>
                     resolving || pathOf(args.importer) === args.importer
                         ? undefined
                         : { path: resolved(args.path, args.importer) },
                 )
+            }
 
             build.onLoad(
                 { filter: /\.abide$/, namespace: componentNamespace },

package/src/server/appTree.ts

@@ -15,6 +15,7 @@
 import { type Dirent, existsSync, readdirSync } from 'node:fs' // bun has no directory listing or sync existence check of its own
 import { ABIDE_ADDRESS } from '#shared/ADDRESSES.ts'
 import {
+    HOLDS_SERVER,
     LIB_DIRECTORY,
     PUBLIC_DIRECTORY,
     RESERVED_DIRECTORIES,
@@ -28,7 +29,7 @@ type AppFiles = {
     abide: string[]
     /** Every handler file, in path order. */
     handlers: string[]
-    /** Every module under a `server` or a `lib` directory, in path order — run as it is imported. */
+    /** Every module under a `server` or a `lib` directory, in path order — read for 37.13. */
     modules: string[]
     /** Every file under a `public` directory, to the address it is answered at below the mount. */
     published: Map<string, string>
@@ -90,7 +91,14 @@ function walk(
         if (entry.isDirectory()) {
             let within = reserved
             if (RESERVED_DIRECTORIES.has(entry.name)) {
-                if (reserved !== undefined)
+                // 23.16 — `server` nests in the fences that hold code.
+                if (
+                    reserved !== undefined &&
+                    !(
+                        entry.name === SERVER_DIRECTORY &&
+                        HOLDS_SERVER.has(reserved.name)
+                    )
+                )
                     refuse(
                         path,
                         `abide: ${path} is a ${entry.name} directory under the ${reserved.name} directory ${reserved.path}. RULEBOOK 23.16.`,

package/src/server/generatedSurfaces.ts

@@ -29,7 +29,7 @@ import { type Listed, surfaceOf } from './surfaceOf.ts'
 const OPENAPI_LOG = namedLogger('abide:openapi')
 const MCP_LOG = namedLogger('abide:mcp')
 
-// What MCP and OpenAPI add to a listing: whether the handler is keyed.
+// What OpenAPI adds to a listing: whether the handler is keyed.
 type Published = Listed & { keyed: boolean }
 
 /** Every handler `surface` lists (`surfaceOf`). */
@@ -212,18 +212,8 @@ export function openApi(
     return Object.keys(document().paths).length > 0 ? document : undefined
 }
 
-/** What the MCP surface publishes: a tool per call that takes args or writes, a resource per read. */
-type Tools = { tools: Published[]; resources: Published[] }
+const published = new WeakMap<Map<string, Mounted>, Reactive<Published[]>>()
 
-const published = new WeakMap<Map<string, Mounted>, Reactive<Tools>>()
-
-function toolsOf(handlers: Map<string, Mounted>): Tools {
-    const found: Tools = { tools: [], resources: [] }
-    for (const one of listed(handlers, 'mcp'))
-        if (one.keyed || one.method !== 'GET') found.tools.push(one)
-        else found.resources.push(one)
-    return found
-}
 
 type JsonRpc = {
     jsonrpc: '2.0'
@@ -264,18 +254,20 @@ export class McpSurface {
 
     /** Whether the route table publishes any handler to it. 20.7. */
     get opened(): boolean {
-        const { tools, resources } = this.#published()
-        return tools.length > 0 || resources.length > 0
+        return this.#published().length > 0
     }
 
-    #published(): Tools {
-        return overTable(published, this.#handlers, toolsOf)()
+    #published(): Published[] {
+        // Every handler the MCP surface lists, each a tool — a read as much as a mutation. 20.9.
+        return overTable(published, this.#handlers, (handlers) =>
+            listed(handlers, 'mcp'),
+        )()
     }
 
     /** Every tool it lists. 20.9. */
     list(): ToolDefinition[] {
         const listing: ToolDefinition[] = []
-        for (const tool of this.#published().tools) {
+        for (const tool of this.#published()) {
             if (tool.description === undefined)
                 MCP_LOG.warning(
                     `${tool.name} is published with no description.`,
@@ -305,7 +297,7 @@ export class McpSurface {
     }
 
     #tool(name: unknown): Published | undefined {
-        return this.#published().tools.find((one) => one.name === name)
+        return this.#published().find((one) => one.name === name)
     }
 
     async #called(
@@ -335,7 +327,7 @@ export class McpSurface {
                 return {
                     result: {
                         protocolVersion: MCP_PROTOCOL_VERSION,
-                        capabilities: { tools: {}, resources: {} },
+                        capabilities: { tools: {} },
                         serverInfo: appIdentity(),
                     },
                 }
@@ -343,19 +335,6 @@ export class McpSurface {
                 return { result: {} }
             case 'tools/list':
                 return { result: { tools: this.list() } }
-            case 'resources/list':
-                return {
-                    result: {
-                        resources: this.#published().resources.map(
-                            (resource) => ({
-                                uri: `abide:${resource.address}`,
-                                name: resource.name,
-                                description: resource.description ?? '',
-                                mimeType: 'application/json',
-                            }),
-                        ),
-                    },
-                }
             case 'tools/call': {
                 const tool = this.#tool(params?.name)
                 if (tool === undefined)
@@ -375,25 +354,6 @@ export class McpSurface {
                     },
                 }
             }
-            case 'resources/read': {
-                const uri = String(params?.uri ?? '')
-                const resource = this.#published().resources.find(
-                    (one) => `abide:${one.address}` === uri,
-                )
-                if (resource === undefined)
-                    return mcpFailure(-32602, `No resource at ${uri}.`)
-                const { text, failed } = await this.#called(
-                    resource,
-                    undefined,
-                    asker,
-                )
-                if (failed) return mcpFailure(-32603, text)
-                return {
-                    result: {
-                        contents: [{ uri, mimeType: 'application/json', text }],
-                    },
-                }
-            }
             default:
                 return mcpFailure(-32601, `No method ${method}.`)
         }
@@ -404,8 +364,7 @@ export class McpSurface {
  * Answers one MCP JSON-RPC request over `surface`, or `undefined` where it publishes nothing.
  *
  * 20.9 — THE STREAMABLE-HTTP MCP ENDPOINT, answering JSON-RPC over `POST`, as the request's own
- * caller: a handler that takes no args is a resource, read at its address; one that takes args, and
- * every mutation, is a tool.
+ * caller: every handler it lists is a tool, a read as much as a mutation.
  */
 export async function answerMcp(
     surface: McpSurface,

package/src/server/versionOf.ts

@@ -1,8 +1,7 @@
 // 18.7 — THE VERSION A VALUE'S STANDING PRODUCTION IS NAMED BY OVER THE WIRE. Stamped where it is
 // asked for rather than where a production is minted, so a value no browser follows pays nothing on
 // its production path. A production is told apart from the one before by the ordinal, what is held
-// (6.10 moves no ordinal for `undefined`) and the patch epoch of what is held (5.7 moves no ordinal
-// for a patch).
+// and the patch epoch of what is held (5.7 moves no ordinal for a patch).
 //
 // ONE COUNTER FOR THE PROCESS, started at the boot time in microseconds, so no two productions share
 // a number: not two values, not an entry evicted and built again, and not this process and the one

package/src/shared/RESERVED_DIRECTORIES.ts

@@ -22,3 +22,9 @@ export const RESERVED_DIRECTORIES: ReadonlySet<string> = new Set([
     LIB_DIRECTORY,
     TESTS_DIRECTORY,
 ])
+
+/** 23.16 — the fences a `server` directory nests in: it fences a graph rather than an address. */
+export const HOLDS_SERVER: ReadonlySet<string> = new Set([
+    LIB_DIRECTORY,
+    TESTS_DIRECTORY,
+])

package/src/shared/reactive/Cursor.ts

@@ -1,14 +1,12 @@
-// THE CURSOR. RULEBOOK 2.5: `for await (… of s)` — the production in flight, then each one after
-// it. On a streaming producer that is one turn per CHUNK, read from the chunk buffer by ordinal,
-// so two chunks between two `await`s are two turns of the loop. On every other value it is the
-// standing production: a burst between two turns collapses to the latest, since nothing else is
-// held. An app that wants every message keeps them — a channel is an array.
+// THE CURSOR. RULEBOOK 2.6: a streaming producer's chunks, read from the chunk buffer by ordinal,
+// so two chunks between two `await`s are two turns of the loop, and a patch or a write over the
+// stream moves no place (5.7, 9.12). Where the run ENDS is the caller's settling, handed to
+// `closeOn`: `for await` over a `Reactive` is `Reactive.ts`'s `producedRun`.
 //
 // A NARROW FACE rather than the `Cell`, the same way `tracking.ts` takes a `Tracked`: what a
 // cursor reads is a handful of fields, and naming them keeps the cell's internals out of a
 // second file.
 
-import { PATCHES } from './PATCHES.ts'
 import {
     dropReader,
     newSubscriber,
@@ -23,21 +21,14 @@ import {
  * place in a stream's chunk buffer without the buffer having to hold one.
  */
 export type Retained = Tracked & {
-    /** The window a `throttle` or a `debounce` holds open, `holding` while a production waits on it. */
-    cap: { holding: boolean } | null
     ordinal: number
     ring: unknown[]
     ringBase: number
-    servable: boolean
-    state: number
-    /**
-     * Non-null on a streaming producer, whose ring is the accumulation of the run being served
-     * (9.1) and is retained whole — the chunks ARE the value.
-     */
-    stream: object | null
-    value: unknown
 }
 
+/** What `take` answers when the cursor has caught up — never a chunk, which may be `undefined`. */
+export const CAUGHT_UP: unique symbol = Symbol('caught up')
+
 // The cursors standing over each source, for a patch to keep the place of the ones behind (5.7).
 const CURSORS = new WeakMap<Retained, Set<Cursor>>()
 
@@ -70,61 +61,36 @@ export function hasCursorBehind(source: Retained): boolean {
 }
 
 /**
- * A live reader of a source's productions, one turn per production, in order.
+ * A reader of a stream's chunks, in order, waking whoever waits on it when one lands.
  *
- * A RECORD, NOT A SCOPE. The four closures this was — `take`, `notify`, `stop` and `next` — shared
- * one environment holding `at`, `waiting`, `source` and `reader`, and a cursor OUTLIVES the call
- * that made it: a `for await` holds one for the life of the loop, so the environment and every
- * function object hanging off it is live that whole time. Fields on a prototype are the object
- * alone, and `at` — read and written on every turn — becomes a property load on a fixed structure
- * rather than a scope load.
+ * A RECORD, NOT A SCOPE. A cursor outlives the call that made it — a `for await` holds one for the
+ * life of the loop — so fields on a prototype are the object alone, and `at`, read and written on
+ * every turn, is a property load on a fixed structure rather than a scope load.
  */
-export class Cursor implements AsyncIterator<unknown> {
+export class Cursor {
     source: Retained
-    /** The ordinal of the last production this cursor handed over. */
+    /** The ordinal of the last chunk this cursor handed over. */
     at: number
-    /**
-     * The patch epoch the value it last handed over stood at.
-     *
-     * A PATCH MINTS NO ORDINAL (5.7) — the follow's version tells a patch from a production by
-     * exactly that — so a cursor over a value patched in place reads the change off the object.
-     */
-    patched: number
-    /**
-     * The turns asked for and not yet answered.
-     *
-     * A QUEUE rather than one slot because a consumer may ask twice before either answer arrives
-     * — `Promise.all([ it.next(), it.next() ])` is the shape, and with one slot the second `next`
-     * overwrote the first's resolver and that promise never settled at all. `for await` asks one
-     * at a time, which is why nothing here said so.
-     */
-    waiting: ((result: IteratorResult<unknown>) => void)[]
+    /** Called once at the next wake, then cleared. */
+    wake: (() => void) | null
+    /** Whether the run `closeOn` was handed has settled. */
+    closed: boolean
+    /** What that run rejected with. */
+    failure: unknown
     reader: Subscriber
 
     constructor(source: Retained, from: number) {
         this.source = source
         this.at = from
-        this.patched = 0
-        this.waiting = []
-        // The one closure left, and it captures this cursor and nothing else. `notify` is
-        // called as a method on the SUBSCRIBER, so it cannot be the cursor's own method —
-        // and widening `Subscriber` with a back-edge would put a field on the shape every
-        // reader in the graph carries for the sake of the few that are cursors.
-        // Registered outside the tracking protocol, so the source it waits on is declared
-        // rather than discovered — see the same shape in `Reactive`'s `settled`.
+        this.wake = null
+        this.closed = false
+        this.failure = undefined
+        // The one closure left, and it captures this cursor and nothing else. `notify` is called as a
+        // method on the SUBSCRIBER, so it cannot be the cursor's own method. Registered outside the
+        // tracking protocol, so the source it waits on is declared rather than discovered — see the
+        // same shape in `Reactive`'s `settled`.
         this.reader = newSubscriber([source], null)
-        // One production per waiting turn, in the order they were asked for: a burst that
-        // lands three productions on a consumer holding two turns answers both.
-        this.reader.notify = (): void => {
-            const waiting = this.waiting
-            while (waiting.length !== 0) {
-                const next = this.take()
-                if (next === null) return
-                ;(waiting.shift() as (result: IteratorResult<unknown>) => void)(
-                    next,
-                )
-            }
-        }
+        this.reader.notify = (): void => this.woken()
         source.readers.push(this.reader)
         let cursors = CURSORS.get(source)
         if (cursors === undefined) {
@@ -135,83 +101,60 @@ export class Cursor implements AsyncIterator<unknown> {
     }
 
     /**
-     * One production, or `null` where the cursor has caught up.
+     * The next chunk, or `CAUGHT_UP`.
      *
-     * Reading a stream's chunks by ordinal is what keeps a burst from being a gap or a repeat.
+     * Reading by ordinal is what keeps a burst from being a gap or a repeat.
      */
-    take(): IteratorResult<unknown> | null {
+    take(): unknown {
         const source = this.source
-        let at = this.at
-        if (source.stream === null) {
-            const value = source.value
-            // 6.10: an `undefined` standing is caught up, not a turn.
-            if (value === undefined) return null
-            const patched =
-                value !== null && typeof value === 'object'
-                    ? (PATCHES.written.get(value) ?? 0)
-                    : 0
-            if (at >= source.ordinal && patched === this.patched) return null
-            // 5.9 — A PRODUCTION A WINDOW HOLDS has minted its ordinal and is not yet the value: the
-            // turn is the release's, which wakes this cursor.
-            if (source.cap?.holding === true) return null
-            // The standing production is the only one held, so everything minted or patched
-            // since the last turn collapses into it.
-            this.at = source.ordinal
-            this.patched = patched
-            return { value, done: false }
-        }
-        if (at >= source.ordinal) return null
-        // A run that restarted moved the buffer past this cursor: answer from its start.
-        if (at < source.ringBase) at = source.ringBase
-        const value = source.ring[at - source.ringBase]
-        this.at = at + 1
-        return { value, done: false }
-    }
-
-    next(): Promise<IteratorResult<unknown>> {
-        if (!this.reader.alive)
-            return Promise.resolve({ value: undefined, done: true })
-        // A TURN ALREADY ASKED FOR AND NOT ANSWERED KEEPS THE ORDER: taking from the
-        // ring here while one is queued would hand the later caller the earlier
-        // production.
-        if (this.waiting.length === 0) {
-            const ready = this.take()
-            // NOT `async`, and no `await` on the caught-up arm. A cursor behind a
-            // stream's chunks is the common shape while a burst drains, and an
-            // `async` here would put a microtask tick between every one of those
-            // turns.
-            if (ready !== null) return Promise.resolve(ready)
-        }
-        const waiting = this.waiting
-        return new Promise((resolve) => {
-            waiting.push(resolve)
-        })
+        if (this.at >= source.ordinal) return CAUGHT_UP
+        const value = source.ring[this.at - source.ringBase]
+        this.at += 1
+        return value
     }
 
     /**
-     * Ends the cursor: `for await` calls this on `break`, on `return` and on a throw.
+     * Ends the cursor's run where `run` settles: `closed` is set, `failure` holds a rejection, and
+     * the current `turn` wakes.
      *
-     * It is the only thing that drops the subscriber — a live cursor has no end of its own.
+     * ONE REACTION ON THE CLOSE FOR THE WHOLE RUN, never one per chunk held until the run ends. A
+     * chunk landing in the same turn as the close is still unread when the close wakes the caller,
+     * so a drain before reading `closed` hands it over rather than losing it to whichever settled
+     * first.
      */
-    return(): Promise<IteratorResult<unknown>> {
-        return this.stop()
+    closeOn(run: PromiseLike<unknown>): void {
+        run.then(
+            () => {
+                this.closed = true
+                this.woken()
+            },
+            (error: unknown) => {
+                this.closed = true
+                this.failure = error
+                this.woken()
+            },
+        )
+    }
+
+    /** Settles at the next chunk or the close, whichever lands first. */
+    turn(): Promise<void> {
+        return new Promise((resolve) => {
+            this.wake = resolve
+        })
     }
 
-    throw(): Promise<IteratorResult<unknown>> {
-        return this.stop()
+    private woken(): void {
+        const wake = this.wake
+        this.wake = null
+        wake?.()
     }
 
-    stop(): Promise<IteratorResult<unknown>> {
+    /** Drops the subscriber; nothing else does. */
+    stop(): void {
         const reader = this.reader
         reader.alive = false
         dropReader(this.source, reader)
         CURSORS.get(this.source)?.delete(this)
-        const waiting = this.waiting
-        while (waiting.length !== 0)
-            (waiting.shift() as (result: IteratorResult<unknown>) => void)({
-                value: undefined,
-                done: true,
-            })
-        return Promise.resolve({ value: undefined, done: true })
+        this.wake = null
     }
 }