@cotal-ai/core 0.40.0 → 0.41.1

package/dist/endpoint.js

@@ -26,6 +26,26 @@ export const DEFAULT_SERVER = "nats://127.0.0.1:4222";
 const PLANE3_FRAME_HEADER = "Cotal-Delivery-Frame";
 /** Space joined when none is given on the CLI (the `cotal-<space>` cmux tab, etc.). */
 export const DEFAULT_SPACE = "main";
+/** How many channel filters one multi-filter consumer create may carry.
+ *
+ *  A create names every requested channel in one request, so the request grows with the channel
+ *  count and the CLIENT's request timeout is what gives way, not the broker: the create is never
+ *  refused, it just does not answer. Measured on an isolated broker, one message per channel,
+ *  `limit=5`: 70 filters answer in 43ms, 1,000 in 246ms, 5,000 in 5,345ms, and 10,000 does not
+ *  answer at all, failing `timeout` after 5,023ms. Note 5,000 SUCCEEDED while taking longer than
+ *  10,000 took to fail, which is what says the ceiling is on the create request rather than on the
+ *  read: past roughly 5s the create itself is what times out.
+ *
+ *  1,000 is chosen from that sweep rather than from the failure point: it is a fifth of the largest
+ *  count that still answered, and it answers in a quarter second, so a batch stays far away from
+ *  both the timeout and the response-deadline budget the dashboard has to share with its DM read.
+ *  A space with the 69 chat channels this was built for is still ONE read, so the round-trip claim
+ *  in #1210 is unchanged at that size. */
+export const MULTI_FILTER_BATCH = 1_000;
+/** How many filter batches may be in flight at once. Bounded because the point of #1210 was to stop
+ *  issuing one read per channel: a space large enough to need batches must not get the fan-out back
+ *  under another name. */
+export const MULTI_FILTER_READ_CONCURRENCY = 4;
 /**
  * Events: "message" (CotalMessage), "presence" (PresenceEvent), "roster" (Presence[]), "error" (Error),
  * "connection" ({ connected: boolean }) — true on every successful (re)bind (initial start, manual
@@ -185,6 +205,8 @@ export class CotalEndpoint extends EventEmitter {
     roster = new Map();
     /** Resolves when the current presence watch has consumed its complete initial KV snapshot. */
     presenceSnapshot = Promise.resolve();
+    /** False from connection reset until the watch marks the last entry in its initial replay. */
+    presenceSnapshotPopulated = false;
     /**
      * Observer-local age of the last presence-KV delivery (any key, including DEL/PURGE). Distinct
      * from each peer's `ts`: that is the publisher's heartbeat. Whole-bucket silence past TTL is
@@ -192,8 +214,8 @@ export class CotalEndpoint extends EventEmitter {
      * latter (#1045).
      */
     lastPresenceWatchAt = 0;
-    /** Last emitted presence-view freshness. Suppresses duplicate `presence-view` events. */
-    presenceViewFresh = true;
+    /** Last emitted presence-view state. Suppresses duplicate `presence-view` events. */
+    presenceViewState = "unpopulated";
     status = "idle";
     activity;
     /** Mirror of the connector's authoritative attention state, published in presence (advisory). The
@@ -830,7 +852,8 @@ export class CotalEndpoint extends EventEmitter {
         this.confirmingChatSubs.clear();
         this.roster.clear();
         this.lastPresenceWatchAt = 0;
-        this.presenceViewFresh = true;
+        this.presenceSnapshotPopulated = false;
+        this.emitPresenceViewIfChanged();
         this.joinSeq.clear();
         this.channelConfigs.clear();
         this.channelDefaults = {};
@@ -1608,29 +1631,31 @@ export class CotalEndpoint extends EventEmitter {
         return [...this.roster.values()].sort((a, b) => a.card.name.localeCompare(b.card.name));
     }
     /**
-     * Freshness of THIS observer's presence watch, not of any peer. `fresh: false` means the
-     * whole bucket has been silent past the liveness window — the view is stale as of
-     * `staleSince`, and {@link getRoster} is last-known rather than a current offline verdict.
-     * A watch that has not yet delivered anything is not stale (there is no T to name).
+     * Trust state of THIS observer's presence watch, not of any peer. `unpopulated` means the
+     * current watch has not completed its initial snapshot, so {@link getRoster} may be partial and
+     * cannot support an absence verdict. `stale` means the whole bucket has been silent past the
+     * liveness window, so the roster is last-known as of `staleSince`. `fresh` is false for both
+     * unsafe states so consumers written before `state` was added degrade in the safe direction.
      */
     presenceView() {
         if (!this.doWatch)
-            return { fresh: true };
-        if (this.lastPresenceWatchAt === 0)
-            return { fresh: true };
+            return { state: "current", fresh: true };
+        if (!this.presenceSnapshotPopulated)
+            return { state: "unpopulated", fresh: false };
         const staleSince = this.lastPresenceWatchAt + this.ttlMs;
         if (Date.now() < staleSince)
-            return { fresh: true };
-        return { fresh: false, staleSince };
+            return { state: "current", fresh: true };
+        return { state: "stale", fresh: false, staleSince };
     }
     /** Wait until the current presence watch has consumed its initial KV snapshot. An empty bucket
-     * emits no watch entry, so the timeout keeps a genuinely empty mesh bounded. */
+     * emits no watch entry, so the timeout keeps a genuinely empty mesh bounded and is reported
+     * distinctly from snapshot completion. */
     async waitForPresenceSnapshot(timeoutMs = 1_000) {
         let timer;
         try {
-            await Promise.race([
-                this.presenceSnapshot,
-                new Promise((resolve) => { timer = setTimeout(resolve, timeoutMs); }),
+            return await Promise.race([
+                this.presenceSnapshot.then(() => "snapshot"),
+                new Promise((resolve) => { timer = setTimeout(() => resolve("timeout"), timeoutMs); }),
             ]);
         }
         finally {
@@ -2099,7 +2124,107 @@ export class CotalEndpoint extends EventEmitter {
      *  reclaims its ephemeral consumer before the promise rejects. */
     async channelHistory(channel, opts) {
         // history from any sender
-        return this.streamHistory(chatStream(this.space), chatSubject(this.space, "*", "*", channel), opts?.limit ?? 100, undefined, opts?.signal);
+        return (await this.streamHistory(chatStream(this.space), [chatSubject(this.space, "*", "*", channel)], opts?.limit ?? 100, undefined, opts?.signal)).map((r) => r.msg);
+    }
+    /**
+     * The newest `limit` chat messages across MANY channels at once, oldest-first within the page,
+     * each tagged with the channel the BROKER delivered it on.
+     *
+     * **One read, not one per channel.** The CHAT stream already interleaves every channel into one
+     * sequence space, so "the newest N across these channels" is the tail of ONE stream, and a
+     * consumer takes a SET of filter subjects. The dashboard's activity feed used to answer this by
+     * calling {@link channelHistory} once per channel and merging: each of those is a widening probe
+     * loop, so the cost carried two multipliers (a probe loop per channel, and a fan-out across every
+     * channel). Counted on the wire over a seeded corpus of 69 chat channels and 24 event channels at
+     * limit 200: 2524 broker requests and about 8.0 MB transferred to return a 143,401-byte page,
+     * against 143 requests and about 0.91 MB here. With no link cost the counts and the page size
+     * repeat exactly across runs; the byte totals move by tens of bytes. `pnpm smoke:web-activity-read-cost` reproduces the
+     * second column and a frozen copy of the fan-out shape; the first is that same suite run against
+     * `544a974b7` (Cotal #1210).
+     *
+     * **The broker does the filtering, so the wire carries only what is asked for.** A channel left
+     * out of `channels` costs nothing: its messages are never delivered, so a space whose volume is
+     * dominated by channels the caller does not want stays cheap. That is the same "filter before the
+     * fetch" property the per-channel fan-out had, kept rather than traded away.
+     *
+     * **The channel comes from the SUBJECT, never from the payload.** A message claims a `channel`
+     * field, and this method ignores it: the tag is derived from the subject the broker routed the
+     * message on, the same derivation {@link listChannels} uses to name a channel in the first place.
+     *
+     * **Concrete channels only.** Filter subjects on one consumer may not overlap, and a wildcard
+     * channel subsumes its own subtree, so a wildcard here is refused rather than silently dropped or
+     * silently double-counted.
+     *
+     * **Observer/admin credentials only, and the broker is what says so.** A multi-filter create
+     * cannot encode its filter in the API subject, so it rides the bare
+     * `$JS.API.CONSUMER.CREATE.<CHAT>` row that only the read-only dashboard profiles hold. An agent
+     * credential pins the filter into the subject per channel and is denied here by the broker, which
+     * is the correct answer: this method reads across channels, and an agent's read ACL is per
+     * channel.
+     */
+    async multiChannelHistory(channels, opts) {
+        const subjects = [...new Set(channels.map((channel) => {
+                if (!isConcreteChannel(channel))
+                    throw new Error(`multiChannelHistory: "${channel}" is a wildcard channel - one consumer's filter subjects may not overlap, so name the concrete channels`);
+                // `chatSubject` builds the filter through `token()`, which REWRITES rather than refuses: it
+                // maps a character a subject may not carry to `_`, trims each segment, and drops empty ones.
+                // So "foo/bar" would filter on `foo_bar`, ".lead" on `lead`, and "team..b" on `team.b` - the
+                // caller names one channel and the broker returns another, which is the exact promise this
+                // method makes ("a channel left out of the list never crosses the link") inverted. This is the
+                // same aliasing `assertValidChannel` was written for on the policy path; the read path needs
+                // it too, and it fails loud rather than serving a channel nobody asked for.
+                assertValidChannel(channel);
+                return chatSubject(this.space, "*", "*", channel);
+            }))];
+        // No channels is not an empty stream, but it IS an empty answer, and asking the broker for a
+        // consumer with no filter would read the WHOLE stream instead of none of it.
+        if (subjects.length === 0)
+            return [];
+        const limit = opts?.limit ?? 100;
+        // ONE CREATE CANNOT CARRY AN UNBOUNDED FILTER LIST. The create names every subject in one
+        // request and the client's request timeout is what gives way, so past roughly 5,000 filters the
+        // read does not answer at all and the route loses the whole chat source: measured on an
+        // isolated broker, 10,000 channels failed `timeout` after 5,023ms while the fan-out this
+        // replaced still returned 2,739 messages on the same corpus. Reading in batches keeps the
+        // single-read cost at the sizes this was built for (69 channels is one batch, so #1210's
+        // round-trip numbers are unchanged) and degrades to a few reads instead of none above that.
+        // `batch` is a knob rather than a constant so the batched path can be compared against the
+        // single-create path on ONE corpus: forcing a small batch makes a space that would otherwise be
+        // one read take many, which is the only way to assert the two select the same messages.
+        const size = Math.max(1, Math.trunc(opts?.batch ?? MULTI_FILTER_BATCH));
+        const batches = [];
+        for (let i = 0; i < subjects.length; i += size)
+            batches.push(subjects.slice(i, i + size));
+        const pages = new Array(batches.length);
+        let next = 0;
+        const readBatch = async () => {
+            for (;;) {
+                const i = next++;
+                if (i >= batches.length)
+                    return;
+                pages[i] = await this.streamHistory(chatStream(this.space), batches[i], limit, undefined, opts?.signal);
+            }
+        };
+        // A BATCH THAT FAILS FAILS THE READ. Returning the batches that answered would be the newest
+        // `limit` across SOME of the channels asked for while looking like the newest across all of
+        // them, which is a wrong page presented as a right one. Throwing keeps the caller's existing
+        // envelope: the dashboard marks `chat` missing and says the page is partial, which is what it
+        // already did when this method was one read.
+        await Promise.all(Array.from({ length: Math.min(MULTI_FILTER_READ_CONCURRENCY, batches.length) }, readBatch));
+        // MERGE ON ARRIVAL, NOT ON `ts`. Each batch returns the newest `limit` within its own subjects,
+        // and the newest `limit` overall is a subset of their union, so re-selecting by stream sequence
+        // reproduces exactly what one create over the whole list would have selected. Sorting by the
+        // payload's `ts` here instead would change which messages the page holds, which is the
+        // selection question this pull request already had to answer once.
+        const rows = pages.flat().sort((a, b) => a.seq - b.seq).slice(-limit);
+        return rows.map(({ subject, msg }) => {
+            const p = parseSubject(subject);
+            // The filter set is built from chat subjects, so this cannot fire against a healthy broker.
+            // It is here because the alternative to raising is tagging a message with a guess.
+            if (p?.kind !== "chat")
+                throw new Error(`multiChannelHistory: the broker delivered ${subject}, which is not a chat subject on this space`);
+            return { channel: p.rest, msg };
+        });
     }
     /** Read a channel's recent history THROUGH THE DELIVERY DAEMON instead of through a consumer this
      *  connection creates itself — the mediated read of SPEC's "Mediated reads (normative)" rule (no raw
@@ -2146,7 +2271,7 @@ export class CotalEndpoint extends EventEmitter {
      *  skips for them — only an `admin`-profile cred can read it. */
     async dmHistory(opts) {
         // every inst.<recipOwner>.<recipActor>.<sndOwner>.<sndActor> DM — the whole DM subtree (god-view)
-        return this.streamHistory(dmStream(this.space), `${spacePrefix(this.space)}.inst.>`, opts?.limit ?? 100, undefined, opts?.signal);
+        return (await this.streamHistory(dmStream(this.space), [`${spacePrefix(this.space)}.inst.>`], opts?.limit ?? 100, undefined, opts?.signal)).map((r) => r.msg);
     }
     /**
      * The `limit` MOST RECENT messages matching `subject`, oldest-first within the page.
@@ -2171,7 +2296,7 @@ export class CotalEndpoint extends EventEmitter {
      *
      * `before` pages toward the past: pass the `seq` of the oldest message you already have.
      */
-    async streamHistory(stream, subject, limit, before, signal) {
+    async streamHistory(stream, subjects, limit, before, signal) {
         if (!this.nc)
             throw new Error("endpoint not started");
         signal?.throwIfAborted();
@@ -2210,7 +2335,7 @@ export class CotalEndpoint extends EventEmitter {
             // Deliberately NOT `getMessage({ last_by_subj })`, which would be the obvious way to ask: it
             // needs `$JS.API.STREAM.MSG.GET`, which read credentials do not hold. That grant hole already
             // shipped once from this function and turned every non-admin history read into an empty list.
-            const ceiling = before !== undefined ? before - 1 : await this.lastMatchingSeq(js, stream, subject, signal);
+            const ceiling = before !== undefined ? before - 1 : await this.lastMatchingSeq(js, stream, subjects, signal);
             if (ceiling < 1)
                 return [];
             // Widen from the exact ceiling until a window holds a full page, or until the window IS the
@@ -2219,6 +2344,25 @@ export class CotalEndpoint extends EventEmitter {
             // Geometric growth keeps the number of attempts logarithmic, so total wasted transfer is a
             // small multiple of a page.
             //
+            // THE FIRST WINDOW IS ONE PAGE WIDE, NOT FOUR. It used to open at `limit * 4` on the reasoning
+            // that a filtered subject is sparse inside its stream and a wider first look would land the
+            // page in one drain. That is true for one channel of a busy stream and false for a subject
+            // that IS most of its stream, and the second case is the one a whole-backlog read takes: the
+            // window succeeds on the first attempt and drains four pages to keep one, because
+            // `drainWindow` delivers everything in the window and keeps the tail. Measured on `/api/dms`
+            // at limit 500 against a 2500-message backlog: 1,995,854 to 1,995,859 bytes moved across
+            // four runs to return a 346,001-byte page, and 8161ms to 8753ms on that link, so all four
+            // missed the dashboard's 8000ms deadline with nothing else on the connection (Cotal #1210).
+            // That cost does not keep growing with the backlog, and saying it did was wrong: the old first
+            // span was `max(limit * 4, 64)`, so at limit 500 it is 2000 messages, and ANY backlog of 2000
+            // or more drains the same 2000-message window. The point is that the window, not the backlog,
+            // sets the cost, and four pages to return one is already past the deadline on this link for
+            // every such deployment. One page wide makes the
+            // SUCCESSFUL drain
+            // obey the same bound the failed ones already promised: it moves at most one page. A sparse
+            // subject pays one more widening step for that, which is four round trips against a transfer
+            // several times the size of the answer.
+            //
             // A SHORT PAGE is either "the channel is exhausted" or "the window is still above the
             // first match". Sequence 1 is the wrong floor for the first of those: three matches at
             // the high end of a busy stream are exhausted as soon as the window's lower edge passes
@@ -2227,17 +2371,17 @@ export class CotalEndpoint extends EventEmitter {
             // drain, full) never pays for it. The remaining unbounded-looking case is a subject
             // whose FIRST match really is near sequence 1; that span is the channel's own, not the
             // stream's.
-            let span = Math.max(limit * 4, 64);
+            let span = Math.max(limit, 64);
             let floor = 1;
             let floorKnown = false;
             for (;;) {
                 signal?.throwIfAborted();
                 const start = Math.max(floor, ceiling - span + 1);
-                const page = await this.drainWindow(js, stream, subject, start, ceiling, limit, signal);
+                const page = await this.drainWindow(js, stream, subjects, start, ceiling, limit, signal);
                 if (page.length >= limit)
                     return page.slice(-limit);
                 if (!floorKnown) {
-                    floor = Math.max(1, await this.firstMatchingSeq(js, stream, subject, signal));
+                    floor = Math.max(1, await this.firstMatchingSeq(js, stream, subjects, signal));
                     floorKnown = true;
                 }
                 if (start <= floor)
@@ -2268,19 +2412,13 @@ export class CotalEndpoint extends EventEmitter {
             throw e;
         }
     }
-    /** The newest stream sequence matching `subject`, or 0 when the subject has no messages.
-     *
-     *  One ordered consumer at `DeliverPolicy.Last` with this subject's filter: its `num_pending`
-     *  (available from the create, before anything is delivered) is 0 for an empty subject, and
-     *  otherwise one message carries the sequence. Same CREATE/INFO/NEXT/DELETE surface `drainWindow`
-     *  already uses, so no broker authority is added. */
     /** The oldest stream sequence matching `subject`, or 0 when the subject has no messages.
      *  Mirror of {@link lastMatchingSeq}: same CREATE/INFO/NEXT/DELETE surface, `DeliverPolicy.All`
      *  instead of `Last`, first delivered seq instead of last. Read credentials already hold this. */
-    async firstMatchingSeq(js, stream, subject, signal) {
+    async firstMatchingSeq(js, stream, subjects, signal) {
         signal?.throwIfAborted();
         const consumer = await js.consumers.get(stream, {
-            filter_subjects: [subject],
+            filter_subjects: subjects,
             deliver_policy: DeliverPolicy.All,
         });
         try {
@@ -2299,7 +2437,7 @@ export class CotalEndpoint extends EventEmitter {
                 signal?.removeEventListener("abort", stop);
                 iter.stop();
             }
-            throw new Error(`history: the broker reported messages on ${subject} but delivered none - the read was cut short, not empty`);
+            throw new Error(`history: the broker reported messages on ${subjectLabel(subjects)} but delivered none - the read was cut short, not empty`);
         }
         finally {
             try {
@@ -2317,10 +2455,10 @@ export class CotalEndpoint extends EventEmitter {
      *  (available from the create, before anything is delivered) is 0 for an empty subject, and
      *  otherwise one message carries the sequence. Same CREATE/INFO/NEXT/DELETE surface `drainWindow`
      *  already uses, so no broker authority is added. */
-    async lastMatchingSeq(js, stream, subject, signal) {
+    async lastMatchingSeq(js, stream, subjects, signal) {
         signal?.throwIfAborted();
         const consumer = await js.consumers.get(stream, {
-            filter_subjects: [subject],
+            filter_subjects: subjects,
             deliver_policy: DeliverPolicy.Last,
         });
         try {
@@ -2345,7 +2483,7 @@ export class CotalEndpoint extends EventEmitter {
             // dropped link looks like from here. Returning 0 would make the caller report an empty
             // channel, which is the same "could not read means no history" lie the narrowed catch above
             // exists to stop.
-            throw new Error(`history: the broker reported messages on ${subject} but delivered none - the read was cut short, not empty`);
+            throw new Error(`history: the broker reported messages on ${subjectLabel(subjects)} but delivered none - the read was cut short, not empty`);
         }
         finally {
             try {
@@ -2361,10 +2499,10 @@ export class CotalEndpoint extends EventEmitter {
      *  One ephemeral ordered consumer, one batched pull — `AckPolicy.None`, so no per-message ack
      *  round trip. Fetches exactly the pending count so it returns as soon as the window is
      *  delivered rather than blocking for the pull's full expiry. */
-    async drainWindow(js, stream, subject, start, ceiling, limit, signal) {
+    async drainWindow(js, stream, subjects, start, ceiling, limit, signal) {
         signal?.throwIfAborted();
         const out = [];
-        const consumer = await js.consumers.get(stream, { filter_subjects: [subject], opt_start_seq: start });
+        const consumer = await js.consumers.get(stream, { filter_subjects: subjects, opt_start_seq: start });
         try {
             // A freshly created consumer already carries its ConsumerInfo, so read the CACHED copy: the
             // explicit uncached `info()` this used to call was a round trip for data we already had.
@@ -2393,7 +2531,7 @@ export class CotalEndpoint extends EventEmitter {
                     if (m.seq >= ceiling) { // reached the page's upper bound
                         if (m.seq === ceiling) {
                             try {
-                                out.push(m.json());
+                                out.push({ seq: m.seq, subject: m.subject, msg: m.json() });
                             }
                             catch { /* skip undecodable */ }
                         }
@@ -2401,7 +2539,7 @@ export class CotalEndpoint extends EventEmitter {
                         break;
                     }
                     try {
-                        out.push(m.json());
+                        out.push({ seq: m.seq, subject: m.subject, msg: m.json() });
                         if (out.length > limit)
                             out.shift();
                     }
@@ -2417,13 +2555,15 @@ export class CotalEndpoint extends EventEmitter {
                 iter.stop();
             }
             if (!complete)
-                throw new Error(`history: read ${delivered} of ${pending} messages on ${subject} before the stream ended early - the window was cut short, not empty`);
+                throw new Error(`history: read ${delivered} of ${pending} messages on ${subjectLabel(subjects)} before the stream ended early - the window was cut short, not empty`);
             return out;
         }
         finally {
             // DELETE THE EPHEMERAL CONSUMER. The pinned client gives an ordered consumer a 5-minute
             // inactive threshold, so leaving them behind is not free: the widening search below can make
-            // up to eight per call, the dashboard makes one call per channel, and a reload repeats it.
+            // up to eight per call, and a reload repeats every call the page makes. The dashboard used to
+            // make one per channel; since #1210 its activity feed makes one for all of chat and one for
+            // DMs, and the single-channel routes still make one each.
             // Left alone that accumulates consumers on the broker until the thresholds expire, and the
             // resulting resource exhaustion would land in streamHistory's catch and read as empty history.
             try {
@@ -4370,7 +4510,9 @@ export class CotalEndpoint extends EventEmitter {
                 // @nats-io/kv marks the final initial replay entry isUpdate=true. Later updates stay true.
                 if (!ready && e.isUpdate) {
                     ready = true;
+                    this.presenceSnapshotPopulated = true;
                     hydrated();
+                    this.emitPresenceViewIfChanged();
                 }
             }
             hydrated();
@@ -4451,7 +4593,8 @@ export class CotalEndpoint extends EventEmitter {
             this.emit("roster", this.getRoster());
             return;
         }
-        this.setPresenceViewFresh(true);
+        if (this.presenceSnapshotPopulated)
+            this.emitPresenceViewIfChanged();
         // Any offline materialization (a stale snapshot OR a graceful-leave record) drops the advisory
         // attention fields — an offline peer must not carry a stale `[focus]`/`locally muted` hint.
         const p = stale || raw.status === "offline" ? this.toOffline(raw) : raw;
@@ -4505,11 +4648,12 @@ export class CotalEndpoint extends EventEmitter {
         this.emit("presence", { type: "offline", presence: offline });
         this.emit("roster", this.getRoster());
     }
-    setPresenceViewFresh(fresh) {
-        if (fresh === this.presenceViewFresh)
+    emitPresenceViewIfChanged() {
+        const view = this.presenceView();
+        if (view.state === this.presenceViewState)
             return;
-        this.presenceViewFresh = fresh;
-        this.emit("presence-view", this.presenceView());
+        this.presenceViewState = view.state;
+        this.emit("presence-view", view);
     }
     sweep() {
         const now = Date.now();
@@ -4518,7 +4662,7 @@ export class CotalEndpoint extends EventEmitter {
         // sidebar with nothing saying the window went blind (#1045). Gate the per-peer age-out on
         // watch freshness; surface the view as stale instead.
         if (this.lastPresenceWatchAt !== 0 && now - this.lastPresenceWatchAt > this.ttlMs) {
-            this.setPresenceViewFresh(false);
+            this.emitPresenceViewIfChanged();
             return;
         }
         let changed = false;
@@ -4541,6 +4685,12 @@ export class CotalEndpoint extends EventEmitter {
  *  never absent and never a non-string. An absent or non-string id is a malformed envelope under
  *  SPEC sec 5; each delivery pump handles it per its own class (durable term, live drop, history
  *  skip) so it never reaches the receiver's id-keyed machinery as `undefined`. */
+/** What a history read failure NAMES when it could not finish. One filter subject is the useful
+ *  thing to print; a set of sixty-nine of them is a wall of text in a message a human has to read,
+ *  so a set says its size and the stream it was read from instead. */
+function subjectLabel(subjects) {
+    return subjects.length === 1 ? subjects[0] : `${subjects.length} filtered subjects`;
+}
 function isUsableMessageId(id) {
     return typeof id === "string";
 }