@pyreon/core 0.22.0 → 0.24.0

package/lib/index.js

@@ -1,3 +1,4 @@
+import { n as Fragment, r as h, t as EMPTY_PROPS } from "./_chunks/h-CYSD6aBx.js";
 import { effect, getReactiveTrace, setSnapshotCapture, signal } from "@pyreon/reactivity";
 
 //#region src/lifecycle.ts
@@ -145,8 +146,19 @@ const _errorBoundaryStack = [];
 function pushErrorBoundary(handler) {
 	_errorBoundaryStack.push(handler);
 }
-function popErrorBoundary() {
-	_errorBoundaryStack.pop();
+/**
+* Remove a SPECIFIC handler from the error-boundary stack by reference
+* identity. Each `ErrorBoundary` registers `onUnmount(() => popErrorBoundary(handler))`
+* with its OWN handler — so unmount in any order (LIFO, FIFO, middle-out)
+* correctly removes the right handler.
+*/
+function popErrorBoundary(handler) {
+	if (handler === void 0) {
+		_errorBoundaryStack.pop();
+		return;
+	}
+	const idx = _errorBoundaryStack.lastIndexOf(handler);
+	if (idx !== -1) _errorBoundaryStack.splice(idx, 1);
 }
 /**
 * Dispatch an error to the nearest active ErrorBoundary.
@@ -334,11 +346,59 @@ process.env.NODE_ENV;
 function pushContext(values) {
 	getStack().push(values);
 }
+/**
+* Pop the LAST frame from the context stack.
+*
+* NOTE: position-based pop. Safe ONLY when the caller can guarantee that the
+* top of the stack is the frame they want to remove (the strict LIFO contract).
+* The `provide()` helper does NOT use this — it uses identity-based removal
+* via `removeContextFrame` because reactive boundaries can push snapshot
+* frames between a component's `provide(ctx, value)` and its eventual
+* unmount, making the top-of-stack unsafe to assume.
+*/
 function popContext() {
 	const stack = getStack();
 	if (stack.length === 0) return;
 	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
+* their pushed frame on unmount even when other frames have been pushed
+* between push and pop (e.g. a reactive boundary's `restoreContextStack`
+* pushing snapshot frames during the descendant's lifecycle). The
+* symmetric position-based `popContext()` would pop the wrong frame in
+* that case and orphan the descendant's provider frame on the live stack
+* — the root cause of the 321k-entry context-stack leak under repeated
+* reactive remounts.
+*
+* Uses `lastIndexOf` (LIFO match) — picks the most-recently-pushed frame
+* with that exact reference, so `provide(ctx, a); provide(ctx, b)` followed
+* by two unmounts removes them in reverse order.
+*/
+function removeContextFrame(frame) {
+	const stack = getStack();
+	const idx = stack.lastIndexOf(frame);
+	if (idx !== -1) stack.splice(idx, 1);
+}
 function useContext(context) {
 	const stack = getStack();
 	for (let i = stack.length - 1; i >= 0; i--) {
@@ -359,31 +419,95 @@ function useContext(context) {
 * }
 */
 function provide(context, value) {
-	pushContext(new Map([[context.id, value]]));
-	onUnmount(() => popContext());
+	const frame = new Map([[context.id, value]]);
+	pushContext(frame);
+	onUnmount(() => removeContextFrame(frame));
 }
 /**
 * Provide a value for `context` during `fn()`.
 * Used by the renderer when it encounters a `<Provider>` component.
 */
 function withContext(context, value, fn) {
-	pushContext(new Map([[context.id, value]]));
+	const frame = new Map([[context.id, value]]);
+	pushContext(frame);
 	try {
 		fn();
 	} finally {
-		popContext();
+		removeContextFrame(frame);
 	}
 }
 /**
-* 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.
@@ -400,12 +524,16 @@ function captureContextStack() {
 */
 function restoreContextStack(snapshot, fn) {
 	const stack = getStack();
-	const insertIndex = stack.length;
 	for (const frame of snapshot) stack.push(frame);
 	try {
 		return fn();
 	} finally {
-		stack.splice(insertIndex, snapshot.length);
+		for (let i = snapshot.length - 1; i >= 0; i--) {
+			const frame = snapshot[i];
+			if (!frame) continue;
+			const idx = stack.lastIndexOf(frame);
+			if (idx !== -1) stack.splice(idx, 1);
+		}
 	}
 }
 setSnapshotCapture({
@@ -413,52 +541,6 @@ setSnapshotCapture({
 	restore: (snap, fn) => restoreContextStack(snap, fn)
 });
 
-//#endregion
-//#region src/h.ts
-/**
-* Marker for fragment nodes — renders children without a wrapper element.
-*
-* MUST use `Symbol.for(...)` (global registry, keyed by string), NOT
-* `Symbol(...)` (fresh per evaluation). `h.ts` is inlined into BOTH the
-* main `lib/index.js` and the `lib/jsx-runtime.js` published bundles —
-* each bundle's evaluation of a bare `Symbol(...)` would produce a
-* DISTINCT Symbol identity. JSX `<>` compiles to `jsx(Fragment, ...)` and
-* resolves to jsx-runtime's identity; `runtime-server` checks
-* `vnode.type === Fragment` against the main-entry identity. Mismatch
-* fell through to `renderElement` and crashed SSG with
-* `TypeError: Cannot convert a Symbol value to a string`.
-* `Symbol.for()` keys by string in a global registry shared across all
-* bundle evaluations — same identity everywhere.
-*/
-const Fragment = Symbol.for("Pyreon.Fragment");
-/**
-* Hyperscript function — the compiled output of JSX.
-* `<div class="x">hello</div>` → `h("div", { class: "x" }, "hello")`
-*
-* Generic on P so TypeScript validates props match the component's signature
-* at the call site, then stores the result in the loosely-typed VNode.
-*/
-/** Shared empty props sentinel — identity-checked in mountElement to skip applyProps. */
-const EMPTY_PROPS = {};
-function h(type, props, ...children) {
-	return {
-		type,
-		props: props ?? EMPTY_PROPS,
-		children: normalizeChildren(children),
-		key: props?.key ?? null
-	};
-}
-function normalizeChildren(children) {
-	for (let i = 0; i < children.length; i++) if (Array.isArray(children[i])) return flattenChildren(children);
-	return children;
-}
-function flattenChildren(children) {
-	const result = [];
-	for (const child of children) if (Array.isArray(child)) result.push(...flattenChildren(child));
-	else result.push(child);
-	return result;
-}
-
 //#endregion
 //#region src/dynamic.ts
 const __DEV__$4 = process.env.NODE_ENV !== "production";
@@ -577,7 +659,7 @@ function ErrorBoundary(props) {
 		return true;
 	};
 	pushErrorBoundary(handler);
-	onUnmount(() => popErrorBoundary());
+	onUnmount(() => popErrorBoundary(handler));
 	return () => {
 		const err = error();
 		if (err != null) return props.fallback(err, reset);
@@ -1198,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, 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/jsx-dev-runtime.js

@@ -1,98 +1,4 @@
-//#region src/h.ts
-/**
-* Marker for fragment nodes — renders children without a wrapper element.
-*
-* MUST use `Symbol.for(...)` (global registry, keyed by string), NOT
-* `Symbol(...)` (fresh per evaluation). `h.ts` is inlined into BOTH the
-* main `lib/index.js` and the `lib/jsx-runtime.js` published bundles —
-* each bundle's evaluation of a bare `Symbol(...)` would produce a
-* DISTINCT Symbol identity. JSX `<>` compiles to `jsx(Fragment, ...)` and
-* resolves to jsx-runtime's identity; `runtime-server` checks
-* `vnode.type === Fragment` against the main-entry identity. Mismatch
-* fell through to `renderElement` and crashed SSG with
-* `TypeError: Cannot convert a Symbol value to a string`.
-* `Symbol.for()` keys by string in a global registry shared across all
-* bundle evaluations — same identity everywhere.
-*/
-const Fragment = Symbol.for("Pyreon.Fragment");
-/**
-* Hyperscript function — the compiled output of JSX.
-* `<div class="x">hello</div>` → `h("div", { class: "x" }, "hello")`
-*
-* Generic on P so TypeScript validates props match the component's signature
-* at the call site, then stores the result in the loosely-typed VNode.
-*/
-/** Shared empty props sentinel — identity-checked in mountElement to skip applyProps. */
-const EMPTY_PROPS = {};
-function h(type, props, ...children) {
-	return {
-		type,
-		props: props ?? EMPTY_PROPS,
-		children: normalizeChildren(children),
-		key: props?.key ?? null
-	};
-}
-function normalizeChildren(children) {
-	for (let i = 0; i < children.length; i++) if (Array.isArray(children[i])) return flattenChildren(children);
-	return children;
-}
-function flattenChildren(children) {
-	const result = [];
-	for (const child of children) if (Array.isArray(child)) result.push(...flattenChildren(child));
-	else result.push(child);
-	return result;
-}
+import { n as Fragment } from "./_chunks/h-CYSD6aBx.js";
+import { jsx, jsxs } from "./jsx-runtime.js";
 
-//#endregion
-//#region src/jsx-runtime.ts
-/**
-* JSX automatic runtime.
-*
-* When tsconfig has `"jsxImportSource": "@pyreon/core"`, the TS/bundler compiler
-* rewrites JSX to imports from this file automatically:
-*   <div class="x" />  →  jsx("div", { class: "x" })
-*
-* The triple-slash reference above makes this file self-declare its DOM-lib
-* dependency. Without it, any consumer whose tsconfig has `lib: ["ESNext"]`
-* (no DOM) — e.g. backend-only packages like @pyreon/cli — fails to typecheck
-* once `@pyreon/core` becomes resolvable from their dependency graph (e.g. via
-* a transitive devDep), because tsc auto-resolves jsxImportSource and pulls
-* jsx-runtime.ts into the consumer's compilation unit.
-*/
-function jsx(type, props, key) {
-	const descriptors = Object.getOwnPropertyDescriptors(props);
-	let hasGetter = false;
-	for (const k in descriptors) if (descriptors[k].get) {
-		hasGetter = true;
-		break;
-	}
-	const children = props.children;
-	if (!hasGetter) {
-		const { children: _ignored, ...rest } = props;
-		const propsWithKey = key != null ? {
-			...rest,
-			key
-		} : rest;
-		if (typeof type === "function") return h(type, children !== void 0 ? {
-			...propsWithKey,
-			children
-		} : propsWithKey);
-		return h(type, propsWithKey, ...children === void 0 ? [] : Array.isArray(children) ? children : [children]);
-	}
-	const propsWithKey = {};
-	for (const k in descriptors) {
-		if (k === "children") continue;
-		Object.defineProperty(propsWithKey, k, descriptors[k]);
-	}
-	if (key != null) propsWithKey.key = key;
-	if (typeof type === "function") {
-		if (children !== void 0) propsWithKey.children = children;
-		return h(type, propsWithKey);
-	}
-	return h(type, propsWithKey, ...children === void 0 ? [] : Array.isArray(children) ? children : [children]);
-}
-const jsxs = jsx;
-
-//#endregion
-export { Fragment, jsx as jsxDEV, jsxs };
-//# sourceMappingURL=jsx-dev-runtime.js.map
+export { Fragment, jsx as jsxDEV, jsxs };

package/lib/jsx-runtime.js

@@ -1,49 +1,5 @@
-//#region src/h.ts
-/**
-* Marker for fragment nodes — renders children without a wrapper element.
-*
-* MUST use `Symbol.for(...)` (global registry, keyed by string), NOT
-* `Symbol(...)` (fresh per evaluation). `h.ts` is inlined into BOTH the
-* main `lib/index.js` and the `lib/jsx-runtime.js` published bundles —
-* each bundle's evaluation of a bare `Symbol(...)` would produce a
-* DISTINCT Symbol identity. JSX `<>` compiles to `jsx(Fragment, ...)` and
-* resolves to jsx-runtime's identity; `runtime-server` checks
-* `vnode.type === Fragment` against the main-entry identity. Mismatch
-* fell through to `renderElement` and crashed SSG with
-* `TypeError: Cannot convert a Symbol value to a string`.
-* `Symbol.for()` keys by string in a global registry shared across all
-* bundle evaluations — same identity everywhere.
-*/
-const Fragment = Symbol.for("Pyreon.Fragment");
-/**
-* Hyperscript function — the compiled output of JSX.
-* `<div class="x">hello</div>` → `h("div", { class: "x" }, "hello")`
-*
-* Generic on P so TypeScript validates props match the component's signature
-* at the call site, then stores the result in the loosely-typed VNode.
-*/
-/** Shared empty props sentinel — identity-checked in mountElement to skip applyProps. */
-const EMPTY_PROPS = {};
-function h(type, props, ...children) {
-	return {
-		type,
-		props: props ?? EMPTY_PROPS,
-		children: normalizeChildren(children),
-		key: props?.key ?? null
-	};
-}
-function normalizeChildren(children) {
-	for (let i = 0; i < children.length; i++) if (Array.isArray(children[i])) return flattenChildren(children);
-	return children;
-}
-function flattenChildren(children) {
-	const result = [];
-	for (const child of children) if (Array.isArray(child)) result.push(...flattenChildren(child));
-	else result.push(child);
-	return result;
-}
+import { n as Fragment, r as h } from "./_chunks/h-CYSD6aBx.js";
 
-//#endregion
 //#region src/jsx-runtime.ts
 /**
 * JSX automatic runtime.

package/lib/types/index.d.ts

@@ -247,7 +247,49 @@ declare function createReactiveContext<T>(defaultValue: T): ReactiveContext<T>;
  */
 declare function setContextStackProvider(fn: () => Map<symbol, unknown>[]): void;
 declare function pushContext(values: Map<symbol, unknown>): void;
+/**
+ * Pop the LAST frame from the context stack.
+ *
+ * NOTE: position-based pop. Safe ONLY when the caller can guarantee that the
+ * top of the stack is the frame they want to remove (the strict LIFO contract).
+ * The `provide()` helper does NOT use this — it uses identity-based removal
+ * via `removeContextFrame` because reactive boundaries can push snapshot
+ * frames between a component's `provide(ctx, value)` and its eventual
+ * 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.
+ *
+ * Internal — used by `provide()` and `withContext()` to safely clean up
+ * their pushed frame on unmount even when other frames have been pushed
+ * between push and pop (e.g. a reactive boundary's `restoreContextStack`
+ * pushing snapshot frames during the descendant's lifecycle). The
+ * symmetric position-based `popContext()` would pop the wrong frame in
+ * that case and orphan the descendant's provider frame on the live stack
+ * — the root cause of the 321k-entry context-stack leak under repeated
+ * reactive remounts.
+ *
+ * Uses `lastIndexOf` (LIFO match) — picks the most-recently-pushed frame
+ * with that exact reference, so `provide(ctx, a); provide(ctx, b)` followed
+ * by two unmounts removes them in reverse order.
+ */
+declare function removeContextFrame(frame: Map<symbol, unknown>): void;
 /**
  * Read the nearest provided value for a context.
  * Falls back to `context.defaultValue` if none found.
@@ -276,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;
 /**
@@ -1416,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, 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.22.0",
+  "version": "0.24.0",
   "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.22.0"
+    "@pyreon/reactivity": "^0.24.0"
   },
   "devDependencies": {
     "@pyreon/manifest": "0.13.1"

package/src/component.ts

@@ -46,6 +46,22 @@ export function propagateError(err: unknown, hooks: LifecycleHooks): boolean {
 // Module-level stack of active ErrorBoundary handlers (innermost last).
 // ErrorBoundary pushes during its own setup (before children mount) so that
 // any child mountComponent error can dispatch up to the nearest boundary.
+//
+// Mutation contract: removal is IDENTITY-based (`lastIndexOf + splice`), not
+// position-based (`pop`). Sibling boundaries unmount in an order that's
+// driven by the renderer (keyed `<For>` reconciliation, `<Show>` flips,
+// route nav), NOT in strict LIFO push order. A position-based `pop()` would
+// remove the wrong frame whenever the unmount order diverges from the push
+// order — the first boundary's `onUnmount` would pop the last boundary's
+// handler, orphaning the first boundary's handler on the stack and removing
+// the surviving boundary's handler from it. Subsequent errors would then
+// route to the orphan (whose owning boundary's signal is already disposed,
+// so the error vanishes silently) and the surviving boundary's children's
+// errors would fall through to whichever boundary happens to sit at
+// `stack[length-1]`. Same root-cause shape as the `popContext()` bug
+// fixed in #725 for `provide()` — see
+// `.claude/rules/anti-patterns.md` "Position-based pop for stack frames
+// that may be pushed by reactive boundaries".
 
 const _errorBoundaryStack: ((err: unknown) => boolean)[] = []
 
@@ -53,8 +69,23 @@ export function pushErrorBoundary(handler: (err: unknown) => boolean): void {
   _errorBoundaryStack.push(handler)
 }
 
-export function popErrorBoundary(): void {
-  _errorBoundaryStack.pop()
+/**
+ * Remove a SPECIFIC handler from the error-boundary stack by reference
+ * identity. Each `ErrorBoundary` registers `onUnmount(() => popErrorBoundary(handler))`
+ * with its OWN handler — so unmount in any order (LIFO, FIFO, middle-out)
+ * correctly removes the right handler.
+ */
+export function popErrorBoundary(handler?: (err: unknown) => boolean): void {
+  if (handler === undefined) {
+    // Back-compat: legacy callers that don't pass a handler get the old
+    // pop-last behaviour. Internal `ErrorBoundary` setup always passes
+    // its handler now; any external direct callers (tests, advanced
+    // consumers) keep working with no-arg form.
+    _errorBoundaryStack.pop()
+    return
+  }
+  const idx = _errorBoundaryStack.lastIndexOf(handler)
+  if (idx !== -1) _errorBoundaryStack.splice(idx, 1)
 }
 
 /**