Skip to content

Commit 9d89df7

Browse files
ryansolidClaude via Cursorcursoragent
authored
frames: A0 correctness pass — S-flush, C3 hold, C5 data scope, C12 report, rulings (#3837)
* fix(web/frames): the address is an async source — one landing per bound address, one response per store (S-flush) A0 (SCs are rendered data): a frame is one async value outward. The mount's covering <Loading> now pends on the bound address's FIRST FLUSH — content or error — through `FrameHost.landing(address)`, read per bound address through a fresh node (frames-rulings 1.5, 1.6 (i)): a switch is a new question on the source, the superseded address's late writes release nothing, an unrevealed boundary stays on its fallback and a revealed one holds. The two hand-rolled shell gates (`boundaryComponent`'s arm/release/settle/setGate and `adoptBoundary`'s twin), `followAddress`'s re-arm and frameless waiter, and `onApply`-as-release go. An unstaged response announces itself to the host at its header (`start`), so the address reads "in flight" from the header to the landing. The store is one response's (1.4 full; 2.1/2.2): a version bump or rebind replaces the store wholesale — root, segments, slot records, the error — so a byte-identical root under a new version still applies as the new version's (C7 c), a held record leaves with the response that carried it (C6 a1, b2), and `argsEquivalent`/`clearStreamRecords` delete; the mount's `#slotArgs` value compare is what preserves occurrence state. The host keeps the latest landed version as `shown` so a mount opened mid-flight seeds the committed value (holds-latest) and the landing fans out as the version's whole set. The occurrence's name decides its class: a called occurrence (`prop#n`) found without its record waits for it — never evaluated argless (C18 ×3 flip; the #2968 poll stays as the document face's re-sync trigger, scoped to called occurrences) — and a bare occurrence is direct-insert. A reveal is an apply (2.3, interim): the document face's reveal cascade syncs the adopting frame, so a direct-insert range the fragment carried mounts (C2 b) and a record drained before its range was shown takes effect at the reveal (C4 d). Pins flipped to `test`: C2 (b), C4 (d), C6 (a1, b2), C7 (c), C17 (a — re-pinned: B's first flush, not its `start`, releases), C17 (c), harness C2 ×1, C18 ×3. Re-pinned: frames-binding-slots "orphan record … waits" (was "still mounts"), frames-hn-client zero-data occurrence is the bare prop. Co-authored-by: Claude via Cursor <[email protected]> Co-authored-by: Cursor <[email protected]> * fix(web/frames): hydration-done counts the frame's holds — a waiting adopted occurrence is a pending boundary (C3) Frames-rulings 3.1 (ruled): hydration-done follows non-SC Solid 2 — done is what `checkHydrationComplete` says (the root pass over, `_pendingBoundaries` zero), and the frames client participates through that mechanism, with no accounting of its own. 3.2, the carrier: ONE registration per frame while a sync leaves an adopted occurrence waiting to mount (for its record, for a `{$ref}`'s data), released by the first sync that leaves none or by disposal. solid-js: `sharedConfig.holdBoundary(id)` (internal) — `initBoundaryResume`'s registration for a holder with nothing to resume: the count, the owner's `_hp` mark, the disposal release; returns the release, which checks completion. One assignment in `enableHydration`. web/frames: `FrameOptions.hold()` (adopt path; wired by `adoptBoundary` under the component's owner, only while `isHydrationInProgress()`, keyed `sc:<fid>` so no fragment's bookkeeping is touched); `#syncSlots` tracks whether a full sync left an unmounted occurrence waiting and registers/releases at its end; `dispose` releases. Harness: the C3 law exempts a done that fired at or after the mount's disposal — a disposed holder owes no claim (its release is what lets done fire, as a disposed <Loading>'s is). Verified to hide nothing on `next` (C3 stays 280/500 there). Pins flipped to `test`: C3 (a), harness C3 ×1. Campaign (500 cases): C3 280 → 0 (seed 3289), 268 → 0 (seed 91501); only C19 remains. Co-authored-by: Claude via Cursor <[email protected]> Co-authored-by: Cursor <[email protected]> * fix(web/frames): a data chunk of a superseded response lands nowhere (C5) Frames-rulings 1.2: a `data` chunk lands in its own response's table or nowhere. The integration rotates the address's table at the header and creates it at first use; the transport restamps every chunk with its response's version; but `createFrameHost.apply` routed `data` straight to the data hook with no version read — so a superseded response's late chunk was the first use and filled the table that was now the current response's (R4). The data path is now under the store's version guard like every other chunk: with the response announced to the store at its header (S-flush), a `data` chunk whose version is below the store's is dropped. Pins flipped to `test`: C5 (a), (b), (e). Co-authored-by: Claude via Cursor <[email protected]> Co-authored-by: Cursor <[email protected]> * fix(web/frames): report a rejected server <Loading> fragment inside an adopted frame in dev; the client shows the server's outcome (C12 c, client half) Frames-rulings 3.3 under A0's corollary 4 (inward): a server `<Loading>` inside a server component is the SERVER's boundary; its outcome arrives as markup and the client shows whatever the server rendered for it — never a blank it invents, never a client error fallback for a server state. A rejected one has no client twin to surface its `<key>_fr` rejection (`hydratedCreateLoadingBoundary`'s `s === 2` arm runs only for a boundary registered against it), so the adoption that claims its placeholder observes the rejection and names it in dev (0 B prod). The blank the position shows today is the server half's gap: `server.ts`'s error path hands `sink.fragment` a `" "` template (the client twin, when there is one, renders over it; a server component's boundary has none). Pins: C12 (c) re-pinned per 3.3 — (c1) the rejection is reported in dev, the client invents no error state (test); (c2) the position shows the server's rendered outcome, never a blank (test.fails, the server half). Co-authored-by: Claude via Cursor <[email protected]> Co-authored-by: Cursor <[email protected]> * web/frames: trim the hold's bytes — one mounted read per occurrence in #syncSlots, the guard reads isHydrationInProgress alone −48 B min on the frames client (43,411 → 43,363); the zombie check now precedes the {$ref} wait, so a zombie held on a ref is unmounted at once rather than when the ref resolves. Co-authored-by: Claude via Cursor <[email protected]> Co-authored-by: Cursor <[email protected]> * web/frames: the data guard needs no undefined check (n < undefined is false) Co-authored-by: Claude via Cursor <[email protected]> Co-authored-by: Cursor <[email protected]> * docs(server-components): frames rulings — the three seams the consistency reds and the size audit's duplicates share (proposed) Draft, marked "proposed — maintainer ruling pending"; no engine changes. The frames/hydration consistency contract (spec/frames-consistency-contract) found thirteen reds across C2, C3, C4, C5, C6, C7, C12 and C17; the SC size audit (size/sc-audit §4) listed the layer's duplicated seams. This document tests the hypothesis that they are the same seams seen from two sides, and drafts the rulings — numbered one-sentence statements in the L2 section's voice, each with the mechanism that carries it today, the state it lives in twice, and the reds it decides — grouped by the three questions the reds cluster on: - Response identity (C5, C6, C17): a response owns what it delivered; a `data` chunk lands in its own response's table or nowhere; a record resolves its refs through its own response's table wherever the frame is bound; a bump drops what the previous version never applied; the shell gate is the bound address's; a switch keeps on screen what was on screen. - Applied state per version (C7, C2, C4): the store is the truth and the applied state is a cache of it keyed by version; a bump re-applies a byte-identical root; a reveal is an apply; applied means shown. - Hydration-done accounting (C3, C12, S1's C3b and `.fails`): done counts every occurrence the document delivered; every frames hold is counted once per frame; a claim owns the fragment's outcome; the client consumes the ids the server consumed. For each: the fix shape as one collapsed carrier (response-owned data cells, records carrying their resolver, one shell gate, one applied record, one hold counter), a byte estimate (− collapse / + carrier) read off the audit's function table, the pins that flip, and what touches public surface or the server half. Two-readings items for the maintainer: 1.4 (narrow/full), 1.6 (per-address gate value vs holds-latest), 3.1 (done counts the page vs the root pass — S1's pin and the contract's contradict). What the rulings do not decide (plain bugs, product questions, the wire) and an order of work gated by the contract's pins and scripts/size. Co-authored-by: Claude via Cursor <[email protected]> * docs(server-components): frames rulings — C13 confirmed, C18 first, C19 under seam 3; gate is #3813 Co-authored-by: Cursor <[email protected]> * docs(server-components): frames rulings — principle: SCs are rendered data; a frame is one async value outward, its inner boundaries are the server's; 3.1 ruled Co-authored-by: Cursor <[email protected]> * docs(server-components): A0 — equivalence: SCs are rendered data, the hold model governs; axioms annotated with the Solid 2 rules they restate Co-authored-by: Cursor <[email protected]> * docs(server-components): frames rulings — prior art comparison Per-reading comparison (1.3, 1.4, 1.6, 2.3, 3.1, 3.3, 3.5, 3.6) and per- product-question comparison (C12 (c), settles-once projections, live containers, slot-trails-html) against RSC/Flight+Fizz, Next.js, React Router/Remix, Turbo/htmx, Phoenix LiveView, Qwik, Astro server islands, Marko, Vue and Solid Router. Adds an addressing section (content-keyed vs tree-shaped vs DOM-addressed vs connection-tree) for the maintainer's A3/A4 model, a summary table, and a list of mechanisms the references have that we don't. Primary-source citations; verified vs inferred marked. Co-authored-by: Claude via Cursor <[email protected]> Co-authored-by: Cursor <[email protected]> * docs(plans): bring the frames A0 re-attribution and the savings-pass plan onto the rulings branch (from size/frames-a0-reattribution @ 1e0be39) The plans tonight's correctness pass implements (frames-savings-pass.md Phase A: A0–A6), carried with the code per the maintainer's preference. Squashed from the branch's nine commits; content unchanged. Co-authored-by: Claude via Cursor <[email protected]> Co-authored-by: Cursor <[email protected]> * docs(server-components): frames rulings — the overnight pass's defaults, the server-half drafts, the as-landed table What the rulings do NOT decide: the nine readings the 2026-10-06 pass took by default (first flush not start; warm switch-back shows the committed value; the name decides the class on every sync; 2.3's interim with S-flush; 1.2 by the version guard; 3.2 via initBoundaryResume keyed sc:<fid> while in progress; 3.3's dev report; S-adopted documented; the harness's C3 dispose exemption), each with its alternative. The server half: C13's delimiter with the client's one-write status, the plain-response streaming bound (complete.bound), C12 (c)'s error template located in finalizeError/the done closure with the two decisions the server PR must make. Order of work: the as-landed table (#3830–#3833), what each step left undone. Public surface: landing, hold, holdBoundary, the behaviour notes. Co-authored-by: Claude via Cursor <[email protected]> Co-authored-by: Cursor <[email protected]> * docs(server-components): frames rulings — the maintainer's 2026-10-06 decisions: the defaults accepted, the C3 hold cost accepted (caps raised), #3827 closed as superseded by S-flush Co-authored-by: Cursor <[email protected]> * size: raise frames/hydration caps for C3 hold (maintainer Size-Exception) The C3 hold (frames-rulings 3.1, ruled) costs +59 B min on every hydrating page (sharedConfig.holdBoundary in solid-js) and the pass nets +104 B min on the frames client (S-flush −187, the hold and C5's guard +291). Six scenarios are over their cap past the 20 B minified allowance; the maintainer accepted the cost 2026-10-06 ("pay the cost for correctness"). Each cap is set at the 0.01 KB step at or below measured + 10 B, with its recorded minified, from a local measurement that matches CI on this machine: hydrating (no stores) 17.71 -> 17.73 KB, page base 44.84 -> 44.89 KB, page live 48.51 -> 48.60 KB (floor-caps.json, under the PR's Size-Exception:); hydrating + stores 28.87 -> 28.93 KB, compiled hydrating 30.93 -> 31.03 KB, frames eager 13.78 -> 13.79 KB (scenarios.js). The three pre-existing over-cap-within-allowance scenarios (signals floor, isPending, CSR) are at +0 B minified and are not raised. Co-authored-by: Cursor <[email protected]> * docs(server-components): frames rulings — the pass lands as one PR, #3837 Co-authored-by: Cursor <[email protected]> * docs: record 2026-10-06 rulings (3.6 (iii), wire order, §6 decisions, holes eager) and the measured Phase D floor Co-authored-by: Cursor <[email protected]> --------- Co-authored-by: Claude via Cursor <[email protected]> Co-authored-by: Cursor <[email protected]>
1 parent 59fb244 commit 9d89df7

27 files changed

Lines changed: 5309 additions & 1019 deletions
Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,5 @@
1+
---
2+
"@solidjs/web": patch
3+
---
4+
5+
frames: the address is an async source (S-flush) — a mount's covering `<Loading>` pends on the bound address's first flush through `FrameHost.landing(address)` (content or error), per bound address, so a switch is a new question and the superseded address's late writes release nothing (contract C17 a, c); the store is one response's — a version bump or rebind replaces it wholesale, root included (C6 a1, b2; C7 c); a called occurrence (`prop#n`) found without its record waits for it instead of being evaluated argless (C18); the document face's reveal cascade syncs the adopting frame — a reveal is an apply (C2 b, C4 d).
Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,5 @@
1+
---
2+
"@solidjs/web": patch
3+
---
4+
5+
frames: a `data` chunk is under the store's version guard like every other chunk — a superseded response's late data lands nowhere, never in the table that is now the current response's (contract C5 a, b, e).
Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,5 @@
1+
---
2+
"@solidjs/web": patch
3+
---
4+
5+
frames (dev): a server `<Loading>` fragment inside an adopted server component that rejects on the server is reported — the client shows what the server rendered for that outcome and invents no error state of its own (contract C12 c, client half).
Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,6 @@
1+
---
2+
"solid-js": patch
3+
"@solidjs/web": patch
4+
---
5+
6+
Hydration-done counts the frames client's holds (frames-rulings 3.1, ruled): an adopted occurrence the frame has not claimed yet — waiting for its args record or a `{$ref}`'s data — registers as a pending boundary through the same registration a streamed `<Loading>` resume takes (`sharedConfig.holdBoundary`, internal), so `onHydrationEnd` and `isHydrationInProgress()` mean the same thing with or without server components (contract C3 a).

‎documentation/plans/frames-a0-reattribution.md‎

Lines changed: 1265 additions & 0 deletions
Large diffs are not rendered by default.

‎documentation/plans/frames-savings-pass.md‎

Lines changed: 574 additions & 0 deletions
Large diffs are not rendered by default.

‎documentation/server-components/frames-rulings-prior-art.md‎

Lines changed: 720 additions & 0 deletions
Large diffs are not rendered by default.

‎documentation/server-components/frames-rulings.md‎

Lines changed: 1544 additions & 0 deletions
Large diffs are not rendered by default.

‎documentation/server-components/server-components-principles.md‎

Lines changed: 80 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -48,40 +48,88 @@ mechanism that shouldn't exist. This is that pass for server components.
4848

4949
## 2. Axioms
5050

51-
Everything below is derived from these seven statements plus one liveness rule. A
52-
mechanism that cannot cite an axiom is a bug in the architecture even if it fixes a
53-
bug in the behavior.
54-
51+
Everything below is derived from one equivalence, seven statements, and one liveness
52+
rule. A mechanism that cannot cite an axiom is a bug in the architecture even if it
53+
fixes a bug in the behavior. **And (2026-10-05): a mechanism that cites only A3–A7
54+
for something the hold model already decides is likewise a bug — cite the L2 rule.**
55+
A1–A7 are SC-internal; each one is the SC *form* of a rule Solid 2 already has
56+
(named per axiom below), and a mechanism that satisfies the SC form while
57+
duplicating what the core rule already provides — a second version space, a second
58+
gate, a second "done" — has cited the wrong document.
59+
60+
- **A0 — Equivalence** (maintainer, 2026-10-05). *"SCs are no different than other
61+
rendered data."* *"Hydration ending follows non-SC Solid 2."* *"SCs participate in
62+
`<Loading>` until their first flush the same way, and can have their own internal
63+
loading states the client doesn't care about."* A server component's output —
64+
frame markup, records, traces — is async rendered data, and
65+
[`packages/signals/docs/SPEC-ASYNC-SEMANTICS.md`](../../packages/signals/docs/SPEC-ASYNC-SEMANTICS.md)
66+
(the L2 hold model: rulings 1–9 and the A-rules) is the governing document for
67+
anything async in this layer, with `documentation/solid-2.0/05-async-data.md` for
68+
the `<Loading>` rules and `solid-js` hydration for "done": **the frames layer adds
69+
a transport, never a second model.** Outward, a frame is one async value — the
70+
enclosing `<Loading>` and hydration-done wait for its first flush, a refetch or
71+
switch is a new question under the supersession rules; inward, its server
72+
boundaries are the server's — markup the client renders and tracks nothing of.
73+
Applied to the frames client, ruling by ruling, in
74+
[`frames-rulings.md`](frames-rulings.md) ("Principle"), which marks every ruling
75+
`Restates: <core rule>` or `Frames-specific: <transport property>`.
5576
- **A1 — Single-copy.** Server content travels exactly once: as HTML if it is
5677
markup, as a data record if the client needs the value. Never both. (At t = 0,
5778
values recoverable from the rendered page are recovered, not re-sent.)
79+
*Transport-specific* — a property of the wire; no core analogue, nothing to
80+
restate.
5881
- **A2 — Hydrate once.** Client components hydrate at t = 0 and never again. After
5982
boot the server never renders a client component; post-load responses carry server
6083
content and slot records only.
84+
*SC form of* the non-SC hydration rule — hydration is the one-time adoption of the
85+
document, finished when `_pendingBoundaries` reaches zero (`hydration.ts`
86+
`checkHydrationComplete`); a frame's hold on that is a pending boundary like any
87+
other, not a second end (A0; `frames-rulings.md` 3.1, ruled).
6188
- **A3 — Addresses key content, not mounts.** Every byte the server produces belongs
6289
to a `(function, arguments)` address. Arrival — any transport: preload, refetch,
6390
single-flight region, document inline — *only writes the address's store*. There is
6491
no code path from arrival to DOM.
92+
*SC form of* supersession / provenance — L2 ruling 5 and A18: an address is a
93+
source, a response is a flight answering one question on it, and an older
94+
question's landing is not the answer. "Only writes the store" is "a landing
95+
replaces the value; readers pull."
6596
- **A4 — Sites own mounts.** A consumption site owns one mounted frame, bound to one
6697
address at a time. DOM changes are pulls: the bound address's store advanced a
6798
version, or the site rebound to a different address. Binding follows the site's own
6899
reactive expression, nothing else.
100+
*SC form of* latest-wins — L2 ruling 1 / A15 / A30: the mount reads the source's
101+
current value; a rebind is a new read, and the version it sees is the one the hold
102+
model says is current, not a frame-side counter.
69103
- **A5 — One record shape.** A slot/region record has one meaning and one
70104
availability point on every transport. The t = 0 document emits the same records a
71105
stream would; a consumer never branches on "how did this arrive."
106+
*Transport-specific* — the wire's own uniformity rule; its core echo is only that
107+
`ssrSource` adoption (`05-async-data.md`) treats a serialized value and a streamed
108+
one as the same value.
72109
- **A6 — One reveal owner.** A pending placeholder has exactly one owner: the frame
73110
store/flush model. The document is the t = 0 frame (id `""`), not a parallel
74111
system with its own policy.
112+
*SC form of* the one-frame concept — L2 ruling 1 and A15 ("one reveal"): a flush is
113+
one landing, and a landing has one owner. DR-4 is this axiom applied to the
114+
document.
75115
- **A7 — Identity-first matching.** Occurrence identity is frame-wide. Reconciliation
76116
matches client-owned ranges by identity first and position second; a live range is
77117
*never* detached because of where it sat.
118+
*Transport-specific* — a morph rule for server-produced markup around client-owned
119+
ranges; the core has no reconciliation of foreign markup to restate.
78120
- **L1 — Liveness.** Every pending state resolves to exactly one of: content, error,
79121
or detectable truncation. Nothing pends silently forever. (This is the axiom
80122
solidjs/solid#2958 showed was missing: a truncated stream must be observable, and
81123
the `_$HY.fe` seam it relies on must actually exist.)
124+
*SC form of* A19 / A27 liveness — a hold that can never land is a bug, not a
125+
state; an unreachable source settles as an error (A5 for the escaping case).
126+
Truncation is the transport's way of making the source unreachable *observably*.
82127

83128
A1, A2 are unchanged from the shipped design and have never been the source of a bug
84-
class. A3–A7 and L1 are the corrective ones.
129+
class. A3–A7 and L1 are the corrective ones. A0 is the one the maintainer had stated
130+
and this document had not caught: the axioms above were written SC-internally, so a
131+
mechanism could satisfy A3 or A6 to the letter while building a second copy of what
132+
the hold model already provides — see §4's 2026-10-05 note.
85133

86134
### The derived data flow
87135

@@ -692,6 +740,33 @@ exists to undo another mechanism's consequences; deletes with its cause.
692740
Score: 24 derived (several simplified), 8 compensatory deletions, 3 restructured.
693741
The deletions are precisely the mechanisms with the worst bug-per-line record.
694742

743+
**2026-10-05 — what A0 would have made unrepresentable.** The consistency
744+
contract (`frames-consistency-contract.md` on
745+
[solidjs/solid#3813](https://github.com/solidjs/solid/pull/3813), 22 `test.fails`)
746+
pinned reds that each pass the audit above —
747+
every one of them cites A3, A4 or A6 honestly — and each is an A0 violation: a
748+
second copy of something the hold model already decides.
749+
750+
- **Two version spaces** (rows 5, 7 above; contract C5–C7, rulings 1.1–1.2, 2.1–2.2):
751+
`#version` on the frame store and the applied-version in the DOM, each
752+
bookkeeping that A3/A4's "latest version" already is — L2 ruling 1 / A18 decide
753+
which landing is current; there is one.
754+
- **Two gates** (row 32; C17, rulings 1.5–1.6): a frame-side shell gate beside the
755+
enclosing `<Loading>`'s pending state, where A0's outward face says the boundary
756+
*is* the gate for the frame's first flush.
757+
- **A second notion of done** (rows 32, 34; C3, ruling 3.1 — ruled): a frames-side
758+
hydration-end beside `_pendingBoundaries`, where A2 + A0 say a frame's hold is a
759+
pending boundary registered with the one counter.
760+
- **Client-side error state for a server boundary** (row 23; C12 (c), ruling 3.3):
761+
a client `<Errored>` for a boundary the server owns, where A0's inward face says
762+
the client shows whatever the server rendered for the outcome and never invents
763+
one.
764+
765+
The rulings, their fixes and byte estimates are in
766+
[`frames-rulings.md`](frames-rulings.md); the lesson for this document is the
767+
standard added to §2 — a mechanism that cites only A3–A7 for what the L2 rule
768+
decides cites the wrong document.
769+
695770
---
696771

697772
## 5. Settled questions

‎packages/solid/src/client/hydration.ts‎

Lines changed: 26 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -202,6 +202,24 @@ type SharedConfig = {
202202
* @internal
203203
*/
204204
isClaiming?: () => boolean;
205+
/**
206+
* Register a hold on hydration-done under the current owner — a pending
207+
* boundary in everything but a resume. Hydration-done follows non-SC
208+
* Solid 2 (frames-rulings 3.1): a client hold on adopted server markup
209+
* — an occurrence waiting for its args record, a `{$ref}` wait — counts
210+
* through the same registration a streamed `<Loading>` resume takes, so
211+
* `onHydrationEnd` and `isHydrationInProgress` mean the same thing with
212+
* or without server components. Call it under the holding owner (its
213+
* disposal releases), with an `id` no fragment uses, and only while
214+
* `isHydrationInProgress()` — a hold taken on a page that never hydrated,
215+
* or after it settled, is the holder's business, not the page's. Returns
216+
* the release (idempotent). Assigned by enableHydration(); absent in CSR
217+
* bundles (nothing to hold). Cross-package wiring; not part of the
218+
* user-facing API.
219+
*
220+
* @internal
221+
*/
222+
holdBoundary?: (id: string) => () => void;
205223
};
206224

207225
/**
@@ -1867,6 +1885,14 @@ export function enableHydration() {
18671885
sharedConfig.isHydrationInProgress = isHydrationInProgress;
18681886
sharedConfig.onHydrationEnd = onHydrationEnd;
18691887
sharedConfig.isClaiming = isClaiming;
1888+
// A client hold on adopted markup is a resume's registration — the count,
1889+
// the owner's `_hp` mark (a rerun under it is still the claim in
1890+
// progress), the disposal release — with nothing to resume; `id` keys the
1891+
// registration's bookkeeping, and the holder passes one no fragment uses.
1892+
sharedConfig.holdBoundary = id => {
1893+
const release = initBoundaryResume(getOwner()!, id)[2];
1894+
return () => release() && checkHydrationComplete();
1895+
};
18701896

18711897
// Take ownership of streamed-fragment reveals (see the fragment ledger).
18721898
// The header script creates `_$HY` before any module runs, so the hook is

0 commit comments

Comments
 (0)