@pyreon/core 0.23.0 → 0.24.1

package/lib/analysis/index.js.html

@@ -5386,7 +5386,7 @@ var drawChart = (function (exports) {
   </script>
   <script>
     /*<!--*/
-    const data = {"version":2,"tree":{"name":"root","children":[{"name":"index.js","children":[{"name":"src","children":[{"uid":"1b1bcb41-1","name":"lifecycle.ts"},{"uid":"1b1bcb41-3","name":"component.ts"},{"uid":"1b1bcb41-5","name":"compat-marker.ts"},{"uid":"1b1bcb41-7","name":"compat-shared.ts"},{"uid":"1b1bcb41-9","name":"context.ts"},{"uid":"1b1bcb41-11","name":"dynamic.ts"},{"uid":"1b1bcb41-13","name":"telemetry.ts"},{"uid":"1b1bcb41-15","name":"error-boundary.ts"},{"uid":"1b1bcb41-17","name":"for.ts"},{"uid":"1b1bcb41-19","name":"ref.ts"},{"uid":"1b1bcb41-21","name":"defer.ts"},{"uid":"1b1bcb41-23","name":"lazy.ts"},{"uid":"1b1bcb41-25","name":"map-array.ts"},{"uid":"1b1bcb41-27","name":"portal.ts"},{"uid":"1b1bcb41-29","name":"props.ts"},{"uid":"1b1bcb41-31","name":"show.ts"},{"uid":"1b1bcb41-33","name":"style.ts"},{"uid":"1b1bcb41-35","name":"suspense.ts"},{"uid":"1b1bcb41-37","name":"index.ts"}]}]},{"name":"jsx-dev-runtime.js","children":[{"name":"src/jsx-dev-runtime.ts","uid":"1b1bcb41-39"}]},{"name":"jsx-runtime.js","children":[{"name":"src/jsx-runtime.ts","uid":"1b1bcb41-41"}]},{"name":"_chunks/h-CYSD6aBx.js","children":[{"name":"src/h.ts","uid":"1b1bcb41-43"}]}],"isRoot":true},"nodeParts":{"1b1bcb41-1":{"renderedLength":3090,"gzipLength":1316,"brotliLength":0,"metaUid":"1b1bcb41-0"},"1b1bcb41-3":{"renderedLength":1908,"gzipLength":881,"brotliLength":0,"metaUid":"1b1bcb41-2"},"1b1bcb41-5":{"renderedLength":3173,"gzipLength":1409,"brotliLength":0,"metaUid":"1b1bcb41-4"},"1b1bcb41-7":{"renderedLength":2346,"gzipLength":1033,"brotliLength":0,"metaUid":"1b1bcb41-6"},"1b1bcb41-9":{"renderedLength":5216,"gzipLength":2147,"brotliLength":0,"metaUid":"1b1bcb41-8"},"1b1bcb41-11":{"renderedLength":490,"gzipLength":292,"brotliLength":0,"metaUid":"1b1bcb41-10"},"1b1bcb41-13":{"renderedLength":1990,"gzipLength":950,"brotliLength":0,"metaUid":"1b1bcb41-12"},"1b1bcb41-15":{"renderedLength":1666,"gzipLength":843,"brotliLength":0,"metaUid":"1b1bcb41-14"},"1b1bcb41-17":{"renderedLength":700,"gzipLength":478,"brotliLength":0,"metaUid":"1b1bcb41-16"},"1b1bcb41-19":{"renderedLength":86,"gzipLength":98,"brotliLength":0,"metaUid":"1b1bcb41-18"},"1b1bcb41-21":{"renderedLength":4387,"gzipLength":1891,"brotliLength":0,"metaUid":"1b1bcb41-20"},"1b1bcb41-23":{"renderedLength":461,"gzipLength":273,"brotliLength":0,"metaUid":"1b1bcb41-22"},"1b1bcb41-25":{"renderedLength":1018,"gzipLength":571,"brotliLength":0,"metaUid":"1b1bcb41-24"},"1b1bcb41-27":{"renderedLength":818,"gzipLength":491,"brotliLength":0,"metaUid":"1b1bcb41-26"},"1b1bcb41-29":{"renderedLength":6310,"gzipLength":2344,"brotliLength":0,"metaUid":"1b1bcb41-28"},"1b1bcb41-31":{"renderedLength":2022,"gzipLength":854,"brotliLength":0,"metaUid":"1b1bcb41-30"},"1b1bcb41-33":{"renderedLength":1858,"gzipLength":825,"brotliLength":0,"metaUid":"1b1bcb41-32"},"1b1bcb41-35":{"renderedLength":1104,"gzipLength":614,"brotliLength":0,"metaUid":"1b1bcb41-34"},"1b1bcb41-37":{"renderedLength":0,"gzipLength":0,"brotliLength":0,"metaUid":"1b1bcb41-36"},"1b1bcb41-39":{"renderedLength":0,"gzipLength":0,"brotliLength":0,"metaUid":"1b1bcb41-38"},"1b1bcb41-41":{"renderedLength":1789,"gzipLength":834,"brotliLength":0,"metaUid":"1b1bcb41-40"},"1b1bcb41-43":{"renderedLength":1813,"gzipLength":957,"brotliLength":0,"metaUid":"1b1bcb41-42"}},"nodeMetas":{"1b1bcb41-0":{"id":"/src/lifecycle.ts","moduleParts":{"index.js":"1b1bcb41-1"},"imported":[],"importedBy":[{"uid":"1b1bcb41-36"},{"uid":"1b1bcb41-2"},{"uid":"1b1bcb41-8"},{"uid":"1b1bcb41-14"},{"uid":"1b1bcb41-20"}]},"1b1bcb41-2":{"id":"/src/component.ts","moduleParts":{"index.js":"1b1bcb41-3"},"imported":[{"uid":"1b1bcb41-0"}],"importedBy":[{"uid":"1b1bcb41-36"},{"uid":"1b1bcb41-14"}]},"1b1bcb41-4":{"id":"/src/compat-marker.ts","moduleParts":{"index.js":"1b1bcb41-5"},"imported":[],"importedBy":[{"uid":"1b1bcb41-36"},{"uid":"1b1bcb41-14"}]},"1b1bcb41-6":{"id":"/src/compat-shared.ts","moduleParts":{"index.js":"1b1bcb41-7"},"imported":[],"importedBy":[{"uid":"1b1bcb41-36"}]},"1b1bcb41-8":{"id":"/src/context.ts","moduleParts":{"index.js":"1b1bcb41-9"},"imported":[{"uid":"1b1bcb41-44"},{"uid":"1b1bcb41-0"}],"importedBy":[{"uid":"1b1bcb41-36"}]},"1b1bcb41-10":{"id":"/src/dynamic.ts","moduleParts":{"index.js":"1b1bcb41-11"},"imported":[{"uid":"1b1bcb41-42"}],"importedBy":[{"uid":"1b1bcb41-36"}]},"1b1bcb41-12":{"id":"/src/telemetry.ts","moduleParts":{"index.js":"1b1bcb41-13"},"imported":[{"uid":"1b1bcb41-44"}],"importedBy":[{"uid":"1b1bcb41-36"},{"uid":"1b1bcb41-14"}]},"1b1bcb41-14":{"id":"/src/error-boundary.ts","moduleParts":{"index.js":"1b1bcb41-15"},"imported":[{"uid":"1b1bcb41-44"},{"uid":"1b1bcb41-4"},{"uid":"1b1bcb41-2"},{"uid":"1b1bcb41-0"},{"uid":"1b1bcb41-12"}],"importedBy":[{"uid":"1b1bcb41-36"}]},"1b1bcb41-16":{"id":"/src/for.ts","moduleParts":{"index.js":"1b1bcb41-17"},"imported":[],"importedBy":[{"uid":"1b1bcb41-36"}]},"1b1bcb41-18":{"id":"/src/ref.ts","moduleParts":{"index.js":"1b1bcb41-19"},"imported":[],"importedBy":[{"uid":"1b1bcb41-36"},{"uid":"1b1bcb41-20"}]},"1b1bcb41-20":{"id":"/src/defer.ts","moduleParts":{"index.js":"1b1bcb41-21"},"imported":[{"uid":"1b1bcb41-44"},{"uid":"1b1bcb41-42"},{"uid":"1b1bcb41-0"},{"uid":"1b1bcb41-18"}],"importedBy":[{"uid":"1b1bcb41-36"}]},"1b1bcb41-22":{"id":"/src/lazy.ts","moduleParts":{"index.js":"1b1bcb41-23"},"imported":[{"uid":"1b1bcb41-44"},{"uid":"1b1bcb41-42"}],"importedBy":[{"uid":"1b1bcb41-36"}]},"1b1bcb41-24":{"id":"/src/map-array.ts","moduleParts":{"index.js":"1b1bcb41-25"},"imported":[],"importedBy":[{"uid":"1b1bcb41-36"}]},"1b1bcb41-26":{"id":"/src/portal.ts","moduleParts":{"index.js":"1b1bcb41-27"},"imported":[],"importedBy":[{"uid":"1b1bcb41-36"}]},"1b1bcb41-28":{"id":"/src/props.ts","moduleParts":{"index.js":"1b1bcb41-29"},"imported":[],"importedBy":[{"uid":"1b1bcb41-36"}]},"1b1bcb41-30":{"id":"/src/show.ts","moduleParts":{"index.js":"1b1bcb41-31"},"imported":[],"importedBy":[{"uid":"1b1bcb41-36"}]},"1b1bcb41-32":{"id":"/src/style.ts","moduleParts":{"index.js":"1b1bcb41-33"},"imported":[],"importedBy":[{"uid":"1b1bcb41-36"}]},"1b1bcb41-34":{"id":"/src/suspense.ts","moduleParts":{"index.js":"1b1bcb41-35"},"imported":[{"uid":"1b1bcb41-42"}],"importedBy":[{"uid":"1b1bcb41-36"}]},"1b1bcb41-36":{"id":"/src/index.ts","moduleParts":{"index.js":"1b1bcb41-37"},"imported":[{"uid":"1b1bcb41-2"},{"uid":"1b1bcb41-4"},{"uid":"1b1bcb41-6"},{"uid":"1b1bcb41-8"},{"uid":"1b1bcb41-10"},{"uid":"1b1bcb41-14"},{"uid":"1b1bcb41-16"},{"uid":"1b1bcb41-42"},{"uid":"1b1bcb41-20"},{"uid":"1b1bcb41-22"},{"uid":"1b1bcb41-0"},{"uid":"1b1bcb41-24"},{"uid":"1b1bcb41-26"},{"uid":"1b1bcb41-28"},{"uid":"1b1bcb41-18"},{"uid":"1b1bcb41-30"},{"uid":"1b1bcb41-32"},{"uid":"1b1bcb41-34"},{"uid":"1b1bcb41-12"}],"importedBy":[],"isEntry":true},"1b1bcb41-38":{"id":"/src/jsx-dev-runtime.ts","moduleParts":{"jsx-dev-runtime.js":"1b1bcb41-39"},"imported":[{"uid":"1b1bcb41-40"}],"importedBy":[],"isEntry":true},"1b1bcb41-40":{"id":"/src/jsx-runtime.ts","moduleParts":{"jsx-runtime.js":"1b1bcb41-41"},"imported":[{"uid":"1b1bcb41-42"}],"importedBy":[{"uid":"1b1bcb41-38"}],"isEntry":true},"1b1bcb41-42":{"id":"/src/h.ts","moduleParts":{"_chunks/h-CYSD6aBx.js":"1b1bcb41-43"},"imported":[],"importedBy":[{"uid":"1b1bcb41-36"},{"uid":"1b1bcb41-10"},{"uid":"1b1bcb41-20"},{"uid":"1b1bcb41-22"},{"uid":"1b1bcb41-34"},{"uid":"1b1bcb41-40"}]},"1b1bcb41-44":{"id":"@pyreon/reactivity","moduleParts":{},"imported":[],"importedBy":[{"uid":"1b1bcb41-8"},{"uid":"1b1bcb41-14"},{"uid":"1b1bcb41-20"},{"uid":"1b1bcb41-22"},{"uid":"1b1bcb41-12"}]}},"env":{"rollup":"4.23.0"},"options":{"gzip":true,"brotli":false,"sourcemap":false}};
+    const data = {"version":2,"tree":{"name":"root","children":[{"name":"index.js","children":[{"name":"src","children":[{"uid":"48c493c7-1","name":"lifecycle.ts"},{"uid":"48c493c7-3","name":"component.ts"},{"uid":"48c493c7-5","name":"compat-marker.ts"},{"uid":"48c493c7-7","name":"compat-shared.ts"},{"uid":"48c493c7-9","name":"context.ts"},{"uid":"48c493c7-11","name":"dynamic.ts"},{"uid":"48c493c7-13","name":"telemetry.ts"},{"uid":"48c493c7-15","name":"error-boundary.ts"},{"uid":"48c493c7-17","name":"for.ts"},{"uid":"48c493c7-19","name":"ref.ts"},{"uid":"48c493c7-21","name":"defer.ts"},{"uid":"48c493c7-23","name":"lazy.ts"},{"uid":"48c493c7-25","name":"map-array.ts"},{"uid":"48c493c7-27","name":"portal.ts"},{"uid":"48c493c7-29","name":"props.ts"},{"uid":"48c493c7-31","name":"show.ts"},{"uid":"48c493c7-33","name":"style.ts"},{"uid":"48c493c7-35","name":"suspense.ts"},{"uid":"48c493c7-37","name":"index.ts"}]}]},{"name":"jsx-dev-runtime.js","children":[{"name":"src/jsx-dev-runtime.ts","uid":"48c493c7-39"}]},{"name":"jsx-runtime.js","children":[{"name":"src/jsx-runtime.ts","uid":"48c493c7-41"}]},{"name":"_chunks/h-CYSD6aBx.js","children":[{"name":"src/h.ts","uid":"48c493c7-43"}]}],"isRoot":true},"nodeParts":{"48c493c7-1":{"renderedLength":3090,"gzipLength":1316,"brotliLength":0,"metaUid":"48c493c7-0"},"48c493c7-3":{"renderedLength":1908,"gzipLength":881,"brotliLength":0,"metaUid":"48c493c7-2"},"48c493c7-5":{"renderedLength":3173,"gzipLength":1409,"brotliLength":0,"metaUid":"48c493c7-4"},"48c493c7-7":{"renderedLength":2346,"gzipLength":1033,"brotliLength":0,"metaUid":"48c493c7-6"},"48c493c7-9":{"renderedLength":9041,"gzipLength":3596,"brotliLength":0,"metaUid":"48c493c7-8"},"48c493c7-11":{"renderedLength":490,"gzipLength":292,"brotliLength":0,"metaUid":"48c493c7-10"},"48c493c7-13":{"renderedLength":1990,"gzipLength":950,"brotliLength":0,"metaUid":"48c493c7-12"},"48c493c7-15":{"renderedLength":1666,"gzipLength":843,"brotliLength":0,"metaUid":"48c493c7-14"},"48c493c7-17":{"renderedLength":700,"gzipLength":478,"brotliLength":0,"metaUid":"48c493c7-16"},"48c493c7-19":{"renderedLength":86,"gzipLength":98,"brotliLength":0,"metaUid":"48c493c7-18"},"48c493c7-21":{"renderedLength":4387,"gzipLength":1891,"brotliLength":0,"metaUid":"48c493c7-20"},"48c493c7-23":{"renderedLength":461,"gzipLength":273,"brotliLength":0,"metaUid":"48c493c7-22"},"48c493c7-25":{"renderedLength":1018,"gzipLength":571,"brotliLength":0,"metaUid":"48c493c7-24"},"48c493c7-27":{"renderedLength":818,"gzipLength":491,"brotliLength":0,"metaUid":"48c493c7-26"},"48c493c7-29":{"renderedLength":6310,"gzipLength":2344,"brotliLength":0,"metaUid":"48c493c7-28"},"48c493c7-31":{"renderedLength":2022,"gzipLength":854,"brotliLength":0,"metaUid":"48c493c7-30"},"48c493c7-33":{"renderedLength":1858,"gzipLength":825,"brotliLength":0,"metaUid":"48c493c7-32"},"48c493c7-35":{"renderedLength":1104,"gzipLength":614,"brotliLength":0,"metaUid":"48c493c7-34"},"48c493c7-37":{"renderedLength":0,"gzipLength":0,"brotliLength":0,"metaUid":"48c493c7-36"},"48c493c7-39":{"renderedLength":0,"gzipLength":0,"brotliLength":0,"metaUid":"48c493c7-38"},"48c493c7-41":{"renderedLength":1789,"gzipLength":834,"brotliLength":0,"metaUid":"48c493c7-40"},"48c493c7-43":{"renderedLength":1813,"gzipLength":957,"brotliLength":0,"metaUid":"48c493c7-42"}},"nodeMetas":{"48c493c7-0":{"id":"/src/lifecycle.ts","moduleParts":{"index.js":"48c493c7-1"},"imported":[],"importedBy":[{"uid":"48c493c7-36"},{"uid":"48c493c7-2"},{"uid":"48c493c7-8"},{"uid":"48c493c7-14"},{"uid":"48c493c7-20"}]},"48c493c7-2":{"id":"/src/component.ts","moduleParts":{"index.js":"48c493c7-3"},"imported":[{"uid":"48c493c7-0"}],"importedBy":[{"uid":"48c493c7-36"},{"uid":"48c493c7-14"}]},"48c493c7-4":{"id":"/src/compat-marker.ts","moduleParts":{"index.js":"48c493c7-5"},"imported":[],"importedBy":[{"uid":"48c493c7-36"},{"uid":"48c493c7-14"}]},"48c493c7-6":{"id":"/src/compat-shared.ts","moduleParts":{"index.js":"48c493c7-7"},"imported":[],"importedBy":[{"uid":"48c493c7-36"}]},"48c493c7-8":{"id":"/src/context.ts","moduleParts":{"index.js":"48c493c7-9"},"imported":[{"uid":"48c493c7-44"},{"uid":"48c493c7-0"}],"importedBy":[{"uid":"48c493c7-36"}]},"48c493c7-10":{"id":"/src/dynamic.ts","moduleParts":{"index.js":"48c493c7-11"},"imported":[{"uid":"48c493c7-42"}],"importedBy":[{"uid":"48c493c7-36"}]},"48c493c7-12":{"id":"/src/telemetry.ts","moduleParts":{"index.js":"48c493c7-13"},"imported":[{"uid":"48c493c7-44"}],"importedBy":[{"uid":"48c493c7-36"},{"uid":"48c493c7-14"}]},"48c493c7-14":{"id":"/src/error-boundary.ts","moduleParts":{"index.js":"48c493c7-15"},"imported":[{"uid":"48c493c7-44"},{"uid":"48c493c7-4"},{"uid":"48c493c7-2"},{"uid":"48c493c7-0"},{"uid":"48c493c7-12"}],"importedBy":[{"uid":"48c493c7-36"}]},"48c493c7-16":{"id":"/src/for.ts","moduleParts":{"index.js":"48c493c7-17"},"imported":[],"importedBy":[{"uid":"48c493c7-36"}]},"48c493c7-18":{"id":"/src/ref.ts","moduleParts":{"index.js":"48c493c7-19"},"imported":[],"importedBy":[{"uid":"48c493c7-36"},{"uid":"48c493c7-20"}]},"48c493c7-20":{"id":"/src/defer.ts","moduleParts":{"index.js":"48c493c7-21"},"imported":[{"uid":"48c493c7-44"},{"uid":"48c493c7-42"},{"uid":"48c493c7-0"},{"uid":"48c493c7-18"}],"importedBy":[{"uid":"48c493c7-36"}]},"48c493c7-22":{"id":"/src/lazy.ts","moduleParts":{"index.js":"48c493c7-23"},"imported":[{"uid":"48c493c7-44"},{"uid":"48c493c7-42"}],"importedBy":[{"uid":"48c493c7-36"}]},"48c493c7-24":{"id":"/src/map-array.ts","moduleParts":{"index.js":"48c493c7-25"},"imported":[],"importedBy":[{"uid":"48c493c7-36"}]},"48c493c7-26":{"id":"/src/portal.ts","moduleParts":{"index.js":"48c493c7-27"},"imported":[],"importedBy":[{"uid":"48c493c7-36"}]},"48c493c7-28":{"id":"/src/props.ts","moduleParts":{"index.js":"48c493c7-29"},"imported":[],"importedBy":[{"uid":"48c493c7-36"}]},"48c493c7-30":{"id":"/src/show.ts","moduleParts":{"index.js":"48c493c7-31"},"imported":[],"importedBy":[{"uid":"48c493c7-36"}]},"48c493c7-32":{"id":"/src/style.ts","moduleParts":{"index.js":"48c493c7-33"},"imported":[],"importedBy":[{"uid":"48c493c7-36"}]},"48c493c7-34":{"id":"/src/suspense.ts","moduleParts":{"index.js":"48c493c7-35"},"imported":[{"uid":"48c493c7-42"}],"importedBy":[{"uid":"48c493c7-36"}]},"48c493c7-36":{"id":"/src/index.ts","moduleParts":{"index.js":"48c493c7-37"},"imported":[{"uid":"48c493c7-2"},{"uid":"48c493c7-4"},{"uid":"48c493c7-6"},{"uid":"48c493c7-8"},{"uid":"48c493c7-10"},{"uid":"48c493c7-14"},{"uid":"48c493c7-16"},{"uid":"48c493c7-42"},{"uid":"48c493c7-20"},{"uid":"48c493c7-22"},{"uid":"48c493c7-0"},{"uid":"48c493c7-24"},{"uid":"48c493c7-26"},{"uid":"48c493c7-28"},{"uid":"48c493c7-18"},{"uid":"48c493c7-30"},{"uid":"48c493c7-32"},{"uid":"48c493c7-34"},{"uid":"48c493c7-12"}],"importedBy":[],"isEntry":true},"48c493c7-38":{"id":"/src/jsx-dev-runtime.ts","moduleParts":{"jsx-dev-runtime.js":"48c493c7-39"},"imported":[{"uid":"48c493c7-40"}],"importedBy":[],"isEntry":true},"48c493c7-40":{"id":"/src/jsx-runtime.ts","moduleParts":{"jsx-runtime.js":"48c493c7-41"},"imported":[{"uid":"48c493c7-42"}],"importedBy":[{"uid":"48c493c7-38"}],"isEntry":true},"48c493c7-42":{"id":"/src/h.ts","moduleParts":{"_chunks/h-CYSD6aBx.js":"48c493c7-43"},"imported":[],"importedBy":[{"uid":"48c493c7-36"},{"uid":"48c493c7-10"},{"uid":"48c493c7-20"},{"uid":"48c493c7-22"},{"uid":"48c493c7-34"},{"uid":"48c493c7-40"}]},"48c493c7-44":{"id":"@pyreon/reactivity","moduleParts":{},"imported":[],"importedBy":[{"uid":"48c493c7-8"},{"uid":"48c493c7-14"},{"uid":"48c493c7-20"},{"uid":"48c493c7-22"},{"uid":"48c493c7-12"}]}},"env":{"rollup":"4.23.0"},"options":{"gzip":true,"brotli":false,"sourcemap":false}};
 
     const run = () => {
       const width = window.innerWidth;

package/lib/index.js

@@ -362,6 +362,23 @@ function popContext() {
 	stack.pop();
 }
 /**
+* Read the current live stack length WITHOUT allocating a snapshot.
+*
+* SSR cleanup uses this as a position marker: capture the live length
+* before a component renders, pop the live stack back to that length
+* after. Previously these sites called `captureContextStack().length`,
+* which allocated a full snapshot array (potentially 40k+ entries
+* under deeply-nested reactive boundaries — the same allocation the
+* `captureContextStack` dedup work is designed to shrink) just to
+* read its length. This helper avoids the allocation entirely AND
+* decouples SSR cleanup from `captureContextStack`'s snapshot shape,
+* so dedup at capture time can never silently break SSR length
+* bookkeeping.
+*/
+function getContextStackLength() {
+	return getStack().length;
+}
+/**
 * Remove a SPECIFIC frame from the context stack by reference identity.
 *
 * Internal — used by `provide()` and `withContext()` to safely clean up
@@ -420,15 +437,77 @@ function withContext(context, value, fn) {
 	}
 }
 /**
-* Capture a snapshot of the current context stack.
+* Capture a snapshot of the current context stack, **deduplicated** so
+* only the topmost frame for each context-id is retained.
 *
 * Used by `mountReactive` to preserve the context that was active when a
 * reactive boundary (e.g. `<Show>`, `<For>`) was set up. When the boundary
 * later mounts new children inside an effect, the snapshot is restored so
 * those children can see ancestor providers via `useContext()`.
+*
+* **Why dedup is semantically equivalent to a full snapshot:**
+* `useContext()` walks the stack in reverse and returns the first frame
+* matching the requested context-id (`for (let i = stack.length - 1; i >= 0; i--)`
+* — see implementation below in this file). Any frame deeper in the
+* stack that ALSO provides the same id is unreachable by definition —
+* the reverse walk stops at the first match. Those shadowed frames are
+* dead weight in the snapshot: they carry no observable value, they
+* cost memory, and they can NEVER affect program behavior.
+*
+* The dedup walks frames from top to bottom keeping a `seen` set of
+* already-resolved context ids. A frame is kept iff at least one of
+* its keys is NOT in `seen` (i.e. it's the topmost provider for at
+* least one id). All of a frame's keys are added to `seen` regardless
+* of whether the frame is kept — `seen` represents "ids that are
+* already provided by a more-recent frame".
+*
+* **Why this is safe for `restoreContextStack`:**
+* `restoreContextStack` pushes the snapshot's frames onto the live
+* stack, runs `fn()`, then removes those frames by **reference
+* identity** (`stack.lastIndexOf(frame)`) — NOT by position or count
+* of the snapshot. A deduped snapshot pushes fewer frames; the same
+* reference-identity cleanup removes exactly those frames. No
+* bookkeeping invariant breaks.
+*
+* **Why this is safe for the live stack length invariant:**
+* SSR cleanup uses `getContextStackLength()` (a sibling helper) for
+* position-marker bookkeeping. That helper reads the LIVE stack
+* length, NOT the snapshot length, so dedup at capture time has zero
+* effect on SSR cleanup behavior.
+*
+* **Why this is needed:**
+* Under deeply-nested reactive boundaries (a `<Show>` inside a `<For>`
+* inside a `<Suspense>`, each effect capturing its own snapshot at
+* setup time), the live stack temporarily holds the same context-id
+* pushed multiple times during nested `restoreContextStack` windows.
+* The pre-dedup `[...getStack()]` snapshot baked those duplicates in
+* permanently — each effect's closure retained an O(stack-depth)
+* array for its lifetime. Reported heap snapshots from 0.21.x showed
+* 1.22 MB / 321k-entry arrays from this pattern. The 0.23.0
+* restoreContextStack reference-identity fix cleaned the LIVE stack
+* but left the residual snapshot-amplification — observable as 20
+* arrays at 157 KB each (40k entries) retained by effect closures.
+* This dedup collapses each captured snapshot to ~N entries, where
+* N is the number of DISTINCT context ids in scope (typically 2-10
+* in real apps).
 */
 function captureContextStack() {
-	return [...getStack()];
+	const stack = getStack();
+	if (stack.length <= 1) return stack.slice();
+	const seen = /* @__PURE__ */ new Set();
+	const reversed = [];
+	for (let i = stack.length - 1; i >= 0; i--) {
+		const frame = stack[i];
+		if (!frame) continue;
+		let unique = false;
+		for (const id of frame.keys()) if (!seen.has(id)) {
+			seen.add(id);
+			unique = true;
+		}
+		if (unique) reversed.push(frame);
+	}
+	reversed.reverse();
+	return reversed;
 }
 /**
 * Execute `fn()` with a previously captured context stack active.
@@ -1201,5 +1280,5 @@ function Suspense(props) {
 }
 
 //#endregion
-export { CSS_UNITLESS, Defer, Dynamic, EMPTY_PROPS, ErrorBoundary, For, ForSymbol, Fragment, Match, MatchSymbol, NATIVE_COMPAT_MARKER, Portal, PortalSymbol, REACTIVE_PROP, Show, Suspense, Switch, _rp, _wrapSpread, captureContextStack, createContext, createReactiveContext, createRef, createUniqueId, cx, defineComponent, dispatchToErrorBoundary, h, isNativeCompat, lazy, makeReactiveProps, mapArray, mapCompatDomProps, mergeProps, nativeCompat, normalizeStyleValue, onErrorCaptured, onMount, onUnmount, onUpdate, popContext, propagateError, provide, pushContext, registerErrorHandler, removeContextFrame, reportError, restoreContextStack, runWithHooks, setContextStackProvider, shallowEqualProps, splitProps, toKebabCase, useContext, withContext };
+export { CSS_UNITLESS, Defer, Dynamic, EMPTY_PROPS, ErrorBoundary, For, ForSymbol, Fragment, Match, MatchSymbol, NATIVE_COMPAT_MARKER, Portal, PortalSymbol, REACTIVE_PROP, Show, Suspense, Switch, _rp, _wrapSpread, captureContextStack, createContext, createReactiveContext, createRef, createUniqueId, cx, defineComponent, dispatchToErrorBoundary, getContextStackLength, h, isNativeCompat, lazy, makeReactiveProps, mapArray, mapCompatDomProps, mergeProps, nativeCompat, normalizeStyleValue, onErrorCaptured, onMount, onUnmount, onUpdate, popContext, propagateError, provide, pushContext, registerErrorHandler, removeContextFrame, reportError, restoreContextStack, runWithHooks, setContextStackProvider, shallowEqualProps, splitProps, toKebabCase, useContext, withContext };
 //# sourceMappingURL=index.js.map

package/lib/types/index.d.ts

@@ -258,6 +258,21 @@ declare function pushContext(values: Map<symbol, unknown>): void;
  * unmount, making the top-of-stack unsafe to assume.
  */
 declare function popContext(): void;
+/**
+ * Read the current live stack length WITHOUT allocating a snapshot.
+ *
+ * SSR cleanup uses this as a position marker: capture the live length
+ * before a component renders, pop the live stack back to that length
+ * after. Previously these sites called `captureContextStack().length`,
+ * which allocated a full snapshot array (potentially 40k+ entries
+ * under deeply-nested reactive boundaries — the same allocation the
+ * `captureContextStack` dedup work is designed to shrink) just to
+ * read its length. This helper avoids the allocation entirely AND
+ * decouples SSR cleanup from `captureContextStack`'s snapshot shape,
+ * so dedup at capture time can never silently break SSR length
+ * bookkeeping.
+ */
+declare function getContextStackLength(): number;
 /**
  * Remove a SPECIFIC frame from the context stack by reference identity.
  *
@@ -303,12 +318,59 @@ declare function provide<T>(context: Context<T>, value: T): void;
 declare function withContext<T>(context: Context<T>, value: T, fn: () => void): void;
 type ContextSnapshot = Map<symbol, unknown>[];
 /**
- * Capture a snapshot of the current context stack.
+ * Capture a snapshot of the current context stack, **deduplicated** so
+ * only the topmost frame for each context-id is retained.
  *
  * Used by `mountReactive` to preserve the context that was active when a
  * reactive boundary (e.g. `<Show>`, `<For>`) was set up. When the boundary
  * later mounts new children inside an effect, the snapshot is restored so
  * those children can see ancestor providers via `useContext()`.
+ *
+ * **Why dedup is semantically equivalent to a full snapshot:**
+ * `useContext()` walks the stack in reverse and returns the first frame
+ * matching the requested context-id (`for (let i = stack.length - 1; i >= 0; i--)`
+ * — see implementation below in this file). Any frame deeper in the
+ * stack that ALSO provides the same id is unreachable by definition —
+ * the reverse walk stops at the first match. Those shadowed frames are
+ * dead weight in the snapshot: they carry no observable value, they
+ * cost memory, and they can NEVER affect program behavior.
+ *
+ * The dedup walks frames from top to bottom keeping a `seen` set of
+ * already-resolved context ids. A frame is kept iff at least one of
+ * its keys is NOT in `seen` (i.e. it's the topmost provider for at
+ * least one id). All of a frame's keys are added to `seen` regardless
+ * of whether the frame is kept — `seen` represents "ids that are
+ * already provided by a more-recent frame".
+ *
+ * **Why this is safe for `restoreContextStack`:**
+ * `restoreContextStack` pushes the snapshot's frames onto the live
+ * stack, runs `fn()`, then removes those frames by **reference
+ * identity** (`stack.lastIndexOf(frame)`) — NOT by position or count
+ * of the snapshot. A deduped snapshot pushes fewer frames; the same
+ * reference-identity cleanup removes exactly those frames. No
+ * bookkeeping invariant breaks.
+ *
+ * **Why this is safe for the live stack length invariant:**
+ * SSR cleanup uses `getContextStackLength()` (a sibling helper) for
+ * position-marker bookkeeping. That helper reads the LIVE stack
+ * length, NOT the snapshot length, so dedup at capture time has zero
+ * effect on SSR cleanup behavior.
+ *
+ * **Why this is needed:**
+ * Under deeply-nested reactive boundaries (a `<Show>` inside a `<For>`
+ * inside a `<Suspense>`, each effect capturing its own snapshot at
+ * setup time), the live stack temporarily holds the same context-id
+ * pushed multiple times during nested `restoreContextStack` windows.
+ * The pre-dedup `[...getStack()]` snapshot baked those duplicates in
+ * permanently — each effect's closure retained an O(stack-depth)
+ * array for its lifetime. Reported heap snapshots from 0.21.x showed
+ * 1.22 MB / 321k-entry arrays from this pattern. The 0.23.0
+ * restoreContextStack reference-identity fix cleaned the LIVE stack
+ * but left the residual snapshot-amplification — observable as 20
+ * arrays at 157 KB each (40k entries) retained by effect closures.
+ * This dedup collapses each captured snapshot to ~N entries, where
+ * N is the number of DISTINCT context ids in scope (typically 2-10
+ * in real apps).
  */
 declare function captureContextStack(): ContextSnapshot;
 /**
@@ -1443,5 +1505,5 @@ declare function registerErrorHandler(handler: ErrorHandler): () => void;
  */
 declare function reportError(ctx: ErrorContext): void;
 //#endregion
-export { type AnchorAttributes, type ButtonAttributes, type CSSProperties, CSS_UNITLESS, type ClassValue, type CleanupFn, type ComponentFn, type ComponentInstance, type Context, type ContextSnapshot, Defer, type DeferProps, Dynamic, type DynamicProps, EMPTY_PROPS, ErrorBoundary, type ErrorContext, type ErrorHandler, type ExtractProps, For, type ForProps, ForSymbol, type FormAttributes, Fragment, type HigherOrderComponent, type ImgAttributes, type InputAttributes, type LazyComponent, type LifecycleHooks, Match, type MatchProps, MatchSymbol, NATIVE_COMPAT_MARKER, type NativeItem, Portal, type PortalProps, PortalSymbol, type Props, type PyreonHTMLAttributes, REACTIVE_PROP, type ReactiveContext, type ReactiveTraceEntry, type Ref, type RefCallback, type RefProp, type SelectAttributes, Show, type ShowProps, type StyleValue, Suspense, type SvgAttributes, Switch, type SwitchProps, type TargetedEvent, type TextareaAttributes, type VNode, type VNodeChild, type VNodeChildAccessor, type VNodeChildAtom, _rp, _wrapSpread, captureContextStack, createContext, createReactiveContext, createRef, createUniqueId, cx, defineComponent, dispatchToErrorBoundary, h, isNativeCompat, lazy, makeReactiveProps, mapArray, mapCompatDomProps, mergeProps, nativeCompat, normalizeStyleValue, onErrorCaptured, onMount, onUnmount, onUpdate, popContext, propagateError, provide, pushContext, registerErrorHandler, removeContextFrame, reportError, restoreContextStack, runWithHooks, setContextStackProvider, shallowEqualProps, splitProps, toKebabCase, useContext, withContext };
+export { type AnchorAttributes, type ButtonAttributes, type CSSProperties, CSS_UNITLESS, type ClassValue, type CleanupFn, type ComponentFn, type ComponentInstance, type Context, type ContextSnapshot, Defer, type DeferProps, Dynamic, type DynamicProps, EMPTY_PROPS, ErrorBoundary, type ErrorContext, type ErrorHandler, type ExtractProps, For, type ForProps, ForSymbol, type FormAttributes, Fragment, type HigherOrderComponent, type ImgAttributes, type InputAttributes, type LazyComponent, type LifecycleHooks, Match, type MatchProps, MatchSymbol, NATIVE_COMPAT_MARKER, type NativeItem, Portal, type PortalProps, PortalSymbol, type Props, type PyreonHTMLAttributes, REACTIVE_PROP, type ReactiveContext, type ReactiveTraceEntry, type Ref, type RefCallback, type RefProp, type SelectAttributes, Show, type ShowProps, type StyleValue, Suspense, type SvgAttributes, Switch, type SwitchProps, type TargetedEvent, type TextareaAttributes, type VNode, type VNodeChild, type VNodeChildAccessor, type VNodeChildAtom, _rp, _wrapSpread, captureContextStack, createContext, createReactiveContext, createRef, createUniqueId, cx, defineComponent, dispatchToErrorBoundary, getContextStackLength, h, isNativeCompat, lazy, makeReactiveProps, mapArray, mapCompatDomProps, mergeProps, nativeCompat, normalizeStyleValue, onErrorCaptured, onMount, onUnmount, onUpdate, popContext, propagateError, provide, pushContext, registerErrorHandler, removeContextFrame, reportError, restoreContextStack, runWithHooks, setContextStackProvider, shallowEqualProps, splitProps, toKebabCase, useContext, withContext };
 //# sourceMappingURL=index2.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyreon/core",
-  "version": "0.23.0",
+  "version": "0.24.1",
   "description": "Core component model and lifecycle for Pyreon",
   "homepage": "https://github.com/pyreon/pyreon/tree/main/packages/core#readme",
   "bugs": {
@@ -53,7 +53,7 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@pyreon/reactivity": "^0.23.0"
+    "@pyreon/reactivity": "^0.24.1"
   },
   "devDependencies": {
     "@pyreon/manifest": "0.13.1"

package/src/context.ts

@@ -89,6 +89,24 @@ export function popContext() {
   stack.pop()
 }
 
+/**
+ * Read the current live stack length WITHOUT allocating a snapshot.
+ *
+ * SSR cleanup uses this as a position marker: capture the live length
+ * before a component renders, pop the live stack back to that length
+ * after. Previously these sites called `captureContextStack().length`,
+ * which allocated a full snapshot array (potentially 40k+ entries
+ * under deeply-nested reactive boundaries — the same allocation the
+ * `captureContextStack` dedup work is designed to shrink) just to
+ * read its length. This helper avoids the allocation entirely AND
+ * decouples SSR cleanup from `captureContextStack`'s snapshot shape,
+ * so dedup at capture time can never silently break SSR length
+ * bookkeeping.
+ */
+export function getContextStackLength(): number {
+  return getStack().length
+}
+
 /**
  * Remove a SPECIFIC frame from the context stack by reference identity.
  *
@@ -179,17 +197,92 @@ export function withContext<T>(context: Context<T>, value: T, fn: () => void) {
 export type ContextSnapshot = Map<symbol, unknown>[]
 
 /**
- * Capture a snapshot of the current context stack.
+ * Capture a snapshot of the current context stack, **deduplicated** so
+ * only the topmost frame for each context-id is retained.
  *
  * Used by `mountReactive` to preserve the context that was active when a
  * reactive boundary (e.g. `<Show>`, `<For>`) was set up. When the boundary
  * later mounts new children inside an effect, the snapshot is restored so
  * those children can see ancestor providers via `useContext()`.
+ *
+ * **Why dedup is semantically equivalent to a full snapshot:**
+ * `useContext()` walks the stack in reverse and returns the first frame
+ * matching the requested context-id (`for (let i = stack.length - 1; i >= 0; i--)`
+ * — see implementation below in this file). Any frame deeper in the
+ * stack that ALSO provides the same id is unreachable by definition —
+ * the reverse walk stops at the first match. Those shadowed frames are
+ * dead weight in the snapshot: they carry no observable value, they
+ * cost memory, and they can NEVER affect program behavior.
+ *
+ * The dedup walks frames from top to bottom keeping a `seen` set of
+ * already-resolved context ids. A frame is kept iff at least one of
+ * its keys is NOT in `seen` (i.e. it's the topmost provider for at
+ * least one id). All of a frame's keys are added to `seen` regardless
+ * of whether the frame is kept — `seen` represents "ids that are
+ * already provided by a more-recent frame".
+ *
+ * **Why this is safe for `restoreContextStack`:**
+ * `restoreContextStack` pushes the snapshot's frames onto the live
+ * stack, runs `fn()`, then removes those frames by **reference
+ * identity** (`stack.lastIndexOf(frame)`) — NOT by position or count
+ * of the snapshot. A deduped snapshot pushes fewer frames; the same
+ * reference-identity cleanup removes exactly those frames. No
+ * bookkeeping invariant breaks.
+ *
+ * **Why this is safe for the live stack length invariant:**
+ * SSR cleanup uses `getContextStackLength()` (a sibling helper) for
+ * position-marker bookkeeping. That helper reads the LIVE stack
+ * length, NOT the snapshot length, so dedup at capture time has zero
+ * effect on SSR cleanup behavior.
+ *
+ * **Why this is needed:**
+ * Under deeply-nested reactive boundaries (a `<Show>` inside a `<For>`
+ * inside a `<Suspense>`, each effect capturing its own snapshot at
+ * setup time), the live stack temporarily holds the same context-id
+ * pushed multiple times during nested `restoreContextStack` windows.
+ * The pre-dedup `[...getStack()]` snapshot baked those duplicates in
+ * permanently — each effect's closure retained an O(stack-depth)
+ * array for its lifetime. Reported heap snapshots from 0.21.x showed
+ * 1.22 MB / 321k-entry arrays from this pattern. The 0.23.0
+ * restoreContextStack reference-identity fix cleaned the LIVE stack
+ * but left the residual snapshot-amplification — observable as 20
+ * arrays at 157 KB each (40k entries) retained by effect closures.
+ * This dedup collapses each captured snapshot to ~N entries, where
+ * N is the number of DISTINCT context ids in scope (typically 2-10
+ * in real apps).
  */
 export function captureContextStack(): ContextSnapshot {
-  // Shallow copy — each frame (Map) is shared by reference, which is
-  // correct because providers don't mutate frames after creation.
-  return [...getStack()]
+  const stack = getStack()
+  // Fast path: empty stack or single frame is the common case for
+  // top-level mounts and zero-context apps. Skip the dedup machinery.
+  if (stack.length <= 1) return stack.slice()
+
+  // Walk top-to-bottom, keeping the topmost frame for each context-id.
+  // Each frame is a Map<symbol, unknown>; `seen` tracks ids already
+  // provided by a more-recent frame.
+  const seen = new Set<symbol>()
+  const reversed: Map<symbol, unknown>[] = []
+  for (let i = stack.length - 1; i >= 0; i--) {
+    const frame = stack[i]
+    if (!frame) continue
+    // A frame is unique if it provides at least one not-yet-seen id.
+    // Iterate ALL keys to accumulate them into `seen` (so deeper
+    // frames sharing any one of them are correctly shadowed even if
+    // they also have other unique keys).
+    let unique = false
+    for (const id of frame.keys()) {
+      if (!seen.has(id)) {
+        seen.add(id)
+        unique = true
+      }
+    }
+    if (unique) reversed.push(frame)
+  }
+  // We walked top-to-bottom; the result is in reverse stack order.
+  // Reverse back so the snapshot is in bottom-to-top order, matching
+  // the order `restoreContextStack` pushes them.
+  reversed.reverse()
+  return reversed
 }
 
 /**

package/src/index.ts

@@ -8,6 +8,7 @@ export {
   captureContextStack,
   createContext,
   createReactiveContext,
+  getContextStackLength,
   popContext,
   provide,
   pushContext,

package/src/tests/context.test.ts

@@ -1,13 +1,17 @@
 import { runWithHooks } from '../component'
 import {
+  captureContextStack,
   createContext,
+  getContextStackLength,
   popContext,
   provide,
   pushContext,
+  restoreContextStack,
   setContextStackProvider,
   useContext,
   withContext,
 } from '../context'
+import type { ContextSnapshot } from '../context'
 import type { ComponentFn, Props } from '../types'
 
 describe('createContext', () => {
@@ -259,3 +263,367 @@ describe('setContextStackProvider', () => {
     setContextStackProvider(() => freshStack)
   })
 })
+
+// ─── captureContextStack — dedup semantics ───────────────────────────────────
+//
+// The capture step deduplicates: only the topmost frame per context-id is
+// retained in the snapshot. This is a HEAP-LEAK fix: under deeply-nested
+// reactive boundaries, each effect's setup-time snapshot used to grow with
+// the live stack's transient duplicates (40k+ entries reported in 0.21.x;
+// see context.ts JSDoc for the full story). Dedup collapses the captured
+// size to ~N entries where N is the number of distinct context ids in
+// scope (typically 2-10 in real apps).
+//
+// Safety property: `useContext` walks the stack in reverse and stops at
+// the first matching frame; any shadowed frame is unreachable. The dedup
+// preserves the topmost frame per id, so `useContext` returns the same
+// value before and after.
+
+describe('captureContextStack — dedup', () => {
+  const restoreStack: Map<symbol, unknown>[][] = []
+  let testStack: Map<symbol, unknown>[]
+
+  beforeEach(() => {
+    testStack = []
+    setContextStackProvider(() => testStack)
+  })
+
+  afterEach(() => {
+    while (restoreStack.length > 0) restoreStack.pop()
+    const freshStack: Map<symbol, unknown>[] = []
+    setContextStackProvider(() => freshStack)
+  })
+
+  test('empty stack snapshot is empty', () => {
+    expect(captureContextStack()).toEqual([])
+  })
+
+  test('single frame snapshot is identical', () => {
+    const ctx = createContext('default')
+    pushContext(new Map([[ctx.id, 'A']]))
+    const snap = captureContextStack()
+    expect(snap).toHaveLength(1)
+    expect(snap[0]).toBe(testStack[0]) // same reference
+    popContext()
+  })
+
+  test('stack with no duplicate ids snapshots verbatim', () => {
+    const a = createContext('a-default')
+    const b = createContext('b-default')
+    const c = createContext('c-default')
+    pushContext(new Map([[a.id, 'A']]))
+    pushContext(new Map([[b.id, 'B']]))
+    pushContext(new Map([[c.id, 'C']]))
+    const snap = captureContextStack()
+    expect(snap).toHaveLength(3)
+    expect(snap.map((f) => Array.from(f.values()))).toEqual([['A'], ['B'], ['C']])
+    popContext()
+    popContext()
+    popContext()
+  })
+
+  test('duplicate ids collapse to topmost', () => {
+    // Same context-id pushed 3 times — typical of nested restoreContextStack
+    // windows. Only the topmost should appear in the snapshot.
+    const ctx = createContext('default')
+    pushContext(new Map([[ctx.id, 'A']]))
+    pushContext(new Map([[ctx.id, 'B']]))
+    pushContext(new Map([[ctx.id, 'C']]))
+    const snap = captureContextStack()
+    expect(snap).toHaveLength(1)
+    expect(snap[0]!.get(ctx.id)).toBe('C') // topmost wins
+    popContext()
+    popContext()
+    popContext()
+  })
+
+  test('mixed: deep stack with mostly duplicates collapses', () => {
+    // Simulates the bug shape: same context pushed 40 times via nested
+    // restore windows + one unique frame at the top.
+    const repeated = createContext('default')
+    const unique = createContext('default')
+    for (let i = 0; i < 40; i++) {
+      pushContext(new Map([[repeated.id, `dup-${i}`]]))
+    }
+    pushContext(new Map([[unique.id, 'unique']]))
+    expect(testStack).toHaveLength(41)
+
+    const snap = captureContextStack()
+    // Result: topmost `repeated` frame + the `unique` frame = 2 entries.
+    // Pre-fix this snapshot would have all 41 frames — the leak.
+    expect(snap).toHaveLength(2)
+    // Ordering must match push order (bottom-to-top in the array).
+    expect(snap[0]!.get(repeated.id)).toBe('dup-39')
+    expect(snap[1]!.get(unique.id)).toBe('unique')
+
+    for (let i = 0; i < 41; i++) popContext()
+  })
+
+  test('multi-key frame: kept if it provides ANY un-shadowed id', () => {
+    // Frame with two contexts; only one is shadowed by a deeper push.
+    const a = createContext('a')
+    const b = createContext('b')
+    pushContext(new Map<symbol, unknown>([[a.id, 'a1'], [b.id, 'b1']]))
+    pushContext(new Map([[a.id, 'a2']])) // shadows `a`, NOT `b`
+
+    const snap = captureContextStack()
+    // Both frames should remain: the upper provides `a`, the lower
+    // still provides un-shadowed `b`.
+    expect(snap).toHaveLength(2)
+
+    // Verify useContext semantics survive: a→a2, b→b1
+    setContextStackProvider(() => snap)
+    expect(useContext(a)).toBe('a2')
+    expect(useContext(b)).toBe('b1')
+    setContextStackProvider(() => testStack)
+
+    popContext()
+    popContext()
+  })
+
+  test('multi-key frame: dropped if ALL its ids are shadowed', () => {
+    const a = createContext('a')
+    const b = createContext('b')
+    pushContext(new Map<symbol, unknown>([[a.id, 'a1'], [b.id, 'b1']]))
+    pushContext(new Map<symbol, unknown>([[a.id, 'a2'], [b.id, 'b2']]))
+
+    const snap = captureContextStack()
+    expect(snap).toHaveLength(1)
+    expect(snap[0]!.get(a.id)).toBe('a2')
+    expect(snap[0]!.get(b.id)).toBe('b2')
+
+    popContext()
+    popContext()
+  })
+
+  test('useContext returns same value pre/post dedup for arbitrary read patterns', () => {
+    // Cross-check: build a complex stack, capture, then verify useContext
+    // returns the same value when reading from the original stack vs the
+    // deduped snapshot. This is the load-bearing semantic-equivalence
+    // assertion for the safety argument.
+    const a = createContext('a-default')
+    const b = createContext('b-default')
+    const c = createContext('c-default')
+    pushContext(new Map([[a.id, 'a1']]))
+    pushContext(new Map<symbol, unknown>([[a.id, 'a2'], [b.id, 'b1']]))
+    pushContext(new Map([[c.id, 'c1']]))
+    pushContext(new Map([[a.id, 'a3']]))
+    pushContext(new Map([[b.id, 'b2']]))
+
+    // Read against original stack
+    const beforeA = useContext(a)
+    const beforeB = useContext(b)
+    const beforeC = useContext(c)
+
+    // Capture (dedup happens) and read against the snapshot
+    const snap = captureContextStack()
+    setContextStackProvider(() => snap)
+    const afterA = useContext(a)
+    const afterB = useContext(b)
+    const afterC = useContext(c)
+
+    expect(afterA).toBe(beforeA) // 'a3' from the topmost frame
+    expect(afterB).toBe(beforeB) // 'b2' from the topmost frame
+    expect(afterC).toBe(beforeC) // 'c1' (still the only c-provider)
+
+    // Clean up
+    setContextStackProvider(() => testStack)
+    for (let i = 0; i < 5; i++) popContext()
+  })
+})
+
+// ─── restoreContextStack — works against deduped snapshots ───────────────────
+
+describe('restoreContextStack — with deduped snapshots', () => {
+  let testStack: Map<symbol, unknown>[]
+
+  beforeEach(() => {
+    testStack = []
+    setContextStackProvider(() => testStack)
+  })
+
+  afterEach(() => {
+    const freshStack: Map<symbol, unknown>[] = []
+    setContextStackProvider(() => freshStack)
+  })
+
+  test('restores deduped snapshot — fn() sees correct context, stack cleans up', () => {
+    const ctx = createContext('default')
+    pushContext(new Map([[ctx.id, 'A']]))
+    pushContext(new Map([[ctx.id, 'B']]))
+    pushContext(new Map([[ctx.id, 'C']]))
+
+    const snap = captureContextStack()
+    expect(snap).toHaveLength(1) // dedup collapsed to topmost
+
+    // Now empty the stack to simulate post-mount state
+    popContext()
+    popContext()
+    popContext()
+    expect(testStack).toHaveLength(0)
+
+    // Restore the deduped snapshot
+    const observed = restoreContextStack(snap, () => {
+      // Inside fn(): stack has the deduped frame
+      expect(testStack).toHaveLength(1)
+      return useContext(ctx)
+    })
+
+    // fn() saw the topmost-frame value, NOT 'default' — semantic equivalence
+    expect(observed).toBe('C')
+    // After restore, the snapshot's frames are removed by reference identity
+    expect(testStack).toHaveLength(0)
+  })
+
+  test('restoring 40-duplicate stack only pushes/pops 1 frame post-dedup', () => {
+    // This is the bug-shape regression test. Pre-dedup, this snapshot was
+    // 40 entries; restore pushed 40 then removed 40. Post-dedup, both
+    // operations move 1 frame.
+    const ctx = createContext('default')
+    for (let i = 0; i < 40; i++) {
+      pushContext(new Map([[ctx.id, `dup-${i}`]]))
+    }
+    const snap = captureContextStack()
+    expect(snap).toHaveLength(1)
+
+    // Empty the live stack so the restore is observable in isolation.
+    while (testStack.length > 0) popContext()
+
+    let observedLenInside = -1
+    restoreContextStack(snap, () => {
+      observedLenInside = testStack.length
+    })
+
+    // 1 push during fn, 1 splice after = stack stays balanced.
+    expect(observedLenInside).toBe(1)
+    expect(testStack).toHaveLength(0)
+  })
+})
+
+// ─── Leak audit: snapshot allocations stay bounded under deep stacks ─────────
+//
+// This is the regression lock for the heap-snapshot finding that motivated
+// the dedup. Reported in 0.21.x: 1.22 MB / 321k-entry arrays retained by
+// effect closures under deeply-nested reactive boundaries. The 0.23.0
+// restoreContextStack fix cleaned the live stack but residual snapshot
+// amplification persisted (~3 MB / 20×40k-entry arrays). This dedup
+// closes that. The test below makes the bug-shape impossible to
+// re-introduce silently: it builds the deep-stack scenario, captures
+// N snapshots that previously would each have held the stack-depth, and
+// asserts the TOTAL frame count across all snapshots scales with the
+// number of DISTINCT context ids in scope, NOT with the stack depth.
+
+describe('captureContextStack — leak audit (regression lock)', () => {
+  let testStack: Map<symbol, unknown>[]
+
+  beforeEach(() => {
+    testStack = []
+    setContextStackProvider(() => testStack)
+  })
+
+  afterEach(() => {
+    const freshStack: Map<symbol, unknown>[] = []
+    setContextStackProvider(() => freshStack)
+  })
+
+  test('1000 snapshots of a deep duplicate-heavy stack retain bounded total frames', () => {
+    // Build a stack of 100 frames, all pushing the same context (simulates
+    // nested restoreContextStack windows). Then capture 1000 snapshots —
+    // one per effect setup, as happens in a large component tree.
+    const ctx = createContext('default')
+    for (let i = 0; i < 100; i++) {
+      pushContext(new Map([[ctx.id, `dup-${i}`]]))
+    }
+
+    const snapshots: ContextSnapshot[] = []
+    for (let i = 0; i < 1000; i++) {
+      snapshots.push(captureContextStack())
+    }
+
+    // Pre-dedup: 1000 snapshots × 100 frames = 100,000 frame references.
+    // Post-dedup: 1000 snapshots × 1 frame (topmost) = 1,000 frame references.
+    // The assertion bounds total retention at the dedup-correct ceiling.
+    const totalFrames = snapshots.reduce((sum, s) => sum + s.length, 0)
+    expect(totalFrames).toBe(1000) // 1000 snapshots × 1 unique id
+
+    // Clean up
+    for (let i = 0; i < 100; i++) popContext()
+  })
+
+  test('mixed deep stack: total frames bounded by distinct id count, not depth', () => {
+    // 50 unique contexts pushed into a stack of 500 frames (10 duplicates
+    // per context). Capture 100 snapshots.
+    const ctxs = Array.from({ length: 50 }, () => createContext('default'))
+    for (let depth = 0; depth < 10; depth++) {
+      for (const ctx of ctxs) {
+        pushContext(new Map([[ctx.id, `d${depth}`]]))
+      }
+    }
+    expect(testStack).toHaveLength(500)
+
+    const snapshots: ContextSnapshot[] = []
+    for (let i = 0; i < 100; i++) {
+      snapshots.push(captureContextStack())
+    }
+
+    // Pre-dedup: 100 × 500 = 50,000 frame references.
+    // Post-dedup: 100 × 50 (topmost per distinct id) = 5,000 frame
+    // references. 10× reduction matches the empirical bug-shape.
+    const totalFrames = snapshots.reduce((sum, s) => sum + s.length, 0)
+    expect(totalFrames).toBe(100 * 50)
+
+    // Clean up
+    for (let i = 0; i < 500; i++) popContext()
+  })
+})
+
+// ─── getContextStackLength ──────────────────────────────────────────────────
+
+describe('getContextStackLength', () => {
+  let testStack: Map<symbol, unknown>[]
+
+  beforeEach(() => {
+    testStack = []
+    setContextStackProvider(() => testStack)
+  })
+
+  afterEach(() => {
+    const freshStack: Map<symbol, unknown>[] = []
+    setContextStackProvider(() => freshStack)
+  })
+
+  test('returns the LIVE stack length, not the deduped snapshot length', () => {
+    // This is the load-bearing distinction: SSR cleanup uses
+    // `getContextStackLength()` as a position marker, and it must reflect
+    // the live (un-deduped) stack length so subsequent `popContext` calls
+    // pop the right number of frames.
+    const ctx = createContext('default')
+    pushContext(new Map([[ctx.id, 'A']]))
+    pushContext(new Map([[ctx.id, 'B']]))
+    pushContext(new Map([[ctx.id, 'C']]))
+
+    expect(getContextStackLength()).toBe(3) // live length
+    expect(captureContextStack()).toHaveLength(1) // deduped snapshot length
+
+    popContext()
+    popContext()
+    popContext()
+  })
+
+  test('zero on empty stack', () => {
+    expect(getContextStackLength()).toBe(0)
+  })
+
+  test('matches stack array length after push/pop cycles', () => {
+    const ctx = createContext('default')
+    expect(getContextStackLength()).toBe(0)
+    pushContext(new Map([[ctx.id, 'A']]))
+    expect(getContextStackLength()).toBe(1)
+    pushContext(new Map([[ctx.id, 'B']]))
+    expect(getContextStackLength()).toBe(2)
+    popContext()
+    expect(getContextStackLength()).toBe(1)
+    popContext()
+    expect(getContextStackLength()).toBe(0)
+  })
+})