svelte-effect-runtime 2.3.1 → 2.4.1

package/.dist/chunks/{transform-B4g76Ur4.js → transform-s9gKPYu5.js}

@@ -4,9 +4,9 @@ import MagicString from "magic-string";
 import ts from "typescript";
 //#region src/markup/transform/constants.ts
 const HELPERS = {
-	value: "__ser_markup_value",
-	promise: "__ser_markup_promise",
-	run: "__ser_markup_run"
+	value: "__SER___markup_value",
+	promise: "__SER___markup_promise",
+	run: "__SER___markup_run"
 };
 //#endregion
 //#region src/markup/transform/apply.ts
@@ -24,11 +24,14 @@ function blank_script_blocks(content) {
 }
 function inject_helpers(magic, content, helpers = []) {
 	if (content.includes(HELPERS.value)) return;
+	const import_helpers = unique_import_helpers(helpers);
+	const local_helpers = helpers.filter((helper) => !is_import_helper(helper));
 	const helper_segments = [
 		`import { value as ${HELPERS.value} } from "svelte-effect-runtime/internal/generators";`,
 		`import { promise as ${HELPERS.promise} } from "svelte-effect-runtime/internal/generators";`,
 		`import { run as ${HELPERS.run} } from "svelte-effect-runtime/internal/generators";`,
-		...helpers
+		...import_helpers,
+		...local_helpers
 	].map((helper) => typeof helper === "string" ? { text: helper } : helper);
 	const helper_block = helper_segments.map((segment) => segment.text).join("\n");
 	const script_tag = find_instance_script_tag(content);
@@ -105,6 +108,18 @@ function find_instance_script_tag(content) {
 		};
 	}
 }
+function unique_import_helpers(helpers) {
+	const seen = /* @__PURE__ */ new Set();
+	return helpers.filter((helper) => {
+		if (!is_import_helper(helper)) return false;
+		if (seen.has(helper.text)) return false;
+		seen.add(helper.text);
+		return true;
+	});
+}
+function is_import_helper(helper) {
+	return helper.text.trimStart().startsWith("import ");
+}
 //#endregion
 //#region src/markup/transform/classify.ts
 /**
@@ -254,6 +269,149 @@ function is_record(value) {
 	return typeof value === "object" && value !== null;
 }
 //#endregion
+//#region src/markup/transform/effect-bindings.ts
+const EFFECT_PACKAGE_MODULE = "effect";
+const EFFECT_DIRECT_MODULE = "effect/Effect";
+const GENERATED_EFFECT_NAME = "__SER___Effect";
+/**
+* Collects Effect import bindings that markup callback rewriting can trust.
+*
+* @example
+* ```ts
+* const bindings = collect_effect_callback_bindings(
+*   `<script>import { Effect as E } from "effect";<\/script>`,
+* );
+* ```
+*
+* @since 2.4.0
+* @param content - Full Svelte component source before markup lowering.
+* @returns Binding metadata used to identify Effect callback combinators.
+*/
+function collect_effect_callback_bindings(content) {
+	const state = make_effect_binding_state();
+	const scripts = collect_script_blocks(content);
+	for (const script of scripts) collect_source_file_bindings(ts.createSourceFile("component-script.ts", script, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS), state);
+	ensure_implicit_effect_binding(state);
+	const wrapper = choose_effect_wrapper(state);
+	return {
+		effect_object_names: new Set(state.effect_object_names),
+		effect_module_names: new Set(state.effect_module_names),
+		effect_package_names: new Set(state.effect_package_names),
+		direct_members: new Map(state.direct_members),
+		wrapper_expression: wrapper.expression,
+		wrapper_import: wrapper.import_text ? { text: wrapper.import_text } : void 0
+	};
+}
+function make_effect_binding_state() {
+	return {
+		effect_object_names: [],
+		effect_module_names: [],
+		effect_package_names: [],
+		direct_members: /* @__PURE__ */ new Map(),
+		local_names: /* @__PURE__ */ new Set(),
+		implicit_effect_import: false
+	};
+}
+function collect_script_blocks(content) {
+	return [...content.matchAll(/<script\b[^>]*>([\s\S]*?)<\/script\s*>/gi)].map((match) => match[1] ?? "");
+}
+function collect_source_file_bindings(source_file, state) {
+	for (const statement of source_file.statements) collect_statement_binding(statement, state);
+}
+function collect_statement_binding(statement, state) {
+	if (ts.isImportDeclaration(statement)) {
+		collect_import_binding(statement, state);
+		return;
+	}
+	if (ts.isImportEqualsDeclaration(statement)) {
+		state.local_names.add(statement.name.text);
+		return;
+	}
+	if (ts.isVariableStatement(statement)) {
+		for (const declaration of statement.declarationList.declarations) collect_binding_name(declaration.name, state.local_names);
+		return;
+	}
+	if (ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement) || ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement) || ts.isEnumDeclaration(statement) || ts.isModuleDeclaration(statement)) {
+		if (statement.name) state.local_names.add(statement.name.text);
+	}
+}
+function collect_import_binding(statement, state) {
+	if (!ts.isStringLiteral(statement.moduleSpecifier)) return;
+	const module_name = statement.moduleSpecifier.text;
+	const clause = statement.importClause;
+	if (!clause) return;
+	if (clause.name) state.local_names.add(clause.name.text);
+	const named_bindings = clause.namedBindings;
+	if (!named_bindings) return;
+	if (ts.isNamespaceImport(named_bindings)) {
+		collect_namespace_import_binding(module_name, named_bindings.name.text, state);
+		return;
+	}
+	for (const element of named_bindings.elements) collect_named_import_binding(module_name, element, state);
+}
+function collect_namespace_import_binding(module_name, local_name, state) {
+	state.local_names.add(local_name);
+	if (module_name === EFFECT_DIRECT_MODULE) {
+		add_ordered_name(state.effect_module_names, local_name);
+		return;
+	}
+	if (module_name === EFFECT_PACKAGE_MODULE) add_ordered_name(state.effect_package_names, local_name);
+}
+function collect_named_import_binding(module_name, element, state) {
+	const imported_name = element.propertyName?.text ?? element.name.text;
+	const local_name = element.name.text;
+	state.local_names.add(local_name);
+	if (module_name === EFFECT_PACKAGE_MODULE && imported_name === "Effect") {
+		add_ordered_name(state.effect_object_names, local_name);
+		return;
+	}
+	if (module_name === EFFECT_DIRECT_MODULE) state.direct_members.set(local_name, imported_name);
+}
+function collect_binding_name(name, local_names) {
+	if (ts.isIdentifier(name)) {
+		local_names.add(name.text);
+		return;
+	}
+	for (const element of name.elements) {
+		if (ts.isOmittedExpression(element)) continue;
+		collect_binding_name(element.name, local_names);
+	}
+}
+function ensure_implicit_effect_binding(state) {
+	if (has_effect_binding(state) || state.local_names.has("Effect")) return;
+	add_ordered_name(state.effect_object_names, "Effect");
+	state.implicit_effect_import = true;
+}
+function has_effect_binding(state) {
+	return state.effect_object_names.length > 0 || state.effect_module_names.length > 0 || state.effect_package_names.length > 0 || state.direct_members.size > 0;
+}
+function choose_effect_wrapper(state) {
+	const effect_object = state.effect_object_names[0];
+	if (effect_object) return {
+		expression: effect_object,
+		import_text: state.implicit_effect_import ? `import { Effect } from "effect";` : void 0
+	};
+	const effect_module = state.effect_module_names[0];
+	if (effect_module) return { expression: effect_module };
+	const effect_package = state.effect_package_names[0];
+	if (effect_package) return { expression: `${effect_package}.Effect` };
+	const generated_name = make_generated_effect_name(state.local_names);
+	return {
+		expression: generated_name,
+		import_text: `import { Effect as ${generated_name} } from "effect";`
+	};
+}
+function make_generated_effect_name(local_names) {
+	if (!local_names.has(GENERATED_EFFECT_NAME)) return GENERATED_EFFECT_NAME;
+	let index = 1;
+	while (local_names.has(`${GENERATED_EFFECT_NAME}_${index}`)) index += 1;
+	return `${GENERATED_EFFECT_NAME}_${index}`;
+}
+function add_ordered_name(names, name) {
+	if (names.includes(name)) return;
+	names.push(name);
+}
+//#endregion
 //#region src/error.ts
 /**
 * Formats a runtime-owned error message with a stable screaming-case code.
@@ -483,7 +641,7 @@ function strip_arrow_function(expr) {
 * @returns Whether the expression parses as an arrow or function expression.
 */
 function is_callback_function_expression(expr) {
-	const wrapped = `const __ser_callback = ${expr};`;
+	const wrapped = `const __SER___callback = ${expr};`;
 	const stmt = ts.createSourceFile("callback.ts", wrapped, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS).statements[0];
 	if (!ts.isVariableStatement(stmt)) return false;
 	const initializer = stmt.declarationList.declarations[0]?.initializer;
@@ -504,7 +662,7 @@ function is_callback_function_expression(expr) {
 *   yield* appears inside a nested non-generator callback.
 */
 function analyze_event_body_yield_star(body) {
-	const wrapped = `function* __ser_event() { ${body}; }`;
+	const wrapped = `function* __SER___event() { ${body}; }`;
 	const stmt = ts.createSourceFile("event.ts", wrapped, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS).statements[0];
 	if (!ts.isFunctionDeclaration(stmt) || !stmt.body) return {
 		has_top_level_yield_star: false,
@@ -525,7 +683,7 @@ function analyze_event_body_yield_star(body) {
 * @returns Identifier names referenced by the expression.
 */
 function collect_free_identifiers(expr_text) {
-	const wrapped = `function* __w() { return (${expr_text}); }`;
+	const wrapped = `function* __SER___w() { return (${expr_text}); }`;
 	let sf;
 	try {
 		sf = ts.createSourceFile("expr.ts", wrapped, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
@@ -581,18 +739,249 @@ function is_property_access_name(node) {
 	return ts.isPropertyAccessExpression(parent) && parent.name === node || ts.isPropertyAssignment(parent) && parent.name === node || ts.isBindingElement(parent) && parent.propertyName === node || ts.isImportSpecifier(parent) || ts.isExportSpecifier(parent);
 }
 //#endregion
+//#region src/markup/transform/effect-callbacks.ts
+const MATCH_EFFECT_MEMBERS = new Map([["match", "matchEffect"], ["matchCause", "matchCauseEffect"]]);
+const EFFECTFUL_CALLBACK_MEMBERS = new Set([
+	"andThen",
+	"catchAll",
+	"catchAllCause",
+	"catchCause",
+	"catchTag",
+	"flatMap",
+	"forEach",
+	"tap",
+	"tapError",
+	"tapErrorCause"
+]);
+const EFFECTFUL_HANDLER_MEMBERS = new Set([
+	"matchCauseEffect",
+	"matchEffect",
+	"tapBoth"
+]);
+/**
+* Rewrites effectful callback shorthand inside event handler expressions.
+*
+* @example
+* ```ts
+* normalize_effect_callback_yields(
+*   `yield* action.pipe(Effect.flatMap((value) => yield* next(value)))`,
+*   collect_effect_callback_bindings(source),
+* );
+* ```
+*
+* @since 2.0.0
+* @param expr_text - Markup expression text before it is wrapped in the
+*   generated Effect runner.
+* @param bindings - Local Effect import bindings collected from the Svelte
+*   component's script blocks.
+* @returns The expression with nested Effect callback `yield*` shorthand
+*   lowered into explicit Effect callbacks, plus any import needed by generated
+*   wrapper calls.
+*/
+function normalize_effect_callback_yields(expr_text, bindings) {
+	const source_text = `const __SER___expression = ${expr_text};`;
+	const source_file = ts.createSourceFile("event-expression.ts", source_text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+	const statement = source_file.statements[0];
+	const magic = new MagicString(expr_text);
+	const context = {
+		source_file,
+		source_text,
+		magic,
+		offset: 27,
+		bindings,
+		changed: false,
+		uses_wrapper: false
+	};
+	if (!ts.isVariableStatement(statement)) return {
+		expr_text,
+		helpers: []
+	};
+	const expression = statement.declarationList.declarations[0]?.initializer;
+	if (!expression) return {
+		expr_text,
+		helpers: []
+	};
+	visit_expression(expression, context);
+	if (!context.changed) return {
+		expr_text,
+		helpers: []
+	};
+	const helpers = context.uses_wrapper && bindings.wrapper_import ? [bindings.wrapper_import] : [];
+	return {
+		expr_text: magic.toString(),
+		helpers
+	};
+}
+function visit_expression(node, context) {
+	if (is_non_generator_callback_with_top_level_yield(node)) return;
+	if (ts.isCallExpression(node)) {
+		rewrite_match_call(node, context);
+		rewrite_effectful_handler_call(node, context);
+		rewrite_effectful_callback_arguments(node, context);
+	}
+	node.forEachChild((child) => {
+		visit_expression(child, context);
+	});
+}
+function rewrite_match_call(call, context) {
+	const member = get_effect_member(call.expression, context);
+	const upgraded_name = member && MATCH_EFFECT_MEMBERS.get(member.name);
+	const options = get_last_object_argument(call);
+	if (!member || !upgraded_name || !options) return;
+	const handlers = get_handler_properties(options);
+	if (!handlers.some((handler) => handler.callback && is_non_generator_callback_with_top_level_yield(handler.callback))) return;
+	rewrite_effect_member_name(member, upgraded_name, context);
+	context.changed = true;
+	for (const handler of handlers) {
+		if (!handler.callback) continue;
+		if (is_non_generator_callback_with_top_level_yield(handler.callback)) rewrite_callback_to_effect_gen(handler.callback, context);
+		else rewrite_callback_to_effect_sync(handler.callback, context);
+	}
+}
+function rewrite_effectful_handler_call(call, context) {
+	const member = get_effect_member(call.expression, context);
+	const options = get_last_object_argument(call);
+	if (!member || !EFFECTFUL_HANDLER_MEMBERS.has(member.name) || !options) return;
+	for (const handler of get_handler_properties(options)) if (handler.callback && is_non_generator_callback_with_top_level_yield(handler.callback)) rewrite_callback_to_effect_gen(handler.callback, context);
+}
+function rewrite_effectful_callback_arguments(call, context) {
+	const member = get_effect_member(call.expression, context);
+	if (!member || !EFFECTFUL_CALLBACK_MEMBERS.has(member.name)) return;
+	for (const argument of call.arguments) if (is_callback_expression(argument) && is_non_generator_callback_with_top_level_yield(argument)) rewrite_callback_to_effect_gen(argument, context);
+}
+function rewrite_callback_to_effect_gen(callback, context) {
+	if (is_async_function(callback)) return;
+	if (ts.isArrowFunction(callback)) {
+		rewrite_arrow_callback(callback, "gen", context);
+		return;
+	}
+	rewrite_function_body(callback, "gen", context);
+}
+function rewrite_callback_to_effect_sync(callback, context) {
+	if (is_async_function(callback)) return;
+	if (ts.isArrowFunction(callback)) {
+		rewrite_arrow_callback(callback, "sync", context);
+		return;
+	}
+	rewrite_function_body(callback, "sync", context);
+}
+function rewrite_arrow_callback(callback, wrapper, context) {
+	const start = to_expr_pos(callback.getStart(context.source_file), context);
+	const end = to_expr_pos(callback.end, context);
+	const params_text = context.source_text.slice(callback.getStart(context.source_file), callback.equalsGreaterThanToken.getStart(context.source_file)).trim();
+	const body_text = get_body_text(callback.body, context);
+	const replacement = `${params_text} => ${make_effect_body(callback.body, body_text, wrapper, context)}`;
+	context.magic.overwrite(start, end, replacement);
+	context.changed = true;
+}
+function rewrite_function_body(callback, wrapper, context) {
+	const body_start = to_expr_pos(callback.body.getStart(context.source_file), context);
+	const body_end = to_expr_pos(callback.body.end, context);
+	const body_text = get_body_text(callback.body, context);
+	const rewritten_body = make_effect_body(callback.body, body_text, wrapper, context);
+	context.magic.overwrite(body_start, body_end, `{ return ${rewritten_body}; }`);
+	context.changed = true;
+}
+function make_effect_body(body, body_text, wrapper, context) {
+	const wrapper_access = make_effect_access(wrapper, context);
+	if (wrapper === "gen") {
+		if (ts.isBlock(body)) return `${wrapper_access}(function* () ${body_text})`;
+		return `${wrapper_access}(function* () { return (${body_text}); })`;
+	}
+	if (ts.isBlock(body)) return `${wrapper_access}(() => ${body_text})`;
+	return `${wrapper_access}(() => (${body_text}))`;
+}
+function get_body_text(body, context) {
+	return context.source_text.slice(body.getStart(context.source_file), body.end).trim();
+}
+function get_handler_properties(object_literal) {
+	return object_literal.properties.flatMap((property) => {
+		if (!ts.isPropertyAssignment(property)) return [];
+		const name = get_property_name(property.name);
+		if (name !== "onFailure" && name !== "onSuccess") return [];
+		return [{ callback: is_callback_expression(property.initializer) ? property.initializer : void 0 }];
+	});
+}
+function get_last_object_argument(call) {
+	const last_argument = call.arguments[call.arguments.length - 1];
+	if (!last_argument || !ts.isObjectLiteralExpression(last_argument)) return;
+	return last_argument;
+}
+function get_effect_member(expression, context) {
+	if (ts.isIdentifier(expression)) {
+		const direct_member = context.bindings.direct_members.get(expression.text);
+		if (!direct_member) return;
+		return {
+			name: direct_member,
+			name_start: to_expr_pos(expression.getStart(context.source_file), context),
+			name_end: to_expr_pos(expression.end, context),
+			direct: true
+		};
+	}
+	if (!ts.isPropertyAccessExpression(expression)) return;
+	if (!is_effect_namespace_expression(expression.expression, context)) return;
+	return {
+		name: expression.name.text,
+		name_start: to_expr_pos(expression.name.getStart(context.source_file), context),
+		name_end: to_expr_pos(expression.name.end, context),
+		direct: false
+	};
+}
+function rewrite_effect_member_name(member, upgraded_name, context) {
+	if (member.direct) {
+		context.magic.overwrite(member.name_start, member.name_end, make_effect_access(upgraded_name, context));
+		return;
+	}
+	context.magic.overwrite(member.name_start, member.name_end, upgraded_name);
+}
+function make_effect_access(member_name, context) {
+	context.uses_wrapper = true;
+	return `${context.bindings.wrapper_expression}.${member_name}`;
+}
+function is_effect_namespace_expression(expression, context) {
+	if (ts.isIdentifier(expression)) return context.bindings.effect_object_names.has(expression.text) || context.bindings.effect_module_names.has(expression.text);
+	if (!ts.isPropertyAccessExpression(expression)) return false;
+	if (expression.name.text !== "Effect") return false;
+	if (!ts.isIdentifier(expression.expression)) return false;
+	return context.bindings.effect_package_names.has(expression.expression.text);
+}
+function get_property_name(name) {
+	if (ts.isIdentifier(name) || ts.isStringLiteral(name)) return name.text;
+}
+function is_callback_expression(node) {
+	return ts.isArrowFunction(node) || ts.isFunctionExpression(node);
+}
+function is_non_generator_callback_with_top_level_yield(node) {
+	if (!is_callback_expression(node)) return false;
+	if (ts.isFunctionExpression(node) && node.asteriskToken) return false;
+	return contains_top_level_yield_star(node.body);
+}
+function is_async_function(node) {
+	return node.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+}
+function to_expr_pos(pos, context) {
+	return pos - context.offset;
+}
+//#endregion
 //#region src/markup/transform/emit.ts
 /**
 * Emits source edits for classified markup Effect expressions.
 *
 * @since 2.0.0
 * @param classified - Candidates paired with their Svelte markup context.
+* @param effect_context - Effect import bindings available to markup
+*   expression rewrites.
 * @returns Replacements ready to apply to the original component source.
 */
-function emit_replacements(classified) {
-	return classified.map(({ candidate, kind }) => emit_replacement(candidate, kind));
+function emit_replacements(classified, effect_context) {
+	return classified.map(({ candidate, kind }) => emit_replacement(candidate, kind, effect_context));
 }
-function emit_replacement(candidate, kind) {
+function emit_replacement(candidate, kind, effect_context) {
+	const normalized = normalize_effect_callback_yields(candidate.expr_text, effect_context);
+	const normalized_candidate = {
+		...candidate,
+		expr_text: normalized.expr_text
+	};
 	const id = make_cache_id(candidate);
 	const id_text = JSON.stringify(id);
 	const helper_name = make_helper_name(candidate);
@@ -600,29 +989,30 @@ function emit_replacement(candidate, kind) {
 	let helpers;
 	let relocation;
 	if (kind === "await") {
-		const effect = make_effect_helper(candidate, helper_name);
+		const effect = make_effect_helper(normalized_candidate, helper_name);
 		replacement_text = emit_promise_expression(id_text, effect);
-		helpers = [effect.helper];
+		helpers = [...normalized.helpers, effect.helper];
 	} else if (kind === "render") {
-		const effect = make_effect_helper(candidate, helper_name);
+		const effect = make_effect_helper(normalized_candidate, helper_name);
 		replacement_text = emit_render_expression(id_text, effect);
-		helpers = [effect.helper];
+		helpers = [...normalized.helpers, effect.helper];
 	} else if (kind === "each") {
-		const effect = make_effect_helper(candidate, helper_name);
+		const effect = make_effect_helper(normalized_candidate, helper_name);
 		replacement_text = emit_each_expression(id_text, effect);
-		helpers = [effect.helper];
+		helpers = [...normalized.helpers, effect.helper];
 	} else if (kind === "event") {
-		replacement_text = make_event_handler(candidate).text;
-		helpers = [];
+		const event = make_event_handler(normalized_candidate);
+		replacement_text = event.text;
+		helpers = normalized.helpers;
 		relocation = make_relocation(candidate, replacement_text, {
 			originalStart: 0,
 			originalEnd: candidate.expr_text.length,
-			generatedText: candidate.expr_text
+			generatedText: event.expr_text
 		});
 	} else {
-		const effect = make_effect_helper(candidate, helper_name);
+		const effect = make_effect_helper(normalized_candidate, helper_name);
 		replacement_text = emit_each_expression(id_text, effect);
-		helpers = [effect.helper];
+		helpers = [...normalized.helpers, effect.helper];
 	}
 	return {
 		start: candidate.start,
@@ -633,9 +1023,13 @@ function emit_replacement(candidate, kind) {
 	};
 }
 function make_event_handler(candidate) {
-	if (is_callback_function_expression(candidate.expr_text)) throw new YieldStarInEventCallbackError(candidate.filename, candidate.expr_text);
-	if (analyze_event_body_yield_star(candidate.expr_text).has_nested_invalid_yield_star) throw new AsyncEffectInEventCallbackError(candidate.filename, candidate.expr_text);
-	return { text: `(event) => { void ${HELPERS.run}(function* () { ${candidate.expr_text}; }); }` };
+	const expr_text = candidate.expr_text;
+	if (is_callback_function_expression(expr_text)) throw new YieldStarInEventCallbackError(candidate.filename, expr_text);
+	if (analyze_event_body_yield_star(expr_text).has_nested_invalid_yield_star) throw new AsyncEffectInEventCallbackError(candidate.filename, expr_text);
+	return {
+		expr_text,
+		text: `(event) => { ${HELPERS.run}(function* () { ${expr_text}; }); }`
+	};
 }
 function emit_promise_expression(id_text, effect) {
 	return `${HELPERS.promise}(${id_text}, ${effect.deps_text}, () => ${effect.call})`;
@@ -672,7 +1066,7 @@ function make_cache_id(candidate) {
 	return `${candidate.filename}:${candidate.start}:${candidate.end}`;
 }
 function make_helper_name(candidate) {
-	return `__ser_markup_effect_${candidate.start}_${candidate.end}`;
+	return `__SER___markup_effect_${candidate.start}_${candidate.end}`;
 }
 function make_relocation(candidate, replacement_text, inner) {
 	const generated_start = replacement_text.indexOf(inner.generatedText);
@@ -797,7 +1191,7 @@ function sanitize_markup(content, filename) {
 		const declaration_yields = collect_declaration_yield_expressions(content, open, leading_ws, trimmed);
 		if (declaration_yields.length > 0) {
 			for (const declaration_yield of declaration_yields) {
-				const placeholder = `__ser_markup_placeholder_${helper_index}`;
+				const placeholder = `__SER___markup_placeholder_${helper_index}`;
 				helper_index += 1;
 				candidates.push({
 					placeholder,
@@ -846,7 +1240,7 @@ function sanitize_markup(content, filename) {
 			continue;
 		}
 		/** Create a placeholder and replace the expression (preserving tag prefixes). */
-		const placeholder = `__ser_markup_placeholder_${helper_index}`;
+		const placeholder = `__SER___markup_placeholder_${helper_index}`;
 		helper_index += 1;
 		candidates.push({
 			placeholder,
@@ -1034,6 +1428,7 @@ function transform_markup_effect(content, filename) {
 	};
 	/** Find all brace expressions containing yield* and replace with placeholders. */
 	const work = sanitize_markup(content, filename);
+	const effect_context = collect_effect_callback_bindings(content);
 	if (work.candidates.length === 0) return {
 		code: content,
 		has_yield: false
@@ -1041,7 +1436,7 @@ function transform_markup_effect(content, filename) {
 	const replacements = emit_replacements(classify_candidates(parse(blank_script_blocks(work.code), {
 		filename,
 		modern: true
-	}), work.candidates));
+	}), work.candidates), effect_context);
 	const helpers = replacements.flatMap((replacement) => replacement.helpers ?? []);
 	const magic = new MagicString(content);
 	replacements.sort((a, b) => b.start - a.start);
@@ -1057,4 +1452,4 @@ function transform_markup_effect(content, filename) {
 //#endregion
 export { find_yield_star_node as a, AsyncEffectInSyncRuneError as c, extract_binding_names as i, AwaitInEffectWorkError as l, collect_yield_star_nodes as n, is_yield_star_expression as o, contains_top_level_await as r, collect_free_identifiers as s, transform_markup_effect as t };
 
-//# sourceMappingURL=transform-B4g76Ur4.js.map
+//# sourceMappingURL=transform-s9gKPYu5.js.map