svelte 5.43.3 → 5.43.5

package/package.json

@@ -2,7 +2,7 @@
   "name": "svelte",
   "description": "Cybernetically enhanced web apps",
   "license": "MIT",
-  "version": "5.43.3",
+  "version": "5.43.5",
   "type": "module",
   "types": "./types/index.d.ts",
   "engines": {

package/src/compiler/phases/2-analyze/visitors/BindDirective.js

@@ -159,6 +159,16 @@ export function BindDirective(node, context) {
 
 		mark_subtree_dynamic(context.path);
 
+		const [get, set] = node.expression.expressions;
+		// We gotta jump across the getter/setter functions to avoid the expression metadata field being reset to null
+		context.visit(get.type === 'ArrowFunctionExpression' ? get.body : get, {
+			...context.state,
+			expression: node.metadata.expression
+		});
+		context.visit(set.type === 'ArrowFunctionExpression' ? set.body : set, {
+			...context.state,
+			expression: node.metadata.expression
+		});
 		return;
 	}
 
@@ -247,7 +257,8 @@ export function BindDirective(node, context) {
 
 		node.metadata = {
 			binding_group_name: group_name,
-			parent_each_blocks: each_blocks
+			parent_each_blocks: each_blocks,
+			expression: node.metadata.expression
 		};
 	}
 
@@ -255,5 +266,5 @@ export function BindDirective(node, context) {
 		w.bind_invalid_each_rest(binding.node, binding.node.name);
 	}
 
-	context.next();
+	context.next({ ...context.state, expression: node.metadata.expression });
 }

package/src/compiler/phases/2-analyze/visitors/StyleDirective.js

@@ -23,6 +23,9 @@ export function StyleDirective(node, context) {
 			if (binding.kind !== 'normal') {
 				node.metadata.expression.has_state = true;
 			}
+			if (binding.blocker) {
+				node.metadata.expression.dependencies.add(binding);
+			}
 		}
 	} else {
 		context.next();
@@ -30,9 +33,7 @@ export function StyleDirective(node, context) {
 		for (const chunk of get_attribute_chunks(node.value)) {
 			if (chunk.type !== 'ExpressionTag') continue;
 
-			node.metadata.expression.has_state ||= chunk.metadata.expression.has_state;
-			node.metadata.expression.has_call ||= chunk.metadata.expression.has_call;
-			node.metadata.expression.has_await ||= chunk.metadata.expression.has_await;
+			node.metadata.expression.merge(chunk.metadata.expression);
 		}
 	}
 }

package/src/compiler/phases/3-transform/client/visitors/BindDirective.js

@@ -250,10 +250,13 @@ export function BindDirective(node, context) {
 
 	let statement = defer ? b.stmt(b.call('$.effect', b.thunk(call))) : b.stmt(call);
 
-	// TODO this doesn't account for function bindings
-	if (node.metadata.binding?.blocker) {
+	if (node.metadata.expression.is_async()) {
 		statement = b.stmt(
-			b.call(b.member(node.metadata.binding.blocker, b.id('then')), b.thunk(b.block([statement])))
+			b.call(
+				'$.run_after_blockers',
+				node.metadata.expression.blockers(),
+				b.thunk(b.block([statement]))
+			)
 		);
 	}
 

package/src/compiler/phases/3-transform/client/visitors/RegularElement.js

@@ -484,21 +484,6 @@ function setup_select_synchronization(value_binding, context) {
 	);
 }
 
-/**
- * @param {ExpressionMetadata} target
- * @param {ExpressionMetadata} source
- */
-function merge_metadata(target, source) {
-	target.has_assignment ||= source.has_assignment;
-	target.has_await ||= source.has_await;
-	target.has_call ||= source.has_call;
-	target.has_member_expression ||= source.has_member_expression;
-	target.has_state ||= source.has_state;
-
-	for (const r of source.references) target.references.add(r);
-	for (const b of source.dependencies) target.dependencies.add(b);
-}
-
 /**
  * @param {AST.ClassDirective[]} class_directives
  * @param {ComponentContext} context
@@ -514,7 +499,7 @@ export function build_class_directives_object(
 	const metadata = new ExpressionMetadata();
 
 	for (const d of class_directives) {
-		merge_metadata(metadata, d.metadata.expression);
+		metadata.merge(d.metadata.expression);
 
 		const expression = /** @type Expression */ (context.visit(d.expression));
 		properties.push(b.init(d.name, expression));
@@ -541,7 +526,7 @@ export function build_style_directives_object(
 	const metadata = new ExpressionMetadata();
 
 	for (const d of style_directives) {
-		merge_metadata(metadata, d.metadata.expression);
+		metadata.merge(d.metadata.expression);
 
 		const expression =
 			d.value === true

package/src/compiler/phases/3-transform/client/visitors/shared/component.js

@@ -171,8 +171,6 @@ export function build_component(node, component_name, context) {
 				attribute.value,
 				context,
 				(value, metadata) => {
-					if (!metadata.has_state && !metadata.has_await) return value;
-
 					// When we have a non-simple computation, anything other than an Identifier or Member expression,
 					// then there's a good chance it needs to be memoized to avoid over-firing when read within the
 					// child component (e.g. `active={i === index}`)
@@ -198,7 +196,12 @@ export function build_component(node, component_name, context) {
 				push_prop(b.init(attribute.name, value));
 			}
 		} else if (attribute.type === 'BindDirective') {
-			const expression = /** @type {Expression} */ (context.visit(attribute.expression));
+			const expression = /** @type {Expression} */ (
+				context.visit(attribute.expression, { ...context.state, memoizer })
+			);
+
+			// Bindings are a bit special: we don't want to add them to (async) deriveds but we need to check if they have blockers
+			memoizer.check_blockers(attribute.metadata.expression);
 
 			if (
 				dev &&

package/src/compiler/phases/3-transform/client/visitors/shared/element.js

@@ -122,7 +122,7 @@ export function build_attribute_value(value, context, memoize = (value) => value
 
 		return {
 			value: memoize(expression, chunk.metadata.expression),
-			has_state: chunk.metadata.expression.has_state || chunk.metadata.expression.has_await
+			has_state: chunk.metadata.expression.has_state || chunk.metadata.expression.is_async()
 		};
 	}
 
@@ -170,7 +170,7 @@ export function build_set_class(element, node_id, attribute, class_directives, c
 	if (class_directives.length) {
 		next = build_class_directives_object(class_directives, context);
 		has_state ||= class_directives.some(
-			(d) => d.metadata.expression.has_state || d.metadata.expression.has_await
+			(d) => d.metadata.expression.has_state || d.metadata.expression.is_async()
 		);
 
 		if (has_state) {
@@ -240,7 +240,7 @@ export function build_set_style(node_id, attribute, style_directives, context) {
 	if (style_directives.length) {
 		next = build_style_directives_object(style_directives, context);
 		has_state ||= style_directives.some(
-			(d) => d.metadata.expression.has_state || d.metadata.expression.has_await
+			(d) => d.metadata.expression.has_state || d.metadata.expression.is_async()
 		);
 
 		if (has_state) {

package/src/compiler/phases/3-transform/client/visitors/shared/utils.js

@@ -31,11 +31,7 @@ export class Memoizer {
 	 * @param {boolean} memoize_if_state
 	 */
 	add(expression, metadata, memoize_if_state = false) {
-		for (const binding of metadata.dependencies) {
-			if (binding.blocker) {
-				this.#blockers.add(binding.blocker);
-			}
-		}
+		this.check_blockers(metadata);
 
 		const should_memoize =
 			metadata.has_call || metadata.has_await || (memoize_if_state && metadata.has_state);
@@ -52,6 +48,17 @@ export class Memoizer {
 		return id;
 	}
 
+	/**
+	 * @param {ExpressionMetadata} metadata
+	 */
+	check_blockers(metadata) {
+		for (const binding of metadata.dependencies) {
+			if (binding.blocker) {
+				this.#blockers.add(binding.blocker);
+			}
+		}
+	}
+
 	apply() {
 		return [...this.#sync, ...this.#async].map((memo, i) => {
 			memo.id.name = `$${i}`;
@@ -348,6 +355,7 @@ export function validate_binding(state, binding, expression) {
 			b.call(
 				'$.validate_binding',
 				b.literal(state.analysis.source.slice(binding.start, binding.end)),
+				binding.metadata.expression.blockers(),
 				b.thunk(
 					state.store_to_invalidate ? b.sequence([b.call('$.mark_store_binding'), obj]) : obj
 				),

package/src/compiler/phases/3-transform/server/visitors/shared/component.js

@@ -107,6 +107,9 @@ export function build_inline_component(node, expression, context) {
 
 			push_prop(b.prop('init', b.key(attribute.name), value));
 		} else if (attribute.type === 'BindDirective' && attribute.name !== 'this') {
+			// Bindings are a bit special: we don't want to add them to (async) deriveds but we need to check if they have blockers
+			optimiser.check_blockers(attribute.metadata.expression);
+
 			if (attribute.expression.type === 'SequenceExpression') {
 				const [get, set] = /** @type {SequenceExpression} */ (context.visit(attribute.expression))
 					.expressions;

package/src/compiler/phases/3-transform/server/visitors/shared/element.js

@@ -121,6 +121,8 @@ export function build_element_attributes(node, context, transform) {
 				expression = b.call(expression.expressions[0]);
 			}
 
+			expression = transform(expression, attribute.metadata.expression);
+
 			if (is_content_editable_binding(attribute.name)) {
 				content = expression;
 			} else if (attribute.name === 'value' && node.name === 'textarea') {

package/src/compiler/phases/3-transform/server/visitors/shared/utils.js

@@ -347,16 +347,11 @@ export class PromiseOptimiser {
 	#blockers = new Set();
 
 	/**
-	 *
 	 * @param {Expression} expression
 	 * @param {ExpressionMetadata} metadata
 	 */
 	transform = (expression, metadata) => {
-		for (const binding of metadata.dependencies) {
-			if (binding.blocker) {
-				this.#blockers.add(binding.blocker);
-			}
-		}
+		this.check_blockers(metadata);
 
 		if (metadata.has_await) {
 			this.has_await = true;
@@ -368,6 +363,17 @@ export class PromiseOptimiser {
 		return expression;
 	};
 
+	/**
+	 * @param {ExpressionMetadata} metadata
+	 */
+	check_blockers(metadata) {
+		for (const binding of metadata.dependencies) {
+			if (binding.blocker) {
+				this.#blockers.add(binding.blocker);
+			}
+		}
+	}
+
 	apply() {
 		if (this.expressions.length === 0) {
 			return b.empty;

package/src/compiler/phases/nodes.js

@@ -115,6 +115,21 @@ export class ExpressionMetadata {
 	is_async() {
 		return this.has_await || this.#get_blockers().size > 0;
 	}
+
+	/**
+	 * @param {ExpressionMetadata} source
+	 */
+	merge(source) {
+		this.has_state ||= source.has_state;
+		this.has_call ||= source.has_call;
+		this.has_await ||= source.has_await;
+		this.has_member_expression ||= source.has_member_expression;
+		this.has_assignment ||= source.has_assignment;
+		this.#blockers = null; // so that blockers are recalculated
+
+		for (const r of source.references) this.references.add(r);
+		for (const b of source.dependencies) this.dependencies.add(b);
+	}
 }
 
 /**

package/src/internal/client/constants.js

@@ -6,6 +6,13 @@ export const BLOCK_EFFECT = 1 << 4;
 export const BRANCH_EFFECT = 1 << 5;
 export const ROOT_EFFECT = 1 << 6;
 export const BOUNDARY_EFFECT = 1 << 7;
+/**
+ * Indicates that a reaction is connected to an effect root — either it is an effect,
+ * or it is a derived that is depended on by at least one effect. If a derived has
+ * no dependents, we can disconnect it from the graph, allowing it to either be
+ * GC'd or reconnected later if an effect comes to depend on it again
+ */
+export const CONNECTED = 1 << 9;
 export const CLEAN = 1 << 10;
 export const DIRTY = 1 << 11;
 export const MAYBE_DIRTY = 1 << 12;
@@ -26,8 +33,6 @@ export const EFFECT_PRESERVED = 1 << 19;
 export const USER_EFFECT = 1 << 20;
 
 // Flags exclusive to deriveds
-export const UNOWNED = 1 << 8;
-export const DISCONNECTED = 1 << 9;
 /**
  * Tells that we marked this derived and its reactions as visited during the "mark as (maybe) dirty"-phase.
  * Will be lifted during execution of the derived and during checking its dirty state (both are necessary

package/src/internal/client/dom/template.js

@@ -20,7 +20,7 @@ import {
 	TEMPLATE_USE_MATHML,
 	TEMPLATE_USE_SVG
 } from '../../../constants.js';
-import { COMMENT_NODE, DOCUMENT_FRAGMENT_NODE, TEXT_NODE } from '#client/constants';
+import { COMMENT_NODE, DOCUMENT_FRAGMENT_NODE, EFFECT_RAN, TEXT_NODE } from '#client/constants';
 
 /**
  * @param {TemplateNode} start
@@ -344,7 +344,13 @@ export function comment() {
  */
 export function append(anchor, dom) {
 	if (hydrating) {
-		/** @type {Effect} */ (active_effect).nodes_end = hydrate_node;
+		var effect = /** @type {Effect} */ (active_effect);
+		// When hydrating and outer component and an inner component is async, i.e. blocked on a promise,
+		// then by the time the inner resolves we have already advanced to the end of the hydrated nodes
+		// of the parent component. Check for defined for that reason to avoid rewinding the parent's end marker.
+		if ((effect.f & EFFECT_RAN) === 0 || effect.nodes_end === null) {
+			effect.nodes_end = hydrate_node;
+		}
 		hydrate_next();
 		return;
 	}

package/src/internal/client/index.js

@@ -102,7 +102,8 @@ export {
 	for_await_track_reactivity_loss,
 	run,
 	save,
-	track_reactivity_loss
+	track_reactivity_loss,
+	run_after_blockers
 } from './reactivity/async.js';
 export { eager, flushSync as flush } from './reactivity/batch.js';
 export {

package/src/internal/client/reactivity/async.js

@@ -84,6 +84,14 @@ export function flatten(blockers, sync, async, fn) {
 	}
 }
 
+/**
+ * @param {Array<Promise<void>>} blockers
+ * @param {(values: Value[]) => any} fn
+ */
+export function run_after_blockers(blockers, fn) {
+	flatten(blockers, [], [], fn);
+}
+
 /**
  * Captures the current effect context so that we can restore it after
  * some asynchronous work has happened (so that e.g. `await a + b`

package/src/internal/client/reactivity/deriveds.js

@@ -9,15 +9,14 @@ import {
 	EFFECT_PRESERVED,
 	MAYBE_DIRTY,
 	STALE_REACTION,
-	UNOWNED,
 	ASYNC,
-	WAS_MARKED
+	WAS_MARKED,
+	CONNECTED
 } from '#client/constants';
 import {
 	active_reaction,
 	active_effect,
 	set_signal_status,
-	skip_reaction,
 	update_reaction,
 	increment_write_version,
 	set_active_effect,
@@ -27,7 +26,7 @@ import {
 import { equals, safe_equals } from './equality.js';
 import * as e from '../errors.js';
 import * as w from '../warnings.js';
-import { async_effect, destroy_effect, teardown } from './effects.js';
+import { async_effect, destroy_effect, effect_tracking, teardown } from './effects.js';
 import { eager_effects, internal_set, set_eager_effects, source } from './sources.js';
 import { get_stack } from '../dev/tracing.js';
 import { async_mode_flag, tracing_mode_flag } from '../../flags/index.js';
@@ -61,9 +60,7 @@ export function derived(fn) {
 			? /** @type {Derived} */ (active_reaction)
 			: null;
 
-	if (active_effect === null || (parent_derived !== null && (parent_derived.f & UNOWNED) !== 0)) {
-		flags |= UNOWNED;
-	} else {
+	if (active_effect !== null) {
 		// Since deriveds are evaluated lazily, any effects created inside them are
 		// created too late to ensure that the parent effect is added to the tree
 		active_effect.f |= EFFECT_PRESERVED;
@@ -368,12 +365,16 @@ export function update_derived(derived) {
 		return;
 	}
 
+	// During time traveling we don't want to reset the status so that
+	// traversal of the graph in the other batches still happens
 	if (batch_values !== null) {
-		batch_values.set(derived, derived.v);
+		// only cache the value if we're in a tracking context, otherwise we won't
+		// clear the cache in `mark_reactions` when dependencies are updated
+		if (effect_tracking()) {
+			batch_values.set(derived, derived.v);
+		}
 	} else {
-		var status =
-			(skip_reaction || (derived.f & UNOWNED) !== 0) && derived.deps !== null ? MAYBE_DIRTY : CLEAN;
-
+		var status = (derived.f & CONNECTED) === 0 ? MAYBE_DIRTY : CLEAN;
 		set_signal_status(derived, status);
 	}
 }

package/src/internal/client/reactivity/effects.js

@@ -25,7 +25,6 @@ import {
 	ROOT_EFFECT,
 	EFFECT_TRANSPARENT,
 	DERIVED,
-	UNOWNED,
 	CLEAN,
 	EAGER_EFFECT,
 	HEAD_EFFECT,
@@ -33,7 +32,8 @@ import {
 	EFFECT_PRESERVED,
 	STALE_REACTION,
 	USER_EFFECT,
-	ASYNC
+	ASYNC,
+	CONNECTED
 } from '#client/constants';
 import * as e from '../errors.js';
 import { DEV } from 'esm-env';
@@ -48,11 +48,11 @@ import { without_reactive_context } from '../dom/elements/bindings/shared.js';
  * @param {'$effect' | '$effect.pre' | '$inspect'} rune
  */
 export function validate_effect(rune) {
-	if (active_effect === null && active_reaction === null) {
-		e.effect_orphan(rune);
-	}
+	if (active_effect === null) {
+		if (active_reaction === null) {
+			e.effect_orphan(rune);
+		}
 
-	if (active_reaction !== null && (active_reaction.f & UNOWNED) !== 0 && active_effect === null) {
 		e.effect_in_unowned_derived();
 	}
 
@@ -103,7 +103,7 @@ function create_effect(type, fn, sync, push = true) {
 		deps: null,
 		nodes_start: null,
 		nodes_end: null,
-		f: type | DIRTY,
+		f: type | DIRTY | CONNECTED,
 		first: null,
 		fn,
 		last: null,

package/src/internal/client/reactivity/sources.js

@@ -23,18 +23,18 @@ import {
 	DIRTY,
 	BRANCH_EFFECT,
 	EAGER_EFFECT,
-	UNOWNED,
 	MAYBE_DIRTY,
 	BLOCK_EFFECT,
 	ROOT_EFFECT,
 	ASYNC,
-	WAS_MARKED
+	WAS_MARKED,
+	CONNECTED
 } from '#client/constants';
 import * as e from '../errors.js';
 import { legacy_mode_flag, tracing_mode_flag } from '../../flags/index.js';
 import { get_stack, tag_proxy } from '../dev/tracing.js';
 import { component_context, is_runes } from '../context.js';
-import { Batch, eager_block_effects, schedule_effect } from './batch.js';
+import { Batch, batch_values, eager_block_effects, schedule_effect } from './batch.js';
 import { proxy } from '../proxy.js';
 import { execute_derived } from './deriveds.js';
 
@@ -211,7 +211,8 @@ export function internal_set(source, value) {
 			if ((source.f & DIRTY) !== 0) {
 				execute_derived(/** @type {Derived} */ (source));
 			}
-			set_signal_status(source, (source.f & UNOWNED) === 0 ? CLEAN : MAYBE_DIRTY);
+
+			set_signal_status(source, (source.f & CONNECTED) !== 0 ? CLEAN : MAYBE_DIRTY);
 		}
 
 		source.wv = increment_write_version();
@@ -333,9 +334,17 @@ function mark_reactions(signal, status) {
 		}
 
 		if ((flags & DERIVED) !== 0) {
+			var derived = /** @type {Derived} */ (reaction);
+
+			batch_values?.delete(derived);
+
 			if ((flags & WAS_MARKED) === 0) {
-				reaction.f |= WAS_MARKED;
-				mark_reactions(/** @type {Derived} */ (reaction), MAYBE_DIRTY);
+				// Only connected deriveds can be reliably unmarked right away
+				if (flags & CONNECTED) {
+					reaction.f |= WAS_MARKED;
+				}
+
+				mark_reactions(derived, MAYBE_DIRTY);
 			}
 		} else if (not_dirty) {
 			if ((flags & BLOCK_EFFECT) !== 0) {