@tsrx/core 0.1.24 → 0.1.25

package/src/transform/jsx/index.js

@@ -49,7 +49,6 @@ import {
 	create_style_ref_setup_statements,
 	get_style_element_stylesheet,
 } from '../style-ref.js';
-import { is_function_or_component_node } from '../../utils/ast.js';
 import {
 	is_interleaved_body as is_interleaved_body_core,
 	is_capturable_jsx_child,
@@ -57,10 +56,6 @@ import {
 } from '../jsx-interleave.js';
 import { is_hoist_safe_jsx_node } from '../jsx-hoist.js';
 
-const HOOK_OUTER_ASSIGNMENT_ERROR =
-	'Hook calls inside conditional or repeated TSRX scopes must keep their results local to the generated hook component.';
-const HOOK_CALLBACK_OUTER_MUTATION_ERROR =
-	'Hook callbacks inside conditional or repeated TSRX scopes must not mutate bindings declared outside the generated hook component.';
 const TEMPLATE_FRAGMENT_ERROR =
 	'JSX fragment syntax is not needed in TSRX templates. TSRX renders in immediate mode, so everything is already a fragment. Use `<>...</>` only in expression position.';
 const TSRX_FOR_RETURN_ERROR =
@@ -89,44 +84,6 @@ function report_jsx_fragment_in_tsrx_error(node, transform_context) {
 	);
 }
 
-/**
- * @param {AST.Node} node
- * @param {string[]} names
- * @param {string} hook_name
- * @param {TransformContext} transform_context
- * @returns {void}
- */
-function report_hook_outer_assignment_error(node, names, hook_name, transform_context) {
-	const target =
-		names.length === 1 ? `\`${names[0]}\`` : names.map((name) => `\`${name}\``).join(', ');
-	error(
-		`${HOOK_OUTER_ASSIGNMENT_ERROR} The ${hook_name} result is assigned to ${target}, which is declared outside that generated component. Declare the hook result inside the TSRX branch, or move the hook into an explicit child component and pass values with props.`,
-		transform_context.filename,
-		node,
-		transform_context.errors,
-		transform_context.comments,
-	);
-}
-
-/**
- * @param {AST.Node} node
- * @param {string[]} names
- * @param {string} hook_name
- * @param {TransformContext} transform_context
- * @returns {void}
- */
-function report_hook_callback_outer_mutation_error(node, names, hook_name, transform_context) {
-	const target =
-		names.length === 1 ? `\`${names[0]}\`` : names.map((name) => `\`${name}\``).join(', ');
-	error(
-		`${HOOK_CALLBACK_OUTER_MUTATION_ERROR} The ${hook_name} callback mutates ${target}. Read outer values through props or dependencies, and move mutable state into an explicit child component when it needs to change over time.`,
-		transform_context.filename,
-		node,
-		transform_context.errors,
-		transform_context.comments,
-	);
-}
-
 /**
  * Local alias for the shared `JsxTransformContext`. Kept as a typedef so the
  * rest of this file's `@param {TransformContext}` annotations don't all have
@@ -1038,1273 +995,898 @@ function is_interleaved_body(body_nodes) {
 }
 
 /**
- * @param {any} node
+ * @param {any[]} body_nodes
  * @param {TransformContext} transform_context
+ * @param {boolean} include_platform_setup
  * @returns {boolean}
  */
-function needs_hook_split(node, transform_context) {
-	const body = node.body?.body || [];
-	return (
-		transform_context.platform.hooks?.componentBodyHookHelpers === true &&
-		node.body?.type === 'BlockStatement' &&
-		(find_hook_split_index(body, transform_context) !== -1 ||
-			body_contains_component_body_branch_hook_return(body, transform_context))
+function body_contains_top_level_hook_call(
+	body_nodes,
+	transform_context,
+	include_platform_setup = false,
+) {
+	return body_nodes.some((node) =>
+		statement_contains_top_level_hook_call(node, transform_context, include_platform_setup),
 	);
 }
 
 /**
  * @param {any} node
  * @param {TransformContext} transform_context
- * @returns {any}
- */
-function create_hook_split_block(node, transform_context) {
-	if (
-		transform_context.platform.hooks?.componentBodyHookHelpers !== true ||
-		!should_extract_hook_helpers(transform_context) ||
-		node.body?.type !== 'BlockStatement'
-	) {
-		return null;
-	}
-
-	const source_body = node.body.body || [];
-	const branch_rewrite = rewrite_component_body_branch_hook_returns(source_body, transform_context);
-	const body = branch_rewrite.body;
-	const split_index = find_hook_split_index(body, transform_context);
-	if (split_index === -1 && !branch_rewrite.changed) {
-		return null;
-	}
-
-	let block_body;
-	if (split_index === -1) {
-		block_body = expand_native_tsrx_return_statement_list(body, transform_context);
-	} else {
-		const split_statement = body[split_index];
-		const continuation_body = body.slice(split_index + 1);
-		const helper = create_hook_safe_helper(
-			expand_native_tsrx_return_statement_list(continuation_body, transform_context),
-			undefined,
-			get_body_source_node(continuation_body) || split_statement,
-			transform_context,
-		);
-
-		block_body = [
-			...body.slice(0, split_index + 1),
-			...helper.setup_statements,
-			set_loc(b.return(helper.component_element), split_statement),
-		];
-	}
-
-	const block = b.block(block_body, node.body);
-	block.metadata = {
-		...(block.metadata || {}),
-		hook_split_block: true,
-	};
-	return block;
-}
-
-/**
- * @param {any[]} body_nodes
- * @param {TransformContext} transform_context
+ * @param {boolean} include_platform_setup
  * @returns {boolean}
  */
-function body_contains_component_body_branch_hook_return(body_nodes, transform_context) {
-	return body_nodes.some((node) =>
-		statement_contains_component_body_branch_hook_return(node, transform_context),
-	);
+function statement_contains_top_level_hook_call(node, transform_context, include_platform_setup) {
+	return node_contains_top_level_hook_call(node, false, transform_context, include_platform_setup);
 }
 
 /**
  * @param {any} node
+ * @param {boolean} inside_nested_function
  * @param {TransformContext} transform_context
+ * @param {boolean} include_platform_setup
  * @returns {boolean}
  */
-function statement_contains_component_body_branch_hook_return(node, transform_context) {
+function node_contains_top_level_hook_call(
+	node,
+	inside_nested_function,
+	transform_context,
+	include_platform_setup,
+) {
 	if (!node || typeof node !== 'object') {
 		return false;
 	}
 
-	if (Array.isArray(node)) {
-		return body_contains_component_body_branch_hook_return(node, transform_context);
+	if (
+		inside_nested_function &&
+		(node.type === 'FunctionDeclaration' ||
+			node.type === 'FunctionExpression' ||
+			node.type === 'ArrowFunctionExpression')
+	) {
+		return false;
 	}
 
-	if (is_function_or_class_boundary(node)) {
+	if (
+		node.type === 'FunctionDeclaration' ||
+		node.type === 'FunctionExpression' ||
+		node.type === 'ArrowFunctionExpression'
+	) {
+		const next_inside_nested_function = true;
+		for (const key of Object.keys(node)) {
+			if (key === 'loc' || key === 'start' || key === 'end' || key === 'metadata') {
+				continue;
+			}
+			if (
+				node_contains_top_level_hook_call(
+					node[key],
+					next_inside_nested_function,
+					transform_context,
+					include_platform_setup,
+				)
+			) {
+				return true;
+			}
+		}
 		return false;
 	}
 
-	if (is_plain_if_statement(node)) {
-		return (
-			branch_needs_component_body_hook_helper(node.consequent, transform_context) ||
-			statement_contains_component_body_branch_hook_return(node.consequent, transform_context) ||
-			branch_needs_component_body_hook_helper(node.alternate, transform_context) ||
-			statement_contains_component_body_branch_hook_return(node.alternate, transform_context)
+	if (
+		!inside_nested_function &&
+		node.type === 'CallExpression' &&
+		(is_hook_callee(node.callee) ||
+			(include_platform_setup &&
+				transform_context.platform.hooks?.isTopLevelSetupCall?.(node, transform_context) === true))
+	) {
+		return true;
+	}
+
+	if (Array.isArray(node)) {
+		return node.some((child) =>
+			node_contains_top_level_hook_call(
+				child,
+				inside_nested_function,
+				transform_context,
+				include_platform_setup,
+			),
 		);
 	}
 
-	if (node.type === 'BlockStatement') {
-		return body_contains_component_body_branch_hook_return(node.body || [], transform_context);
+	for (const key of Object.keys(node)) {
+		if (key === 'loc' || key === 'start' || key === 'end' || key === 'metadata') {
+			continue;
+		}
+		if (
+			node_contains_top_level_hook_call(
+				node[key],
+				inside_nested_function,
+				transform_context,
+				include_platform_setup,
+			)
+		) {
+			return true;
+		}
 	}
 
 	return false;
 }
 
 /**
- * @param {any[]} body_nodes
- * @param {TransformContext} transform_context
- * @returns {{ body: any[], changed: boolean }}
- */
-function rewrite_component_body_branch_hook_returns(body_nodes, transform_context) {
-	let changed = false;
-	const body = body_nodes.map((node) => {
-		const next_node = rewrite_component_body_branch_hook_return_statement(node, transform_context);
-		if (next_node !== node) {
-			changed = true;
-		}
-		return next_node;
-	});
-	return changed ? { body, changed } : { body: body_nodes, changed: false };
-}
-
-/**
- * @param {any} node
- * @param {TransformContext} transform_context
- * @returns {any}
+ * @param {any} callee
+ * @returns {boolean}
  */
-function rewrite_component_body_branch_hook_return_statement(node, transform_context) {
-	if (!node || typeof node !== 'object' || is_function_or_class_boundary(node)) {
-		return node;
-	}
-
-	if (is_plain_if_statement(node)) {
-		const consequent = rewrite_component_body_hook_return_branch(
-			node.consequent,
-			transform_context,
-		);
-		const alternate = node.alternate
-			? rewrite_component_body_hook_return_branch(node.alternate, transform_context)
-			: { node: node.alternate, changed: false };
+function is_hook_callee(callee) {
+	if (!callee) return false;
 
-		if (!consequent.changed && !alternate.changed) {
-			return node;
-		}
-		return set_loc(b.if(node.test, consequent.node, alternate.node), node);
+	if (callee.type === 'Identifier') {
+		return /^use[A-Z0-9]/.test(callee.name);
 	}
 
-	if (node.type === 'BlockStatement') {
-		const rewritten = rewrite_component_body_branch_hook_returns(
-			node.body || [],
-			transform_context,
-		);
-		return rewritten.changed ? set_loc(b.block(rewritten.body, node), node) : node;
+	if (
+		!callee.computed &&
+		callee.type === 'MemberExpression' &&
+		callee.property?.type === 'Identifier'
+	) {
+		return /^use[A-Z0-9]/.test(callee.property.name);
 	}
 
-	return node;
+	return false;
 }
 
 /**
- * @param {any} branch
- * @param {TransformContext} transform_context
- * @returns {{ node: any, changed: boolean }}
+ * @param {AST.Identifier[]} bindings
+ * @param {Set<string>} [mapped_bindings]
+ * @returns {AST.ObjectPattern}
  */
-function rewrite_component_body_hook_return_branch(branch, transform_context) {
-	if (!branch || typeof branch !== 'object') {
-		return { node: branch, changed: false };
-	}
+function create_helper_props_pattern(bindings, mapped_bindings = new Set()) {
+	return /** @type {any} */ ({
+		type: 'ObjectPattern',
+		properties: bindings.map((binding) =>
+			create_helper_props_property(binding, mapped_bindings.has(binding.name)),
+		),
+		metadata: { path: [] },
+	});
+}
 
-	if (is_plain_if_statement(branch)) {
-		const next_node = rewrite_component_body_branch_hook_return_statement(
-			branch,
-			transform_context,
-		);
-		return { node: next_node, changed: next_node !== branch };
-	}
+/**
+ * @param {AST.Identifier} binding
+ * @param {boolean} [map_binding]
+ * @returns {AST.Property}
+ */
+function create_helper_props_property(binding, map_binding = false) {
+	const key = map_binding ? clone_identifier(binding) : create_generated_identifier(binding.name);
+	const value = map_binding ? clone_identifier(binding) : create_generated_identifier(binding.name);
 
-	const branch_body = branch.type === 'BlockStatement' ? branch.body || [] : [branch];
-	const rewritten = rewrite_component_body_branch_hook_returns(branch_body, transform_context);
-	const body = rewritten.body;
-	const needs_helper = branch_needs_component_body_hook_helper_body(body, transform_context);
+	return b.prop('init', key, value, false, true);
+}
 
-	if (!needs_helper) {
-		if (!rewritten.changed) {
-			return { node: branch, changed: false };
-		}
-		const node =
-			branch.type === 'BlockStatement'
-				? set_loc(b.block(body, branch), branch)
-				: (body[0] ?? branch);
-		return { node, changed: true };
-	}
+/**
+ * @param {AST.Identifier} helper_id
+ * @param {AST.Identifier[]} bindings
+ * @param {any} source_node
+ * @param {{
+ * 	mapWrapper?: boolean,
+ * 	mapBindingNames?: boolean,
+ * 	mapBindingValues?: boolean,
+ * }} [mapping]
+ * @returns {ESTreeJSX.JSXElement}
+ */
+function create_helper_component_element(helper_id, bindings, source_node, mapping = {}) {
+	const { mapWrapper = true, mapBindingNames = true, mapBindingValues = true } = mapping;
+	const attributes = bindings.map((binding) =>
+		b.jsx_attribute(
+			identifier_to_jsx_name(
+				mapBindingNames ? clone_identifier(binding) : create_generated_identifier(binding.name),
+			),
+			to_jsx_expression_container(
+				mapBindingValues ? clone_identifier(binding) : create_generated_identifier(binding.name),
+				binding,
+			),
+		),
+	);
 
-	const helper_body = expand_native_tsrx_return_statement_list(body, transform_context);
-	const helper = create_hook_safe_helper(
-		helper_body,
-		undefined,
-		get_body_source_node(body) || branch,
-		transform_context,
+	const opening_element = b.jsx_opening_element(
+		identifier_to_jsx_name(clone_identifier(helper_id)),
+		attributes,
+		true,
 	);
-	const node = set_loc(
-		b.block([...helper.setup_statements, set_loc(b.return(helper.component_element), branch)]),
-		branch,
+	const element = b.jsx_element_fresh(
+		mapWrapper ? set_loc(opening_element, source_node) : opening_element,
 	);
-	return { node, changed: true };
+
+	return mapWrapper ? set_loc(element, source_node) : element;
 }
 
 /**
- * @param {any} branch
- * @param {TransformContext} transform_context
- * @returns {boolean}
+ * @param {{ base_name: string, next_id: number, helpers: any[], statics: any[] }} helper_state
+ * @param {string} suffix
+ * @returns {string}
  */
-function branch_needs_component_body_hook_helper(branch, transform_context) {
-	if (!branch || typeof branch !== 'object' || is_plain_if_statement(branch)) {
-		return false;
-	}
-	const body = branch.type === 'BlockStatement' ? branch.body || [] : [branch];
-	return branch_needs_component_body_hook_helper_body(body, transform_context);
+function create_helper_name(helper_state, suffix) {
+	helper_state.next_id += 1;
+	return `${helper_state.base_name}__${suffix}${helper_state.next_id}`;
 }
 
 /**
- * @param {any[]} body
- * @param {TransformContext} transform_context
- * @returns {boolean}
+ * @param {string} base_name
+ * @returns {{ base_name: string, next_id: number, helpers: any[], statics: any[] }}
  */
-function branch_needs_component_body_hook_helper_body(body, transform_context) {
-	return (
-		body_has_top_level_component_body_return(body) &&
-		body_contains_direct_top_level_hook_call(body, transform_context, true)
-	);
+function create_helper_state(base_name) {
+	return {
+		base_name,
+		next_id: 0,
+		helpers: [],
+		statics: [],
+	};
 }
 
 /**
- * @param {any[]} body
- * @returns {boolean}
+ * @param {{ helpers: any[], statics: any[] }} helper_state
+ * @returns {{ generated_helpers: any[], generated_statics: any[] } | null}
  */
-function body_has_top_level_component_body_return(body) {
-	return body.some((node) => node?.type === 'ReturnStatement');
+function create_generated_helper_metadata(helper_state) {
+	if (helper_state.helpers.length === 0 && helper_state.statics.length === 0) {
+		return null;
+	}
+	return {
+		generated_helpers: helper_state.helpers,
+		generated_statics: helper_state.statics,
+	};
 }
 
 /**
- * @param {any[]} body
- * @param {TransformContext} transform_context
- * @param {boolean} include_platform_setup
- * @returns {boolean}
+ * @param {any} metadata
+ * @returns {any}
  */
-function body_contains_direct_top_level_hook_call(body, transform_context, include_platform_setup) {
-	return body.some((node) =>
-		statement_contains_direct_top_level_hook_call(node, transform_context, include_platform_setup),
-	);
+function strip_function_transform_metadata(metadata) {
+	const { native_tsrx, ...next_metadata } = metadata || {};
+	return next_metadata;
 }
 
 /**
- * @param {any} node
- * @param {TransformContext} transform_context
- * @param {boolean} include_platform_setup
- * @returns {boolean}
+ * @param {AST.BlockStatement} node
+ * @param {{ next: () => any, visit: (node: any, state?: TransformContext) => any, state: TransformContext, path: AST.Node[] }} context
+ * @returns {any}
  */
-function statement_contains_direct_top_level_hook_call(
-	node,
-	transform_context,
-	include_platform_setup,
-) {
-	if (!node || typeof node !== 'object') {
-		return false;
-	}
-
-	if (is_function_or_class_boundary(node)) {
-		return false;
+function transform_block_statement(node, { next, visit, state, path }) {
+	if (node.metadata?.native_return_block) {
+		return next() ?? node;
 	}
 
-	if (
-		is_plain_if_statement(node) ||
-		is_switch_control_node(node) ||
-		is_try_control_node(node) ||
-		is_for_of_control_node(node)
-	) {
-		return false;
+	if (get_active_native_tsrx_function(path)?.metadata?.native_tsrx_body) {
+		const block = create_native_tsrx_statement_list_block(node, state);
+		if (block) {
+			return visit(block, state);
+		}
 	}
 
-	return statement_contains_top_level_hook_call(node, transform_context, include_platform_setup);
+	return next() ?? node;
 }
 
 /**
- * @param {any[]} body_nodes
- * @param {TransformContext} transform_context
- * @returns {number}
+ * @param {any} node
+ * @param {{ next: () => any, visit: (node: any, state?: TransformContext) => any, state: TransformContext, path: AST.Node[] }} context
+ * @returns {any}
  */
-function find_hook_split_index(body_nodes, transform_context) {
-	for (let i = 0; i < body_nodes.length; i += 1) {
-		if (!is_component_body_conditional_return_statement(body_nodes[i])) {
-			continue;
-		}
-
-		if (body_contains_top_level_hook_call(body_nodes.slice(i + 1), transform_context, true)) {
-			return i;
+function transform_return_statement(node, { next, visit, state, path }) {
+	const active_native_tsrx_function = get_active_native_tsrx_function(path);
+	if (active_native_tsrx_function && is_native_tsrx_node(node.argument)) {
+		if (!active_native_tsrx_function.metadata?.native_tsrx_body) {
+			const statements = mark_native_pretransformed_jsx(
+				create_native_tsrx_render_statements(node.argument, state),
+			);
+			if (statements.length === 1) {
+				return visit(statements[0], state);
+			}
+			const block = b.block(statements, node.argument);
+			block.metadata = {
+				...(block.metadata || {}),
+				native_return_block: true,
+			};
+			return visit(block, state);
 		}
+		return visit(create_native_tsrx_render_block(node.argument, state), state);
 	}
 
-	return -1;
+	return next() ?? node;
 }
 
 /**
  * @param {any} node
- * @returns {boolean}
+ * @param {{ state: TransformContext, path: AST.Node[] }} context
+ * @returns {any}
  */
-function is_component_body_conditional_return_statement(node) {
-	if (!is_if_control_node(node)) {
-		return false;
+function transform_jsx_code_block(node, { state, path }) {
+	const body_nodes = get_jsx_code_block_body_nodes(node, state);
+	const parent = /** @type {any} */ (path.at(-1));
+
+	if (parent && parent.body === node && is_function_or_class_boundary(parent)) {
+		const block = b.block(
+			mark_native_pretransformed_jsx(build_render_statements(body_nodes, true, state)),
+			node,
+		);
+		block.metadata = {
+			...(block.metadata || {}),
+			native_return_block: true,
+		};
+		return block;
 	}
 
-	return (
-		statement_contains_component_body_return(node.consequent) ||
-		statement_contains_component_body_return(node.alternate)
+	const expression = b.call(
+		b.arrow([], b.block(build_render_statements(body_nodes, true, state), node)),
 	);
+
+	return in_jsx_child_context(path) ? to_jsx_expression_container(expression, node) : expression;
 }
 
 /**
- * @param {any} node
- * @returns {boolean}
+ * @param {AST.Node[]} path
+ * @returns {any | null}
  */
-function statement_contains_component_body_return(node) {
-	if (!node || typeof node !== 'object') {
-		return false;
-	}
-
-	if (node.type === 'ReturnStatement') {
-		return true;
+function get_active_native_tsrx_function(path) {
+	for (let i = path.length - 1; i >= 0; i -= 1) {
+		const node = /** @type {any} */ (path[i]);
+		if (is_function_or_class_boundary(node)) {
+			return node.metadata?.native_tsrx ? node : null;
+		}
 	}
+	return null;
+}
 
-	if (is_function_or_class_boundary(node)) {
-		return false;
-	}
+/**
+ * @param {any} node
+ * @param {{ next: () => any, state: TransformContext, path: AST.Node[] }} context
+ * @returns {any}
+ */
+function transform_function(node, context) {
+	// Lower a `@{ … }` function body (JSXCodeBlock) to an ordinary block: the
+	// setup statements followed by `return <render>` when the block produces a
+	// render output. The parser already marks the render JSX as native_tsrx, so
+	// from here it flows through the existing native-component machinery exactly
+	// like the older fenced `{ return <> … </> }` shape.
+	const has_jsx_code_block_body = node.body?.type === 'JSXCodeBlock';
+	lower_jsx_code_block_function_body(node);
 
-	if (Array.isArray(node)) {
-		return node.some(statement_contains_component_body_return);
+	if (
+		has_jsx_code_block_body ||
+		node.metadata?.native_tsrx_function ||
+		function_has_native_tsrx_return(node)
+	) {
+		return transform_native_tsrx_function(node, context, {
+			nativeBody: has_jsx_code_block_body || !!node.metadata?.native_tsrx_function,
+		});
 	}
 
-	if (node.type === 'BlockStatement') {
-		return (node.body || []).some(statement_contains_component_body_return);
-	}
+	return transform_function_with_hook_helpers(node, context);
+}
 
-	if (is_if_control_node(node)) {
-		return (
-			statement_contains_component_body_return(node.consequent) ||
-			statement_contains_component_body_return(node.alternate)
-		);
-	}
+/**
+ * @param {any} node
+ * @returns {void}
+ */
+function lower_jsx_code_block_function_body(node) {
+	if (node.body?.type !== 'JSXCodeBlock') return;
 
-	if (is_switch_control_node(node)) {
-		return (node.cases || []).some((/** @type {any} */ switch_case) =>
-			statement_contains_component_body_return(switch_case.consequent || []),
-		);
+	const code_block = node.body;
+	const statements = [...code_block.body];
+	if (code_block.render != null) {
+		let render = code_block.render;
+		if (!is_native_tsrx_node(render)) {
+			// A control-flow output (@if/@for/@switch/@try) isn't itself a native
+			// template node, so `return @if (…) { … }` wouldn't be recognized as a
+			// component render output. Wrap it in a native fragment so it flows
+			// through the same children-rendering path as a `<> … </>` render.
+			const fragment = b.jsx_fragment([render]);
+			fragment.metadata = { ...fragment.metadata, native_tsrx: true };
+			render = fragment;
+		}
+		statements.push(b.return(render, code_block.render));
 	}
-
-	if (is_try_control_node(node)) {
-		return (
-			statement_contains_component_body_return(node.block) ||
-			statement_contains_component_body_return(node.handler?.body) ||
-			statement_contains_component_body_return(node.finalizer)
-		);
+	node.body = b.block(statements, code_block);
+	if (node.type === 'ArrowFunctionExpression') {
+		node.expression = false;
 	}
-
-	return false;
 }
 
 /**
- * @param {any[]} body_nodes
- * @param {TransformContext} transform_context
- * @param {boolean} include_platform_setup
- * @returns {boolean}
+ * @param {any} node
+ * @param {{ next: () => any, state: TransformContext }} context
+ * @param {{ nativeBody?: boolean }} [options]
+ * @returns {any}
  */
-function body_contains_top_level_hook_call(
-	body_nodes,
-	transform_context,
-	include_platform_setup = false,
-) {
-	return body_nodes.some((node) =>
-		statement_contains_top_level_hook_call(node, transform_context, include_platform_setup),
+function transform_native_tsrx_function(node, { next, state }, { nativeBody = false } = {}) {
+	const helper_state =
+		state.helper_state || create_helper_state(get_function_helper_base_name(node));
+	const saved_helper_state = state.helper_state;
+	const saved_bindings = state.available_bindings;
+	const saved_hook_helpers_enabled = state.hook_helpers_enabled;
+
+	state.helper_state = helper_state;
+	state.hook_helpers_enabled = is_uppercase_function_like(node);
+	node.metadata = {
+		...(node.metadata || {}),
+		native_tsrx: true,
+		...(nativeBody ? { native_tsrx_body: true } : {}),
+	};
+	state.available_bindings = merge_binding_maps(
+		saved_bindings,
+		collect_function_scope_bindings(node),
 	);
-}
 
-/**
- * @param {any} node
- * @param {TransformContext} transform_context
- * @param {boolean} include_platform_setup
- * @returns {boolean}
- */
-function statement_contains_top_level_hook_call(node, transform_context, include_platform_setup) {
-	return node_contains_top_level_hook_call(node, false, transform_context, include_platform_setup);
+	validate_native_await(node, state);
+
+	const inner = /** @type {any} */ (next() ?? node);
+	if (
+		inner !== node &&
+		node.type === 'ArrowFunctionExpression' &&
+		is_native_tsrx_node(node.body) &&
+		inner.body?.type === 'BlockStatement'
+	) {
+		inner.expression = false;
+	}
+
+	state.helper_state = saved_helper_state;
+	state.available_bindings = saved_bindings;
+	state.hook_helpers_enabled = saved_hook_helpers_enabled;
+
+	inner.metadata = {
+		...strip_function_transform_metadata(inner.metadata),
+		native_tsrx_function: true,
+		...(nativeBody ? { native_tsrx_body: true } : {}),
+		...(!saved_helper_state ? create_generated_helper_metadata(helper_state) || {} : {}),
+	};
+
+	return inner;
 }
 
 /**
  * @param {any} node
- * @param {boolean} inside_nested_function
  * @param {TransformContext} transform_context
- * @param {boolean} include_platform_setup
- * @returns {boolean}
+ * @returns {void}
  */
-function node_contains_top_level_hook_call(
-	node,
-	inside_nested_function,
-	transform_context,
-	include_platform_setup,
-) {
-	if (!node || typeof node !== 'object') {
-		return false;
+function validate_native_await(node, transform_context) {
+	const await_node = find_native_await(node);
+	if (!await_node) {
+		return;
 	}
 
-	if (
-		inside_nested_function &&
-		(node.type === 'FunctionDeclaration' ||
-			node.type === 'FunctionExpression' ||
-			node.type === 'ArrowFunctionExpression')
-	) {
-		return false;
+	const validator = transform_context.platform.hooks?.validateComponentAwait;
+	if (validator) {
+		validator(await_node, node, transform_context, false, transform_context.source || '');
+		return;
 	}
 
-	if (
-		node.type === 'FunctionDeclaration' ||
-		node.type === 'FunctionExpression' ||
-		node.type === 'ArrowFunctionExpression'
-	) {
-		const next_inside_nested_function = true;
-		for (const key of Object.keys(node)) {
-			if (key === 'loc' || key === 'start' || key === 'end' || key === 'metadata') {
-				continue;
-			}
-			if (
-				node_contains_top_level_hook_call(
-					node[key],
-					next_inside_nested_function,
-					transform_context,
-					include_platform_setup,
-				)
-			) {
-				return true;
-			}
-		}
-		return false;
+	if (transform_context.platform.validation.requireUseServerForAwait) {
+		error(
+			'Top-level `await` in TSRX functions requires a module-level `"use server"` directive.',
+			transform_context.filename,
+			await_node,
+			transform_context.errors,
+			transform_context.comments,
+		);
 	}
+}
 
+/**
+ * @param {any} node
+ * @returns {any | null}
+ */
+function find_native_await(node) {
 	if (
-		!inside_nested_function &&
-		node.type === 'CallExpression' &&
-		(is_hook_callee(node.callee) ||
-			(include_platform_setup &&
-				transform_context.platform.hooks?.isTopLevelSetupCall?.(node, transform_context) === true))
+		node.type === 'ArrowFunctionExpression' &&
+		node.body?.type !== 'BlockStatement' &&
+		node_contains_native_tsrx_template(node.body)
 	) {
-		return true;
+		return find_first_top_level_await(node.body, false);
 	}
 
-	if (Array.isArray(node)) {
-		return node.some((child) =>
-			node_contains_top_level_hook_call(
-				child,
-				inside_nested_function,
-				transform_context,
-				include_platform_setup,
-			),
-		);
+	if (node.body?.type === 'JSXCodeBlock') {
+		return find_native_await_in_list(get_raw_jsx_code_block_body_nodes(node.body));
 	}
 
-	for (const key of Object.keys(node)) {
-		if (key === 'loc' || key === 'start' || key === 'end' || key === 'metadata') {
-			continue;
-		}
-		if (
-			node_contains_top_level_hook_call(
-				node[key],
-				inside_nested_function,
-				transform_context,
-				include_platform_setup,
-			)
-		) {
-			return true;
-		}
-	}
+	const body = node.body?.type === 'BlockStatement' ? node.body.body || [] : [];
+	return find_native_await_in_list(body);
+}
 
-	return false;
+/**
+ * @param {any[]} statements
+ * @returns {any | null}
+ */
+function find_native_await_in_list(statements) {
+	for (const statement of statements) {
+		const found = find_native_await_in_statement(statement);
+		if (found) return found;
+	}
+	return null;
 }
 
 /**
- * @param {any} callee
- * @returns {boolean}
+ * @param {any} statement
+ * @returns {any | null}
  */
-function is_hook_callee(callee) {
-	if (!callee) return false;
+function find_native_await_in_statement(statement) {
+	if (!statement || typeof statement !== 'object') return null;
 
-	if (callee.type === 'Identifier') {
-		return /^use[A-Z0-9]/.test(callee.name);
+	if (statement.type === 'ReturnStatement' && is_native_tsrx_node(statement.argument)) {
+		return find_first_top_level_await_in_tsrx_function_body(statement.argument.children || []);
 	}
 
 	if (
-		!callee.computed &&
-		callee.type === 'MemberExpression' &&
-		callee.property?.type === 'Identifier'
+		statement.type === 'ReturnStatement' &&
+		node_contains_native_tsrx_template(statement.argument)
 	) {
-		return /^use[A-Z0-9]/.test(callee.property.name);
+		return find_first_top_level_await(statement.argument, false);
 	}
 
-	return false;
-}
+	if (is_function_or_class_boundary(statement)) {
+		return null;
+	}
 
-/**
- * @param {AST.Identifier[]} bindings
- * @param {Set<string>} [mapped_bindings]
- * @returns {AST.ObjectPattern}
- */
-function create_helper_props_pattern(bindings, mapped_bindings = new Set()) {
-	return /** @type {any} */ ({
-		type: 'ObjectPattern',
-		properties: bindings.map((binding) =>
-			create_helper_props_property(binding, mapped_bindings.has(binding.name)),
-		),
-		metadata: { path: [] },
-	});
-}
+	if (statement.type === 'BlockStatement') {
+		return find_native_await_in_list(statement.body || []);
+	}
 
-/**
- * @param {AST.Identifier} binding
- * @param {boolean} [map_binding]
- * @returns {AST.Property}
- */
-function create_helper_props_property(binding, map_binding = false) {
-	const key = map_binding ? clone_identifier(binding) : create_generated_identifier(binding.name);
-	const value = map_binding ? clone_identifier(binding) : create_generated_identifier(binding.name);
+	if (is_if_control_node(statement)) {
+		return (
+			find_native_await_in_statement(statement.consequent) ||
+			find_native_await_in_statement(statement.alternate)
+		);
+	}
 
-	return b.prop('init', key, value, false, true);
+	if (is_switch_control_node(statement)) {
+		for (const switch_case of statement.cases || []) {
+			const found = find_native_await_in_list(switch_case.consequent || []);
+			if (found) return found;
+		}
+		return null;
+	}
+
+	if (is_try_control_node(statement)) {
+		return (
+			find_native_await_in_statement(statement.block) ||
+			find_native_await_in_statement(statement.handler?.body) ||
+			find_native_await_in_statement(statement.finalizer)
+		);
+	}
+
+	return find_first_top_level_await(statement, false);
 }
 
 /**
- * @param {AST.Identifier} helper_id
- * @param {AST.Identifier[]} bindings
- * @param {any} source_node
- * @param {{
- * 	mapWrapper?: boolean,
- * 	mapBindingNames?: boolean,
- * 	mapBindingValues?: boolean,
- * }} [mapping]
- * @returns {ESTreeJSX.JSXElement}
+ * @param {any} node
+ * @param {{ next: () => any, state: TransformContext }} context
+ * @returns {any}
  */
-function create_helper_component_element(helper_id, bindings, source_node, mapping = {}) {
-	const { mapWrapper = true, mapBindingNames = true, mapBindingValues = true } = mapping;
-	const attributes = bindings.map((binding) =>
-		b.jsx_attribute(
-			identifier_to_jsx_name(
-				mapBindingNames ? clone_identifier(binding) : create_generated_identifier(binding.name),
-			),
-			to_jsx_expression_container(
-				mapBindingValues ? clone_identifier(binding) : create_generated_identifier(binding.name),
-				binding,
-			),
-		),
-	);
+function transform_function_with_hook_helpers(node, { next, state }) {
+	if (!state.platform.hooks?.moduleScopedHookComponents) {
+		return next() ?? node;
+	}
 
-	const opening_element = b.jsx_opening_element(
-		identifier_to_jsx_name(clone_identifier(helper_id)),
-		attributes,
-		true,
-	);
-	const element = b.jsx_element_fresh(
-		mapWrapper ? set_loc(opening_element, source_node) : opening_element,
-	);
+	const has_hook_bearing_tsrx = function_contains_hook_bearing_tsrx(node, state);
+	if (state.helper_state || !is_uppercase_function_like(node) || !has_hook_bearing_tsrx) {
+		return next() ?? node;
+	}
 
-	return mapWrapper ? set_loc(element, source_node) : element;
+	const helper_state = create_helper_state(get_function_helper_base_name(node));
+	const saved_helper_state = state.helper_state;
+	const saved_bindings = state.available_bindings;
+	const saved_hook_helpers_enabled = state.hook_helpers_enabled;
+
+	state.helper_state = helper_state;
+	state.hook_helpers_enabled = true;
+	state.available_bindings = collect_function_scope_bindings(node);
+
+	const inner = /** @type {any} */ (next() ?? node);
+
+	state.helper_state = saved_helper_state;
+	state.available_bindings = saved_bindings;
+	state.hook_helpers_enabled = saved_hook_helpers_enabled;
+
+	inner.metadata = {
+		...strip_function_transform_metadata(inner.metadata),
+		...(create_generated_helper_metadata(helper_state) || {}),
+	};
+
+	return inner;
 }
 
 /**
- * @param {{ base_name: string, next_id: number, helpers: any[], statics: any[] }} helper_state
- * @param {string} suffix
+ * @param {any} node
  * @returns {string}
  */
-function create_helper_name(helper_state, suffix) {
-	helper_state.next_id += 1;
-	return `${helper_state.base_name}__${suffix}${helper_state.next_id}`;
+function get_function_helper_base_name(node) {
+	return get_function_like_name(node) || 'TSRXTemplate';
 }
 
 /**
- * @param {string} base_name
- * @returns {{ base_name: string, next_id: number, helpers: any[], statics: any[] }}
+ * @param {any} node
+ * @returns {boolean}
  */
-function create_helper_state(base_name) {
-	return {
-		base_name,
-		next_id: 0,
-		helpers: [],
-		statics: [],
-	};
+function is_uppercase_function_like(node) {
+	const name = get_function_like_name(node);
+	return !!(name && /^[A-Z]/.test(name));
 }
 
 /**
- * @param {{ helpers: any[], statics: any[] }} helper_state
- * @returns {{ generated_helpers: any[], generated_statics: any[] } | null}
+ * @param {any} node
+ * @returns {string | null}
  */
-function create_generated_helper_metadata(helper_state) {
-	if (helper_state.helpers.length === 0 && helper_state.statics.length === 0) {
-		return null;
+function get_function_like_name(node) {
+	if (node.id?.type === 'Identifier') {
+		return node.id.name;
 	}
-	return {
-		generated_helpers: helper_state.helpers,
-		generated_statics: helper_state.statics,
-	};
-}
 
-/**
- * @param {any} metadata
- * @returns {any}
- */
-function strip_function_transform_metadata(metadata) {
-	const { native_tsrx, hook_split, ...next_metadata } = metadata || {};
-	return next_metadata;
-}
+	const parent = /** @type {any} */ (node.metadata?.path?.at(-1));
+	if (!parent) return null;
 
-/**
- * @param {AST.BlockStatement} node
- * @param {{ next: () => any, visit: (node: any, state?: TransformContext) => any, state: TransformContext, path: AST.Node[] }} context
- * @returns {any}
- */
-function transform_block_statement(node, { next, visit, state, path }) {
-	if (node.metadata?.hook_split_block || node.metadata?.native_return_block) {
-		return next() ?? node;
+	if (parent.type === 'VariableDeclarator' && parent.init === node) {
+		return get_static_binding_name(parent.id);
 	}
 
-	const parent = /** @type {any} */ (path.at(-1));
-	if (parent?.metadata?.hook_split && parent.body === node) {
-		const block = create_hook_split_block(parent, state);
-		if (block) {
-			return visit(block, state);
-		}
+	if (parent.type === 'Property' && parent.value === node) {
+		return get_static_property_name(parent.key);
 	}
 
-	if (get_active_native_tsrx_function(path)?.metadata?.native_tsrx_body) {
-		const block = create_native_tsrx_statement_list_block(node, state);
-		if (block) {
-			return visit(block, state);
-		}
+	if (parent.type === 'MethodDefinition' && parent.value === node) {
+		return get_static_property_name(parent.key);
 	}
 
-	return next() ?? node;
+	if (parent.type === 'AssignmentExpression' && parent.right === node) {
+		return get_static_binding_name(parent.left);
+	}
+
+	return null;
 }
 
 /**
  * @param {any} node
- * @param {{ next: () => any, visit: (node: any, state?: TransformContext) => any, state: TransformContext, path: AST.Node[] }} context
- * @returns {any}
+ * @returns {string | null}
  */
-function transform_return_statement(node, { next, visit, state, path }) {
-	const active_native_tsrx_function = get_active_native_tsrx_function(path);
-	if (active_native_tsrx_function && is_native_tsrx_node(node.argument)) {
-		if (!active_native_tsrx_function.metadata?.native_tsrx_body) {
-			const statements = mark_native_pretransformed_jsx(
-				create_native_tsrx_render_statements(node.argument, state),
-			);
-			if (statements.length === 1) {
-				return visit(statements[0], state);
-			}
-			const block = b.block(statements, node.argument);
-			block.metadata = {
-				...(block.metadata || {}),
-				native_return_block: true,
-			};
-			return visit(block, state);
-		}
-		return visit(create_native_tsrx_render_block(node.argument, state), state);
+function get_static_binding_name(node) {
+	if (node?.type === 'Identifier') {
+		return node.name;
 	}
-
-	return next() ?? node;
+	if (node?.type === 'MemberExpression' && !node.computed) {
+		return get_static_property_name(node.property);
+	}
+	return null;
 }
 
 /**
- * @param {any} node
- * @param {{ state: TransformContext, path: AST.Node[] }} context
- * @returns {any}
+ * @param {any} key
+ * @returns {string | null}
  */
-function transform_jsx_code_block(node, { state, path }) {
-	const body_nodes = get_jsx_code_block_body_nodes(node, state);
-	const parent = /** @type {any} */ (path.at(-1));
-
-	if (parent && parent.body === node && is_function_or_class_boundary(parent)) {
-		const block = b.block(
-			mark_native_pretransformed_jsx(build_render_statements(body_nodes, true, state)),
-			node,
-		);
-		block.metadata = {
-			...(block.metadata || {}),
-			native_return_block: true,
-		};
-		return block;
+function get_static_property_name(key) {
+	if (key?.type === 'Identifier') {
+		return key.name;
 	}
-
-	const expression = b.call(
-		b.arrow([], b.block(build_render_statements(body_nodes, true, state), node)),
-	);
-
-	return in_jsx_child_context(path) ? to_jsx_expression_container(expression, node) : expression;
+	if (key?.type === 'Literal' && typeof key.value === 'string') {
+		return key.value;
+	}
+	return null;
 }
 
 /**
- * @param {AST.Node[]} path
- * @returns {any | null}
+ * @param {any} node
+ * @returns {Map<string, AST.Identifier>}
  */
-function get_active_native_tsrx_function(path) {
-	for (let i = path.length - 1; i >= 0; i -= 1) {
-		const node = /** @type {any} */ (path[i]);
-		if (is_function_or_class_boundary(node)) {
-			return node.metadata?.native_tsrx ? node : null;
+function collect_function_scope_bindings(node) {
+	const bindings = collect_param_bindings(node.params || []);
+	if (node.body?.type === 'BlockStatement') {
+		for (const statement of node.body.body || []) {
+			if (statement.type === 'ReturnStatement' && is_native_tsrx_node(statement.argument)) {
+				for (const child of get_tsrx_render_children(statement.argument)) {
+					collect_statement_bindings(child, bindings);
+				}
+			} else {
+				collect_statement_bindings(statement, bindings);
+			}
 		}
 	}
-	return null;
+	return bindings;
 }
 
 /**
- * @param {any} node
- * @param {{ next: () => any, state: TransformContext, path: AST.Node[] }} context
- * @returns {any}
+ * @param {Map<string, AST.Identifier>} outer
+ * @param {Map<string, AST.Identifier>} inner
+ * @returns {Map<string, AST.Identifier>}
  */
-function transform_function(node, context) {
-	// Lower a `@{ … }` function body (JSXCodeBlock) to an ordinary block: the
-	// setup statements followed by `return <render>` when the block produces a
-	// render output. The parser already marks the render JSX as native_tsrx, so
-	// from here it flows through the existing native-component machinery exactly
-	// like the older fenced `{ return <> … </> }` shape.
-	const has_jsx_code_block_body = node.body?.type === 'JSXCodeBlock';
-	lower_jsx_code_block_function_body(node);
-
-	if (
-		has_jsx_code_block_body ||
-		node.metadata?.native_tsrx_function ||
-		function_has_native_tsrx_return(node)
-	) {
-		return transform_native_tsrx_function(node, context, {
-			nativeBody: has_jsx_code_block_body || !!node.metadata?.native_tsrx_function,
-		});
+function merge_binding_maps(outer, inner) {
+	const merged = new Map(outer);
+	for (const [name, binding] of inner) {
+		merged.set(name, binding);
 	}
-
-	return transform_function_with_hook_helpers(node, context);
+	return merged;
 }
 
 /**
  * @param {any} node
- * @returns {void}
+ * @returns {boolean}
  */
-function lower_jsx_code_block_function_body(node) {
-	if (node.body?.type !== 'JSXCodeBlock') return;
+function function_has_native_tsrx_return(node) {
+	if (!node) return false;
 
-	const code_block = node.body;
-	const statements = [...code_block.body];
-	if (code_block.render != null) {
-		let render = code_block.render;
-		if (!is_native_tsrx_node(render)) {
-			// A control-flow output (@if/@for/@switch/@try) isn't itself a native
-			// template node, so `return @if (…) { … }` wouldn't be recognized as a
-			// component render output. Wrap it in a native fragment so it flows
-			// through the same children-rendering path as a `<> … </>` render.
-			const fragment = b.jsx_fragment([render]);
-			fragment.metadata = { ...fragment.metadata, native_tsrx: true };
-			render = fragment;
-		}
-		statements.push(b.return(render, code_block.render));
+	if (node.body?.type === 'JSXCodeBlock') {
+		return true;
 	}
-	node.body = b.block(statements, code_block);
-	if (node.type === 'ArrowFunctionExpression') {
-		node.expression = false;
+
+	if (node.type === 'ArrowFunctionExpression' && node.body?.type !== 'BlockStatement') {
+		return node_contains_native_tsrx_template(node.body);
 	}
+
+	const body = node.body?.type === 'BlockStatement' ? node.body.body : [];
+	return statements_contain_native_tsrx_return(body);
 }
 
 /**
- * @param {any} node
- * @param {{ next: () => any, state: TransformContext }} context
- * @param {{ nativeBody?: boolean }} [options]
- * @returns {any}
+ * @param {any[]} statements
+ * @returns {boolean}
  */
-function transform_native_tsrx_function(node, { next, state }, { nativeBody = false } = {}) {
-	const helper_state =
-		state.helper_state || create_helper_state(get_function_helper_base_name(node));
-	const saved_helper_state = state.helper_state;
-	const saved_bindings = state.available_bindings;
-	const saved_hook_helpers_enabled = state.hook_helpers_enabled;
+function statements_contain_native_tsrx_return(statements) {
+	return statements.some((statement) => statement_contains_native_tsrx_return(statement));
+}
 
-	state.helper_state = helper_state;
-	state.hook_helpers_enabled = is_uppercase_function_like(node);
-	node.metadata = {
-		...(node.metadata || {}),
-		native_tsrx: true,
-		...(nativeBody ? { native_tsrx_body: true } : {}),
-		...(nativeBody && needs_hook_split(node, state) ? { hook_split: true } : {}),
-	};
-	state.available_bindings = merge_binding_maps(
-		saved_bindings,
-		collect_function_scope_bindings(node),
-	);
+/**
+ * @param {any} statement
+ * @returns {boolean}
+ */
+function statement_contains_native_tsrx_return(statement) {
+	if (!statement || typeof statement !== 'object') return false;
 
-	validate_native_await(node, state);
+	if (statement.type === 'ReturnStatement') {
+		return node_contains_native_tsrx_template(statement.argument);
+	}
 
-	const inner = /** @type {any} */ (next() ?? node);
-	if (
-		inner !== node &&
-		node.type === 'ArrowFunctionExpression' &&
-		is_native_tsrx_node(node.body) &&
-		inner.body?.type === 'BlockStatement'
-	) {
-		inner.expression = false;
+	if (is_function_or_class_boundary(statement)) {
+		return false;
 	}
 
-	state.helper_state = saved_helper_state;
-	state.available_bindings = saved_bindings;
-	state.hook_helpers_enabled = saved_hook_helpers_enabled;
-
-	inner.metadata = {
-		...strip_function_transform_metadata(inner.metadata),
-		native_tsrx_function: true,
-		...(nativeBody ? { native_tsrx_body: true } : {}),
-		...(!saved_helper_state ? create_generated_helper_metadata(helper_state) || {} : {}),
-	};
-
-	return inner;
-}
-
-/**
- * @param {any} node
- * @param {TransformContext} transform_context
- * @returns {void}
- */
-function validate_native_await(node, transform_context) {
-	const await_node = find_native_await(node);
-	if (!await_node) {
-		return;
+	if (statement.type === 'BlockStatement') {
+		return statements_contain_native_tsrx_return(statement.body || []);
 	}
 
-	const validator = transform_context.platform.hooks?.validateComponentAwait;
-	if (validator) {
-		validator(await_node, node, transform_context, false, transform_context.source || '');
-		return;
+	if (is_if_control_node(statement)) {
+		return (
+			statement_contains_native_tsrx_return(statement.consequent) ||
+			statement_contains_native_tsrx_return(statement.alternate)
+		);
 	}
 
-	if (transform_context.platform.validation.requireUseServerForAwait) {
-		error(
-			'Top-level `await` in TSRX functions requires a module-level `"use server"` directive.',
-			transform_context.filename,
-			await_node,
-			transform_context.errors,
-			transform_context.comments,
+	if (is_switch_control_node(statement)) {
+		return (statement.cases || []).some((/** @type {any} */ c) =>
+			statements_contain_native_tsrx_return(c.consequent || []),
 		);
 	}
-}
 
-/**
- * @param {any} node
- * @returns {any | null}
- */
-function find_native_await(node) {
-	if (
-		node.type === 'ArrowFunctionExpression' &&
-		node.body?.type !== 'BlockStatement' &&
-		node_contains_native_tsrx_template(node.body)
-	) {
-		return find_first_top_level_await(node.body, false);
+	if (is_try_control_node(statement)) {
+		return (
+			statement_contains_native_tsrx_return(statement.block) ||
+			statement_contains_native_tsrx_return(statement.pending) ||
+			statement_contains_native_tsrx_return(statement.handler?.body) ||
+			statement_contains_native_tsrx_return(statement.finalizer)
+		);
 	}
 
-	if (node.body?.type === 'JSXCodeBlock') {
-		return find_native_await_in_list(get_raw_jsx_code_block_body_nodes(node.body));
+	for (const key of Object.keys(statement)) {
+		if (key === 'loc' || key === 'start' || key === 'end' || key === 'metadata') {
+			continue;
+		}
+		const value = statement[key];
+		if (Array.isArray(value)) {
+			if (statements_contain_native_tsrx_return(value)) return true;
+		} else if (statement_contains_native_tsrx_return(value)) {
+			return true;
+		}
 	}
 
-	const body = node.body?.type === 'BlockStatement' ? node.body.body || [] : [];
-	return find_native_await_in_list(body);
-}
-
-/**
- * @param {any[]} statements
- * @returns {any | null}
- */
-function find_native_await_in_list(statements) {
-	for (const statement of statements) {
-		const found = find_native_await_in_statement(statement);
-		if (found) return found;
-	}
-	return null;
+	return false;
 }
 
 /**
- * @param {any} statement
- * @returns {any | null}
+ * @param {any} node
+ * @returns {boolean}
  */
-function find_native_await_in_statement(statement) {
-	if (!statement || typeof statement !== 'object') return null;
-
-	if (statement.type === 'ReturnStatement' && is_native_tsrx_node(statement.argument)) {
-		return find_first_top_level_await_in_tsrx_function_body(statement.argument.children || []);
-	}
-
-	if (
-		statement.type === 'ReturnStatement' &&
-		node_contains_native_tsrx_template(statement.argument)
-	) {
-		return find_first_top_level_await(statement.argument, false);
-	}
-
-	if (is_function_or_class_boundary(statement)) {
-		return null;
-	}
+function node_contains_native_tsrx_template(node) {
+	if (!node || typeof node !== 'object') return false;
+	if (is_native_tsrx_node(node)) return true;
 
-	if (statement.type === 'BlockStatement') {
-		return find_native_await_in_list(statement.body || []);
+	if (is_function_or_class_boundary(node)) {
+		return false;
 	}
 
-	if (is_if_control_node(statement)) {
-		return (
-			find_native_await_in_statement(statement.consequent) ||
-			find_native_await_in_statement(statement.alternate)
-		);
+	if (Array.isArray(node)) {
+		return node.some(node_contains_native_tsrx_template);
 	}
 
-	if (is_switch_control_node(statement)) {
-		for (const switch_case of statement.cases || []) {
-			const found = find_native_await_in_list(switch_case.consequent || []);
-			if (found) return found;
+	for (const key of Object.keys(node)) {
+		if (key === 'loc' || key === 'start' || key === 'end' || key === 'metadata') {
+			continue;
+		}
+		if (node_contains_native_tsrx_template(node[key])) {
+			return true;
 		}
-		return null;
-	}
-
-	if (is_try_control_node(statement)) {
-		return (
-			find_native_await_in_statement(statement.block) ||
-			find_native_await_in_statement(statement.handler?.body) ||
-			find_native_await_in_statement(statement.finalizer)
-		);
 	}
 
-	return find_first_top_level_await(statement, false);
+	return false;
 }
 
 /**
  * @param {any} node
- * @param {{ next: () => any, state: TransformContext }} context
  * @returns {any}
  */
-function transform_function_with_hook_helpers(node, { next, state }) {
-	const has_hook_bearing_tsrx = function_contains_hook_bearing_tsrx(node, state);
-	if (state.helper_state || !is_uppercase_function_like(node) || !has_hook_bearing_tsrx) {
-		return next() ?? node;
-	}
-
-	const helper_state = create_helper_state(get_function_helper_base_name(node));
-	const saved_helper_state = state.helper_state;
-	const saved_bindings = state.available_bindings;
-	const saved_hook_helpers_enabled = state.hook_helpers_enabled;
-
-	state.helper_state = helper_state;
-	state.hook_helpers_enabled = true;
-	state.available_bindings = collect_function_scope_bindings(node);
-
-	const inner = /** @type {any} */ (next() ?? node);
-
-	state.helper_state = saved_helper_state;
-	state.available_bindings = saved_bindings;
-	state.hook_helpers_enabled = saved_hook_helpers_enabled;
+function collect_tsrx_stylesheet(node) {
+	/** @type {any[]} */
+	const styles = [];
+	collect_style_elements(node.children || [], styles);
 
-	inner.metadata = {
-		...strip_function_transform_metadata(inner.metadata),
-		...(create_generated_helper_metadata(helper_state) || {}),
-	};
+	if (styles.length === 0) return null;
+	if (styles.length > 1) {
+		throw new Error('TSRX fragments can only have one style tag');
+	}
 
-	return inner;
+	return styles[0];
 }
 
 /**
  * @param {any} node
- * @returns {string}
+ * @param {TransformContext} transform_context
+ * @returns {{ css: any, style_refs: any[], fragment: any } | null}
  */
-function get_function_helper_base_name(node) {
-	return get_function_like_name(node) || 'TSRXTemplate';
+function prepare_tsrx_fragment_styles(node, transform_context) {
+	const css = collect_tsrx_stylesheet(node);
+	if (!css) return null;
+
+	const style_refs = collect_style_ref_attributes(node);
+	apply_css_definition_metadata(node, css, transform_context, style_refs.length > 0);
+	transform_context.stylesheets.push(css);
+	const fragment = annotate_tsrx_with_hash(
+		node,
+		css.hash,
+		transform_context.platform.jsx.classAttrName ??
+			(transform_context.platform.jsx.rewriteClassAttr ? 'className' : 'class'),
+		transform_context.typeOnly,
+	);
+	return { css, style_refs, fragment };
 }
 
 /**
+ * @template T
  * @param {any} node
- * @returns {boolean}
+ * @param {TransformContext} transform_context
+ * @param {(style_context: { css: any, style_refs: any[], fragment: any } | null) => T} callback
+ * @returns {T}
  */
-function is_uppercase_function_like(node) {
-	const name = get_function_like_name(node);
-	return !!(name && /^[A-Z]/.test(name));
+function with_tsrx_fragment_styles(node, transform_context, callback) {
+	const style_context = prepare_tsrx_fragment_styles(node, transform_context);
+	return callback(style_context);
 }
 
 /**
- * @param {any} node
- * @returns {string | null}
+ * @param {any} fragment
+ * @param {{ css: any, style_refs: any[], fragment: any } | null} style_context
+ * @param {TransformContext} transform_context
+ * @returns {AST.Statement[]}
  */
-function get_function_like_name(node) {
-	if (node.id?.type === 'Identifier') {
-		return node.id.name;
-	}
-
-	const parent = /** @type {any} */ (node.metadata?.path?.at(-1));
-	if (!parent) return null;
-
-	if (parent.type === 'VariableDeclarator' && parent.init === node) {
-		return get_static_binding_name(parent.id);
-	}
-
-	if (parent.type === 'Property' && parent.value === node) {
-		return get_static_property_name(parent.key);
-	}
-
-	if (parent.type === 'MethodDefinition' && parent.value === node) {
-		return get_static_property_name(parent.key);
-	}
-
-	if (parent.type === 'AssignmentExpression' && parent.right === node) {
-		return get_static_binding_name(parent.left);
+function create_tsrx_style_ref_setup_statements(fragment, style_context, transform_context) {
+	if (!style_context || style_context.style_refs.length === 0) {
+		return [];
 	}
 
-	return null;
+	return create_style_ref_setup_statements(
+		style_context.style_refs,
+		create_style_class_map(fragment, style_context.css),
+		{
+			allowMutableRefTarget: transform_context.platform.jsx.multiRefStrategy === 'array',
+			createTempIdentifier: () =>
+				create_generated_identifier(create_style_ref_temp_name(transform_context)),
+		},
+	);
 }
 
 /**
  * @param {any} node
- * @returns {string | null}
- */
-function get_static_binding_name(node) {
-	if (node?.type === 'Identifier') {
-		return node.name;
-	}
-	if (node?.type === 'MemberExpression' && !node.computed) {
-		return get_static_property_name(node.property);
-	}
-	return null;
-}
-
-/**
- * @param {any} key
- * @returns {string | null}
- */
-function get_static_property_name(key) {
-	if (key?.type === 'Identifier') {
-		return key.name;
-	}
-	if (key?.type === 'Literal' && typeof key.value === 'string') {
-		return key.value;
-	}
-	return null;
-}
-
-/**
- * @param {any} node
- * @returns {Map<string, AST.Identifier>}
- */
-function collect_function_scope_bindings(node) {
-	const bindings = collect_param_bindings(node.params || []);
-	if (node.body?.type === 'BlockStatement') {
-		for (const statement of node.body.body || []) {
-			if (statement.type === 'ReturnStatement' && is_native_tsrx_node(statement.argument)) {
-				for (const child of get_tsrx_render_children(statement.argument)) {
-					collect_statement_bindings(child, bindings);
-				}
-			} else {
-				collect_statement_bindings(statement, bindings);
-			}
-		}
-	}
-	return bindings;
-}
-
-/**
- * @param {Map<string, AST.Identifier>} outer
- * @param {Map<string, AST.Identifier>} inner
- * @returns {Map<string, AST.Identifier>}
- */
-function merge_binding_maps(outer, inner) {
-	const merged = new Map(outer);
-	for (const [name, binding] of inner) {
-		merged.set(name, binding);
-	}
-	return merged;
-}
-
-/**
- * @param {any} node
- * @returns {boolean}
- */
-function function_has_native_tsrx_return(node) {
-	if (!node) return false;
-
-	if (node.body?.type === 'JSXCodeBlock') {
-		return true;
-	}
-
-	if (node.type === 'ArrowFunctionExpression' && node.body?.type !== 'BlockStatement') {
-		return node_contains_native_tsrx_template(node.body);
-	}
-
-	const body = node.body?.type === 'BlockStatement' ? node.body.body : [];
-	return statements_contain_native_tsrx_return(body);
-}
-
-/**
- * @param {any[]} statements
- * @returns {boolean}
- */
-function statements_contain_native_tsrx_return(statements) {
-	return statements.some((statement) => statement_contains_native_tsrx_return(statement));
-}
-
-/**
- * @param {any} statement
- * @returns {boolean}
- */
-function statement_contains_native_tsrx_return(statement) {
-	if (!statement || typeof statement !== 'object') return false;
-
-	if (statement.type === 'ReturnStatement') {
-		return node_contains_native_tsrx_template(statement.argument);
-	}
-
-	if (is_function_or_class_boundary(statement)) {
-		return false;
-	}
-
-	if (statement.type === 'BlockStatement') {
-		return statements_contain_native_tsrx_return(statement.body || []);
-	}
-
-	if (is_if_control_node(statement)) {
-		return (
-			statement_contains_native_tsrx_return(statement.consequent) ||
-			statement_contains_native_tsrx_return(statement.alternate)
-		);
-	}
-
-	if (is_switch_control_node(statement)) {
-		return (statement.cases || []).some((/** @type {any} */ c) =>
-			statements_contain_native_tsrx_return(c.consequent || []),
-		);
-	}
-
-	if (is_try_control_node(statement)) {
-		return (
-			statement_contains_native_tsrx_return(statement.block) ||
-			statement_contains_native_tsrx_return(statement.pending) ||
-			statement_contains_native_tsrx_return(statement.handler?.body) ||
-			statement_contains_native_tsrx_return(statement.finalizer)
-		);
-	}
-
-	for (const key of Object.keys(statement)) {
-		if (key === 'loc' || key === 'start' || key === 'end' || key === 'metadata') {
-			continue;
-		}
-		const value = statement[key];
-		if (Array.isArray(value)) {
-			if (statements_contain_native_tsrx_return(value)) return true;
-		} else if (statement_contains_native_tsrx_return(value)) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
-/**
- * @param {any} node
- * @returns {boolean}
- */
-function node_contains_native_tsrx_template(node) {
-	if (!node || typeof node !== 'object') return false;
-	if (is_native_tsrx_node(node)) return true;
-
-	if (is_function_or_class_boundary(node)) {
-		return false;
-	}
-
-	if (Array.isArray(node)) {
-		return node.some(node_contains_native_tsrx_template);
-	}
-
-	for (const key of Object.keys(node)) {
-		if (key === 'loc' || key === 'start' || key === 'end' || key === 'metadata') {
-			continue;
-		}
-		if (node_contains_native_tsrx_template(node[key])) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
-/**
- * @param {any} node
- * @returns {any}
- */
-function collect_tsrx_stylesheet(node) {
-	/** @type {any[]} */
-	const styles = [];
-	collect_style_elements(node.children || [], styles);
-
-	if (styles.length === 0) return null;
-	if (styles.length > 1) {
-		throw new Error('TSRX fragments can only have one style tag');
-	}
-
-	return styles[0];
-}
-
-/**
- * @param {any} node
- * @param {TransformContext} transform_context
- * @returns {{ css: any, style_refs: any[], fragment: any } | null}
- */
-function prepare_tsrx_fragment_styles(node, transform_context) {
-	const css = collect_tsrx_stylesheet(node);
-	if (!css) return null;
-
-	const style_refs = collect_style_ref_attributes(node);
-	apply_css_definition_metadata(node, css, transform_context, style_refs.length > 0);
-	transform_context.stylesheets.push(css);
-	const fragment = annotate_tsrx_with_hash(
-		node,
-		css.hash,
-		transform_context.platform.jsx.classAttrName ??
-			(transform_context.platform.jsx.rewriteClassAttr ? 'className' : 'class'),
-		transform_context.typeOnly,
-	);
-	return { css, style_refs, fragment };
-}
-
-/**
- * @template T
- * @param {any} node
- * @param {TransformContext} transform_context
- * @param {(style_context: { css: any, style_refs: any[], fragment: any } | null) => T} callback
- * @returns {T}
- */
-function with_tsrx_fragment_styles(node, transform_context, callback) {
-	const style_context = prepare_tsrx_fragment_styles(node, transform_context);
-	return callback(style_context);
-}
-
-/**
- * @param {any} fragment
- * @param {{ css: any, style_refs: any[], fragment: any } | null} style_context
- * @param {TransformContext} transform_context
- * @returns {AST.Statement[]}
- */
-function create_tsrx_style_ref_setup_statements(fragment, style_context, transform_context) {
-	if (!style_context || style_context.style_refs.length === 0) {
-		return [];
-	}
-
-	return create_style_ref_setup_statements(
-		style_context.style_refs,
-		create_style_class_map(fragment, style_context.css),
-		{
-			allowMutableRefTarget: transform_context.platform.jsx.multiRefStrategy === 'array',
-			createTempIdentifier: () =>
-				create_generated_identifier(create_style_ref_temp_name(transform_context)),
-		},
-	);
-}
-
-/**
- * @param {any} node
- * @param {any} stylesheet
- * @param {TransformContext} transform_context
- * @returns {AST.Expression}
+ * @param {any} stylesheet
+ * @param {TransformContext} transform_context
+ * @returns {AST.Expression}
  */
 function create_style_expression_value(node, stylesheet, transform_context) {
 	const class_map = create_style_class_map_from_stylesheet(stylesheet);
@@ -2844,7 +2426,10 @@ function should_use_module_scoped_hook_components(transform_context) {
  * @returns {boolean}
  */
 function should_extract_hook_helpers(transform_context) {
-	return !!transform_context.hook_helpers_enabled;
+	return !!(
+		transform_context.hook_helpers_enabled &&
+		transform_context.platform.hooks?.moduleScopedHookComponents
+	);
 }
 
 /**
@@ -3406,11 +2991,6 @@ function build_hoisted_for_of_with_hooks(node, transform_context) {
 	for (const param of loop_params) {
 		collect_pattern_bindings(param, transform_context.available_bindings);
 	}
-	validate_hook_safe_body_does_not_assign_hook_results_to_outer_bindings(
-		original_loop_body,
-		transform_context,
-		loop_scoped_names,
-	);
 
 	const all_helper_bindings = get_referenced_helper_bindings(
 		original_loop_body,
@@ -3695,659 +3275,54 @@ function to_jsx_element(
 }
 
 /**
- * @param {any[]} children
- * @param {TransformContext} transform_context
- * @returns {any[]}
- */
-
-function create_element_children(children, transform_context) {
-	if (children.length === 0) {
-		return [];
-	}
-
-	if (children.every(is_inline_element_child) && !children_contain_return_semantics(children)) {
-		const saved_inside_element_child = transform_context.inside_element_child;
-		transform_context.inside_element_child = true;
-		try {
-			return children.map((/** @type {any} */ child) => to_jsx_child(child, transform_context));
-		} finally {
-			transform_context.inside_element_child = saved_inside_element_child;
-		}
-	}
-
-	const saved_inside_element_child = transform_context.inside_element_child;
-	transform_context.inside_element_child = true;
-	try {
-		return [statement_body_to_jsx_child(children, transform_context)];
-	} finally {
-		transform_context.inside_element_child = saved_inside_element_child;
-	}
-}
-
-/**
- * @param {any[]} children
- * @returns {boolean}
- */
-function children_contain_return_semantics(children) {
-	return children.some(child_contains_return_semantics);
-}
-
-/**
- * @param {any} node
- * @returns {boolean}
- */
-function child_contains_return_semantics(node) {
-	if (!node || typeof node !== 'object') {
-		return false;
-	}
-
-	if (node.type === 'ReturnStatement') {
-		return true;
-	}
-
-	if (
-		node.type === 'FunctionDeclaration' ||
-		node.type === 'FunctionExpression' ||
-		node.type === 'ArrowFunctionExpression'
-	) {
-		return false;
-	}
-
-	if (Array.isArray(node)) {
-		return node.some(child_contains_return_semantics);
-	}
-
-	for (const key of Object.keys(node)) {
-		if (key === 'loc' || key === 'start' || key === 'end' || key === 'metadata') {
-			continue;
-		}
-		if (child_contains_return_semantics(node[key])) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
-/**
- * @param {any} node
- * @returns {boolean}
- */
-function is_inline_element_child(node) {
-	return node && is_render_child_node(node);
-}
-
-/**
- * @param {any[]} body_nodes
- * @param {TransformContext} transform_context
- * @returns {ESTreeJSX.JSXExpressionContainer}
- */
-function statement_body_to_jsx_child(body_nodes, transform_context) {
-	if (
-		should_extract_hook_helpers(transform_context) &&
-		body_contains_top_level_hook_call(body_nodes, transform_context, true)
-	) {
-		return hook_safe_statement_body_to_jsx_child(body_nodes, transform_context);
-	}
-
-	return to_jsx_expression_container(
-		b.call(b.arrow([], b.block(build_render_statements(body_nodes, true, transform_context)))),
-	);
-}
-
-/**
- * @param {any[]} body_nodes
- * @param {TransformContext} transform_context
- * @returns {ESTreeJSX.JSXExpressionContainer}
- */
-function hook_safe_statement_body_to_jsx_child(body_nodes, transform_context) {
-	const source_node = get_body_source_node(body_nodes);
-	const helper = create_hook_safe_helper(body_nodes, undefined, source_node, transform_context);
-
-	return to_jsx_expression_container(
-		create_hook_safe_helper_iife(helper.setup_statements, helper.component_element),
-		source_node,
-	);
-}
-
-/**
- * @param {TransformContext} transform_context
- * @returns {string}
- */
-function create_local_statement_component_name(transform_context) {
-	transform_context.local_statement_component_index += 1;
-	return `StatementBodyHook${transform_context.local_statement_component_index}`;
-}
-
-/**
- * Wraps a list of body nodes into a component and returns
- * statements that return `<ComponentName prop1={prop1} ... />`.
- * Targets can either emit the helper component at module scope or cache the
- * component identity in module state while initializing it from the parent.
- * Used when a control flow branch contains hook calls that must be moved
- * into their own component boundary to satisfy the Rules of Hooks.
- *
- * @param {any[]} body_nodes
- * @param {any} key_expression - Optional key expression to add to the component element (for for-of loops)
- * @param {TransformContext} transform_context
- * @returns {any[]}
- */
-function hook_safe_render_statements(body_nodes, key_expression, transform_context) {
-	const source_node = get_body_source_node(body_nodes);
-	const helper = create_hook_safe_helper(
-		body_nodes,
-		key_expression,
-		source_node,
-		transform_context,
-	);
-	const statements = [...helper.setup_statements];
-
-	statements.push(b.return(helper.component_element));
-
-	return statements;
-}
-
-/**
- * @param {any[]} body_nodes
- * @param {Map<string, AST.Identifier>} available_bindings
- * @returns {AST.Identifier[]}
- */
-function get_referenced_helper_bindings(body_nodes, available_bindings) {
-	const helper_bindings = [];
-	const local_bindings = new Map();
-
-	for (const node of body_nodes) {
-		collect_statement_bindings(node, local_bindings);
-	}
-
-	for (const [name, binding] of available_bindings) {
-		if (local_bindings.has(name)) continue;
-
-		if (references_scope_bindings(body_nodes, new Map([[name, binding]]))) {
-			helper_bindings.push(binding);
-		}
-	}
-
-	return helper_bindings;
-}
-
-/**
- * @param {any[]} body_nodes
- * @param {TransformContext} transform_context
- * @param {Set<string>} [local_binding_names]
- * @returns {void}
- */
-function validate_hook_safe_body_does_not_assign_hook_results_to_outer_bindings(
-	body_nodes,
-	transform_context,
-	local_binding_names,
-) {
-	if (!is_react_like_hook_platform(transform_context)) {
-		return;
-	}
-	if (!body_contains_top_level_hook_call(body_nodes, transform_context, true)) {
-		return;
-	}
-	if (!transform_context.available_bindings || transform_context.available_bindings.size === 0) {
-		return;
-	}
-
-	const shadowed_names = collect_block_binding_names(body_nodes);
-	for (const name of local_binding_names || []) {
-		shadowed_names.add(name);
-	}
-	validate_hook_outer_assignments_in_node(body_nodes, shadowed_names, transform_context, new Set());
-}
-
-/**
- * @param {TransformContext} transform_context
- * @returns {boolean}
- */
-function is_react_like_hook_platform(transform_context) {
-	return (
-		transform_context.platform.name === 'React' || transform_context.platform.name === 'Preact'
-	);
-}
-
-/**
- * @param {any[]} statements
- * @returns {Set<string>}
- */
-function collect_block_binding_names(statements) {
-	const names = new Set();
-	for (const statement of statements || []) {
-		collect_block_binding_names_from_statement(statement, names);
-	}
-	return names;
-}
-
-/**
- * @param {any} statement
- * @param {Set<string>} names
- * @returns {void}
- */
-function collect_block_binding_names_from_statement(statement, names) {
-	if (!statement || typeof statement !== 'object') {
-		return;
-	}
-
-	if (statement.type === 'VariableDeclaration') {
-		for (const declaration of statement.declarations || []) {
-			collect_pattern_names(declaration.id, names);
-		}
-		return;
-	}
-
-	if (
-		(statement.type === 'FunctionDeclaration' || statement.type === 'ClassDeclaration') &&
-		statement.id?.type === 'Identifier'
-	) {
-		names.add(statement.id.name);
-		return;
-	}
-
-	if (
-		statement.type === 'ForOfStatement' ||
-		statement.type === 'ForInStatement' ||
-		(statement.type === 'JSXForExpression' &&
-			(statement.statementType === 'ForOfStatement' ||
-				statement.statementType === 'ForInStatement'))
-	) {
-		if (statement.left?.type === 'VariableDeclaration' && statement.left.kind === 'var') {
-			for (const declaration of statement.left.declarations || []) {
-				collect_pattern_names(declaration.id, names);
-			}
-		}
-		return;
-	}
-
-	if (
-		statement.type === 'ForStatement' &&
-		statement.init?.type === 'VariableDeclaration' &&
-		statement.init.kind === 'var'
-	) {
-		for (const declaration of statement.init.declarations || []) {
-			collect_pattern_names(declaration.id, names);
-		}
-	}
-}
-
-/**
- * @param {any} pattern
- * @param {Set<string>} names
- * @returns {void}
- */
-function collect_pattern_names(pattern, names) {
-	if (!pattern || typeof pattern !== 'object') {
-		return;
-	}
-
-	if (pattern.type === 'Identifier') {
-		names.add(pattern.name);
-		return;
-	}
-
-	if (pattern.type === 'RestElement') {
-		collect_pattern_names(pattern.argument, names);
-		return;
-	}
-
-	if (pattern.type === 'AssignmentPattern') {
-		collect_pattern_names(pattern.left, names);
-		return;
-	}
-
-	if (pattern.type === 'ArrayPattern') {
-		for (const element of pattern.elements || []) {
-			collect_pattern_names(element, names);
-		}
-		return;
-	}
-
-	if (pattern.type === 'ObjectPattern') {
-		for (const property of pattern.properties || []) {
-			if (property.type === 'RestElement') {
-				collect_pattern_names(property.argument, names);
-			} else {
-				collect_pattern_names(property.value, names);
-			}
-		}
-	}
-}
-
-/**
- * @param {any} node
- * @param {Set<string>} shadowed_names
- * @param {TransformContext} transform_context
- * @param {Set<string>} hook_result_names
- * @returns {void}
- */
-function validate_hook_outer_assignments_in_node(
-	node,
-	shadowed_names,
-	transform_context,
-	hook_result_names,
-) {
-	if (!node || typeof node !== 'object') {
-		return;
-	}
-
-	if (Array.isArray(node)) {
-		for (const child of node) {
-			validate_hook_outer_assignments_in_node(
-				child,
-				shadowed_names,
-				transform_context,
-				hook_result_names,
-			);
-		}
-		return;
-	}
-
-	if (is_function_or_component_node(node)) {
-		return;
-	}
-
-	if (node.type === 'CallExpression' && is_hook_callee(node.callee)) {
-		validate_hook_callback_outer_mutations(node, shadowed_names, transform_context);
-	}
-
-	if (node.type === 'BlockStatement') {
-		const next_shadowed = new Set(shadowed_names);
-		const next_hook_result_names = new Set(hook_result_names);
-		for (const name of collect_block_binding_names(node.body || [])) {
-			next_shadowed.add(name);
-		}
-		for (const child of node.body || []) {
-			validate_hook_outer_assignments_in_node(
-				child,
-				next_shadowed,
-				transform_context,
-				next_hook_result_names,
-			);
-		}
-		return;
-	}
-
-	if (node.type === 'VariableDeclaration') {
-		for (const declaration of node.declarations || []) {
-			if (
-				declaration.init &&
-				expression_contains_hook_derived_value(
-					declaration.init,
-					transform_context,
-					hook_result_names,
-				)
-			) {
-				collect_pattern_names(declaration.id, hook_result_names);
-			}
-			validate_hook_outer_assignments_in_node(
-				declaration.init,
-				shadowed_names,
-				transform_context,
-				hook_result_names,
-			);
-		}
-		return;
-	}
-
-	if (
-		node.type === 'AssignmentExpression' &&
-		expression_contains_hook_derived_value(node.right, transform_context, hook_result_names)
-	) {
-		const outer_names = get_referenced_outer_binding_names(
-			node.left,
-			transform_context.available_bindings,
-			shadowed_names,
-		);
-		if (outer_names.length > 0) {
-			report_hook_outer_assignment_error(
-				node.left,
-				outer_names,
-				find_first_hook_call_name(node.right) || 'hook',
-				transform_context,
-			);
-		}
-		for (const name of get_referenced_local_binding_names(node.left, shadowed_names)) {
-			hook_result_names.add(name);
-		}
-	}
-
-	if (is_for_of_control_node(node)) {
-		if (
-			node.left &&
-			node.left.type !== 'VariableDeclaration' &&
-			expression_contains_hook_derived_value(node.right, transform_context, hook_result_names)
-		) {
-			const outer_names = get_referenced_outer_binding_names(
-				node.left,
-				transform_context.available_bindings,
-				shadowed_names,
-			);
-			if (outer_names.length > 0) {
-				report_hook_outer_assignment_error(
-					node.left,
-					outer_names,
-					find_first_hook_call_name(node.right) || 'hook',
-					transform_context,
-				);
-			}
-			for (const name of get_referenced_local_binding_names(node.left, shadowed_names)) {
-				hook_result_names.add(name);
-			}
-		}
-
-		validate_hook_outer_assignments_in_node(
-			node.right,
-			shadowed_names,
-			transform_context,
-			hook_result_names,
-		);
-
-		// Loop-declared bindings (`for (const x of …)`, `for (let x of …)`) live
-		// only in the body. They are deliberately NOT in the enclosing block's
-		// shadowed set (see collect_block_binding_names_from_statement), so add
-		// them just for the body recursion to keep references to the loop var
-		// from being flagged as outer-binding mutations.
-		const body_shadowed = new Set(shadowed_names);
-		if (node.left && node.left.type === 'VariableDeclaration') {
-			for (const declaration of node.left.declarations || []) {
-				collect_pattern_names(declaration.id, body_shadowed);
-			}
-		}
-		validate_hook_outer_assignments_in_node(
-			node.body,
-			body_shadowed,
-			transform_context,
-			hook_result_names,
-		);
-		return;
-	}
-
-	for (const key of Object.keys(node)) {
-		if (key === 'loc' || key === 'start' || key === 'end' || key === 'metadata') {
-			continue;
-		}
-		validate_hook_outer_assignments_in_node(
-			node[key],
-			shadowed_names,
-			transform_context,
-			hook_result_names,
-		);
-	}
-}
-
-/**
- * @param {any} call_node
- * @param {Set<string>} shadowed_names
- * @param {TransformContext} transform_context
- * @returns {void}
- */
-function validate_hook_callback_outer_mutations(call_node, shadowed_names, transform_context) {
-	const hook_name = get_hook_callee_name(call_node.callee);
-	for (const argument of call_node.arguments || []) {
-		if (!is_function_or_component_node(argument)) {
-			continue;
-		}
-		const callback_shadowed_names = create_function_like_shadowed_names(argument, shadowed_names);
-		validate_hook_callback_outer_mutations_in_node(
-			argument.body,
-			callback_shadowed_names,
-			transform_context,
-			hook_name,
-		);
-	}
-}
-
-/**
- * @param {any} node
- * @param {Set<string>} shadowed_names
- * @returns {Set<string>}
- */
-function create_function_like_shadowed_names(node, shadowed_names) {
-	const next_shadowed_names = new Set(shadowed_names);
-	for (const param of node.params || []) {
-		collect_pattern_names(param, next_shadowed_names);
-	}
-	if (node.body?.type === 'BlockStatement') {
-		for (const name of collect_block_binding_names(node.body.body || [])) {
-			next_shadowed_names.add(name);
-		}
-	}
-	return next_shadowed_names;
-}
-
-/**
- * @param {any} node
- * @param {Set<string>} shadowed_names
+ * @param {any[]} children
  * @param {TransformContext} transform_context
- * @param {string} hook_name
- * @returns {void}
+ * @returns {any[]}
  */
-function validate_hook_callback_outer_mutations_in_node(
-	node,
-	shadowed_names,
-	transform_context,
-	hook_name,
-) {
-	if (!node || typeof node !== 'object') {
-		return;
-	}
-
-	if (Array.isArray(node)) {
-		for (const child of node) {
-			validate_hook_callback_outer_mutations_in_node(
-				child,
-				shadowed_names,
-				transform_context,
-				hook_name,
-			);
-		}
-		return;
-	}
-
-	if (is_function_or_component_node(node)) {
-		validate_hook_callback_outer_mutations_in_node(
-			node.body,
-			create_function_like_shadowed_names(node, shadowed_names),
-			transform_context,
-			hook_name,
-		);
-		return;
-	}
-
-	if (node.type === 'BlockStatement') {
-		const next_shadowed_names = new Set(shadowed_names);
-		for (const name of collect_block_binding_names(node.body || [])) {
-			next_shadowed_names.add(name);
-		}
-		for (const child of node.body || []) {
-			validate_hook_callback_outer_mutations_in_node(
-				child,
-				next_shadowed_names,
-				transform_context,
-				hook_name,
-			);
-		}
-		return;
-	}
 
-	if (node.type === 'AssignmentExpression') {
-		const outer_names = get_referenced_outer_binding_names(
-			node.left,
-			transform_context.available_bindings,
-			shadowed_names,
-		);
-		if (outer_names.length > 0) {
-			report_hook_callback_outer_mutation_error(
-				node.left,
-				outer_names,
-				hook_name,
-				transform_context,
-			);
-		}
+function create_element_children(children, transform_context) {
+	if (children.length === 0) {
+		return [];
 	}
 
-	if (node.type === 'UpdateExpression') {
-		const outer_names = get_referenced_outer_binding_names(
-			node.argument,
-			transform_context.available_bindings,
-			shadowed_names,
-		);
-		if (outer_names.length > 0) {
-			report_hook_callback_outer_mutation_error(
-				node.argument,
-				outer_names,
-				hook_name,
-				transform_context,
-			);
+	if (children.every(is_inline_element_child) && !children_contain_return_semantics(children)) {
+		const saved_inside_element_child = transform_context.inside_element_child;
+		transform_context.inside_element_child = true;
+		try {
+			return children.map((/** @type {any} */ child) => to_jsx_child(child, transform_context));
+		} finally {
+			transform_context.inside_element_child = saved_inside_element_child;
 		}
 	}
 
-	for (const key of Object.keys(node)) {
-		if (key === 'loc' || key === 'start' || key === 'end' || key === 'metadata') {
-			continue;
-		}
-		if (key === 'left' && node.type === 'AssignmentExpression') {
-			continue;
-		}
-		if (key === 'argument' && node.type === 'UpdateExpression') {
-			continue;
-		}
-		validate_hook_callback_outer_mutations_in_node(
-			node[key],
-			shadowed_names,
-			transform_context,
-			hook_name,
-		);
+	const saved_inside_element_child = transform_context.inside_element_child;
+	transform_context.inside_element_child = true;
+	try {
+		return [statement_body_to_jsx_child(children, transform_context)];
+	} finally {
+		transform_context.inside_element_child = saved_inside_element_child;
 	}
 }
 
 /**
- * @param {any} node
- * @param {TransformContext} transform_context
- * @param {Set<string>} hook_result_names
+ * @param {any[]} children
  * @returns {boolean}
  */
-function expression_contains_hook_derived_value(node, transform_context, hook_result_names) {
-	return (
-		node_contains_top_level_hook_call(node, false, transform_context, true) ||
-		references_name_in_set(node, hook_result_names)
-	);
+function children_contain_return_semantics(children) {
+	return children.some(child_contains_return_semantics);
 }
 
 /**
  * @param {any} node
- * @param {Set<string>} names
  * @returns {boolean}
  */
-function references_name_in_set(node, names) {
-	if (!node || typeof node !== 'object' || names.size === 0) {
+function child_contains_return_semantics(node) {
+	if (!node || typeof node !== 'object') {
 		return false;
 	}
 
-	if (node.type === 'Identifier') {
-		return names.has(node.name);
+	if (node.type === 'ReturnStatement') {
+		return true;
 	}
 
 	if (
@@ -4359,20 +3334,14 @@ function references_name_in_set(node, names) {
 	}
 
 	if (Array.isArray(node)) {
-		return node.some((child) => references_name_in_set(child, names));
+		return node.some(child_contains_return_semantics);
 	}
 
 	for (const key of Object.keys(node)) {
 		if (key === 'loc' || key === 'start' || key === 'end' || key === 'metadata') {
 			continue;
 		}
-		if (key === 'property' && node.type === 'MemberExpression' && !node.computed) {
-			continue;
-		}
-		if (key === 'key' && node.type === 'Property' && !node.computed && !node.shorthand) {
-			continue;
-		}
-		if (references_name_in_set(node[key], names)) {
+		if (child_contains_return_semantics(node[key])) {
 			return true;
 		}
 	}
@@ -4382,162 +3351,104 @@ function references_name_in_set(node, names) {
 
 /**
  * @param {any} node
- * @param {Set<string>} shadowed_names
- * @returns {string[]}
+ * @returns {boolean}
  */
-function get_referenced_local_binding_names(node, shadowed_names) {
-	const names = new Set();
-	collect_referenced_local_binding_names(node, shadowed_names, names);
-	return [...names];
+function is_inline_element_child(node) {
+	return node && is_render_child_node(node);
 }
 
 /**
- * @param {any} node
- * @param {Set<string>} shadowed_names
- * @param {Set<string>} names
- * @returns {void}
+ * @param {any[]} body_nodes
+ * @param {TransformContext} transform_context
+ * @returns {ESTreeJSX.JSXExpressionContainer}
  */
-function collect_referenced_local_binding_names(node, shadowed_names, names) {
-	if (!node || typeof node !== 'object') {
-		return;
+function statement_body_to_jsx_child(body_nodes, transform_context) {
+	if (
+		should_extract_hook_helpers(transform_context) &&
+		body_contains_top_level_hook_call(body_nodes, transform_context, true)
+	) {
+		return hook_safe_statement_body_to_jsx_child(body_nodes, transform_context);
 	}
 
-	if (node.type === 'Identifier') {
-		if (shadowed_names.has(node.name)) {
-			names.add(node.name);
-		}
-		return;
-	}
+	return to_jsx_expression_container(
+		b.call(b.arrow([], b.block(build_render_statements(body_nodes, true, transform_context)))),
+	);
+}
 
-	if (Array.isArray(node)) {
-		for (const child of node) {
-			collect_referenced_local_binding_names(child, shadowed_names, names);
-		}
-		return;
-	}
+/**
+ * @param {any[]} body_nodes
+ * @param {TransformContext} transform_context
+ * @returns {ESTreeJSX.JSXExpressionContainer}
+ */
+function hook_safe_statement_body_to_jsx_child(body_nodes, transform_context) {
+	const source_node = get_body_source_node(body_nodes);
+	const helper = create_hook_safe_helper(body_nodes, undefined, source_node, transform_context);
 
-	for (const key of Object.keys(node)) {
-		if (key === 'loc' || key === 'start' || key === 'end' || key === 'metadata') {
-			continue;
-		}
-		if (key === 'property' && node.type === 'MemberExpression' && !node.computed) {
-			continue;
-		}
-		if (key === 'key' && node.type === 'Property' && !node.computed && !node.shorthand) {
-			continue;
-		}
-		collect_referenced_local_binding_names(node[key], shadowed_names, names);
-	}
+	return to_jsx_expression_container(
+		create_hook_safe_helper_iife(helper.setup_statements, helper.component_element),
+		source_node,
+	);
 }
 
 /**
- * @param {any} node
- * @param {Map<string, AST.Identifier>} available_bindings
- * @param {Set<string>} shadowed_names
- * @returns {string[]}
+ * @param {TransformContext} transform_context
+ * @returns {string}
  */
-function get_referenced_outer_binding_names(node, available_bindings, shadowed_names) {
-	const names = new Set();
-	collect_referenced_outer_binding_names(node, available_bindings, shadowed_names, names);
-	return [...names];
+function create_local_statement_component_name(transform_context) {
+	transform_context.local_statement_component_index += 1;
+	return `StatementBodyHook${transform_context.local_statement_component_index}`;
 }
 
 /**
- * @param {any} node
- * @param {Map<string, AST.Identifier>} available_bindings
- * @param {Set<string>} shadowed_names
- * @param {Set<string>} names
- * @returns {void}
+ * Wraps a list of body nodes into a component and returns
+ * statements that return `<ComponentName prop1={prop1} ... />`.
+ * Targets can either emit the helper component at module scope or cache the
+ * component identity in module state while initializing it from the parent.
+ * Used when a control flow branch contains hook calls that must be moved
+ * into their own component boundary to satisfy the Rules of Hooks.
+ *
+ * @param {any[]} body_nodes
+ * @param {any} key_expression - Optional key expression to add to the component element (for for-of loops)
+ * @param {TransformContext} transform_context
+ * @returns {any[]}
  */
-function collect_referenced_outer_binding_names(node, available_bindings, shadowed_names, names) {
-	if (!node || typeof node !== 'object') {
-		return;
-	}
-
-	if (node.type === 'Identifier') {
-		if (available_bindings.has(node.name) && !shadowed_names.has(node.name)) {
-			names.add(node.name);
-		}
-		return;
-	}
+function hook_safe_render_statements(body_nodes, key_expression, transform_context) {
+	const source_node = get_body_source_node(body_nodes);
+	const helper = create_hook_safe_helper(
+		body_nodes,
+		key_expression,
+		source_node,
+		transform_context,
+	);
+	const statements = [...helper.setup_statements];
 
-	if (Array.isArray(node)) {
-		for (const child of node) {
-			collect_referenced_outer_binding_names(child, available_bindings, shadowed_names, names);
-		}
-		return;
-	}
+	statements.push(b.return(helper.component_element));
 
-	for (const key of Object.keys(node)) {
-		if (key === 'loc' || key === 'start' || key === 'end' || key === 'metadata') {
-			continue;
-		}
-		if (key === 'property' && node.type === 'MemberExpression' && !node.computed) {
-			continue;
-		}
-		if (key === 'key' && node.type === 'Property' && !node.computed && !node.shorthand) {
-			continue;
-		}
-		collect_referenced_outer_binding_names(node[key], available_bindings, shadowed_names, names);
-	}
+	return statements;
 }
 
 /**
- * @param {any} node
- * @returns {string | null}
+ * @param {any[]} body_nodes
+ * @param {Map<string, AST.Identifier>} available_bindings
+ * @returns {AST.Identifier[]}
  */
-function find_first_hook_call_name(node) {
-	if (!node || typeof node !== 'object') {
-		return null;
-	}
-
-	if (node.type === 'CallExpression' && is_hook_callee(node.callee)) {
-		return get_hook_callee_name(node.callee);
-	}
+function get_referenced_helper_bindings(body_nodes, available_bindings) {
+	const helper_bindings = [];
+	const local_bindings = new Map();
 
-	if (
-		node.type === 'FunctionDeclaration' ||
-		node.type === 'FunctionExpression' ||
-		node.type === 'ArrowFunctionExpression'
-	) {
-		return null;
+	for (const node of body_nodes) {
+		collect_statement_bindings(node, local_bindings);
 	}
 
-	if (Array.isArray(node)) {
-		for (const child of node) {
-			const name = find_first_hook_call_name(child);
-			if (name) return name;
-		}
-		return null;
-	}
+	for (const [name, binding] of available_bindings) {
+		if (local_bindings.has(name)) continue;
 
-	for (const key of Object.keys(node)) {
-		if (key === 'loc' || key === 'start' || key === 'end' || key === 'metadata') {
-			continue;
+		if (references_scope_bindings(body_nodes, new Map([[name, binding]]))) {
+			helper_bindings.push(binding);
 		}
-		const name = find_first_hook_call_name(node[key]);
-		if (name) return name;
 	}
 
-	return null;
-}
-
-/**
- * @param {any} callee
- * @returns {string}
- */
-function get_hook_callee_name(callee) {
-	if (callee?.type === 'Identifier') {
-		return callee.name;
-	}
-	if (
-		callee?.type === 'MemberExpression' &&
-		!callee.computed &&
-		callee.property?.type === 'Identifier'
-	) {
-		return callee.property.name;
-	}
-	return 'hook';
+	return helper_bindings;
 }
 
 /**
@@ -4558,11 +3469,6 @@ export function create_hook_safe_helper(
 	preallocated_helper_id,
 	options = {},
 ) {
-	validate_hook_safe_body_does_not_assign_hook_results_to_outer_bindings(
-		body_nodes,
-		transform_context,
-	);
-
 	const helper_id =
 		preallocated_helper_id ??
 		create_generated_identifier(create_local_statement_component_name(transform_context));
@@ -4887,14 +3793,6 @@ function is_if_control_node(node) {
 	return node?.type === 'IfStatement' || node?.type === 'JSXIfExpression';
 }
 
-/**
- * @param {any} node
- * @returns {boolean}
- */
-function is_plain_if_statement(node) {
-	return node?.type === 'IfStatement' && !is_template_if_node(node);
-}
-
 /**
  * @param {any} node
  * @returns {boolean}
@@ -4941,17 +3839,6 @@ function is_try_control_node(node) {
 	return node?.type === 'TryStatement' || node?.type === 'JSXTryExpression';
 }
 
-/**
- * @param {any} node
- * @returns {boolean}
- */
-function is_for_of_control_node(node) {
-	return (
-		node?.type === 'ForOfStatement' ||
-		(node?.type === 'JSXForExpression' && node.statementType === 'ForOfStatement')
-	);
-}
-
 /**
  * @param {any} node
  * @param {TransformContext} transform_context
@@ -5902,16 +4789,9 @@ function try_statement_to_jsx_child(node, transform_context) {
 		// correctly identifies references to err/reset as non-static
 		const saved_catch_bindings = transform_context.available_bindings;
 		transform_context.available_bindings = new Map(saved_catch_bindings);
-		const catch_scoped_names = new Set();
 		for (const param of catch_params) {
 			collect_pattern_bindings(param, transform_context.available_bindings);
-			collect_pattern_names(param, catch_scoped_names);
 		}
-		validate_hook_safe_body_does_not_assign_hook_results_to_outer_bindings(
-			catch_body_nodes,
-			transform_context,
-			catch_scoped_names,
-		);
 
 		const fallback_fn = b.arrow(
 			catch_params,