holon-sh 0.0.1-dev.11 → 0.0.1-dev.13

package/dist/ext/events.js

@@ -1,15 +1,10 @@
 // The server side of MCP Events, as the Triggers & Events Working Group's design sketch defines it:
 // https://github.com/modelcontextprotocol/experimental-ext-triggers-events/blob/main/docs/design-sketch-proposal.md
-// The draft is experimental, so this lives under ext and may change with it.
-// It serves the poll and push delivery modes, and webhook delivery when given a webhookTtl, from a module of its own
-// that reaches the event types through the internals below. Names follow the sketch, and types are the MCP SDK's own
-// wherever it has them.
+// The draft is experimental, so this lives under ext and may change with it. It serves the poll and push delivery
+// modes. Names follow the sketch, and types are the MCP SDK's own wherever it has them.
 import { ProtocolError, ProtocolErrorCode, SUBSCRIPTION_ID_META_KEY } from "@modelcontextprotocol/server";
-import { webhooks } from "./webhooks.js";
 /** The identifier a server declares the Events extension under, in capabilities.extensions. */
 export const EVENTS_EXTENSION = "io.modelcontextprotocol/events";
-/** Reaches what a delivery mode needs of the events it serves. Not for applications. */
-export const INTERNALS = Symbol.for("holon-sh.events.internals");
 const INVALID_PARAMS = ProtocolErrorCode.InvalidParams;
 const INTERNAL_ERROR = ProtocolErrorCode.InternalError;
 // The sketch's general-purpose codes, provisional until the specification allocates them.
@@ -43,7 +38,7 @@ const caller = (context) => {
 };
 const hex = (bytes) => [...bytes].map(byte => byte.toString(16).padStart(2, "0")).join("");
 // A subscription's id is the same for the same caller, event type and arguments, so it survives reconnects and poll
-// leases, as a webhook subscription's does. It is made with the global crypto, which needs no node:crypto at load.
+// leases. It is made with the global crypto, which needs no node:crypto at load.
 const identify = async (who, name, args) => {
     const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(JSON.stringify([who, name, canonical(args)])));
     return `sub_${hex(new Uint8Array(digest, 0, 16))}`;
@@ -53,11 +48,11 @@ const unique = () => `sub_${hex(crypto.getRandomValues(new Uint8Array(16)))}`;
 // A teardown that fails has nobody to tell, and must not take the process down.
 const settle = (run) => { Promise.resolve().then(run).catch(() => { }); };
 const integer = (value, minimum) => value === undefined || Number.isInteger(value) && value >= minimum;
-// What each type without a check function keeps of what it emits, for polls and reconnecting streams: the sketch's
-// emit buffer.
+const OFFERED = ["poll", "push"];
+// What each type keeps of what it emits, for polls and reconnecting streams: the sketch's emit buffer.
 const KEPT_EVENTS = 10_000;
 const KEPT_AGE = 10 * 60_000;
-// How long a poll is told to wait before the next, and how often a stream asks a check function.
+// How long a poll is told to wait before the next.
 const INTERVAL = 1000;
 // How often a stream hears from the server when nothing happens, as the sketch recommends.
 const HEARTBEAT = 30_000;
@@ -69,17 +64,20 @@ const MAX_SUBSCRIPTIONS = 10_000;
 const MAX_SUBSCRIPTIONS_PER_CALLER = 1000;
 // How many event types events/list returns at a time.
 const PAGE_SIZE = 100;
+/**
+ * What a stream sends before it ends and its client resumes from its cursor. The draft leaves flow control to the
+ * transport, but the MCP SDK's HTTP transport queues whatever a stream sends without waiting for its reader:
+ * https://github.com/modelcontextprotocol/experimental-ext-triggers-events/blob/main/docs/design-sketch-proposal.md#note-on-flow-control
+ */
+const STREAM_BUDGET = 2 ** 20;
 /**
  * Event types a process emits and the MCP servers it creates serve, in the poll and push delivery modes of MCP Events,
  * the draft extension of the Triggers & Events Working Group. Each type keeps the last ten thousand events it emits,
  * for ten minutes, for polls and for streams that reconnect: those cursors last as long as the process, and after a
- * restart a client is told that events were skipped. A type with a check function uses its source's cursors instead,
- * which outlive the process. A type is asked again, and a poll told to come back, every second. A stream hears from
- * the server every thirty seconds.
+ * restart a client is told that events were skipped. A poll is told to come back every second, and a stream hears
+ * from the server every thirty seconds.
  */
-export function createEvents({ webhookTtl, webhook } = {}) {
-    const modes = webhookTtl === undefined ? [] : [webhooks({ ...webhook, ttl: webhookTtl, heartbeat: HEARTBEAT })];
-    const offered = ["poll", "push", ...modes.map(mode => mode.name)];
+export function createEvents() {
     // Cursors are positions in this process's memory. One from another process names nothing here. The name is made
     // without node:crypto, which is not there when a server is evaluated for its contract.
     const epoch = `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`;
@@ -88,33 +86,21 @@ export function createEvents({ webhookTtl, webhook } = {}) {
     let subscribed = 0;
     const callers = new Map();
     const position = (type, sequence = type.sequence) => `${epoch}.${sequence}`;
-    // An event emitted to one subscription that it could not be given is owed to it as a gap, on its next poll or
-    // stream. The ids owed one are as many as the events a type keeps.
-    const owe = (type, id) => {
-        type.owed.delete(id);
-        type.owed.set(id, true);
-        if (type.owed.size > KEPT_EVENTS)
-            type.owed.delete(type.owed.keys().next().value);
-    };
-    // What a subscription is owed after a cursor from the events emitted: the ones for it, in order, where delivery
-    // starts, and where it now stands. A null cursor starts from now, and so does one from another process. One past
-    // the events still kept starts from the oldest kept, and says that events were skipped.
-    const since = (state, subscription, cursor, maxAgeMs, limit = Infinity) => {
-        const type = state;
-        const now = { events: [], start: position(type), cursor: position(type), hasMore: false };
-        if (cursor == null)
-            return { ...now, truncated: false };
-        const [process, text] = cursor.split(".");
-        const sequence = Number(text);
-        if (process !== epoch || !Number.isInteger(sequence) || sequence > type.sequence)
-            return { ...now, truncated: true };
-        const floor = maxAgeMs === undefined ? -Infinity : Date.now() - maxAgeMs;
-        const later = type.kept.filter(kept => kept.sequence > sequence);
+    // What a subscription is owed after a cursor, up to `until`: the events for it, in order, where delivery starts,
+    // and where it now stands. A null cursor starts where the subscription was opened, and so does one from another
+    // process, which says that events were skipped. One past the events still kept starts from the oldest kept, and
+    // says so too.
+    const since = (type, subscription, cursor, { maxAgeMs, maxEvents: limit = Infinity, opened = type.sequence, until = type.sequence } = {}) => {
+        const [process, text] = cursor?.split(".") ?? [];
+        const resumed = cursor != null && process === epoch && Number.isInteger(Number(text)) && Number(text) <= type.sequence;
+        const sequence = resumed ? Number(text) : opened;
+        const floor = maxAgeMs === undefined || !resumed ? -Infinity : Date.now() - maxAgeMs;
+        const later = type.kept.filter(kept => kept.sequence > sequence && kept.sequence <= until);
         const recent = later.filter(kept => kept.at >= floor);
-        const truncated = sequence < type.dropped || recent.length < later.length;
+        const truncated = cursor != null && !resumed || sequence < type.dropped || recent.length < later.length;
         const events = [];
         const failures = [];
-        let reached = recent.length ? recent[0].sequence - 1 : type.sequence;
+        let reached = recent.length ? recent[0].sequence - 1 : until;
         const start = position(type, reached);
         for (const kept of recent) {
             if (events.length === limit)
@@ -124,49 +110,14 @@ export function createEvents({ webhookTtl, webhook } = {}) {
             if (event)
                 events.push(event);
         }
-        return { events, failures, start, cursor: position(type), truncated, hasMore: false };
-    };
-    // What a subscription is owed after a cursor from the type's check function. The cursor is the author's own. Each
-    // event is placed at its own cursor when it has one, so a batch can be cut short; otherwise at the cursor before
-    // the batch, which is safe to resume from. After a gap, delivery starts from the position the check reached.
-    const checked = async (type, { arguments: args, context }, cursor, maxAgeMs, limit = Infinity) => {
-        const result = await type.check(cursor ?? null, args, context);
-        const next = result?.cursor ?? null;
-        // A null cursor asks for the current position and nothing before it, except of a source that has no positions:
-        // each check of that is asked with null, and answers with what is new.
-        if (cursor == null && next !== null)
-            return { events: [], start: next, cursor: next, truncated: false, hasMore: false };
-        const items = result?.events ?? [];
-        const floor = maxAgeMs === undefined || cursor == null ? -Infinity : Date.now() - maxAgeMs;
-        let truncated = next !== null && Boolean(result.truncated);
-        const events = [];
-        const failures = [];
-        let reached = cursor ?? null;
-        let cuttable = false;
-        const answer = (end, hasMore) => ({ events, failures, start: truncated || !events.length ? end : cursor ?? null, cursor: end, truncated, hasMore });
-        for (const [index, item] of items.entries()) {
-            if (events.length === limit && cuttable)
-                return answer(reached, true);
-            const after = index === items.length - 1 ? next : item.cursor ?? reached;
-            const { eventId = crypto.randomUUID(), timestamp = new Date().toISOString(), data, _meta } = item;
-            if (Date.parse(timestamp) < floor)
-                truncated = next !== null;
-            else if (serialisable(type, eventId, { data, _meta }, error => failures.push(error)))
-                events.push({ eventId, name: type.name, timestamp, data, ...(_meta && { _meta }), cursor: after });
-            reached = after;
-            cuttable = item.cursor != null;
-        }
-        return answer(next, Boolean(result.hasMore));
+        return { events, failures, start, cursor: position(type, until), truncated, hasMore: false };
     };
-    // What a subscription is owed after a cursor, whichever way its type learns of events.
-    const read = (type, subscription, cursor, { maxAgeMs, maxEvents } = {}) => type.check ? checked(type, subscription, cursor, maxAgeMs, maxEvents) : since(type, subscription, cursor, maxAgeMs, maxEvents);
     // The occurrence a subscription receives, or nothing when it is not for it. An event emitted to one subscription
     // is for that one alone, and its arguments are not asked.
     // An event that cannot be shaped for a subscription, because `match` or `transform` throws or what `transform`
     // returns cannot be sent as JSON, is skipped for that subscription alone, so its cursor moves past it. It is
     // logged, and `failed` hears of it so a stream can say so once.
-    const shape = (state, { sequence, target, occurrence }, { id, untargetable, arguments: args, context }, failed) => {
-        const type = state;
+    const shape = (type, { sequence, target, occurrence }, { id, untargetable, arguments: args, context }, failed) => {
         let data;
         try {
             if (target !== undefined ? untargetable || target !== id : type.match && !type.match(occurrence.data, args, context))
@@ -176,25 +127,12 @@ export function createEvents({ webhookTtl, webhook } = {}) {
                 JSON.stringify(data);
         }
         catch (error) {
-            skipped(type, occurrence.eventId, error, failed);
+            const { eventId } = occurrence;
+            console.error(`holon-sh/ext/events: event ${eventId} of ${type.name} was skipped for a subscription:`, error);
+            failed({ code: INTERNAL_ERROR, message: `Event ${eventId} could not be delivered and was skipped`, data: { eventId, reason: String(error?.message ?? error) } });
             return undefined;
         }
-        return { ...occurrence, data, ...(sequence !== undefined && { cursor: position(type, sequence) }) };
-    };
-    const skipped = (type, eventId, error, failed) => {
-        console.error(`holon-sh/ext/events: event ${eventId} of ${type.name} was skipped for a subscription:`, error);
-        failed?.({ code: INTERNAL_ERROR, message: `Event ${eventId} could not be delivered and was skipped`, data: { eventId, reason: String(error?.message ?? error) } });
-    };
-    // What a check function found is skipped in the same way when it cannot be sent as JSON.
-    const serialisable = (type, eventId, value, failed) => {
-        try {
-            JSON.stringify(value);
-            return true;
-        }
-        catch (error) {
-            skipped(type, eventId, error, failed);
-            return false;
-        }
+        return { ...occurrence, data, cursor: position(type, sequence) };
     };
     // The event type and arguments a request names, checked as the sketch's errors require, in its order: the type,
     // the delivery mode, the request's own fields, the arguments, and then whether the caller may subscribe. A caller
@@ -203,7 +141,7 @@ export function createEvents({ webhookTtl, webhook } = {}) {
         const type = types.get(name);
         if (!type)
             throw refusal(removed);
-        if (delivery && !type.delivery.includes(delivery))
+        if (!type.delivery.includes(delivery))
             throw refusal({ code: UNSUPPORTED, message: "Unsupported", data: { feature: "deliveryMode", value: delivery } });
         if (cursor != null && typeof cursor !== "string")
             throw new ProtocolError(INVALID_PARAMS, "cursor must be a string or null");
@@ -229,12 +167,11 @@ export function createEvents({ webhookTtl, webhook } = {}) {
         for (const held of [...type.subscriptions.get(id)?.held ?? []])
             held.end(error);
     };
-    // Begins holding a subscription, by a stream, a poll lease or another delivery mode: counted against the limits
-    // first, so a refused one provisions nothing. The type's onSubscribe is called when the first hold of an id
-    // begins, and its onUnsubscribe when the last ends, so two streams of one subscription set it up once. `end` is how
-    // the delivery mode is told the app terminated it; `close` is how the mode says its hold is over.
-    const open = async (state, { id, delivery, arguments: args, context }, end) => {
-        const type = state;
+    // Begins holding a subscription, by a stream or a poll lease: counted against the limits first, so a refused one
+    // provisions nothing. The type's onSubscribe is called when the first hold of an id begins, and its onUnsubscribe
+    // when the last ends, so two streams of one subscription set it up once. `end` is how the holder is told the app
+    // terminated it; `close` is how the holder says its hold is over.
+    const open = async (type, { id, delivery, arguments: args, context }, end) => {
         if (types.get(type.name) !== type)
             throw refusal(removed);
         // Callers without an identity cannot be told apart, so they count together as one.
@@ -255,7 +192,7 @@ export function createEvents({ webhookTtl, webhook } = {}) {
         }
         const current = entry;
         let closed = false;
-        const held = { id, name: type.name, delivery, arguments: args, context, end, close() {
+        const held = { id, arguments: args, context, end, close() {
                 if (closed)
                     return;
                 closed = true;
@@ -306,13 +243,12 @@ export function createEvents({ webhookTtl, webhook } = {}) {
             lent = undefined;
         }
         if (!lent) {
-            const fresh = { type };
+            const fresh = { type, opening: open(type, { ...subscribed, id: key, delivery: "poll" }, error => {
+                    fresh.ended = error;
+                    fresh.release?.();
+                }) };
             lent = fresh;
             leases.set(key, fresh);
-            fresh.opening = open(type, { ...subscribed, id: key, delivery: "poll" }, error => {
-                fresh.ended = error;
-                fresh.release?.();
-            });
             fresh.opening.then(held => {
                 if (shared)
                     held.untargetable = true;
@@ -338,30 +274,20 @@ export function createEvents({ webhookTtl, webhook } = {}) {
         current.timer.unref?.();
         return held;
     };
-    // What a delivery mode works with: `subscription` checks a request, names its event type and the subscription's
-    // id, `open` begins holding a subscription, `read` gives a subscription what it is owed after a cursor (`since` and
-    // `shape` for emitted events alone), `position` is a type's cursor, a type's `sinks` hear what is emitted, and its
-    // `subscriptions` are the ones held by every mode, by id.
-    const internals = { types, subscription, open, read, since, shape, position };
     return {
-        [INTERNALS]: internals,
         /**
          * Declares an event type and returns the function that emits it. `match` decides which subscriptions receive an
-         * event from their arguments, and `transform` shapes its data for each. `check` returns what happened after a
-         * cursor, for event types whose source keeps its own history.
+         * event from their arguments, and `transform` shapes its data for each.
          */
-        event(name, { description, inputSchema, payloadSchema, _meta, match, transform, check, delivery = offered.filter(mode => !check || mode !== "webhook"), authorize, onSubscribe, onUnsubscribe }) {
+        event(name, { description, inputSchema, payloadSchema, _meta, match, transform, delivery = OFFERED, authorize, onSubscribe, onUnsubscribe }) {
             if (types.has(name))
                 throw new Error(`Event ${name} is already declared.`);
-            const unknown = delivery.filter(mode => !offered.includes(mode));
+            const unknown = delivery.filter(mode => !OFFERED.includes(mode));
             if (unknown.length || !delivery.length)
-                throw new Error(`Event ${name} is delivered by ${delivery.join(", ") || "nothing"}, but only ${offered.join(", ")} are served.`);
-            // Webhook delivery sends what is emitted, and does not ask a check function.
-            if (check && delivery.includes("webhook"))
-                throw new Error(`Event ${name} has a check function, which webhook delivery does not read.`);
+                throw new Error(`Event ${name} is delivered by ${delivery.join(", ") || "nothing"}, but only ${OFFERED.join(", ")} are served.`);
             const type = {
-                name, order: ++declared, description, inputSchema, payloadSchema, _meta, match, transform, check: check, interval: INTERVAL, delivery, authorize, onSubscribe, onUnsubscribe,
-                sequence: 0, dropped: 0, kept: [], sinks: new Set(), subscriptions: new Map(), owed: new Map(),
+                name, order: ++declared, description, inputSchema, payloadSchema, _meta, delivery, match, transform, authorize, onSubscribe, onUnsubscribe,
+                sequence: 0, dropped: 0, kept: [], sinks: new Set(), subscriptions: new Map(),
             };
             types.set(name, type);
             return {
@@ -369,26 +295,15 @@ export function createEvents({ webhookTtl, webhook } = {}) {
                     const occurrence = { eventId, name, timestamp, data };
                     // Data that cannot be sent as JSON is refused here, before anything is kept or sent.
                     JSON.stringify(occurrence);
-                    // A type with a check function is asked for what polls are owed, so what it emits is pushed and not kept.
-                    if (type.check) {
-                        // An event for one subscription that has no stream to take it is lost.
-                        if (target !== undefined && ![...type.subscriptions.get(target)?.held ?? []].some(held => held.delivery !== "poll"))
-                            owe(type, target);
-                        for (const sink of type.sinks)
-                            sink({ target, occurrence });
-                        return;
-                    }
                     // An event for one subscription is kept like any other, so the subscription has it when it comes back.
                     const kept = { sequence: ++type.sequence, at: Date.now(), target, occurrence };
                     type.kept.push(kept);
                     while (type.kept.length > KEPT_EVENTS || type.kept[0].at < kept.at - KEPT_AGE)
                         type.dropped = type.kept.shift().sequence;
                     for (const sink of type.sinks)
-                        sink(kept);
+                        sink();
                 },
                 cursor() {
-                    if (type.check)
-                        throw new Error(`Event ${name} has a check function, whose cursor is its source's own.`);
                     return position(type);
                 },
                 terminate(id, error = forbidden) {
@@ -408,9 +323,8 @@ export function createEvents({ webhookTtl, webhook } = {}) {
         },
         /** Serves the declared event types on an MCP server: events/list, events/poll and events/stream. */
         serve(mcp) {
-            const underlying = "server" in mcp ? mcp.server : mcp;
             // The custom methods are registered through the parts of the server this module uses.
-            const server = underlying;
+            const server = ("server" in mcp ? mcp.server : mcp);
             // The sketch declares capabilities.events. The MCP SDK's client drops top-level capabilities it does not know,
             // so the extension is declared under capabilities.extensions too, where SDK clients read it.
             // Clients are never told the event types changed: over Holon's stateless HTTP, the notification reaches none.
@@ -440,32 +354,43 @@ export function createEvents({ webhookTtl, webhook } = {}) {
                     ...(start + PAGE_SIZE < all.length && { nextCursor: String(page.at(-1).order) }),
                 };
             });
-            for (const mode of modes)
-                mode.serve(underlying, internals);
             server.setRequestHandler("events/poll", { params }, async (request, ctx) => {
                 const { type, subscription: subscribed } = await subscription(request, ctx.http, "poll");
+                // Taken before the lease, which waits for onSubscribe. The sketch's poll from null returns no events and a
+                // fresh cursor: this one is where the subscription opened, so the next poll has what onSubscribe emitted.
+                const opened = type.sequence;
                 const held = await lease(type, subscribed);
                 // Each poll is answered for its own caller, with the lease's id.
-                const { events, start, failures, truncated, ...rest } = await read(type, { ...subscribed, id: held.id, untargetable: held.untargetable }, request.cursor, request);
-                const lost = !held.untargetable && type.owed.delete(held.id);
+                const { events, start, failures, ...rest } = since(type, { ...subscribed, id: held.id, untargetable: held.untargetable }, request.cursor, { maxAgeMs: request.maxAgeMs, maxEvents: request.maxEvents, opened, ...(request.cursor == null && { until: opened }) });
                 // A poll carries its cursor once, for the whole response.
-                return { events: events.map(({ cursor, ...event }) => event), ...rest, truncated: truncated || lost, nextPollMs: type.interval };
+                return { events: events.map(({ cursor, ...event }) => event), ...rest, nextPollMs: INTERVAL };
             });
             server.setRequestHandler("events/stream", { params }, async (request, ctx) => {
-                const { type: state, subscription: subscribed } = await subscription(request, ctx.http, "push");
-                const type = state;
+                const { type, subscription: subscribed } = await subscription(request, ctx.http, "push");
                 const { signal } = ctx.mcpReq;
                 const meta = { [SUBSCRIPTION_ID_META_KEY]: ctx.mcpReq.id };
                 let done = false;
                 let ending;
+                // Set when the app terminates the stream: the last event emitted before, which the stream still sends.
+                let until;
                 let wake = () => { };
                 const finish = () => {
                     done = true;
                     wake();
                 };
+                // What is emitted from here on is the stream's, so it has what onSubscribe emits to it.
+                const opened = type.sequence;
                 const held = await open(type, { ...subscribed, delivery: "push" }, error => {
+                    // Lost access ends delivery at once, even while what came before is still being sent. Otherwise only the
+                    // first end counts, and the stream first sends what was emitted before it.
+                    const lost = error.code === FORBIDDEN;
+                    if (ending && !lost)
+                        return;
                     ending = error;
-                    finish();
+                    if (lost)
+                        return finish();
+                    until = type.sequence;
+                    wake();
                 });
                 // A client that left while the subscription was being set up is not waited for.
                 if (signal.aborted) {
@@ -479,32 +404,30 @@ export function createEvents({ webhookTtl, webhook } = {}) {
                 }
                 signal.addEventListener("abort", finish, { once: true });
                 // A stream that cannot be written to is over.
+                let sent = 0;
                 const notify = async (method, body) => {
                     if (signal.aborted)
                         return;
+                    const params = { ...body, _meta: meta };
                     try {
-                        await ctx.mcpReq.notify({ method: `notifications/events/${method}`, params: { ...body, _meta: meta } });
+                        await ctx.mcpReq.notify({ method: `notifications/events/${method}`, params });
                     }
                     catch {
                         finish();
                     }
+                    if ((sent += JSON.stringify(params).length) > STREAM_BUDGET)
+                        finish();
                 };
-                // The stream follows its cursor: emitted events wake it, and a type with a check function is asked again
-                // every interval. What it is owed waits in the buffer or the source, not here, so a slow client is not owed
-                // more memory than one batch; when what it is owed is no longer kept, it is told of the gap.
+                // The stream follows its cursor, and emitted events wake it. What it is owed waits in the buffer, not here, so
+                // a slow client is not owed more memory than one batch; when what it is owed is no longer kept, it is told of
+                // the gap.
                 let cursor = request.cursor ?? null;
                 let behind = true;
-                // What a type with a check function emitted and the stream has yet to send. The check function finds it
-                // too, so when too much waits the oldest is let go.
-                const pushed = [];
-                const sink = (kept) => {
-                    if (type.check) {
-                        pushed.push(kept);
-                        if (pushed.length > KEPT_EVENTS)
-                            pushed.shift();
-                    }
-                    else
-                        behind = true;
+                const sink = () => {
+                    // Nothing emitted after the app terminated the stream is for it.
+                    if (until !== undefined)
+                        return;
+                    behind = true;
                     wake();
                 };
                 type.sinks.add(sink);
@@ -529,71 +452,36 @@ export function createEvents({ webhookTtl, webhook } = {}) {
                 }, HEARTBEAT);
                 let first = true;
                 try {
-                    let due = 0;
                     while (!done) {
-                        if (type.check ? Date.now() >= due : behind) {
+                        if (behind) {
                             behind = false;
-                            let result;
-                            try {
-                                result = await read(type, held, cursor, { ...(first && request.maxAgeMs !== undefined && { maxAgeMs: request.maxAgeMs }) });
-                            }
-                            catch (error) {
-                                // Without a first answer there is no stream to tell, and the request fails.
-                                if (first)
-                                    throw error;
-                                await notify("error", { error: described(error) });
-                            }
-                            due = Date.now() + type.interval;
-                            if (result) {
-                                // A check function's gap is told after the events that follow it, at the position after them, since
-                                // the position before them is not known and the client's cursor must not go back. The stream is
-                                // confirmed before anything else is said on it.
-                                const after = type.check && result.truncated && !first;
-                                const truncated = result.truncated || first && type.owed.delete(held.id);
-                                if (first || truncated && !after)
-                                    await notify("active", { cursor: type.check && result.truncated ? cursor : result.start, truncated });
-                                if (first)
-                                    beat = heartbeats();
-                                first = false;
-                                for (const error of result.failures ?? [])
-                                    await notify("error", { error });
-                                for (const event of result.events) {
-                                    if (done)
-                                        break;
-                                    await notify("event", event);
-                                    cursor = event.cursor ?? null;
-                                }
+                            const result = since(type, held, cursor, { ...(first && request.maxAgeMs !== undefined && { maxAgeMs: request.maxAgeMs }), opened, until });
+                            // The stream is confirmed before anything else is said on it.
+                            if (first || result.truncated)
+                                await notify("active", { cursor: result.start, truncated: result.truncated });
+                            if (first)
+                                beat = heartbeats();
+                            first = false;
+                            for (const error of result.failures)
+                                await notify("error", { error });
+                            for (const event of result.events) {
                                 if (done)
                                     break;
-                                cursor = result.cursor;
-                                if (after)
-                                    await notify("active", { cursor, truncated: true });
-                                if (result.hasMore) {
-                                    due = 0;
-                                    behind = true;
-                                }
+                                await notify("event", event);
+                                cursor = event.cursor ?? null;
                             }
+                            if (done)
+                                break;
+                            cursor = result.cursor;
                         }
-                        // What a type with a check function emits is sent at once, at the cursor the stream has reached.
-                        while (pushed.length && !done) {
-                            let failure;
-                            const event = shape(type, pushed.shift(), held, error => { failure = error; });
-                            if (failure)
-                                await notify("error", { error: failure });
-                            if (event)
-                                await notify("event", { ...event, cursor });
-                        }
-                        if (done)
+                        // Terminated by the app, the stream ends once it has sent what was emitted before.
+                        if (done || until !== undefined && !behind)
                             break;
-                        let timer;
                         await new Promise(resolve => {
                             wake = resolve;
-                            if (done || pushed.length || (!type.check && behind))
+                            if (done || behind)
                                 resolve();
-                            else if (type.check)
-                                timer = setTimeout(resolve, Math.max(0, due - Date.now()));
                         });
-                        clearTimeout(timer);
                         wake = () => { };
                     }
                     if (ending) {
@@ -605,9 +493,6 @@ export function createEvents({ webhookTtl, webhook } = {}) {
                 finally {
                     clearInterval(beat);
                     type.sinks.delete(sink);
-                    // What was emitted to this subscription alone and not sent is owed to it as a gap when it comes back.
-                    if (held.id === subscribed.lease && pushed.some(kept => kept.target === held.id))
-                        owe(type, held.id);
                     held.close();
                 }
                 // The final frame, sent when the server ends the stream; when the client did, nobody is listening.