ripple 0.4.2 → 0.4.4

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

@@ -4,13 +4,7 @@
 /** @typedef {DerivedValue} Derived */
 
 import { DEV } from 'esm-env';
-import {
-	destroy_block,
-	destroy_non_branch_children,
-	effect,
-	pause_block,
-	pre_effect,
-} from './blocks.js';
+import { destroy_block, destroy_non_branch_children, effect } from './blocks.js';
 import {
 	ASYNC_DERIVED_READ_THROWN,
 	BLOCK_HAS_RUN,
@@ -28,30 +22,21 @@ import {
 	UNINITIALIZED,
 	REF_PROP,
 	DEFAULT_NAMESPACE,
-	TRACKED_UPDATED,
 	SUSPENSE_PENDING,
 	SUSPENSE_REJECTED,
-	TRY_BLOCK,
-	DIRECT_CHILD_BLOCK,
 	SCHEDULED,
 	SELECTOR,
 	IF_BLOCK,
+	COMPOSITE_BLOCK,
 	ITEM_BLOCK,
 	RELEASED,
 	RENDER_ENTRY,
 	CREATES_DERIVEDS,
+	NAMESPACE_BLOCK,
+	SVG_BLOCK,
 } 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 { scope_orphan, set_in_derived, track_orphan, update_depth_exceeded } from './errors.js';
 import { render_value } from './expression.js';
 import { throw_invalid_component_type } from './component.js';
 
@@ -61,10 +46,8 @@ import {
 	is_array,
 	object_keys,
 } from '@tsrx/core/runtime/language-helpers';
-import { get_async_track_result } from '../../../utils/async.js';
-import { get_track_async_script_id } from '../../../utils/track-async-serialization.js';
-import { revive } from './transport.js';
 import { hydrating, track_hash_reference } from './hydration.js';
+import { HYDRATION } from 'ripple/internal/client/hydration-enabled';
 import { create_ref_prop as create_core_ref_prop } from '@tsrx/core/runtime/ref';
 
 const FLUSH_MICROTASK = 0;
@@ -130,7 +113,7 @@ let flush_count = 0;
 /** @type {(() => void)[]} */
 var queued_post_block_flush = [];
 /** @type {null | Dependency} */
-let active_dependency = null;
+export let active_dependency = null;
 
 export let tracking = false;
 export let teardown = false;
@@ -170,6 +153,28 @@ export function set_tracking(value) {
 	tracking = value;
 }
 
+/**
+ * @param {boolean} value
+ */
+export function set_mutating_allowed(value) {
+	is_mutating_allowed = value;
+}
+
+/**
+ * Handles a block whose run read a pending async value (see
+ * `track-async.js`). Installed by the first `trackAsync()`, so an application
+ * without one carries none of the boundary request machinery.
+ * @type {((block: Block) => void) | null}
+ */
+let pending_read = null;
+
+/**
+ * @param {(block: Block) => void} fn
+ */
+export function set_pending_read_handler(fn) {
+	pending_read = fn;
+}
+
 /**
  * @param {Block} block
  */
@@ -236,7 +241,7 @@ function update_derived(computed) {
  * @param {Tracked} tracked
  * @param {any} value
  */
-function update_tracked_value_clock(tracked, value) {
+export function update_tracked_value_clock(tracked, value) {
 	tracked.__v = value;
 	tracked.c = increment_clock();
 	mark_subscribers(tracked);
@@ -306,76 +311,51 @@ function run_derived(computed) {
 	}
 }
 
+/**
+ * Routes an error thrown by a block into the nearest boundary with a catch
+ * branch (see `try.js`). Installed by the first `try_block`, so a bundle whose
+ * mount and components create no boundary carries no catch machinery.
+ * @type {((error: unknown, block: Block) => BlockWithTryBoundaryAndCatch | null) | null}
+ */
+let catch_router = null;
+
+/**
+ * @param {(error: unknown, block: Block) => BlockWithTryBoundaryAndCatch | null} fn
+ */
+export function set_catch_router(fn) {
+	catch_router = fn;
+}
+
 /**
  * @param {unknown} error
  * @param {Block} block
  * @returns {BlockWithTryBoundaryAndCatch}
  */
 export function handle_error(error, block) {
-	var boundary_with_catch = get_boundary_with_catch(block);
-	if (boundary_with_catch !== null) {
-		handle_boundary_error(boundary_with_catch, error);
-		return boundary_with_catch;
+	var boundary_with_catch = catch_router === null ? null : catch_router(error, block);
+	if (boundary_with_catch === null) {
+		throw error;
 	}
-
-	throw error;
+	return boundary_with_catch;
 }
 
 /**
  * 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.
+ * boundary, and a read of a pending async value to the handler `trackAsync`
+ * installs (the read is registered as a dependency, so the block re-runs once
+ * the value settles).
  * @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 if (pending_read !== null) {
+		pending_read(block);
 	} 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;
-			}
-		}
+		throw error;
 	}
 }
 
@@ -390,9 +370,10 @@ function handle_run_error(error, block) {
  * @returns {Derived[] | null}
  */
 function prepare_rerun(block) {
-	// A list, an if, and a list item re-run only their own logic; their child
-	// blocks (items, the branch's blocks, an item body's nested blocks) stay.
-	if ((block.f & (FOR_BLOCK | IF_BLOCK | ITEM_BLOCK)) === 0) {
+	// A list, an if, a composite and a list item re-run only their own logic;
+	// their child blocks (items, the branch's blocks, a dynamic element's
+	// children, an item body's nested blocks) stay.
+	if ((block.f & (FOR_BLOCK | IF_BLOCK | ITEM_BLOCK | COMPOSITE_BLOCK)) === 0) {
 		destroy_non_branch_children(block);
 	}
 	run_teardown(block);
@@ -416,16 +397,18 @@ function register_teardown(block, teardown) {
 
 /**
  * Runs the body of a branch block that was just created, in place of a first
- * `run_block`: a branch renders untracked and never re-runs, so the only
- * bookkeeping its first run needs is the globals the body reads and the
- * dependencies a nested `item` records on it. Errors are handled as
- * `run_block` handles them.
+ * `run_block`: a branch renders untracked, so the only bookkeeping its first
+ * run needs is the globals the body reads and the dependencies a nested
+ * `item` records on it (a list item re-runs through `run_block`, see
+ * `run_item`). Errors are handled as `run_block` handles them.
  * @param {Block} block
- * @param {(anchor: any, value: any) => void} fn
+ * @param {(anchor: any, value: any, index?: any, key?: any) => void} fn
  * @param {any} anchor
- * @param {any} value
+ * @param {any} value a list item's value, or its tracked
+ * @param {any} [index] a list item's tracked index (see `create_item`)
+ * @param {any} [key] a keyed list item's key
  */
-export function run_branch(block, fn, anchor, value) {
+export function run_branch(block, fn, anchor, value, index, key) {
 	var previous_block = active_block;
 	var previous_reaction = active_reaction;
 	var previous_tracking = tracking;
@@ -438,7 +421,7 @@ export function run_branch(block, fn, anchor, value) {
 		active_component = block.co;
 		tracking = false;
 		active_dependency = null;
-		fn(anchor, value);
+		fn(anchor, value, index, key);
 		if (active_dependency !== null) {
 			block.d = active_dependency;
 		}
@@ -453,6 +436,43 @@ export function run_branch(block, fn, anchor, value) {
 	}
 }
 
+/**
+ * Runs `fn(block.s, arg)` as a rerun of `block` driven from outside it: an if
+ * whose condition the enclosing render function evaluates renders its branch
+ * this way. The function runs under the block, in the block's namespace, and
+ * the deriveds the block's previous run created are released afterwards
+ * unless still read, as `run_block` does for a rerun. An error propagates to
+ * the caller's block.
+ * @template S, A
+ * @param {Block} block
+ * @param {(state: S, arg: A) => void} fn
+ * @param {A} arg
+ */
+export function run_in_block(block, fn, arg) {
+	var previous_block = active_block;
+	var previous_reaction = active_reaction;
+	var previous_component = active_component;
+	var previous_namespace = active_namespace;
+	var previous_deriveds = (block.f & CREATES_DERIVEDS) !== 0 ? take_created_deriveds(block) : null;
+
+	try {
+		active_block = block;
+		active_reaction = block;
+		active_component = block.co;
+		var ns = block.f & NAMESPACE_BLOCK;
+		active_namespace = ns === 0 ? DEFAULT_NAMESPACE : ns === SVG_BLOCK ? 'svg' : 'mathml';
+		fn(/** @type {S} */ (block.s), arg);
+	} finally {
+		active_block = previous_block;
+		active_reaction = previous_reaction;
+		active_component = previous_component;
+		active_namespace = previous_namespace;
+		if (previous_deriveds !== null) {
+			keep_deriveds(block, release_deriveds(previous_deriveds));
+		}
+	}
+}
+
 /**
  * @param {Block} block
  * @param {boolean} [first_run] true when the block has no children, teardown,
@@ -464,6 +484,7 @@ export function run_block(block, first_run = false) {
 	var previous_tracking = tracking;
 	var previous_dependency = active_dependency;
 	var previous_component = active_component;
+	var previous_namespace = active_namespace;
 	/** @type {Derived[] | null} */
 	var previous_deriveds = null;
 
@@ -471,6 +492,10 @@ export function run_block(block, first_run = false) {
 		active_block = block;
 		active_reaction = block;
 		active_component = block.co;
+		// The namespace the block was created in (see `create_block`): a rerun
+		// from a flush is outside the `with_ns()` call that established it.
+		var ns = block.f & NAMESPACE_BLOCK;
+		active_namespace = ns === 0 ? DEFAULT_NAMESPACE : ns === SVG_BLOCK ? 'svg' : 'mathml';
 
 		if (!first_run) {
 			previous_deriveds = prepare_rerun(block);
@@ -500,6 +525,7 @@ export function run_block(block, first_run = false) {
 		tracking = previous_tracking;
 		active_dependency = previous_dependency;
 		active_component = previous_component;
+		active_namespace = previous_namespace;
 
 		// 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
@@ -514,21 +540,6 @@ export function run_block(block, first_run = false) {
 
 var empty_get_set = { get: undefined, set: undefined };
 
-/**
- * Complete all deferred boundary requests registered on a tracked value.
- * @param {Tracked} t
- * @param {boolean} [show_resolved=true]
- */
-function complete_deferred_boundaries(t, show_resolved = true) {
-	if (t.d !== null) {
-		for (var i = 0; i < t.d.length; i++) {
-			var entry = t.d[i];
-			complete_boundary_request(entry.b, entry.r, show_resolved);
-		}
-		t.d = null;
-	}
-}
-
 class TrackedValue {
 	/**
 	 * @param {any} v
@@ -564,17 +575,6 @@ class TrackedValue {
 	set value(v) {
 		set(this, v);
 	}
-	/**
-	 * 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));
-	}
 }
 
 class DerivedValue {
@@ -618,17 +618,6 @@ class DerivedValue {
 	set value(v) {
 		set(this, v);
 	}
-	/**
-	 * 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));
-	}
 }
 
 if (DEV) {
@@ -649,7 +638,7 @@ export function tracked(v, block, hash, get, set) {
 	var t = /** @type {Tracked} */ (
 		new TrackedValue(v, block || active_block, get || set ? { get, set } : empty_get_set, hash)
 	);
-	if (hydrating && hash !== undefined) {
+	if (HYDRATION && hydrating && hash !== undefined) {
 		track_hash_reference.set(hash, t);
 	}
 	return t;
@@ -680,7 +669,7 @@ export function derived(fn, block, hash, get, set) {
 			created.push(d);
 		}
 	}
-	if (hydrating && hash !== undefined) {
+	if (HYDRATION && hydrating && hash !== undefined) {
 		track_hash_reference.set(hash, d);
 	}
 	return d;
@@ -774,6 +763,30 @@ function keep_deriveds(block, kept) {
 	block.f |= CREATES_DERIVEDS;
 }
 
+/**
+ * A read-only view of a tracked or derived value, for a receiver that should
+ * read but not write it: a derived over a tracked (or a writable derived),
+ * equivalent to `track(() => value.value)`; a read-only derived as it is; a
+ * plain value as it is, like `get`. The view is owned by the block that
+ * creates it, not by the value's block, so a view made in a component is
+ * released with that component even when the value outlives it.
+ * @param {any} value
+ * @param {Block} [block]
+ * @returns {any}
+ */
+export function track_read_only(value, block) {
+	if (!is_ripple_object(value)) {
+		return value;
+	}
+	var owner = block || /** @type {Block} */ (active_block);
+	if ((value.f & DERIVED) !== 0) {
+		var d = /** @type {Derived} */ (value);
+		return d.a.set === undefined ? d : derived(() => get_derived(d), owner);
+	}
+	var t = /** @type {Tracked} */ (value);
+	return derived(() => get_tracked(t), owner);
+}
+
 /**
  * @param {any} v
  * @param {Block} b
@@ -787,7 +800,7 @@ export function track(v, b, hash, get, set) {
 		return v;
 	}
 	if (b === null) {
-		throw new TypeError('track() requires a valid component context');
+		track_orphan();
 	}
 
 	if (typeof v === 'function') {
@@ -796,243 +809,6 @@ export function track(v, b, hash, get, set) {
 	return tracked(v, b, hash, get, set);
 }
 
-/**
- * @param {any} fn
- * @param {Block} b
- * @param {string} hash - Unique hash for SSR serialization/hydration
- * @returns {Tracked | void}
- */
-export function track_async(fn, b, hash) {
-	if (is_ripple_object(fn)) {
-		return fn;
-	}
-
-	var target_block = b || active_block;
-	if (target_block === null) {
-		throw new TypeError('trackAsync() requires a valid component context');
-	}
-
-	if (typeof fn !== 'function') {
-		throw new TypeError(
-			'trackAsync() only accepts function arguments that return a promise or an object with a promise property',
-		);
-	}
-
-	// During hydration, attempt to read serialized data from SSR
-	var had_hydration_data = false;
-	var hydration_value;
-	/** @type {string[] | undefined} */
-	var hydration_deps;
-
-	if (hydrating) {
-		var script_id = get_track_async_script_id(hash);
-		var script_el = document.getElementById(script_id);
-		if (script_el) {
-			var envelope = JSON.parse(/** @type {string} */ (script_el.textContent));
-			script_el.remove();
-
-			if (envelope.ok) {
-				had_hydration_data = true;
-				hydration_value =
-					envelope.payload === undefined ? envelope.value : revive(envelope.payload);
-				hydration_deps = envelope.deps;
-			} else {
-				// trigger the catch block
-				throw new Error(envelope.error?.message ?? 'Unknown server error');
-			}
-		}
-	}
-
-	var t = tracked(had_hydration_data ? hydration_value : SUSPENSE_PENDING, target_block, hash);
-
-	// Capture the call-site block for boundary lookups. target_block is the
-	// component's block (passed by compiler), but the actual try/pending/catch
-	// boundary is an ancestor of active_block (the block executing trackAsync).
-	var call_site_block = /** @type {Block} */ (active_block);
-
-	var version = 0;
-	/** @type {AbortController | null} */
-	var abort_controller = null;
-	var request_id = 0;
-	/** @type {Block | null} */
-	var boundary = null;
-
-	// TODO: decide if instead of insisting on pending, we create our own boundary
-	// we currently require a pending block upstream but we could also
-	// create a try/pending/catch boundary at mount and hydration like
-	// we do on the server so that there is always a boundary present.
-	// It can handle global pending when none were provided.
-	// Not sure about the catch boundary because if none were provided,
-	// the whole app for any error will be unmounted with the catch block rendered
-
-	// Find boundary from the call-site block.
-	boundary = get_pending_boundary(active_block);
-	if (boundary === null) {
-		throw new Error('Missing parent `try { ... } pending { ... }` statement');
-	}
-
-	// If we hydrated with resolved data, the SSR already completed this request.
-	// Otherwise mark a pending request on the boundary for the client-side run.
-	if (!had_hydration_data) {
-		request_id = begin_boundary_request(boundary);
-	}
-
-	pre_effect(() => {
-		if (had_hydration_data) {
-			// First run after hydration: skip fn() entirely (the SSR already
-			// produced the resolved value) and instead register the direct
-			// dependencies from the serialized deps list so future dep changes
-			// trigger a re-run via the normal async path.
-			had_hydration_data = false;
-			if (hydration_deps !== undefined) {
-				for (var i = 0; i < hydration_deps.length; i++) {
-					var dep_ref = track_hash_reference.get(hydration_deps[i]);
-					if (dep_ref !== undefined) {
-						get(dep_ref);
-					}
-				}
-			}
-			return;
-		}
-
-		var current_version = ++version;
-
-		// Abort previous in-flight request
-		if (abort_controller !== null && abort_controller.signal.aborted === false) {
-			abort_controller.abort(TRACKED_UPDATED);
-		}
-		abort_controller = null;
-
-		// Manage boundary request: replace if in-flight, or begin new if previous completed
-		if (request_id > 0 && boundary !== null) {
-			request_id = replace_boundary_request(boundary, request_id);
-		} else if (boundary !== null) {
-			request_id = begin_boundary_request(boundary);
-		}
-
-		// Set to pending before calling fn() in case it's sync.
-		if (t.__v !== SUSPENSE_PENDING) {
-			update_tracked_value_clock(t, SUSPENSE_PENDING);
-		}
-
-		// Temporarily allow mutations so set() doesn't throw inside the pre-effect
-		var previous_is_mutating_allowed = is_mutating_allowed;
-		is_mutating_allowed = true;
-
-		var result;
-		try {
-			result = fn();
-		} catch (e) {
-			is_mutating_allowed = previous_is_mutating_allowed;
-			if (e === ASYNC_DERIVED_READ_THROWN) {
-				// A dependency is still pending or rejected (e.g. chained trackAsync).
-				// Check if any dependency is rejected — if so, propagate rejection.
-				var dep = active_dependency;
-				while (dep !== null) {
-					if (dep.t.__v === SUSPENSE_REJECTED) {
-						update_tracked_value_clock(t, SUSPENSE_REJECTED);
-						complete_deferred_boundaries(t, false);
-						if (request_id > 0 && boundary !== null) {
-							complete_boundary_request(boundary, request_id, false);
-							request_id = 0;
-						}
-						return;
-					}
-					dep = dep.n;
-				}
-				// Dependencies are pending, not rejected — register deferred
-				// rejection so that if the boundary goes to catch mode, this
-				// tracked value is also set to REJECTED.
-				if (request_id > 0 && boundary !== null) {
-					register_boundary_deferred(boundary, request_id, () => {
-						update_tracked_value_clock(t, SUSPENSE_REJECTED);
-					});
-				}
-				return;
-			}
-			throw e;
-		}
-		is_mutating_allowed = previous_is_mutating_allowed;
-
-		// Check if the result is async
-		var previous_tracking = tracking;
-		tracking = false;
-		var async_result = get_async_track_result(result);
-		tracking = previous_tracking;
-
-		if (async_result === null) {
-			// Sync result
-			update_tracked_value_clock(t, result);
-			if (request_id > 0 && boundary !== null) {
-				complete_boundary_request(boundary, request_id);
-				request_id = 0;
-			}
-			return;
-		}
-
-		// Capture per-invocation so async closures (rejection handler, teardown)
-		// have a stable reference. The shared abort_controller is only read
-		// synchronously at the top of the pre_effect to abort the previous request.
-		var current_abort_controller = async_result.abort_controller;
-		abort_controller = current_abort_controller;
-
-		async_result.promise.then(
-			(resolved) => {
-				if (current_version !== version) {
-					// stale
-					return;
-				}
-				update_tracked_value_clock(t, resolved);
-				complete_deferred_boundaries(t);
-				if (request_id > 0 && boundary !== null) {
-					complete_boundary_request(boundary, request_id);
-					request_id = 0;
-				}
-			},
-			(error) => {
-				if (current_version !== version) return; // stale
-
-				var is_internal_abort =
-					error === TRACKED_UPDATED || current_abort_controller?.signal?.reason === TRACKED_UPDATED;
-				if (is_internal_abort) {
-					// Internal abort (superseded by a new request) — don't set rejected
-					if (request_id > 0 && boundary !== null) {
-						complete_boundary_request(boundary, request_id, false);
-						request_id = 0;
-					}
-					complete_deferred_boundaries(t, false);
-					return;
-				}
-
-				update_tracked_value_clock(t, SUSPENSE_REJECTED);
-				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) {
-					handle_boundary_error(boundary_with_catch, error);
-				}
-
-				if (request_id > 0 && boundary !== null) {
-					var should_show_resolved =
-						boundary_with_catch === boundary || boundary === null ? false : true;
-					complete_boundary_request(boundary, request_id, should_show_resolved);
-					request_id = 0;
-				}
-			},
-		);
-
-		return () => {
-			// Teardown: abort in-flight request when block is destroyed
-			if (current_abort_controller !== null && current_abort_controller.signal.aborted === false) {
-				current_abort_controller.abort(TRACKED_UPDATED);
-			}
-		};
-	});
-
-	return t;
-}
-
 /**
  * @param {(Derived | Tracked) | (() => any)} t
  * @returns {boolean}
@@ -1463,9 +1239,7 @@ function flush_microtasks() {
 
 	flush_count++;
 	if (flush_count > 1001) {
-		throw new Error(
-			'Maximum update depth exceeded. This typically indicates that an effect reads and writes the same piece of state.',
-		);
+		update_depth_exceeded();
 	}
 	var pending = queue;
 	queue = create_queue();
@@ -1627,9 +1401,7 @@ export function get_tracked(tracked) {
  */
 export function set(tracked, value) {
 	if (!is_mutating_allowed) {
-		throw new Error(
-			'Assignments or updates to tracked values are not allowed during computed "track(() => ...)" evaluation',
-		);
+		set_in_derived();
 	}
 
 	var old_value = tracked.__v;
@@ -1894,9 +1666,9 @@ export function scope() {
  * @param {string} [err]
  * @returns {Block | never}
  */
-export function safe_scope(err = 'Cannot access outside of a component context') {
+export function safe_scope(err) {
 	if (active_scope === null) {
-		throw new Error(err);
+		scope_orphan(err);
 	}
 
 	return /** @type {Block} */ (active_scope);
@@ -2103,6 +1875,20 @@ export function with_ns(namespace, fn) {
 	}
 }
 
+/**
+ * Sets the active namespace and returns the previous one, for setup code that
+ * switches namespace part-way through a render function (the children of a
+ * `foreignObject`), where a `with_ns()` thunk would hide its declarations.
+ * `run_block` restores the namespace after the render function either way.
+ * @param {keyof typeof NAMESPACE_URI} namespace
+ * @returns {keyof typeof NAMESPACE_URI}
+ */
+export function set_ns(namespace) {
+	var previous_namespace = active_namespace;
+	active_namespace = namespace;
+	return previous_namespace;
+}
+
 /**
  * @returns {symbol}
  */