ripple 0.3.128 → 0.4.1

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 */
@@ -27,7 +27,6 @@ import {
 	TRACKED,
 	UNINITIALIZED,
 	REF_PROP,
-	TRACKED_OBJECT,
 	DEFAULT_NAMESPACE,
 	TRACKED_UPDATED,
 	SUSPENSE_PENDING,
@@ -36,33 +35,34 @@ import {
 	DIRECT_CHILD_BLOCK,
 	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';
 
@@ -82,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} */
@@ -168,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;
@@ -293,13 +313,104 @@ 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;
 	}
 
 	throw error;
 }
 
+/**
+ * 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
+ */
+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,
@@ -311,6 +422,8 @@ export function run_block(block, first_run = false) {
 	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;
@@ -318,11 +431,7 @@ export function run_block(block, first_run = false) {
 		active_component = block.co;
 
 		if (!first_run) {
-			// A list's children are all item branches, so there is nothing to sweep.
-			if ((block.f & FOR_BLOCK) === 0) {
-				destroy_non_branch_children(block);
-			}
-			run_teardown(block);
+			previous_deriveds = prepare_rerun(block);
 		}
 
 		tracking = (block.f & (ROOT_BLOCK | BRANCH_BLOCK)) === 0;
@@ -330,71 +439,34 @@ export function run_block(block, first_run = false) {
 		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);
 		}
 
-		finish_dependencies(block, active_dependency);
-	} catch (error) {
-		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;
-				}
+		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));
+		}
 	}
 }
 
@@ -419,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;
@@ -439,18 +511,8 @@ class TrackedValue {
 		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() {
@@ -460,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));
 	}
 }
 
@@ -475,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;
@@ -501,18 +565,8 @@ class DerivedValue {
 		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() {
@@ -522,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));
 	}
 }
 
@@ -544,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) {
@@ -562,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) {
@@ -634,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
@@ -810,7 +968,7 @@ export function track_async(fn, b, hash) {
 				// 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) {
@@ -886,6 +1044,8 @@ function create_dependency(tracked) {
 		return existing;
 	}
 
+	// link_subscriber, inline: the first read of every block run lands here.
+	var head = tracked.sb;
 	/** @type {Dependency} */
 	var dependency = {
 		c: tracked.c,
@@ -893,9 +1053,12 @@ function create_dependency(tracked) {
 		n: null,
 		r: reaction,
 		sp: null,
-		sn: null,
+		sn: head,
 	};
-	link_subscriber(dependency, tracked);
+	if (head !== null) {
+		head.sp = dependency;
+	}
+	tracked.sb = dependency;
 	return dependency;
 }
 
@@ -930,8 +1093,7 @@ export function unlink_subscriber(dependency) {
 		}
 		tracked.sb = next;
 		if (next === null && (tracked.f & SELECTOR) !== 0) {
-			// Last subscriber gone: release the selector's per-key entry.
-			/** @type {SelectorAccessors} */ (tracked.a).m.delete(tracked.h);
+			release_selector_key(/** @type {Tracked} */ (tracked));
 		}
 	}
 	if (next !== null) {
@@ -941,9 +1103,43 @@ export function unlink_subscriber(dependency) {
 }
 
 /**
- * @typedef {{ get: undefined; set: undefined; m: Map<any, Tracked> }} SelectorAccessors
+ * `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
@@ -1007,13 +1203,14 @@ function mark_subscribers(tracked) {
 		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;
-			// A derived whose owner is gone and that nothing reads any more is
-			// pruned; one still read elsewhere keeps forwarding notifications.
 			if (derived_owner !== null && (derived_owner.f & DESTROYED) !== 0 && derived.sb === null) {
 				unlink_subscriber(dependency);
-			} else {
-				mark_subscribers(derived);
 			}
 		} else if ((flags & DESTROYED) !== 0) {
 			unlink_subscriber(dependency);
@@ -1103,11 +1300,55 @@ function by_block_id(a, b) {
  */
 function flush_queue(pending) {
 	var blocks = pending.blocks;
+	var length = blocks.length;
+
+	if (length > 0) {
+		if (!pending.sorted) {
+			blocks.sort(by_block_id);
+		}
+
+		var has_effects = false;
+
+		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;
+			}
+		}
+
+		// 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);
+		}
 
-	if (!pending.sorted) {
-		blocks.sort(by_block_id);
+		blocks.length = 0;
+		pending.sorted = true;
+		pending.last = 0;
 	}
 
+	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]();
+		}
+	}
+}
+
+/**
+ * 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[]} */
@@ -1115,10 +1356,9 @@ function flush_queue(pending) {
 	/** @type {Block[]} */
 	var effects = [];
 
-	for (var i = 0; i < blocks.length; i++) {
+	for (var i = 0; i < length; i++) {
 		var block = blocks[i];
 		var flags = block.f;
-		block.f = flags & ~SCHEDULED;
 
 		// A paused block is re-checked when it resumes; a destroyed one is gone.
 		if ((flags & (PAUSED | DESTROYED)) !== 0) {
@@ -1133,21 +1373,9 @@ function flush_queue(pending) {
 		}
 	}
 
-	blocks.length = 0;
-	pending.sorted = true;
-	pending.last = 0;
-
 	run_phase(pre_effects);
 	run_phase(other_blocks);
 	run_phase(effects);
-
-	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]();
-		}
-	}
 }
 
 /**
@@ -1156,10 +1384,12 @@ function flush_queue(pending) {
 function run_phase(blocks) {
 	for (var i = 0; i < blocks.length; i++) {
 		var block = blocks[i];
+		var flags = block.f;
 
 		try {
-			if ((block.f & (PAUSED | DESTROYED)) === 0 && is_block_dirty(block)) {
-				run_block(block);
+			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);
@@ -1196,12 +1426,19 @@ function flush_microtasks() {
 	}
 	var pending = queue;
 	queue = create_queue();
-	flush_queue(pending);
+	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();
+	}
 }
 
 /**
@@ -1313,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) {
@@ -1390,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
@@ -1458,16 +1595,17 @@ 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;
@@ -1476,6 +1614,23 @@ export function set(tracked, value) {
 	}
 }
 
+/** @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
@@ -1503,6 +1658,7 @@ export function flush_sync(fn) {
 	var previous_scheduler_mode = scheduler_mode;
 	var previous_queue = queue;
 
+	flush_depth++;
 	try {
 		scheduler_mode = FLUSH_SYNC;
 		queue = create_queue();
@@ -1513,130 +1669,30 @@ export function flush_sync(fn) {
 
 		var result = fn?.();
 
-		if (queue.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;
 		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
@@ -1806,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,
@@ -1817,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();
 }
 
 /**
@@ -1827,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
@@ -1879,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;
-}