ripple 0.3.127 → 0.4.0

package/src/runtime/internal/client/runtime.js

@@ -1,4 +1,4 @@
-/** @import { Block, Component, Dependency, BlockWithTryBoundaryAndCatch, DeferredTrackedEntry } from '#client' */
+/** @import { AppendIntoAnchor, Block, Component, Dependency, BlockWithTryBoundaryAndCatch, DeferredTrackedEntry } from '#client' */
 /** @import { NAMESPACE_URI } from './constants.js' */
 /** @typedef {TrackedValue} Tracked */
 /** @typedef {DerivedValue} Derived */
@@ -18,50 +18,51 @@ import {
 	DERIVED,
 	COMPUTED_PROPERTY,
 	CONTAINS_TEARDOWN,
-	CONTAINS_UPDATE,
 	DESTROYED,
 	EFFECT_BLOCK,
+	FOR_BLOCK,
 	PAUSED,
 	PRE_EFFECT_BLOCK,
 	ROOT_BLOCK,
 	TRACKED,
 	UNINITIALIZED,
 	REF_PROP,
-	TRACKED_OBJECT,
 	DEFAULT_NAMESPACE,
 	TRACKED_UPDATED,
 	SUSPENSE_PENDING,
 	SUSPENSE_REJECTED,
 	TRY_BLOCK,
 	DIRECT_CHILD_BLOCK,
-	UPDATE_SOURCE,
+	SCHEDULED,
+	SELECTOR,
+	IF_BLOCK,
+	RELEASED,
+	RENDER_ENTRY,
+	CREATES_DERIVEDS,
 } from './constants.js';
 import {
 	begin_boundary_request,
 	complete_boundary_request,
 	get_boundary_with_catch,
 	get_pending_boundary,
+	handle_boundary_error,
 	register_boundary_deferred,
 	register_boundary_paused_block,
 	replace_boundary_request,
 } from './try.js';
 import { is_ripple_object } from './utils.js';
+import { render_value } from './expression.js';
+import { throw_invalid_component_type } from './component.js';
 
 import {
-	iterable_array_from,
 	define_property,
 	get_descriptor,
-	get_own_property_symbols,
 	is_array,
 	object_keys,
 } from '@tsrx/core/runtime/language-helpers';
 import { get_async_track_result } from '../../../utils/async.js';
-import {
-	throw_tracked_index_reference_error,
-	throw_tracked_index_value_error,
-} from '../../../utils/errors.js';
 import { get_track_async_script_id } from '../../../utils/track-async-serialization.js';
-import * as devalue from 'devalue';
+import { revive } from './transport.js';
 import { hydrating, track_hash_reference } from './hydration.js';
 import { create_ref_prop as create_core_ref_prop } from '@tsrx/core/runtime/ref';
 
@@ -81,8 +82,25 @@ export let active_namespace = DEFAULT_NAMESPACE;
 /** @type {boolean} */
 export let is_mutating_allowed = true;
 
-/** @type {Map<Tracked | Derived, any>} */
-var old_values = new Map();
+/**
+ * Tracked values written during the current flush that hold their previous
+ * value in `o`, for teardowns that read them; released when the flush ends.
+ * @type {(Tracked | Derived)[]}
+ */
+var old_value_holders = [];
+/** Nesting depth of running flushes; old values are released at depth zero. */
+var flush_depth = 0;
+
+/** @returns {void} */
+function release_old_values() {
+	var holders = old_value_holders;
+	var length = holders.length;
+	if (length === 0) return;
+	for (var i = 0; i < length; i++) {
+		holders[i].o = UNINITIALIZED;
+	}
+	holders.length = 0;
+}
 
 // Used for controlling the flush of blocks
 /** @type {number} */
@@ -92,14 +110,18 @@ let scheduler_mode = FLUSH_MICROTASK;
 let is_micro_task_queued = false;
 /** @type {number} */
 let clock = 0;
-/** @type {Block[]} */
-let queued_root_blocks = [];
-// Flush normally only scans the subtree of each directly-scheduled block, since a
-// tracked's subscribers live inside the subtree of the block that owns it. If a
-// tracked is ever read from outside its owner's subtree (e.g. smuggled across
-// sibling subtrees via a module-level variable), that invariant breaks, so we
-// permanently fall back to scanning the whole root tree to stay correct.
-let disable_scoped_flush = false;
+/**
+ * Blocks scheduled for the next flush. `sorted` tracks whether they were
+ * pushed in creation order, so the common case avoids a sort.
+ * @typedef {{ blocks: Block[]; sorted: boolean; last: number }} Queue
+ */
+/** @type {Queue} */
+let queue = create_queue();
+
+/** @returns {Queue} */
+function create_queue() {
+	return { blocks: [], sorted: true, last: 0 };
+}
 /** @type {(() => void)[]} */
 let queued_microtasks = [];
 /** @type {number} */
@@ -163,7 +185,10 @@ export function run_teardown(block) {
 			active_reaction = null;
 			tracking = false;
 			teardown = true;
-			fn.call(null);
+			// Runtime-internal teardowns keyed on block state get it as their
+			// argument, so they need no per-block closure; user effects have
+			// null state.
+			fn.call(null, block.s);
 		} finally {
 			active_block = previous_block;
 			active_reaction = previous_reaction;
@@ -213,6 +238,7 @@ function update_derived(computed) {
 function update_tracked_value_clock(tracked, value) {
 	tracked.__v = value;
 	tracked.c = increment_clock();
+	mark_subscribers(tracked);
 }
 
 /**
@@ -252,11 +278,11 @@ function run_derived(computed) {
 
 		var value = computed.fn();
 
-		computed.d = active_dependency;
+		finish_dependencies(computed, active_dependency);
 
 		return value;
 	} catch (error) {
-		computed.d = active_dependency;
+		finish_dependencies(computed, active_dependency);
 		if (error === ASYNC_DERIVED_READ_THROWN) {
 			// Check if any dependency is rejected — if so, propagate rejection
 			var dep = active_dependency;
@@ -287,7 +313,7 @@ function run_derived(computed) {
 export function handle_error(error, block) {
 	var boundary_with_catch = get_boundary_with_catch(block);
 	if (boundary_with_catch !== null) {
-		boundary_with_catch.s.c(error);
+		handle_boundary_error(boundary_with_catch, error);
 		return boundary_with_catch;
 	}
 
@@ -295,93 +321,152 @@ export function handle_error(error, block) {
 }
 
 /**
+ * The error path of {@link run_block}, kept out of that hot function so a
+ * healthy mount never compiles it: routes real errors to the nearest catch
+ * boundary and pauses a block that read a pending async value under its
+ * pending boundary.
+ * @param {unknown} error
  * @param {Block} block
  */
-export function run_block(block) {
+function handle_run_error(error, block) {
+	var is_component_direct = false;
+	var is_try_fn_block = false;
+	finish_dependencies(block, active_dependency);
+	// When a derived read throws ASYNC_DERIVED_READ_THROWN, it means the
+	// derived is still SUSPENSE_PENDING. The dependency was already registered,
+	// so we swallow the throw and let the parent continue processing. When
+	// the derived settles, the block will be dirty and rerun automatically.
+	if (error !== ASYNC_DERIVED_READ_THROWN) {
+		handle_error(error, block);
+	} else if (
+		// pending async tracked was read outside allowed blocks
+		(is_component_direct = active_component?.b === block) ||
+		(is_try_fn_block =
+			block.p !== null && (block.p.f & TRY_BLOCK) !== 0 && (block.f & DIRECT_CHILD_BLOCK) !== 0)
+	) {
+		throw new Error(
+			`Reads on pending tracked values directly inside ${is_component_direct ? 'component' : 'try/pending/catch'} body are prohibited. Use trackPending() test or peek() for safe access or create another derived instead.`,
+		);
+	} else {
+		// pending async tracked was read and threw ASYNC_DERIVED_READ_THROWN
+		var boundary = get_pending_boundary(block);
+		if (boundary !== null) {
+			pause_block(block);
+			register_boundary_paused_block(boundary, block);
+
+			// Register deferred boundary completions for async tracked deps.
+			// This handles the case where a child boundary reads a tracked value
+			// whose resolution is managed by a different (parent) boundary.
+			var dep = block.d;
+			while (dep !== null) {
+				var dep_tracked = /** @type {Tracked} */ (dep.t);
+				if (
+					(dep_tracked.__v === SUSPENSE_PENDING || dep_tracked.__v === SUSPENSE_REJECTED) &&
+					(dep_tracked.f & TRACKED) !== 0
+				) {
+					var deferred_req = begin_boundary_request(boundary);
+					var entry = /** @type {DeferredTrackedEntry} */ ({ b: boundary, r: deferred_req });
+					if (dep_tracked.d === null) {
+						dep_tracked.d = [entry];
+					} else {
+						dep_tracked.d.push(entry);
+					}
+				}
+				dep = dep.n;
+			}
+		}
+	}
+}
+
+/**
+ * Clears what a block's previous run left behind before it runs again. A
+ * list's children are all item branches, so there is nothing to sweep; an if
+ * block's children are its branch, which it replaces itself only when the
+ * condition changes. Returns the deriveds the previous run created, to be
+ * released once the new run has destroyed whatever read them (an if block
+ * swaps its branch inside its own run).
+ * @param {Block} block
+ * @returns {Derived[] | null}
+ */
+function prepare_rerun(block) {
+	if ((block.f & (FOR_BLOCK | IF_BLOCK)) === 0) {
+		destroy_non_branch_children(block);
+	}
+	run_teardown(block);
+	return (block.f & CREATES_DERIVEDS) !== 0 ? take_created_deriveds(block) : null;
+}
+
+/**
+ * @param {Block} block
+ * @param {(state?: any) => void} teardown
+ */
+function register_teardown(block, teardown) {
+	block.t = teardown;
+	/** @type {Block | null} */
+	var current = block;
+
+	while (current !== null && (current.f & CONTAINS_TEARDOWN) === 0) {
+		current.f ^= CONTAINS_TEARDOWN;
+		current = current.p;
+	}
+}
+
+/**
+ * @param {Block} block
+ * @param {boolean} [first_run] true when the block has no children, teardown,
+ * or dependencies yet, so that cleanup can be skipped
+ */
+export function run_block(block, first_run = false) {
 	var previous_block = active_block;
 	var previous_reaction = active_reaction;
 	var previous_tracking = tracking;
 	var previous_dependency = active_dependency;
 	var previous_component = active_component;
+	/** @type {Derived[] | null} */
+	var previous_deriveds = null;
 
 	try {
 		active_block = block;
 		active_reaction = block;
 		active_component = block.co;
 
-		destroy_non_branch_children(block);
-		run_teardown(block);
+		if (!first_run) {
+			previous_deriveds = prepare_rerun(block);
+		}
 
 		tracking = (block.f & (ROOT_BLOCK | BRANCH_BLOCK)) === 0;
 		active_dependency = null;
 		var res = block.fn(block.s);
 
 		if (typeof res === 'function') {
-			block.t = res;
-			/** @type {Block | null} */
-			let current = block;
-
-			while (current !== null && (current.f & CONTAINS_TEARDOWN) === 0) {
-				current.f ^= CONTAINS_TEARDOWN;
-				current = current.p;
-			}
+			register_teardown(block, res);
 		}
 
-		block.d = active_dependency;
-	} catch (error) {
-		var is_component_direct = false;
-		var is_try_fn_block = false;
-		block.d = active_dependency;
-		// When a derived read throws ASYNC_DERIVED_READ_THROWN, it means the
-		// derived is still SUSPENSE_PENDING. The dependency was already registered,
-		// so we swallow the throw and let the parent continue processing. When
-		// the derived settles, the block will be dirty and rerun automatically.
-		if (error !== ASYNC_DERIVED_READ_THROWN) {
-			handle_error(error, block);
-		} else if (
-			// pending async tracked was read outside allowed blocks
-			(is_component_direct = active_component?.b === block) ||
-			(is_try_fn_block =
-				block.p !== null && (block.p.f & TRY_BLOCK) !== 0 && (block.f & DIRECT_CHILD_BLOCK) !== 0)
-		) {
-			throw new Error(
-				`Reads on pending tracked values directly inside ${is_component_direct ? 'component' : 'try/pending/catch'} body are prohibited. Use trackPending() test or peek() for safe access or create another derived instead.`,
-			);
-		} else {
-			// pending async tracked was read and threw ASYNC_DERIVED_READ_THROWN
-			var boundary = get_pending_boundary(block);
-			if (boundary !== null) {
-				pause_block(block);
-				register_boundary_paused_block(boundary, block);
-
-				// Register deferred boundary completions for async tracked deps.
-				// This handles the case where a child boundary reads a tracked value
-				// whose resolution is managed by a different (parent) boundary.
-				var dep = block.d;
-				while (dep !== null) {
-					var dep_tracked = /** @type {Tracked} */ (dep.t);
-					if (
-						(dep_tracked.__v === SUSPENSE_PENDING || dep_tracked.__v === SUSPENSE_REJECTED) &&
-						(dep_tracked.f & TRACKED) !== 0
-					) {
-						var deferred_req = begin_boundary_request(boundary);
-						var entry = /** @type {DeferredTrackedEntry} */ ({ b: boundary, r: deferred_req });
-						if (dep_tracked.d === null) {
-							dep_tracked.d = [entry];
-						} else {
-							dep_tracked.d.push(entry);
-						}
-					}
-					dep = dep.n;
-				}
+		if (block.d === null) {
+			// First run (or no dependencies so far): nothing stale to unlink.
+			if (active_dependency !== null) {
+				block.d = active_dependency;
 			}
+		} else {
+			finish_dependencies(block, active_dependency);
 		}
+	} catch (error) {
+		handle_run_error(error, block);
 	} finally {
 		active_block = previous_block;
 		active_reaction = previous_reaction;
 		tracking = previous_tracking;
 		active_dependency = previous_dependency;
 		active_component = previous_component;
+
+		// The previous run's deriveds, whether this run finished or threw, and
+		// after this run's dependencies replaced the old ones (so a derived the
+		// old run read is not kept alive by that stale link). Those still read
+		// stay recorded under the block for its next rerun or destruction: a
+		// rerun that keeps the same branch must not lose them.
+		if (previous_deriveds !== null) {
+			keep_deriveds(block, release_deriveds(previous_deriveds));
+		}
 	}
 }
 
@@ -406,11 +491,11 @@ class TrackedValue {
 	/**
 	 * @param {any} v
 	 * @param {Block} block
-	 * @param {{ get?: Function; set?: Function }} a
+	 * @param {{ get?: Function; set?: Function | true }} a
 	 * @param {string} [hash]
 	 */
 	constructor(v, block, a, hash) {
-		/** @type {{ get?: Function; set?: Function }} */
+		/** @type {{ get?: Function; set?: Function | true }} */
 		this.a = a;
 		/** @type {Block} */
 		this.b = block;
@@ -420,22 +505,14 @@ class TrackedValue {
 		this.d = null;
 		/** @type {number} */
 		this.f = TRACKED;
-		/** @type {string | undefined} */
+		/** @type {any} hydration hash, or the key of a selector match flag */
 		this.h = hash;
+		/** @type {Dependency | null} */
+		this.sb = null;
 		/** @type {any} */
 		this.__v = v;
-	}
-	/** @returns {any} */
-	get [0]() {
-		return throw_tracked_index_value_error();
-	}
-	/** @param {any} v */
-	set [0](v) {
-		throw_tracked_index_value_error();
-	}
-	/** @returns {Tracked} */
-	get [1]() {
-		return throw_tracked_index_reference_error();
+		/** @type {any} previous value while a flush with teardowns is running */
+		this.o = UNINITIALIZED;
 	}
 	/** @returns {any} */
 	get value() {
@@ -445,14 +522,16 @@ class TrackedValue {
 	set value(v) {
 		set(this, v);
 	}
-	/** @returns {2} */
-	get length() {
-		return 2;
-	}
-	/** @returns {Iterator<any | Tracked>} */
-	*[Symbol.iterator]() {
-		yield get_tracked(this);
-		yield this;
+	/**
+	 * A read-only view: a derived over this value, for a receiver that should
+	 * read but not write it. Equivalent to `track(() => tracked.value)`. The
+	 * view is owned by the block that creates it, not by this value's block, so
+	 * a view made in a component is released with that component even when the
+	 * value outlives it.
+	 * @returns {Derived}
+	 */
+	readOnly() {
+		return derived(() => get_tracked(this), /** @type {Block} */ (active_block));
 	}
 }
 
@@ -460,11 +539,11 @@ class DerivedValue {
 	/**
 	 * @param {Function} fn
 	 * @param {Block} block
-	 * @param {{ get?: Function; set?: Function }} a
+	 * @param {{ get?: Function; set?: Function | true }} a
 	 * @param {string} [hash]
 	 */
 	constructor(fn, block, a, hash) {
-		/** @type {{ get?: Function; set?: Function }} */
+		/** @type {{ get?: Function; set?: Function | true }} */
 		this.a = a;
 		/** @type {Block} */
 		this.b = block;
@@ -482,20 +561,12 @@ class DerivedValue {
 		this.fn = fn;
 		/** @type {string | undefined} */
 		this.h = hash;
+		/** @type {Dependency | null} */
+		this.sb = null;
 		/** @type {any} */
 		this.__v = UNINITIALIZED;
-	}
-	/** @returns {any} */
-	get [0]() {
-		return throw_tracked_index_value_error();
-	}
-	/** @param {any} v */
-	set [0](v) {
-		throw_tracked_index_value_error();
-	}
-	/** @returns {Derived} */
-	get [1]() {
-		return throw_tracked_index_reference_error();
+		/** @type {any} previous value while a flush with teardowns is running */
+		this.o = UNINITIALIZED;
 	}
 	/** @returns {any} */
 	get value() {
@@ -505,14 +576,16 @@ class DerivedValue {
 	set value(v) {
 		set(this, v);
 	}
-	/** @returns {2} */
-	get length() {
-		return 2;
-	}
-	/** @returns {Iterator<any | Derived>} */
-	*[Symbol.iterator]() {
-		yield get_derived(this);
-		yield this;
+	/**
+	 * A read-only view (see `TrackedValue#readOnly`). A derived without a
+	 * setter is already read-only and is returned as is; a writable one is
+	 * wrapped in a derived that follows it.
+	 * @returns {Derived}
+	 */
+	readOnly() {
+		return this.a.set === undefined
+			? this
+			: derived(() => get_derived(this), /** @type {Block} */ (active_block));
 	}
 }
 
@@ -527,7 +600,7 @@ if (DEV) {
  * @param {Block} block
  * @param {string} [hash]
  * @param {(value: any) => any} [get]
- * @param {(next: any, prev: any) => any} [set]
+ * @param {((next: any, prev: any) => any) | true} [set]
  * @returns {Tracked}
  */
 export function tracked(v, block, hash, get, set) {
@@ -545,25 +618,126 @@ export function tracked(v, block, hash, get, set) {
  * @param {Block} block
  * @param {string} [hash]
  * @param {(value: any) => any} [get]
- * @param {(next: any, prev: any) => any} [set]
+ * @param {((next: any, prev: any) => any) | true} [set]
  * @returns {Derived}
  */
 export function derived(fn, block, hash, get, set) {
 	var d = /** @type {Derived} */ (
 		new DerivedValue(fn, block || active_block, get || set ? { get, set } : empty_get_set, hash)
 	);
+	// The run that creates a derived owns its release: when that block reruns
+	// or is destroyed, the derived is unsubscribed from its sources unless a
+	// reader that is still alive holds it (see `release_deriveds`).
+	var creator = active_block;
+	if (creator !== null) {
+		var created = created_deriveds.get(creator);
+		if (created === undefined) {
+			created_deriveds.set(creator, [d]);
+			creator.f |= CREATES_DERIVEDS;
+		} else {
+			created.push(d);
+		}
+	}
 	if (hydrating && hash !== undefined) {
 		track_hash_reference.set(hash, d);
 	}
 	return d;
 }
 
+/**
+ * The deriveds each block's latest run created, keyed by the block. A side
+ * table rather than a block field: most blocks never create a derived, and
+ * block creation is the hot path, so blocks keep their shape. A block with an
+ * entry carries `CREATES_DERIVEDS` in its flags, so a rerun or destroy of any
+ * other block never looks here.
+ * @type {Map<Block, Derived[]>}
+ */
+var created_deriveds = new Map();
+
+/**
+ * Removes and returns the deriveds `block`'s latest run created, or null.
+ * @param {Block} block
+ * @returns {Derived[] | null}
+ */
+export function take_created_deriveds(block) {
+	var deriveds = created_deriveds.get(block);
+	block.f &= ~CREATES_DERIVEDS;
+	if (deriveds === undefined) {
+		return null;
+	}
+	created_deriveds.delete(block);
+	return deriveds;
+}
+
+/**
+ * Releases the deriveds a block run created, once that run's readers are
+ * gone: the block reran (its previous run's readers were destroyed by the
+ * rerun) or was destroyed. A derived that a live reader still holds (the
+ * branch is still showing, or it was handed to a longer-lived scope) is
+ * kept. Walked newest first, so a derived read by a later one of the same
+ * run sees that reader unlinked before it is examined; the survivors are
+ * packed into the tail of the same array as they are met, which leaves them
+ * in creation order for the next pass, and slid to the front at the end.
+ * @param {Derived[]} deriveds in creation order; reused for the result
+ * @returns {Derived[] | null} the deriveds kept, in creation order, if any
+ */
+export function release_deriveds(deriveds) {
+	var length = deriveds.length;
+	var kept = length;
+	for (var i = length - 1; i >= 0; i--) {
+		var derived = deriveds[i];
+		var alive = false;
+		for (var sub = derived.sb; sub !== null; sub = sub.sn) {
+			if ((sub.r.f & DESTROYED) === 0) {
+				alive = true;
+				break;
+			}
+		}
+		if (alive) {
+			// `kept` never drops below `i`, so this only overwrites visited slots.
+			deriveds[--kept] = derived;
+		} else {
+			finish_dependencies(derived, null);
+			destroy_computed_children(derived);
+		}
+	}
+	if (kept === length) {
+		return null;
+	}
+	if (kept !== 0) {
+		deriveds.copyWithin(0, kept);
+		deriveds.length = length - kept;
+	}
+	return deriveds;
+}
+
+/**
+ * Records deriveds under `block` again after a rerun kept them, ahead of
+ * whatever the new run created: the kept ones are older, and the release
+ * order (newest first) relies on the list being in creation order.
+ * @param {Block} block
+ * @param {Derived[] | null} kept
+ */
+function keep_deriveds(block, kept) {
+	if (kept === null) {
+		return;
+	}
+	var created = created_deriveds.get(block);
+	if (created !== undefined) {
+		for (var i = 0; i < created.length; i++) {
+			kept.push(created[i]);
+		}
+	}
+	created_deriveds.set(block, kept);
+	block.f |= CREATES_DERIVEDS;
+}
+
 /**
  * @param {any} v
  * @param {Block} b
  * @param {string} [hash]
  * @param {(value: any) => any} [get]
- * @param {(next: any, prev: any) => any} [set]
+ * @param {((next: any, prev: any) => any) | true} [set]
  * @returns {Tracked | Derived}
  */
 export function track(v, b, hash, get, set) {
@@ -617,7 +791,8 @@ export function track_async(fn, b, hash) {
 
 			if (envelope.ok) {
 				had_hydration_data = true;
-				hydration_value = devalue.parse(envelope.payload);
+				hydration_value =
+					envelope.payload === undefined ? envelope.value : revive(envelope.payload);
 				hydration_deps = envelope.deps;
 			} else {
 				// trigger the catch block
@@ -696,7 +871,6 @@ export function track_async(fn, b, hash) {
 		// Set to pending before calling fn() in case it's sync.
 		if (t.__v !== SUSPENSE_PENDING) {
 			update_tracked_value_clock(t, SUSPENSE_PENDING);
-			schedule_update(t.b);
 		}
 
 		// Temporarily allow mutations so set() doesn't throw inside the pre-effect
@@ -715,7 +889,6 @@ export function track_async(fn, b, hash) {
 				while (dep !== null) {
 					if (dep.t.__v === SUSPENSE_REJECTED) {
 						update_tracked_value_clock(t, SUSPENSE_REJECTED);
-						schedule_update(t.b);
 						complete_deferred_boundaries(t, false);
 						if (request_id > 0 && boundary !== null) {
 							complete_boundary_request(boundary, request_id, false);
@@ -748,7 +921,6 @@ export function track_async(fn, b, hash) {
 		if (async_result === null) {
 			// Sync result
 			update_tracked_value_clock(t, result);
-			schedule_update(t.b);
 			if (request_id > 0 && boundary !== null) {
 				complete_boundary_request(boundary, request_id);
 				request_id = 0;
@@ -769,7 +941,6 @@ export function track_async(fn, b, hash) {
 					return;
 				}
 				update_tracked_value_clock(t, resolved);
-				schedule_update(t.b);
 				complete_deferred_boundaries(t);
 				if (request_id > 0 && boundary !== null) {
 					complete_boundary_request(boundary, request_id);
@@ -792,13 +963,12 @@ export function track_async(fn, b, hash) {
 				}
 
 				update_tracked_value_clock(t, SUSPENSE_REJECTED);
-				schedule_update(t.b);
 				complete_deferred_boundaries(t, false);
 
 				// Route error to catch boundary
 				var boundary_with_catch = get_boundary_with_catch(call_site_block);
 				if (boundary_with_catch !== null) {
-					boundary_with_catch.s.c(error);
+					handle_boundary_error(boundary_with_catch, error);
 				}
 
 				if (request_id > 0 && boundary !== null) {
@@ -865,16 +1035,190 @@ function create_dependency(tracked) {
 	if (existing !== null) {
 		reaction.d = existing.n;
 		existing.c = tracked.c;
-		existing.t = tracked;
 		existing.n = null;
+		if (existing.t !== tracked) {
+			unlink_subscriber(existing);
+			existing.t = tracked;
+			link_subscriber(existing, tracked);
+		}
 		return existing;
 	}
 
-	return {
+	// link_subscriber, inline: the first read of every block run lands here.
+	var head = tracked.sb;
+	/** @type {Dependency} */
+	var dependency = {
 		c: tracked.c,
 		t: tracked,
 		n: null,
+		r: reaction,
+		sp: null,
+		sn: head,
 	};
+	if (head !== null) {
+		head.sp = dependency;
+	}
+	tracked.sb = dependency;
+	return dependency;
+}
+
+/**
+ * @param {Dependency} dependency
+ * @param {Tracked | Derived} tracked
+ */
+function link_subscriber(dependency, tracked) {
+	var head = tracked.sb;
+	dependency.sn = head;
+	if (head !== null) {
+		head.sp = dependency;
+	}
+	tracked.sb = dependency;
+}
+
+/**
+ * @param {Dependency} dependency
+ */
+export function unlink_subscriber(dependency) {
+	var prev = dependency.sp;
+	var next = dependency.sn;
+	if (prev !== null) {
+		prev.sn = next;
+	} else {
+		var tracked = dependency.t;
+		// Already unlinked (a destroyed block's dependency can be pruned by a
+		// write during its own teardown, then unlinked again by
+		// remove_dependencies); it must not be mistaken for the list head.
+		if (tracked.sb !== dependency) {
+			return;
+		}
+		tracked.sb = next;
+		if (next === null && (tracked.f & SELECTOR) !== 0) {
+			release_selector_key(/** @type {Tracked} */ (tracked));
+		}
+	}
+	if (next !== null) {
+		next.sp = prev;
+	}
+	dependency.sp = dependency.sn = null;
+}
+
+/**
+ * `n` counts released keys still in the map.
+ * @typedef {{ get: undefined; set: undefined; m: Map<any, Tracked>; n: number }} SelectorAccessors
+ */
+
+/** Released selector keys kept for reuse before the map is swept. */
+var SELECTOR_SWEEP_THRESHOLD = 1024;
+
+/**
+ * The last subscriber of a selector key left. The entry stays in the map so
+ * a key that comes back (a list re-rendering the same items) reuses it
+ * instead of allocating and inserting again; once enough released keys pile
+ * up they are swept out, so the map stays bounded.
+ * @param {Tracked} tracked
+ */
+function release_selector_key(tracked) {
+	var accessors = /** @type {SelectorAccessors} */ (tracked.a);
+	tracked.f |= RELEASED;
+	if (++accessors.n > SELECTOR_SWEEP_THRESHOLD) {
+		var m = accessors.m;
+		for (var [key, t] of m) {
+			if ((t.f & RELEASED) !== 0) {
+				m.delete(key);
+			}
+		}
+		accessors.n = 0;
+	}
+}
+
+/**
+ * A key found in the map again after its subscribers had all left.
+ * @param {Tracked} tracked
+ */
+export function revive_selector_key(tracked) {
+	tracked.f ^= RELEASED;
+	/** @type {SelectorAccessors} */ (tracked.a).n--;
+}
+
+/**
+ * A tracked match flag for one selector key. The selector's shared accessor
+ * object carries the map and the key rides in the hash slot, so the entry can
+ * be released from `unlink_subscriber` without an object per key.
+ * @param {boolean} value
+ * @param {Block} block
+ * @param {SelectorAccessors} accessors
+ * @param {any} key
+ * @returns {Tracked}
+ */
+export function selector_tracked(value, block, accessors, key) {
+	var t = /** @type {Tracked} */ (new TrackedValue(value, block, accessors, key));
+	t.f |= SELECTOR;
+	return t;
+}
+
+/**
+ * Install the dependency chain produced by a run, unsubscribing from any
+ * previous dependencies that were not read again.
+ * @param {Block | Derived} reaction
+ * @param {Dependency | null} dependencies
+ */
+function finish_dependencies(reaction, dependencies) {
+	var stale = reaction.d;
+	while (stale !== null) {
+		unlink_subscriber(stale);
+		stale = stale.n;
+	}
+	reaction.d = dependencies;
+}
+
+/**
+ * Unsubscribe a block from every tracked value it read. Dependencies on
+ * values owned by an already-destroyed block are dropped without unlinking,
+ * since the owner's subscriber list dies with it.
+ * @param {Block} block
+ */
+export function remove_dependencies(block) {
+	var dependency = block.d;
+	while (dependency !== null) {
+		var owner = dependency.t.b;
+		if (owner === null || (owner.f & DESTROYED) === 0) {
+			unlink_subscriber(dependency);
+		}
+		dependency = dependency.n;
+	}
+	block.d = null;
+}
+
+/**
+ * Schedule every reaction subscribed to `tracked`. Deriveds are lazy, so their
+ * own subscribers are marked instead; subscribers that were destroyed without
+ * unlinking are pruned here.
+ * @param {Tracked | Derived} tracked
+ */
+function mark_subscribers(tracked) {
+	var dependency = tracked.sb;
+	while (dependency !== null) {
+		var next = dependency.sn;
+		var reaction = dependency.r;
+		var flags = reaction.f;
+		if ((flags & DERIVED) !== 0) {
+			var derived = /** @type {Derived} */ (reaction);
+			// Marking the derived's own subscribers first prunes its destroyed
+			// readers, so a derived whose owner is gone and that nothing reads any
+			// more is dropped on this write; one still read elsewhere keeps
+			// forwarding notifications.
+			mark_subscribers(derived);
+			var derived_owner = derived.b;
+			if (derived_owner !== null && (derived_owner.f & DESTROYED) !== 0 && derived.sb === null) {
+				unlink_subscriber(dependency);
+			}
+		} else if ((flags & DESTROYED) !== 0) {
+			unlink_subscriber(dependency);
+		} else {
+			schedule_update(/** @type {Block} */ (reaction));
+		}
+		dependency = next;
+	}
 }
 
 /**
@@ -941,125 +1285,114 @@ function trigger_track_get(fn, v) {
 }
 
 /**
- * @param {Block} root_block
+ * @param {Block} a
+ * @param {Block} b
+ * @returns {number}
  */
-function flush_updates(root_block) {
-	/** @type {Block | null} */
-	var current = root_block;
-	var pre_effects = [];
-	var other_blocks = [];
-	var effects = [];
-	// The nearest enclosing directly-scheduled block ("update source"). While it is
-	// non-null we are inside a source's subtree and scan every descendant. Above
-	// sources we only follow the CONTAINS_UPDATE routing path, so sibling subtrees
-	// that contain no update are skipped. When scoping is disabled we treat the
-	// whole root tree as one source — the original full-tree scan.
-	/** @type {Block | null} */
-	var scope_root = disable_scoped_flush ? root_block : null;
+function by_block_id(a, b) {
+	return a.i - b.i;
+}
 
-	while (current !== null) {
-		var flags = current.f;
-		var on_path = (flags & CONTAINS_UPDATE) !== 0;
+/**
+ * Run every scheduled block, in creation order (so a parent runs before its
+ * descendants), in three phases: pre-effects, render blocks, then effects.
+ * @param {Queue} pending
+ */
+function flush_queue(pending) {
+	var blocks = pending.blocks;
+	var length = blocks.length;
 
-		if (on_path) {
-			current.f ^= CONTAINS_UPDATE;
+	if (length > 0) {
+		if (!pending.sorted) {
+			blocks.sort(by_block_id);
 		}
 
-		if ((flags & UPDATE_SOURCE) !== 0) {
-			current.f ^= UPDATE_SOURCE;
-			if (scope_root === null) {
-				scope_root = current;
-			}
-		}
+		var has_effects = false;
 
-		if ((flags & PAUSED) === 0 && (on_path || scope_root !== null)) {
-			if ((flags & PRE_EFFECT_BLOCK) !== 0) {
-				pre_effects.push(current);
-			} else if ((flags & EFFECT_BLOCK) !== 0) {
-				effects.push(current);
-			} else {
-				other_blocks.push(current);
+		for (var i = 0; i < length; i++) {
+			var block = blocks[i];
+			var flags = block.f;
+			block.f = flags & ~SCHEDULED;
+			if ((flags & (PRE_EFFECT_BLOCK | EFFECT_BLOCK)) !== 0) {
+				has_effects = true;
 			}
-			/** @type {Block | null} */
-			var child = current.first;
+		}
 
-			if (child !== null) {
-				current = child;
-				continue;
-			}
+		// New schedules land in the queue that replaced `pending`, so the array
+		// can be run in place. Effects need the three-phase ordering; a queue of
+		// only render blocks (the common flush) runs straight through.
+		if (has_effects) {
+			run_phases(blocks, length);
+		} else {
+			run_phase(blocks);
 		}
 
-		/** @type {Block | null} */
-		var parent = current.p;
-		current = current.next;
+		blocks.length = 0;
+		pending.sorted = true;
+		pending.last = 0;
+	}
 
-		while (current === null && parent !== null) {
-			if (parent === scope_root) {
-				scope_root = null;
-			}
-			current = parent.next;
-			parent = parent.p;
+	if (queued_post_block_flush.length > 0) {
+		var callbacks = queued_post_block_flush;
+		queued_post_block_flush = [];
+		for (var j = 0; j < callbacks.length; j++) {
+			callbacks[j]();
 		}
 	}
+}
 
-	var arr_length = 0;
+/**
+ * Runs a queue that contains effects in three phases: pre-effects, render
+ * blocks, then effects. Kept out of {@link flush_queue} so a render-only flush
+ * never compiles it.
+ * @param {Block[]} blocks
+ * @param {number} length
+ */
+function run_phases(blocks, length) {
+	/** @type {Block[]} */
+	var pre_effects = [];
+	/** @type {Block[]} */
+	var other_blocks = [];
+	/** @type {Block[]} */
+	var effects = [];
 
-	// Phase 1: pre-effects (e.g. update tracked values before render blocks read them)
-	arr_length = pre_effects.length;
-	for (var i = 0; i < arr_length; i++) {
-		var block = pre_effects[i];
+	for (var i = 0; i < length; i++) {
+		var block = blocks[i];
+		var flags = block.f;
 
-		try {
-			if ((block.f & (PAUSED | DESTROYED)) === 0 && is_block_dirty(block)) {
-				run_block(block);
-			}
-		} catch (error) {
-			handle_error(error, block);
+		// A paused block is re-checked when it resumes; a destroyed one is gone.
+		if ((flags & (PAUSED | DESTROYED)) !== 0) {
+			continue;
 		}
-	}
-
-	// Phase 2: all other blocks except effects
-	arr_length = other_blocks.length;
-	for (var i = 0; i < arr_length; i++) {
-		var block = other_blocks[i];
-
-		try {
-			if ((block.f & (PAUSED | DESTROYED)) === 0 && is_block_dirty(block)) {
-				run_block(block);
-			}
-		} catch (error) {
-			handle_error(error, block);
+		if ((flags & PRE_EFFECT_BLOCK) !== 0) {
+			pre_effects.push(block);
+		} else if ((flags & EFFECT_BLOCK) !== 0) {
+			effects.push(block);
+		} else {
+			other_blocks.push(block);
 		}
 	}
 
-	// Phase 3: effects
-	arr_length = effects.length;
-	for (var i = 0; i < arr_length; i++) {
-		var block = effects[i];
-
-		try {
-			if ((block.f & (PAUSED | DESTROYED)) === 0 && is_block_dirty(block)) {
-				run_block(block);
-			}
-		} catch (error) {
-			handle_error(error, block);
-		}
-	}
+	run_phase(pre_effects);
+	run_phase(other_blocks);
+	run_phase(effects);
 }
 
 /**
- * @param {Block[]} root_blocks
+ * @param {Block[]} blocks
  */
-function flush_queued_root_blocks(root_blocks) {
-	for (let i = 0; i < root_blocks.length; i++) {
-		flush_updates(root_blocks[i]);
-	}
+function run_phase(blocks) {
+	for (var i = 0; i < blocks.length; i++) {
+		var block = blocks[i];
+		var flags = block.f;
 
-	if (queued_post_block_flush.length > 0) {
-		var callbacks = queued_post_block_flush;
-		queued_post_block_flush = [];
-		for (var j = 0; j < callbacks.length; j++) {
-			callbacks[j]();
+		try {
+			if ((flags & (PAUSED | DESTROYED)) === 0 && is_block_dirty(block)) {
+				// A block that has never run has no children or teardown to clear.
+				run_block(block, (flags & BLOCK_HAS_RUN) === 0);
+			}
+		} catch (error) {
+			handle_error(error, block);
 		}
 	}
 }
@@ -1091,14 +1424,21 @@ function flush_microtasks() {
 			'Maximum update depth exceeded. This typically indicates that an effect reads and writes the same piece of state.',
 		);
 	}
-	var previous_queued_root_blocks = queued_root_blocks;
-	queued_root_blocks = [];
-	flush_queued_root_blocks(previous_queued_root_blocks);
+	var pending = queue;
+	queue = create_queue();
+	flush_depth++;
+	try {
+		flush_queue(pending);
+	} finally {
+		flush_depth--;
+	}
 
 	if (!is_micro_task_queued) {
 		flush_count = 0;
 	}
-	old_values.clear();
+	if (flush_depth === 0) {
+		release_old_values();
+	}
 }
 
 /**
@@ -1128,64 +1468,27 @@ export function queue_post_block_flush_callback(fn) {
  * @param {Block} block
  */
 export function schedule_update(block) {
+	if ((block.f & SCHEDULED) !== 0) {
+		return;
+	}
+	block.f |= SCHEDULED;
+
 	if (scheduler_mode === FLUSH_MICROTASK) {
 		queue_microtask();
 	}
-	// The scheduled block roots the subtree that flush_updates scans for dirty
-	// subscribers. Mark it even if it (or an ancestor) is already on a routing
-	// path, so the early return below still records it as a scan root.
-	block.f |= UPDATE_SOURCE;
-	let current = block;
-
-	while (current !== null) {
-		var flags = current.f;
-		if ((flags & CONTAINS_UPDATE) !== 0) return;
-		current.f ^= CONTAINS_UPDATE;
-		if ((flags & ROOT_BLOCK) !== 0) {
-			break;
-		}
-		current = /** @type {Block} */ (current.p);
-	}
 
-	queued_root_blocks.push(current);
+	var id = block.i;
+	if (id < queue.last) {
+		queue.sorted = false;
+	}
+	queue.last = id;
+	queue.blocks.push(block);
 }
 
 /**
  * @param {Tracked | Derived} tracked
  */
 function register_dependency(tracked) {
-	if (!disable_scoped_flush && active_block !== null && active_block !== tracked.b) {
-		// Scoped flush only scans the owner's subtree for dirty subscribers, valid
-		// only while every subscriber lives inside it. The subscriber↔owner
-		// ancestry is structural and stable for a block's lifetime (its `.p` chain
-		// never changes — DOM moves don't reparent blocks), so we only need to
-		// verify *new* dependency edges: if this reaction already depended on
-		// `tracked` on its previous run (it's in the prior chain), the ancestry
-		// walk was already done — skip it. This keeps the (possibly deep) walk off
-		// the hot path for the common case of stable subscriptions.
-		var already_seen = false;
-		var prev_dep = active_reaction === null ? null : active_reaction.d;
-		while (prev_dep !== null) {
-			if (prev_dep.t === tracked) {
-				already_seen = true;
-				break;
-			}
-			prev_dep = prev_dep.n;
-		}
-
-		if (!already_seen) {
-			var owner = tracked.b;
-			/** @type {Block | null} */
-			var node = active_block;
-			while (node !== null && node !== owner) {
-				node = node.p;
-			}
-			if (node === null) {
-				disable_scoped_flush = true;
-			}
-		}
-	}
-
 	var dependency = active_dependency;
 
 	if (dependency === null) {
@@ -1247,75 +1550,26 @@ export function get(tracked) {
 		: get_tracked(/** @type {Tracked} */ (tracked));
 }
 
-/**
- * @param {any} lazy
- * @param {number} [index]
- * @returns {any}
- */
-export function lazy_array_get(lazy, index = 0) {
-	if (is_array(lazy)) {
-		return lazy[index];
-	}
-	var flags = lazy.f;
-	if (flags === TRACKED) {
-		return index === 0
-			? get_tracked(/** @type {Tracked} */ (lazy))
-			: index === 1
-				? lazy
-				: undefined;
-	}
-	if (flags === DERIVED) {
-		return index === 0
-			? get_derived(/** @type {Derived} */ (lazy))
-			: index === 1
-				? lazy
-				: undefined;
-	}
-	return iterable_array_from(lazy, index)[0];
-}
-
-/**
- * @param {any} lazy
- * @param {number} [index]
- * @returns {any[]}
- */
-export function lazy_array_rest(lazy, index = 0) {
-	if (is_array(lazy)) {
-		return lazy.slice(index);
-	}
-	var flags = lazy.f;
-	if (flags === TRACKED) {
-		return index === 0
-			? [get_tracked(/** @type {Tracked} */ (lazy)), lazy]
-			: index === 1
-				? [lazy]
-				: [];
-	}
-	if (flags === DERIVED) {
-		return index === 0
-			? [get_derived(/** @type {Derived} */ (lazy)), lazy]
-			: index === 1
-				? [lazy]
-				: [];
-	}
-	return iterable_array_from(lazy, index);
-}
-
 /**
  * @param {Tracked} tracked
  */
 export function get_tracked(tracked) {
 	var value = tracked.__v;
 	if (tracking) {
-		register_dependency(tracked);
+		// register_dependency, inline for the first read of a run.
+		if (active_dependency === null) {
+			active_dependency = create_dependency(tracked);
+		} else {
+			register_dependency(tracked);
+		}
 	}
 
 	if (value === SUSPENSE_PENDING || value === SUSPENSE_REJECTED) {
 		throw ASYNC_DERIVED_READ_THROWN;
 	}
 
-	if (teardown && old_values.has(tracked)) {
-		value = old_values.get(tracked);
+	if (teardown && tracked.o !== UNINITIALIZED) {
+		value = tracked.o;
 	}
 	var get = tracked.a.get;
 	if (get !== undefined) {
@@ -1324,57 +1578,6 @@ export function get_tracked(tracked) {
 	return value;
 }
 
-/**
- * @param {any} lazy
- * @param {any} value
- * @param {number} [index]
- * @returns {void}
- */
-export function lazy_array_set(lazy, value, index = 0) {
-	if (is_array(lazy)) {
-		lazy[index] = value;
-		return;
-	}
-	var flags = lazy.f;
-	if (flags === TRACKED || flags === DERIVED) {
-		if (index === 0) {
-			set(/** @type {Derived | Tracked} */ (lazy), value);
-			return;
-		}
-		if (index === 1) {
-			throw_tracked_index_reference_error();
-		}
-		return;
-	}
-	lazy[index] = value;
-}
-
-/**
- * @param {any} lazy
- * @param {number} [index]
- * @param {number} [d]
- * @returns {number}
- */
-export function lazy_array_update(lazy, index = 0, d = 1) {
-	var value = lazy_array_get(lazy, index);
-	var result = d === 1 ? value++ : value--;
-	lazy_array_set(lazy, value, index);
-	return result;
-}
-
-/**
- * @param {any} lazy
- * @param {number} [index]
- * @param {number} [d]
- * @returns {number}
- */
-export function lazy_array_update_pre(lazy, index = 0, d = 1) {
-	var value = lazy_array_get(lazy, index);
-	var new_value = d === 1 ? ++value : --value;
-	lazy_array_set(lazy, new_value, index);
-	return new_value;
-}
-
 /**
  * @param {Derived | Tracked} tracked
  * @param {any} value
@@ -1392,24 +1595,42 @@ export function set(tracked, value) {
 		var tracked_block = tracked.b;
 
 		if ((tracked_block.f & CONTAINS_TEARDOWN) !== 0) {
-			if (teardown) {
-				old_values.set(tracked, value);
-			} else {
-				old_values.set(tracked, old_value);
+			if (tracked.o === UNINITIALIZED) {
+				old_value_holders.push(tracked);
 			}
+			tracked.o = teardown ? value : old_value;
 		}
 
 		let set = tracked.a.set;
-		if (set !== undefined) {
+		if (typeof set === 'function') {
 			value = untrack(() => set(value, old_value));
+		} else if (DEV && set === undefined && (tracked.f & DERIVED) !== 0) {
+			warn_readonly_derived_write(/** @type {Derived} */ (tracked));
 		}
 
 		tracked.__v = value;
 		tracked.c = increment_clock();
-		schedule_update(tracked_block);
+		mark_subscribers(tracked);
 	}
 }
 
+/** @type {WeakSet<object>} */
+var warned_derived = new WeakSet();
+
+/**
+ * A derived created without a setter is read-only by contract (`Derived<V>`);
+ * a write still lands as a temporary value until the next recompute, so in
+ * development it is reported once per derived.
+ * @param {Derived} derived
+ */
+function warn_readonly_derived_write(derived) {
+	if (warned_derived.has(derived)) return;
+	warned_derived.add(derived);
+	console.warn(
+		'Writing to a read-only derived. Create it with a setter, `track(fn, undefined, true)` or `track(fn, get, set)`, when it is meant to be written.',
+	);
+}
+
 /**
  * @template T
  * @param {() => T} fn
@@ -1435,144 +1656,43 @@ export function untrack(fn) {
  */
 export function flush_sync(fn) {
 	var previous_scheduler_mode = scheduler_mode;
-	var previous_queued_root_blocks = queued_root_blocks;
+	var previous_queue = queue;
 
+	flush_depth++;
 	try {
-		/** @type {Block[]} */
-		var root_blocks = [];
-
 		scheduler_mode = FLUSH_SYNC;
-		queued_root_blocks = root_blocks;
+		queue = create_queue();
 		is_micro_task_queued = false;
 
-		flush_queued_root_blocks(previous_queued_root_blocks);
+		// Drains previous_queue, which then stays empty for the restore below.
+		flush_queue(previous_queue);
 
 		var result = fn?.();
 
-		if (queued_root_blocks.length > 0 || root_blocks.length > 0) {
-			flush_sync();
+		// Each pass runs the blocks scheduled by the previous one.
+		while (queue.blocks.length > 0) {
+			var pending = queue;
+			queue = create_queue();
+			flush_queue(pending);
 		}
 
 		flush_count = 0;
 
+		// Old values only matter to teardowns run by the flush in progress; a
+		// sync flush nested in another flush (an effect calling `flushSync`)
+		// leaves them for the outer flush's remaining teardowns.
+		if (flush_depth === 1) {
+			release_old_values();
+		}
+
 		return /** @type {T} */ (result);
 	} finally {
+		flush_depth--;
 		scheduler_mode = previous_scheduler_mode;
-		queued_root_blocks = previous_queued_root_blocks;
+		queue = previous_queue;
 	}
 }
 
-/**
- * @param {() => Object} fn
- * @returns {Object}
- */
-export function spread_props(fn) {
-	return proxy_props(fn);
-}
-
-/**
- * @param {() => Object} fn
- * @returns {Object}
- */
-export function proxy_props(fn) {
-	const memo = derived(fn, /** @type {Block} */ (active_block));
-
-	return new Proxy(
-		{},
-		{
-			get(_, property) {
-				/** @type {Record<string | symbol, any> | Record<string | symbol, any>[]} */
-				var obj = get_derived(memo);
-
-				// Handle array of objects/spreads (for multiple props)
-				if (is_array(obj)) {
-					// Search in reverse order (right-to-left) since later props override earlier ones
-					/** @type {Record<string | symbol, any>} */
-					var item;
-					for (var i = obj.length - 1; i >= 0; i--) {
-						item = obj[i];
-						if (property in item) {
-							return item[property];
-						}
-					}
-					return undefined;
-				}
-
-				// Single object case
-				return obj[property];
-			},
-			has(_, property) {
-				if (property === TRACKED_OBJECT) {
-					return true;
-				}
-				/** @type {Record<string | symbol, any> | Record<string | symbol, any>[]} */
-				var obj = get_derived(memo);
-
-				// Handle array of objects/spreads
-				if (is_array(obj)) {
-					for (var i = obj.length - 1; i >= 0; i--) {
-						if (property in obj[i]) {
-							return true;
-						}
-					}
-					return false;
-				}
-
-				return property in obj;
-			},
-			getOwnPropertyDescriptor(_, key) {
-				/** @type {Record<string | symbol, any> | Record<string | symbol, any>[]} */
-				var obj = get_derived(memo);
-
-				// Handle array of objects/spreads
-				if (is_array(obj)) {
-					/** @type {Record<string | symbol, any>} */
-					var item;
-					for (var i = obj.length - 1; i >= 0; i--) {
-						item = obj[i];
-						if (key in item) {
-							return get_descriptor(item, key);
-						}
-					}
-					return undefined;
-				}
-
-				if (key in obj) {
-					return get_descriptor(obj, key);
-				}
-			},
-			ownKeys() {
-				/** @type {Record<string | symbol, any> | Record<string | symbol, any>[]} */
-				var obj = get_derived(memo);
-				/** @type {Record<string | symbol, 1>} */
-				var done = {};
-				/** @type {(string | symbol)[]} */
-				var keys = [];
-
-				// Handle array of objects/spreads
-				if (is_array(obj)) {
-					// Collect all keys from all objects, order doesn't matter
-					/** @type {Record<string | symbol, any>} */
-					var item;
-					for (var i = 0; i < obj.length; i++) {
-						item = obj[i];
-						for (const key of Reflect.ownKeys(item)) {
-							if (done[key]) {
-								continue;
-							}
-							done[key] = 1;
-							keys.push(key);
-						}
-					}
-					return keys;
-				}
-
-				return Reflect.ownKeys(obj);
-			},
-		},
-	);
-}
-
 /**
  * @template T
  * @param {() => T} fn
@@ -1742,7 +1862,7 @@ export function safe_scope(err = 'Cannot access outside of a component context')
 export function create_component_ctx() {
 	return {
 		b: active_block,
-		c: null,
+		c: active_component === null ? null : active_component.c,
 		e: null,
 		m: false,
 		p: active_component,
@@ -1753,8 +1873,7 @@ export function create_component_ctx() {
  * @returns {void}
  */
 export function push_component() {
-	var component = create_component_ctx();
-	active_component = component;
+	active_component = create_component_ctx();
 }
 
 /**
@@ -1763,27 +1882,168 @@ export function push_component() {
 export function pop_component() {
 	var component = /** @type {Component} */ (active_component);
 	component.m = true;
-	var effects = component.e;
-	if (effects !== null) {
-		var length = effects.length;
-		for (var i = 0; i < length; i++) {
-			var { b: block, fn, r: reaction } = effects[i];
-			var previous_block = active_block;
-			var previous_reaction = active_reaction;
+	if (component.e !== null) {
+		create_deferred_effects(component.e);
+	}
+	active_component = component.p;
+}
 
-			try {
-				active_block = block;
-				active_reaction = reaction;
-				effect(fn);
-			} finally {
-				active_block = previous_block;
-				active_reaction = previous_reaction;
-			}
-		}
+/**
+ * Renders a component: `fn(props)` runs under a fresh component context (the
+ * owner of the component's context values and deferred effects), and the
+ * element it returns renders before `anchor`.
+ * @param {Function} fn
+ * @param {Node | AppendIntoAnchor} anchor
+ * @param {Record<string, any>} props
+ * @param {Block | null} [block=active_block]
+ * @returns {void}
+ */
+export function render_component(fn, anchor, props, block = active_block) {
+	// An optional component (an undefined prop, an import that resolved to
+	// nothing) renders nothing; any other non-function is a programming error.
+	if (fn == null) {
+		return;
+	}
+	if (typeof fn !== 'function') {
+		throw_invalid_component_type(fn);
+	}
+
+	// push_component, inline: one component per call is the common case.
+	var parent = active_component;
+	/** @type {Component} */
+	var component = (active_component = {
+		b: active_block,
+		c: parent === null ? null : parent.c,
+		e: null,
+		m: false,
+		p: parent,
+	});
+
+	// A module-level component carries its render function under a symbol
+	// (see the compiler): calling it directly skips the element the component
+	// would return only to be rendered here.
+	var render = /** @type {any} */ (fn)[RENDER_ENTRY];
+	if (render !== undefined) {
+		render(anchor, block, props);
+	} else {
+		render_value(fn(props), /** @type {ChildNode} */ (anchor), block);
+	}
+
+	// pop_component, inline.
+	component.m = true;
+	if (component.e !== null) {
+		create_deferred_effects(component.e);
 	}
 	active_component = component.p;
 }
 
+/**
+ * A reaction that stands in for a block whose creation is being decided (see
+ * `probe_if`). Flagged destroyed so a write during the probe prunes
+ * its subscription instead of scheduling it.
+ * @type {any}
+ */
+var probe_reaction = { f: DESTROYED, d: null, blocks: null };
+
+/**
+ * Evaluates an if condition once, tracked, against a scratch reaction that is
+ * never scheduled. When the evaluation recorded no dependency the condition
+ * can never re-run (a block with no dependencies is never scheduled), so the
+ * selected branch is rendered straight away, untracked, and true is returned:
+ * the if needs no block. Otherwise the recorded links are unlinked again and
+ * false is returned: the caller creates the block, whose own first run
+ * evaluates the condition and subscribes it. The links are never handed to
+ * the block, because a write during the block's first run (a child's setup,
+ * a nested if) would prune links that still point at this destroyed reaction
+ * before the block could take them over. A throwing condition (a pending
+ * async read) unlinks what it recorded and rethrows.
+ * @param {(x: any) => any} fn
+ * @param {any} x
+ * @param {Node | import('#client').AppendIntoAnchor} node
+ * @returns {boolean} whether the branch was rendered without a block
+ */
+export function probe_if(fn, x, node) {
+	var previous_reaction = active_reaction;
+	var previous_tracking = tracking;
+	var previous_dependency = active_dependency;
+	active_reaction = probe_reaction;
+	tracking = true;
+	active_dependency = null;
+	/** @type {Dependency | null} */
+	var recorded;
+	/** @type {any} */
+	var branch;
+	try {
+		branch = fn(x);
+		recorded = active_dependency;
+	} catch (error) {
+		unlink_dependencies(active_dependency);
+		active_reaction = previous_reaction;
+		tracking = previous_tracking;
+		active_dependency = previous_dependency;
+		throw error;
+	}
+	active_reaction = previous_reaction;
+	active_dependency = previous_dependency;
+	if (recorded !== null) {
+		unlink_dependencies(recorded);
+		tracking = previous_tracking;
+		return false;
+	}
+	// The branch renders untracked, like a branch block would; `tracking` is
+	// restored by the enclosing `run_block` if the branch throws.
+	if (branch !== undefined) {
+		tracking = false;
+		branch(node, x);
+	}
+	tracking = previous_tracking;
+	return true;
+}
+
+/**
+ * @param {Dependency | null} dependency the head of a recorded chain
+ */
+function unlink_dependencies(dependency) {
+	while (dependency !== null) {
+		unlink_subscriber(dependency);
+		dependency = dependency.n;
+	}
+}
+
+/**
+ * Calls `fn(arg)` with tracking off, so reads inside it subscribe nothing.
+ * `tracking` is restored by the enclosing `run_block` if `fn` throws.
+ * @param {(arg: any, context: any) => void} fn
+ * @param {any} arg
+ * @param {any} [context]
+ */
+export function run_untracked(fn, arg, context) {
+	var previous_tracking = tracking;
+	tracking = false;
+	fn(arg, context);
+	tracking = previous_tracking;
+}
+
+/**
+ * Creates the effects a component registered while rendering, each under the
+ * block and reaction that were active at its `effect()` call.
+ * @param {any[]} effects flat triples: fn, block, reaction (see `user_effect`)
+ */
+function create_deferred_effects(effects) {
+	// Creating an effect block only links and schedules it, so nothing here
+	// can throw between saving and restoring the active block.
+	var previous_block = active_block;
+	var previous_reaction = active_reaction;
+	var length = effects.length;
+	for (var i = 0; i < length; i += 3) {
+		active_block = /** @type {Block} */ (effects[i + 1]);
+		active_reaction = /** @type {Block | Derived | null} */ (effects[i + 2]);
+		effect(/** @type {Function} */ (effects[i]));
+	}
+	active_block = previous_block;
+	active_reaction = previous_reaction;
+}
+
 /**
  * @template T
  * @param {() => T} fn
@@ -1815,40 +2075,3 @@ export function ref_prop() {
 export function create_ref_prop(get_ref_value, set_ref_value) {
 	return create_core_ref_prop(() => untrack(get_ref_value), set_ref_value);
 }
-
-/**
- * @template T
- * @param {T | undefined} value
- * @param {T} fallback
- * @returns {T}
- */
-export function fallback(value, fallback) {
-	return value === undefined ? fallback : value;
-}
-
-/**
- * @param {Record<string | symbol, unknown>} obj
- * @param {string[]} exclude_keys
- * @returns {Record<string | symbol, unknown>}
- */
-export function exclude_from_object(obj, exclude_keys) {
-	var keys = object_keys(obj);
-	/** @type {Record<string | symbol, unknown>} */
-	var new_obj = {};
-
-	for (const key of keys) {
-		if (!exclude_keys.includes(key)) {
-			new_obj[key] = obj[key];
-		}
-	}
-
-	for (const symbol of get_own_property_symbols(obj)) {
-		var ref_fn = obj[symbol];
-
-		if (symbol.description === REF_PROP) {
-			new_obj[symbol] = ref_fn;
-		}
-	}
-
-	return new_obj;
-}