Skip to content

fix(do): size subscription frames before sending them - #406

Closed
prisis wants to merge 3 commits into
alphafrom
perf/ws-subscription-frame-sizing
Closed

prisis wants to merge 3 commits into
alphafrom
perf/ws-subscription-frame-sizing

Conversation

@prisis

@prisis prisis commented Aug 11, 2026 •

Copy link
Copy Markdown
Member

Summary

Live-query fan-out (@lunora/shard-engine, @lunora/do) was sending more
bytes than it needed to, in two distinct ways. Both are fixed here, plus an
advisor lint (@lunora/advisor, @lunora/codegen) for the third — the one
only the app author can fix.

1. Delta-vs-snapshot was decided by row count

A refresh went out as one {type:"delta"} frame per changed row whenever
the diff was expressible, capped only by "no more deltas than rows".

Every delta frame re-pays the whole {"type":"delta","id":…} + "table":…

  • cursor/epoch/watermark envelope around one row body — which the
    snapshot pays once for the entire list. So the deltas stop being the cheaper
    encoding well before they stop being a valid one, and a row count cannot see
    where. Measured, 100-row list of ~290-byte rows:
changed snapshot deltas ratio
1 29,060 B 438 B 0.02x
50 29,060 B 21,980 B 0.76x
100 29,060 B 43,970 B across 100 frames 1.51x

The cap was blind in the other direction too: a single delta into a short
list of small rows already costs more than re-sending the list, and it
allowed that as well.

Now both candidates are rendered and the smaller one is sent — stopping the
render as soon as the running delta total reaches the snapshot, so a
near-total change does not allocate envelopes that lose. subscriptionFrames
owns the frame layout and the choice together, so the sizing cannot drift
from the format — it is the format. Ties go to the snapshot, since one
frame is also one ws.send and one client apply.

subscriptionListDeltas keeps only its four expressibility conditions.
Whether sending the diff is worth it was never something a function with no
view of the wire could answer.

2. unbounded_collect (new advisor lint)

filter_without_index gates on hasFilter, so the widest read of all —
ctx.db.query("t").collect() with no index and no filter — fell straight
through it. The codegen feeder made that structural: it discarded every
discovered read without a .filter(), so no lint could have seen one.

An unindexed read records a whole-table dependency, so the refresh gate can
never skip it: every write to the table re-runs the query and re-sends the
whole table to every subscribed socket. Two of this repo's own examples trip
it, both on live-subscribed list queries.

The feeder now reports every read plus the materializing terminal, matched
against a known terminal set rather than the last chained method —
.collect().then(...) keeps the chain walk going, so the literal last call
is a combinator. withGeoIndex also joins the narrowing methods: it was
missing while only filtered reads were reported (a geo query is normally
written without one), and would otherwise have flagged the exact chain
geo_index_unused tells authors to write.

Linked issues

None — found by a WebSocket payload audit of the subscription fan-out path.

Test plan

  • pnpm run lint:affected:types — 73 projects, 0 errors
  • pnpm run lint:eslint — @lunora/do, @lunora/shard-engine, @lunora/advisor, @lunora/codegen
  • pnpm exec prettier --write on every touched file
  • @lunora/do 537 tests, @lunora/shard-engine 1123 (+8 new), @lunora/codegen 1202, @lunora/advisor 482
  • pnpm run api:check — 47/47 snapshots match (3 updated in this PR: sendDeltaFrames → subscriptionFrames, plus the new terminal field on QueryReadIR / AdvisorQueryRead)
  • Durable Object code changed → the workerd-pool @lunora/do suite is the one above, all green
  • Schema/codegen changed → every examples/* and apps/playground regenerated; only the two expected advisory diffs (examples/chess, examples/feedback-board), and nothing further after the rebase onto alpha
  • pnpm --filter @lunora/shard-engine exec vitest bench — the new bench runs clean

Reviewers should re-run pnpm run api:check and the @lunora/do suite.

Checklist

  • Commit messages follow the Conventional Commits style (feat(scope): subject)
  • Added or updated tests covering the change
  • Updated relevant docs in apps/docs (or README.md for package-local docs) — packages/advisor/docs/index.mdx gained the unbounded_collect row; the apps/docs copy is generated from it by copy-package-docs.js and is gitignored
  • No package.json files in packages/* modified outside the touched package
  • If a new package was added: n/a
  • If migration impact: see the breaking-change note below

Notes for reviewers

Start with packages/shard-engine/src/subscription-delivery.ts — the
whole delta-vs-snapshot decision lives in subscriptionFrames, and
pushSubscriptionData now just sends what it is handed.

Breaking (pre-1.0, alpha): sendDeltaFrames is removed from
@lunora/shard-engine in favour of subscriptionFrames, which returns the
frames rather than sending them. subscriptionListDeltas no longer returns
undefined for a near-total change — it decomposes any expressible diff.
Both are internal to the shard/engine boundary; no app code imports them.

Frame-type flips are one-directional. The new predicate is a strict
subset of the old one, so no socket that previously got a snapshot can now
get deltas — only the reverse. That is what keeps the seven non-JS SDKs
under sdks/ safe: they handle "data" and "delta" in one arm and replace
wholesale, so this strictly reduces their exposure to that pre-existing
limitation.

Deferred: paginated queries never diff

.paginate() returns { page, isDone, continueCursor } — an object, so both
subscriptionListDeltas and the client's applyDelta reject it. A one-row
edit re-sends the entire page (measured 7,279 B for a ~290 B change, 25x),
and usePaginatedQuery holds one subscription per loaded page.

Not fixed here because it cannot be done safely without protocol work: a
client whose applyDelta bails replaces the whole query value with the raw
delta object, so page-deltas need a capability announced on the connect
frame and honoured by all seven SDKs. It is the largest remaining over-send
and worth doing, but as its own change. The new bench keeps a case measuring
what the rejection costs today.

Measured, not changed

subscriptionFrames cost scales with list length, not with how much
changed: ~0.74 ms for a one-row edit to a 200-row list, paid per
(socket, subscription). At 100 subscribers that is ~74 ms of
single-threaded shard time per write. Inherent to the current design
(identity-dependent queries cannot share a result under RLS); the bench pins
it so a regression shows up.

Contributor License Agreement

By submitting this pull request, I confirm that my contribution is made under the terms of the project's license and that you can use, modify, copy, and redistribute this contribution under those terms.

🤖 Generated with Claude Code

https://claude.ai/code/session_01AyG8dyPFieGYzRd7y1MMme

@netlify

netlify Bot commented Aug 11, 2026 •

Copy link
Copy Markdown

✅ Deploy Preview for lunorash ready!

Name Link
🔨 Latest commit 491d00a
🔍 Latest deploy log https://app.netlify.com/projects/lunorash/deploys/6a7b083042064f00075dcc99
😎 Deploy Preview https://deploy-preview-406--lunorash.netlify.app
📱 Preview on mobile
Toggle QR Code...

QR Code

Use your smartphone camera to open QR code link.
🤖 Make changes Run an agent on this branch

To edit notification comments on pull requests, go to your Netlify project configuration.

@github-actions

Copy link
Copy Markdown
Contributor

Thank you for confirming the Contributor License Agreement! 🙏

@github-actions

Copy link
Copy Markdown
Contributor

Thank you for following the naming conventions! 🙏

@coderabbitai

coderabbitai Bot commented Aug 11, 2026 •

Copy link
Copy Markdown

Review Change Stack

Walkthrough

The PR adds advisor support for detecting unbounded .collect() queries. It records query terminal metadata and retains unfiltered reads. It also centralizes subscription frame generation, selects smaller delta or snapshot payloads, and preserves delivery baselines after partial failures.

Changes

Advisor query linting

Layer / File(s) Summary
Query read metadata and discovery
packages/codegen/src/ir.ts, packages/codegen/src/discover-queries.ts, packages/advisor/src/queries.ts
Query discovery retains unfiltered reads and records filter status and recognized terminal methods for advisor query reads.
Unbounded collect lint and advisor integration
packages/advisor/src/lints/helpers.ts, packages/advisor/src/lints/static/*, packages/advisor/src/index.ts, packages/advisor/docs/index.mdx
The advisor adds storage-tier-specific unbounded_collect findings, shared location and shard helpers, lint registration, updated existing lint formatting, and documentation.

Subscription frame delivery

Layer / File(s) Summary
Subscription frame renderer
packages/shard-engine/src/subscription-delivery.ts, packages/shard-engine/src/index.ts
subscriptionFrames now builds complete delta and snapshot frames and selects the shorter representation. sendDeltaFrames is removed.
Shard subscription delivery
packages/do/src/shard-do.ts
ShardDO sends all generated frames and updates its memo baseline only after successful delivery of every frame.
Subscription frame benchmarks
packages/shard-engine/__bench__/subscription-frames.bench.ts
Benchmarks cover multiple change ratios and snapshot fallback cases.

Estimated code review effort: 4 (Complex) | ~60 minutes

Sequence Diagram(s)

sequenceDiagram
  participant ShardDO
  participant subscriptionFrames
  participant trySendFrame
  participant SubscriptionBaseline
  ShardDO->>subscriptionFrames: provide previous baseline and current result
  subscriptionFrames-->>ShardDO: return delta or snapshot frames
  loop every frame
    ShardDO->>trySendFrame: deliver frame
  end
  trySendFrame-->>ShardDO: report delivery status
  ShardDO->>SubscriptionBaseline: advance baseline after all frames succeed
Loading

Possibly related PRs

  • anolilab/lunora#78: Changes shard-do.ts subscription fan-out delivery around the same subscription flow.
  • anolilab/lunora#240: Changes advisor query-read analysis and related static lints.
  • anolilab/lunora#80: Shares ShardDO polling and materialization code with this change.
🚥 Pre-merge checks | ✅ 5
✅ Passed checks (5 passed)
Check name Status Explanation
Docstring Coverage ✅ Passed No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check.
Linked Issues check ✅ Passed Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check ✅ Passed Check skipped because no linked issues were found for this pull request.
Title check ✅ Passed The title clearly identifies the primary change: sizing subscription frames before sending them in the DO path.
Description check ✅ Passed The description covers the required sections and provides clear scope, breaking changes, tests, checklist status, and reviewer notes.
✨ Finishing Touches
📝 Generate docstrings
  • Create stacked PR
  • Commit on current branch
🧪 Generate unit tests (beta)
  • Create PR with unit tests
  • Commit unit tests in branch perf/ws-subscription-frame-sizing

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

Comment @coderabbitai help to get the list of available commands.

@coderabbitai coderabbitai Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Actionable comments posted: 1

🧹 Nitpick comments (1)
packages/shard-engine/src/subscription-delivery.ts (1)

345-347: 🚀 Performance & Scalability | 🔵 Trivial | ⚡ Quick win

Consider stopping frame rendering once the deltas exceed the snapshot.

deltas is fully materialized before the size comparison. For the near-total-change case every row allocates an envelope string that is then discarded. Accumulate the running length during the render and abort as soon as it reaches snapshot.length. The chosen frame set stays identical, because the current rule already rejects deltas at that point.

♻️ Proposed early-abort render
-    const deltas = framed.map(({ frame }) => `{"type":"delta","id":${idJson},"delta":${frame}${suffix}}`);
-
-    return deltas.reduce((total, frame) => total + frame.length, 0) < snapshot.length ? deltas : [snapshot];
+    const deltas: string[] = [];
+    let total = 0;
+
+    for (const { frame } of framed) {
+        const delta = `{"type":"delta","id":${idJson},"delta":${frame}${suffix}}`;
+
+        total += delta.length;
+
+        // Deltas can only grow from here, so the snapshot has already won.
+        if (total >= snapshot.length) {
+            return [snapshot];
+        }
+
+        deltas.push(delta);
+    }
+
+    return deltas;
🤖 Prompt for AI Agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/shard-engine/src/subscription-delivery.ts` around lines 345 - 347,
Update the frame-rendering logic around the deltas construction to accumulate
rendered frame lengths while iterating and stop once the running total reaches
snapshot.length. Preserve the existing selection rule and output: return all
deltas only when their total length is strictly less than snapshot.length;
otherwise return [snapshot], while avoiding materializing or retaining
subsequent frames.
🤖 Prompt for all review comments with AI agents
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@packages/shard-engine/__bench__/subscription-frames.bench.ts`:
- Around line 78-80: Hoist the reordered snapshot payload construction out of
the benchmark callback: precompute snapshotJson alongside the other benchmark
fixtures before the affected bench, then pass that variable to
subscriptionFrames. Keep the rejected-survivors benchmark focused on the
rejection path and preserve the existing snapshotJson setup for the other cases.

---

Nitpick comments:
In `@packages/shard-engine/src/subscription-delivery.ts`:
- Around line 345-347: Update the frame-rendering logic around the deltas
construction to accumulate rendered frame lengths while iterating and stop once
the running total reaches snapshot.length. Preserve the existing selection rule
and output: return all deltas only when their total length is strictly less than
snapshot.length; otherwise return [snapshot], while avoiding materializing or
retaining subsequent frames.
🪄 Autofix

Fix all unresolved CodeRabbit comments on this PR:

  • Push a commit to this branch (recommended)
  • Create a new PR with the fixes

ℹ️ Review info
⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro Plus

Run ID: fda0376e-6d28-4ea5-a1cc-a65a2934c0e6

📥 Commits

Reviewing files that changed from the base of the PR and between c7474df and 038fdb5.

⛔ Files ignored due to path filters (10)
  • api-snapshots/advisor.api.md is excluded by none and included by none
  • api-snapshots/codegen.api.md is excluded by none and included by none
  • api-snapshots/shard-engine.api.md is excluded by none and included by none
  • examples/chess/lunora/_generated/shard.ts is excluded by !**/_generated/** and included by none
  • examples/feedback-board/lunora/_generated/shard.ts is excluded by !**/_generated/** and included by none
  • packages/advisor/__tests__/unbounded-collect.test.ts is excluded by !**/__tests__/**, !**/*.test.ts and included by packages/**
  • packages/codegen/__tests__/discover-queries.test.ts is excluded by !**/__tests__/**, !**/*.test.ts and included by packages/**
  • packages/do/__tests__/shard-do.test.ts is excluded by !**/__tests__/**, !**/*.test.ts and included by packages/**
  • packages/do/__tests__/subscription-data-watermark.test.ts is excluded by !**/__tests__/**, !**/*.test.ts and included by packages/**
  • packages/shard-engine/__tests__/subscription-frames.test.ts is excluded by !**/__tests__/**, !**/*.test.ts and included by packages/**
📒 Files selected for processing (13)
  • packages/advisor/docs/index.mdx
  • packages/advisor/src/index.ts
  • packages/advisor/src/lints/helpers.ts
  • packages/advisor/src/lints/static/filter-on-primary-key.ts
  • packages/advisor/src/lints/static/filter-without-index.ts
  • packages/advisor/src/lints/static/unbounded-collect.ts
  • packages/advisor/src/queries.ts
  • packages/codegen/src/discover-queries.ts
  • packages/codegen/src/ir.ts
  • packages/do/src/shard-do.ts
  • packages/shard-engine/__bench__/subscription-frames.bench.ts
  • packages/shard-engine/src/index.ts
  • packages/shard-engine/src/subscription-delivery.ts

prisis and others added 2 commits August 11, 2026 13:22
A live subscription's refresh went out as one `{type:"delta"}` frame per
changed row whenever the diff was expressible, capped only by "no more
deltas than rows". That cap is a row-count proxy for wire cost, and it is
blind in both directions.

Every delta frame re-pays the whole `{"type":"delta","id":…}` + `"table":…`
+ cursor/epoch/watermark envelope around ONE row body, which the snapshot
pays once for the entire list. So the deltas stop being the cheaper encoding
well before they stop being a valid one. Measured on a 100-row list of
~290-byte rows where every row changed: 43,970 bytes across 100 frames
against 29,060 bytes in a single frame — 1.5x the payload and 100 sends
instead of 1, on the shard's write-flush fan-out path. The cap also misses
the opposite case, where a single delta into a short list of small rows
already costs more than re-sending the list.

Render both candidates and send the smaller one. `subscriptionFrames` now
owns the frame layout and the choice together, so the sizing cannot drift
from the format — it IS the format. `subscriptionListDeltas` keeps only the
four expressibility conditions; cost is no longer its call.

BREAKING CHANGE: `sendDeltaFrames` is removed from `@lunora/shard-engine` in
favour of `subscriptionFrames`, which returns the frames to send rather than
sending them. `subscriptionListDeltas` no longer returns `undefined` for a
near-total change — it decomposes any expressible diff.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AyG8dyPFieGYzRd7y1MMme
`filter_without_index` gates on `hasFilter`, so the widest read of all —
`ctx.db.query("t").collect()`, no index and no filter — fell straight
through it. The codegen feeder made that structural: it discarded every
discovered read that did not call `.filter()`, so no lint could have seen
one.

The cost is not only the scan. A query's result is what a live subscription
pushes over the WebSocket, and the shard's refresh gate can only skip a
subscription whose reads were confined to index slices. An unindexed
`.collect()` records a whole-table dependency instead, so every write to
the table re-runs the query and re-sends the entire table to every
subscribed socket, individually.

The feeder now reports every read plus the materializing call the chain
ends in, matched against a known terminal set rather than taken as the last
chained method — `.collect().then(...)` keeps the chain walk going, so the
literal last call is a promise combinator, not the terminal.

Also adds `withGeoIndex` to the narrowing methods. It was missing while only
filtered reads were reported, where nothing could observe it; once unfiltered
reads are reported it would flag the idiomatic `withGeoIndex(...).collect()`
as an unbounded scan — the exact chain `geo_index_unused` tells authors to
write.

Two examples trip the new lint on live-subscribed list queries; their
regenerated advisories are included.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AyG8dyPFieGYzRd7y1MMme
@prisis prisis changed the title perf(do): size subscription frames before sending them fix(do): size subscription frames before sending them Aug 11, 2026
Two review follow-ups on the frame sizing.

`subscriptionFrames` materialized every delta frame before comparing the
total against the snapshot, so a near-total change — the case the comparison
exists to catch — allocated an envelope per row only to discard the lot.
The running total only grows, so the answer is known the moment it reaches
the snapshot's length. Same comparison, same chosen frames, decided as early
as it can be.

The bench's reordered-survivors case also encoded its snapshot payload
inside the timed body while every other case precomputed it, folding a full
200-row encode plus stringify into a number that is meant to measure the
early-out. The production caller builds that payload once before calling in.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AyG8dyPFieGYzRd7y1MMme
@prisis
prisis force-pushed the perf/ws-subscription-frame-sizing branch from 038fdb5 to 491d00a Compare August 11, 2026 11:31
@codecov-commenter

Copy link
Copy Markdown

Codecov Report

❌ Patch coverage is 96.55172% with 2 lines in your changes missing coverage. Please review.
✅ Project coverage is 87.01%. Comparing base (95d33d6) to head (491d00a).
⚠️ Report is 295 commits behind head on alpha.

Files with missing lines Patch % Lines
packages/do/src/shard-do.ts 66.66% 0 Missing and 1 partial ⚠️
packages/shard-engine/src/subscription-delivery.ts 95.23% 1 Missing ⚠️
Additional details and impacted files
@@            Coverage Diff             @@
##            alpha     #406      +/-   ##
==========================================
- Coverage   87.09%   87.01%   -0.09%     
==========================================
  Files        1172     1201      +29     
  Lines       63383    65291    +1908     
  Branches    15447    16109     +662     
==========================================
+ Hits        55202    56810    +1608     
- Misses       7654     7938     +284     
- Partials      527      543      +16     
Files with missing lines Coverage Δ
packages/advisor/src/index.ts 100.00% <ø> (ø)
packages/advisor/src/lints/helpers.ts 100.00% <100.00%> (ø)
.../advisor/src/lints/static/filter-on-primary-key.ts 100.00% <100.00%> (ø)
...s/advisor/src/lints/static/filter-without-index.ts 100.00% <100.00%> (ø)
...ages/advisor/src/lints/static/unbounded-collect.ts 100.00% <100.00%> (ø)
packages/codegen/src/discover-queries.ts 96.42% <100.00%> (+0.13%) ⬆️
packages/do/src/shard-do.ts 84.76% <66.66%> (-0.21%) ⬇️
packages/shard-engine/src/subscription-delivery.ts 85.26% <95.23%> (+42.40%) ⬆️

... and 57 files with indirect coverage changes

🚀 New features to boost your workflow:
  • ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.
  • 📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.

@codspeed

codspeed Bot commented Aug 11, 2026

Copy link
Copy Markdown

Merging this PR will degrade performance by 5.99%

⚠️ Different runtime environments detected

Some benchmarks with significant performance changes were compared across different runtime environments,
which may affect the accuracy of the results.

Open the report in CodSpeed to investigate

⚡ 2 improved benchmarks
❌ 2 regressed benchmarks
✅ 249 untouched benchmarks
🆕 5 new benchmarks
⏩ 10 skipped benchmarks1

Warning

Please fix the performance issues or acknowledge them on CodSpeed.

Performance Changes

Benchmark BASE HEAD Efficiency
❌ broadcastWhisper to 1024 members 1 ms 1.4 ms -24.58%
❌ in-batch: single IN(...) query + id->doc re-projection 795.2 µs 951.7 µs -16.44%
⚡ flat 3 primitives (the notify.send attribute shape) 62.6 µs 55.6 µs +12.6%
⚡ 1 after-insert no-op trigger 444.4 µs 403.8 µs +10.04%
🆕 1 of 200 rows changed N/A 3.9 ms N/A
🆕 100 of 200 rows changed N/A 4.1 ms N/A
🆕 200 of 200 rows changed N/A 4.3 ms N/A
🆕 200 rows, survivors reordered → rejected N/A 1.1 ms N/A
🆕 paginated { page, isDone, continueCursor } → rejected (not an array) N/A 683.7 µs N/A

Tip

Investigate this regression by commenting @codspeedbot fix this regression on this PR, or directly use the CodSpeed MCP with your agent.


Comparing perf/ws-subscription-frame-sizing (491d00a) with alpha (ccc68a3)2

Open in CodSpeed

Footnotes

  1. 10 benchmarks were skipped, so the baseline results were used instead. If they were deleted from the codebase, click here and archive them to remove them from the performance reports. ↩

  2. No successful run was found on alpha (1b03cea) during the generation of this report, so ccc68a3 was used instead as the comparison base. There might be some changes unrelated to this pull request in this report. ↩

@prisis

prisis commented Aug 11, 2026

Copy link
Copy Markdown
Member Author

Folding this into #407 rather than merging separately.

#407 was stacked on this branch, so it already contained every commit here; it is now rebased onto alpha and carries all five:

  • perf(do): pick delta frames over a snapshot by measured size
  • feat(advisor): flag an unindexed, unfiltered collect
  • perf(shard-engine): stop rendering delta frames once the snapshot wins
  • perf(do): diff paginated live queries instead of re-sending the page
  • fix(do): send a snapshot when a delta would misplace an inserted row

Reviewing them as one unit is more honest anyway: the last commit fixes an insert-ordering desync that this PR's delta path introduced the exposure for, and the two are hard to judge apart.

The review feedback here was applied — the bench snapshotJson hoist (thanks @coderabbitai) and the early-abort render both landed in perf(shard-engine): stop rendering delta frames once the snapshot wins, which is in #407.

Note for anyone comparing CI: the CodSpeed red on this branch flagged broadcastWhisper to 1024 members and an in-batch re-projection — neither is touched by any commit here (no whisper/batch/relation lines in the diff), and CodSpeed's own summary reports "Different runtime environments detected… may affect the accuracy of the results". Cross-runner noise, not a regression.

Closing in favour of #407.

@prisis prisis closed this Aug 11, 2026
@coderabbitai

coderabbitai Bot commented Aug 11, 2026

Copy link
Copy Markdown

Tip

For best results, initiate chat on the files or code changes.

@prisis Acknowledged. I will treat #407 as the review target.

The measured-size selection, early-abort rendering, paginated-query handling, and insert-ordering snapshot fallback should be reviewed together there. The prior snapshotJson hoist feedback is also accounted for in #407.

🐇

You are interacting with an AI system.

@prisis
prisis deleted the perf/ws-subscription-frame-sizing branch August 11, 2026 19:25
@github-actions

Copy link
Copy Markdown
Contributor

This pull request has been automatically locked since there has not been any recent activity after it was closed. Please open a new issue for related bugs.
Please note this issue tracker is not a help forum. We recommend using our GitHub Discussions tab for questions.

@github-actions github-actions Bot locked as resolved and limited conversation to collaborators Sep 10, 2026

This branch was previously deployed

1 inactive deployment
benchmarks — 491d00a0 Deployed Aug 11, 2026 by prisis via Benchmarks #1710
Sign up for free to subscribe to this conversation on GitHub. Already have an account? Sign in.

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants