Repository navigation
feat(net)!: the lite-07 wire addresses groups by start - #8908
Conversation
Quest-Claim: 1406d5e5325fc163
The lite draft names every group by its start: GROUP carries the start and the previous group's start, GROUP_END ends a whole group, drops and skips name spans of starts, and OLD drops are final. Folds in the pre-cut audit's fixes: Subscriber Max Age plus one, one Time anchor, no Padding, a listing kind, Largest Ended, and no RTCDataChannel binding. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The Padding Stream (0x2) and Padding Datagram (0x1) leave lite-07. A datagram keeps its type, 0x0 the only one; any other is discarded. An unknown uni stream type is now stopped with UNEXPECTED_STREAM on every version rather than just dropped, so the peer learns of it at once, as JS already did. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…chor, and whether the largest ended Subscriber Max Age on lite-07 SUBSCRIBE and SUBSCRIBE_UPDATE is milliseconds plus one, 0 for no limit, so the model's unlimited budget crosses the wire as itself. The codec carries Option<Duration>: Lite01/02, which have no field, decode as no limit, which retires the publisher's serving_max_delay, and lite03-06 still send 2^53 - 1 for none. Lite-07 range anchors are 0 None, 1 Time, 2 Relative; type 3 is gone and is malformed. Time is inclusive at both ends. An in-memory absolute position goes out as its group's time, an exclusive end as the inclusive time before it, so the subscriber's ranges and fills need no change. SUBSCRIBE_OK on lite-07 adds Largest Ended after Largest Frame: the publisher sends whether its cache's largest group ended (finished or closed, or reported ended by its source), and a subscriber records it so a relay forwards it. It stays crate-private: nothing in this repo reads it yet. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
… final (JS) SUBSCRIBE_DROP and SUBSCRIBE_SKIP on lite-07 carry a non-empty [Group Start, Group End) span with an exclusive end. A decoded End not past Start is a protocol violation, and an empty span has no encoding. The version predicate is renamed hasGroupSpan. Earlier versions keep their inclusive Group End. The Update field leaves SUBSCRIBE, SUBSCRIBE_UPDATE, and SUBSCRIBE_DROP, and a SUBSCRIBE_UPDATE reopens nothing: - Publisher: no update numbers, no update-time re-offer or re-drop. A group the subscription told the wire about, served or dropped (stale or not), is never served or dropped again on it; only a skip goes out over a drop. The wire record's stale variant collapses into a plain final drop. - Subscriber: an OLD drop is final, accounted in the tail and recorded in the copy as a stale hole under the subscription's current budget, so a wider reader recovers the group through a request of its own. The per-update stale bookkeeping, the tail's reopen paths (restore, unaccount, finished streams) and Ledger.unaccount are gone. A drop that named a group being read ends it on a later YIELDED reset. - Model: the copy's judged ranges are gone; supersedeStale runs only when a new upstream subscription opens. reofferStale and reofferGroups are replaced by continueGroup, which serves only the YIELDED continuation. Tests that asserted reopening are deleted or flipped to the final behavior. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…acks are listed
Lite-07 TRACKS_ADD now leads with a Kind (0x0 a track of groups with its
TRACK_INFO, 0x1 a datagram track with its DATAGRAMS_INFO), and TRACKS_REMOVE
and TRACKS_FINISH name the kind before the name. Any other kind is a
PROTOCOL_VIOLATION. A name is listed at most once per kind, and the duplicate
add / unknown removal rules apply per (kind, name).
The model lists a datagram track a broadcast creates until it ends (finished
or not), and a handler's answer lists either kind, so a relay's copy forwards
its upstream's datagram tracks too. A datagram track served on request, or a
session's datagram track riding a stream subscription (lite-05/06,
moq-transport), is never listed: sessions create those unlisted.
Rust: broadcast::TracksEvent::Added carries info: Listed (Track(track::Info) or
Datagrams(datagram::Info)); Removed and Finished carry kind: Kind.
Lister::add takes impl Into<Listed>; remove and finish take (kind, name).
moq-crypto's e2ee Lister mirrors that. lite::TracksEvent mirrors the model
with lite::Listed.
JS: TracksEvent's added variant is { kind, name } & Listed, where Listed is
{ info: track.Info, datagrams?: false } or { info: datagram.Info, datagrams:
true }; removed and finished set datagrams for a datagram track. Lister.add
takes a Listed; remove and finish take (name, datagrams).
moq-archive and moq-stats (Rust and JS) ignore datagram tracks: neither has
anything to do with one. The IETF listing lists only tracks of groups, as
before.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
… anchor, and whether the largest ended The JS side of the lite-07 SUBSCRIBE changes: - Subscriber Max Age is milliseconds plus one on lite-07, 0 for no limit. Subscribe and SubscribeUpdate carry `maxDelay: number | null`; lite-01/02 decode as null, and lite-03 to 06 send no limit as the largest safe value, as before. - Anchors are 0 none, 1 time (inclusive at both ends, full 64-bit), and 2 relative; any other type is a protocol violation. An absolute anchor goes out as a time, an end as the time before it. The JS model still keys groups by sequence, so a decoded time names that key. - SUBSCRIBE_OK's largest carries whether its group ended. The publisher answers from its track, and the subscriber records it so a relay forwards it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A Track Datagram on a scale-less datagram track carries its producer's bare timestamp, which is its sequence, instead of omitting it. Lite-05/06 already stamp every datagram, so every version with datagrams now carries one: the body codec drops its untimed form and the lookup it needed to tell them apart. A subscriber reads a scale-less one as an unscaled timestamp, which the track checks against the sequence. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
… final SUBSCRIBE_DROP on lite-07 is now Group Start, Group End, Error Code, and SUBSCRIBE_SKIP Group Start, Group End: a span [Start, End) with no count, where an End at or below the Start is a PROTOCOL_VIOLATION. The Update field leaves SUBSCRIBE, SUBSCRIBE_UPDATE, and SUBSCRIBE_DROP. A stale (OLD) drop is final on its subscription. A SUBSCRIBE_UPDATE reopens nothing: the publisher never serves or names again a group it already served or dropped, and the subscriber never owes one again. A relay records a stale drop under the narrowest budget its subscription asked, since the wire no longer says which update a drop crossed; a reader wider than that asks for the group on a request of its own. Deleted with the reopen paths: the publisher's update number, redrop and reoffered sets and stale replacement; the record's stale reports that an update reopened; the track's judged ranges, re-offers, and tail billing; the tail's finished and folded bookkeeping and its update count. The TLA+ model drops updates, the StreamWins rule and config, and NoViolation, and gains NamedOnce. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…imited reader's grace Lite-07 now carries no max age as 0, so a socket's unlimited reader reaches the publisher as no limit rather than as the largest safe budget. The model waits a hole out for its grace under no limit, then gives it up, so the test's late message lands inside that grace. Formatting from `just fix` rides along. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Mirrors Rust: with no update number on SUBSCRIBE_DROP, a lite-07 stale drop that arrives after a widening SUBSCRIBE_UPDATE may have been judged under the budget before it, so the subscriber records it under the narrowest max delay the subscription asked. A recovery's subscription records its own. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The model has no updates to reopen a drop, so the skill drops the update numbers, re-offers, StreamWins and its open finding, adds NamedOnce, and syncs the coverage table to the code. With the state space smaller, the default config now covers two groups and Continuation.cfg two frames and three YIELDED resets; both pass (about 70.8M and 840K distinct states). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…dressing/lite07 # Conflicts: # js/net/src/lite/subscriber.ts # rs/moq-net/src/lite/publisher.rs # rs/moq-net/src/lite/subscribe.rs # rs/moq-net/src/lite/subscriber.rs
…GROUP_END GROUP gains Previous Start (the previous group's start plus one, 0 unknown). The publisher derives it from the skip run directly below the group, or a group just below it, and stops sending SUBSCRIBE_SKIP for a run its GROUP passes over; the run goes out as SUBSCRIBE_SKIP ahead of a drop of that group, or once an update means the group is no longer owed. The subscriber records the passed-over starts as skipped and refuses a previous start at or above the group's own. A Group or Fetch Stream ends a finished group with GROUP_END (Payload Length 0, then End) before its FIN; a bare FIN closes the group. The receiver finishes the group at End, refusing anything after GROUP_END or an End the group refuses as a malformed track, and closes it on a bare FIN. recv::Group splits into finish(end) and close(). A group that expires after its stream opened is closed rather than reset with OLD, and needs no drop; one whose stream never opened is still dropped. A stream whose end was written is never reset for expiry. A scale-less lite-07 FRAME carries its timestamp, its group's start; any other value is a TIMESTAMP_MISMATCH. Fills answer a group the copy records skipped, as a SUBSCRIBE_SKIP would. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…th GROUP_END The JS counterpart of the Rust change. - GROUP encodes and decodes Previous Start plus one on lite-07, 0 when unknown. The subscriber applies the starts it passes over as a skip, and refuses a previous start at or past the group's own as a malformed track. - A Group Stream reads a Payload Length of 0 as GROUP_END, then the group's exclusive End, then the FIN; anything after it, or an End at or before the group's start, is malformed. A bare FIN closes the group. - `Group.Producer.finish(end?)` finishes a group whole at `end`, or closes it without one, and `Group.Consumer.end` reads it back. A finished group's stream and a FETCH that reaches its end write GROUP_END. - A scale-less lite-07 track stamps each frame with its group's start, and the subscriber refuses any other value with TIMESTAMP_MISMATCH. - A lite-07 stream whose group expires after it opened is closed at the next frame boundary rather than reset, and no drop names the group. - The publisher holds a skip back for the GROUP of the cached group just above it, and sends it ahead of that group's drop, or joined to its skip, if the group is given up instead. A drop of a group whose stream opened goes out after a skip of what its GROUP passed over. Tests cover each, and the parked-expiry and copy-fill tests now tell an eviction from a stale group, which lite-07 closes. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A skip held back for the GROUP of the group above it stayed held forever once that group was skipped too: no GROUP would pass over it, and only a drop sent it. A skip of that group now joins the held run, and a drop of it sends the run first, as before. Also catches up the tests that hand-build lite-07 bytes: the moq-tokio receive credit GROUP headers carry a Previous Start, and the lite varint interop GROUP names one, so both languages encode it alike. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…s over skips SubscribeAccounting now describes lite-07 as the code runs it: - A serving Group Stream whose group expires closes with a FIN and no drop (`StreamClose`). Only a stream that never opened is still given up with OLD, and nothing resets a stream once its FIN went out. - Each GROUP passes over the skipped run directly below it. The publisher holds a skip back for the GROUP of a group it still owes (`held`), and sends it ahead of that group's drop or joined to its skip. A drop of a group whose stream opened repeats what its GROUP passed over first (`nahead`), which NamedOnce allows once. Groups start at 1 in SubscribeAccounting.cfg, so a skip of 1 can be held for 2. Both configs pass: 15.9M distinct states in four minutes, and 493K in five seconds for Continuation.cfg. Mutations dropping the join, the skip ahead of a held group's drop, or the skip ahead of a served group's drop each break QuietIsSettled. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Deletes the quest and its links, and moves GROUP's Frame Start and the model's YIELDED half to the YIELDED deferral, which still owns them. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The JS model resolving a lite-07 Time start to its containing group is recorded in the quest that rekeys the JS model by start. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
|
This is the inline finding from the Pullfrog review, which the tooling dropped because it saw no textual diff for ℹ️ A held-back skip run is lost when
|
|
Maintainer decision (2026-11-16, /quest-run)
(Written by Opus 5.5) |
Takes main's group::Producer::finish_at(end)/finish() names (#8961), with JS mirroring them as finishAt(end)/finish(), keeps main's Announce Stream (0x3) while dropping Padding (0x2), and drops main's edits to the re-offer and judged-range tests this branch removes. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Main's changes since touch no function the model covers, and both configs pass there. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
… close never cuts a frame A GROUP whose skip run was held back passes over that run even once the cache's expiry or debt forgot the skip, in Rust and JS and the subscribe model. A JS lite-07 stream that expires mid-frame resets with the frame's failure instead of closing over a truncated frame, as Rust's GroupServe already does. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…skip fix Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…main merge Main's changes since touch only ietf records and the ordered reader, which the model leaves out; both configs pass on the merge. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
|
Applying the maintainer decision on head 8d83f77: main is merged in (no rebase), resolving against #8961, #8910, #8952, and #8929. (Written by Claude Opus 5.5) |
There was a problem hiding this comment.
✅ No new issues found. The held-skip gap from the last review is closed.
Reviewed changes
This run covers the commits since 03d0b70: two fixes and the JS finishAt split, plus three merges of main. Most of the range-diff comes from those merges.
- Held skip survives the cache forgetting it:
TrackRun::serve(and JSserve) now takes the held run's start before computingPrevious Start, asmin(elided − 1, previous_start(key)). A pool expiry or debt that clears the cached skip no longer sends a GROUP withPrevious Start0 and no SUBSCRIBE_SKIP. A run is held only whenprevious_start(above) < run.start, sochecked_sub(1)never drops a real run.lite07_a_held_skip_outlives_the_cache_forgetting_itcovers this, and the TLA+Servenow passes overheld[g]. - JS expiry close waits for the frame in flight: an expired lite-07 stream now closes only after the frame being written completes. If that frame fails, the stream resets with the frame's error rather than sending a FIN over a truncated frame, which matches Rust
GroupServe. - JS
Group.Producer.finishAt(end):finish()no longer takes an end. The subscriber's GROUP_END paths callfinishAt, and every caller injs/has moved to the new shape. The API report is regenerated. - Merges of
main: the PR now usesfinish_at/finishfrom #8961 and suppresses GROUP_END per track withobject_recordsfrom #8952. The fixtures and tests are updated for both.
claude-opus-5-5 | 𝕏
kixelated
left a comment
There was a problem hiding this comment.
Automated review by review (OpenAI)
Reviewed 8d83f77555e58514ec2d0cf340d45691d85dad4e. The held skip now survives cache eviction in Rust and JS. JS expiry waits for the current frame write instead of ending it mid-frame. Rust suppression of GROUP_END now keys off per-track object-record mode, not just the session flag. Those changes look sound by inspection.
Correction to my earlier boundary finding: the draft already limits frame timestamps to below 2^61 and requires scale-less frames to use their group start. A nonempty scale-less group at 2^63 is therefore not conforming wire input. The remaining concern is API enforcement: an unscaled start outside the draft range can still be accepted before encoding later fails. Prefer rejecting it early; this is not evidence that a conforming timestamp cannot be encoded.
Static review only; I didn’t run Rust↔JS interop.
|
Re the automated review's remaining note on rejecting an unscaled start past the draft range early: left as is in this PR. A scale-less key is wire-agnostic in the model ( (Written by Claude Opus 5.5) |
#8908 made every drop final and dropped SUBSCRIBE_UPDATE re-offers, so this drops the re-offer hold rules along with YIELDED. With no continuation left on a subscription, lite-07 GROUP loses Frame Start: every Group Stream starts at frame 0. The subscribe accounting model is re-derived for one Group Stream per group. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Finishes
quest/m2/time-addressing/lite07.md(deleted here, with its links). The lite-07-wip wire carries no group sequence numbers. Each group is named by its start, a GROUP also names the start of the group before it, GROUP_END says where a whole group ends, and every subscription bound, drop, and skip is a span of starts. The PR also carries the pre-cut audit's smaller lite-07 fixes. lite-01..06 and moq-transport are unchanged.Summary
drafts/draft-lcurley-moq-lite.md): every "sequence" now reads as a start. New and changed:Timescaleis 0 and every frame carries its group's start.GROUP_ENDsection, and GROUP gainsPrevious Start.[Group Start, Group End)span.Updateis gone, along with reopen and re-offer.Largest Ended.Subscriber Max Ageis encoded as ms plus one, with 0 meaning no limit.Kind.doc/concept/moq-lite.md:rs/moq-netandjs/net, mirrored, so the two interoperate on lite-07:redrop/reoffered, the tail's update and finished bookkeeping, and the track's re-offers and judged ranges.Previous Start. A subscriber applies the passed-over starts as a skip. The publisher holds back the SUBSCRIBE_SKIP for a run directly below a group whose stream it opens, and sends that run before any drop of the group.finish_at(end); a bare FIN callsfinish(), the names main's moq-dev/moq#8961 gave them.TIMESTAMP_MISMATCH. Datagrams always carry a timestamp.Largest Endedis recorded and forwarded by a relay. JS reads a Time anchor as a full 64-bit value.verify/subscribemodel drops the update numbers and reopen;StreamWins.cfg,StreamWins, andNoViolationgo, and it gainsNamedOnce. It now models the expiry close,Previous Start, and held-back skips. The skill records the new runs.Frame Startand the model's YIELDED half.lite07-finalize,refresh-interval,group-drops, andunused-api/jsare updated to the landed wire.Impact
Wire (breaking, lite-07-wip only, which changes freely): GROUP, FRAME (a
Payload Lengthof 0 is now GROUP_END, and scale-less frames carry a timestamp), datagrams (an always-present Timestamp, no type 0x1), SUBSCRIBE, SUBSCRIBE_UPDATE, SUBSCRIBE_OK, SUBSCRIBE_DROP, SUBSCRIBE_SKIP, TRACKS_ADD, TRACKS_REMOVE, and TRACKS_FINISH all change, and stream type 0x2 is gone. A lite-07-wip build from before this PR cannot talk to one after it. Published lite versions are untouched.Public API (breaking):
moq_net::broadcast::TracksEvent:Added { name, info: Listed }, whereListedisTrack(track::Info)orDatagrams(datagram::Info).Removed { kind, name }andFinished { kind, name }, wherekindis abroadcast::Kind.Lister::add(name, impl Into<Listed>);Lister::removeandLister::finishtake(kind, name).Added { info: Listed::Track(info), .. }where you matchedinfo, and addKind::Tracktoremoveandfinishcalls.@moq/netlisting:{ kind: "added", name } & Listed, whereListedis{ info: Track.Info } | { info: Datagram.Info, datagrams: true }. Removed and finished events setdatagrams: truefor a datagram track.Lister.add(name, { info }),remove(name, datagrams?),finish(name, datagrams?).event.datagramsbefore treatingevent.infoas aTrack.Info, and wrapLister.add's info in{ info }.Group.Producer.finishAt(end)ends a group whole atend, mirroring Rust'sgroup::Producer::finish_at, andGroup.Consumer.endreports it. These are additive. It stays public though nothing outside@moq/netcalls it yet (moq-dev/moq#8929 prunes such exports), since without it a JS publisher could never end a group with GROUP_END the way a Rust one can.Decisions
just test interop --alland the verify-subscribe model before any queueing.Choices for review
Choices made without the maintainer, any of which a review can undo:
Frame Start. The quest says to keep it while YIELDED continuations still set it. YIELDED deferred now removes it.Payload Lengthof 0, then an absoluteEnd.Endat or below the group's start, asgroup::Producer::finishdoes.ietfobject records.Previous Startis plus one, with 0 for unknown. The publisher derives it in three steps:start - 1;[Start, End)with an exclusive end. An empty or inverted span is a PROTOCOL_VIOLATION, where a count of 0 used to be legal.Largest Endedis a byte afterLargest Frame, present whenLargest Groupis not 0. It is 1 for a finished or closed group. An aborted group reads 0, since it can still be fetched; the quest said "finished or closed".stale_budget). Too narrow costs a wider reader one recovery request; too wide would settle a reader on a group it could still get.socket::track_messages_are_read_in_keynow waits half a second instead of exactly one.Kindtoo, not just TRACKS_ADD. Datagram tracks have their own namespace, so a name alone is ambiguous.datagrams: truerather than akindfield, becausekindalready tags JS listing events. Rust usesbroadcast::Kind.timeanchor sent to a JS publisher whose keys are not its timestamps no longer resolves by frame timestamp (main's type 3 did), and on sparse keys a start between two groups skips the one it falls in. Nothing outsidejs/netbuilds atimeanchor.js.md's Plan records the case.Validation
cargo nextest run -p moq-net --all-features: 4000 tests pass on the last slice, and 3989 at the A+B+C merge.--all-targets --all-features -D warningsis clean on moq-net, moq-archive, moq-crypto, moq-stats, and moq-relay.js/net:bun testpasses (3320 tests on the final head) andbun run checkis clean.just checkpasses on the final head. One earlier run under heavy load failedtest rsand a rerun passed; that failing log was lost and is not investigated.just test interop --all(Rust, Node, Bun, Python over lite-07-wip) passes after the drop/update slice and again on the final code, before only doc and quest edits.lite_tracks_interop, Rust and JS both ways, lists a datagram track.tests/integration/group_end.rssends GROUP_END and a bare FIN over a real session.verify/subscribe: the main config finds 15.9M distinct states in 3m37s and passes, andContinuation.cfgfinds 493K in 4s and passes. Three deliberately broken variants (a missing skip join, no skip before a held-back group's drop, no skip before a served group's drop) each failQuietIsSettled, and an earlier one that served an already-told group failsNamedOnce.157042024b: a held-back skip run was lost when its group was skipped too.finish_at/finish, moq-dev/moq#8835's Announce Stream, moq-dev/moq#8958's Min Age join, moq-dev/moq#8910's ordered gaps, moq-dev/moq#8952's per-track ietf records, and moq-dev/moq#8929/moq-dev/moq#8931's pruned API), on the final head:just checkpasses (11825 Rust tests);js/netbun testpasses 3389 tests.just test interop --allpasses: 209 PASS, one known Chromium route-key SKIP.verify/subscribepasses both configs: 15.9M distinct states, and 493K forContinuation.cfg.object_records), since main made those per track.servenow takes the held run itself (Rust and JS; the model'sServemirrors it). Test:lite07_a_held_skip_outlives_the_cache_forgetting_it.GroupServedoes. Test:lite draft-07: an expired stream resets when its frame in flight fails.verify/resumeandverify/failoverwere not rerun. Both assume nothing expires and every group is written whole, and neither distinguishes a finished group from a closed one.just drafts checkpasses, andquest checkpasses.Follow-ups
None.
Models
Size: L
Implementer: Claude Code, claude-opus-5-5, high effort
Implementer: Claude Code, claude-opus-5-5, unknown effort (iterate, L)
Review
Rewritten by
quest reviewafter each round.Head: 8d83f77
Base: origin/main at ca8b08c
Risk: high,
The branch changes lite-07 wire behavior relied on by remote subscribers and relays, so regressions can break interoperability and reverting cannot repair already-transmitted streams.Classified: medium by default
Reviewer: Codex, gpt-6.1-sol, xhigh effort
Session:
01a1e8ed-8b83-7de3-9641-3aa6c205f8eb, round 5Score: 10/10,
The incremental review found no new issues in the merge resolutions or their interactions with branch-added code.Raised the risk to high:
The branch changes lite-07 wire behavior relied on by remote subscribers and relays, so regressions can break interoperability and reverting cannot repair already-transmitted streams.Rounds: 8; first round 2 (medium 2); findings 4 (medium 4): fixed 3, refuted 1, open 0
Findings: none
(Written by Claude Opus 5.5)
🤖 Generated with Claude Code