@tsrx/core 0.1.6 → 0.1.7

package/package.json

@@ -3,7 +3,7 @@
   "description": "Core compiler infrastructure for TSRX syntax",
   "license": "MIT",
   "author": "Dominic Gannaway",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "type": "module",
   "repository": {
     "type": "git",
@@ -31,11 +31,26 @@
       "types": "./types/runtime/ref.d.ts",
       "default": "./src/runtime/ref.js"
     },
-    "./runtime": {
-      "types": "./types/runtime/index.d.ts",
-      "default": "./src/runtime/index.js"
+    "./runtime/events": {
+      "types": "./types/runtime/events.d.ts",
+      "default": "./src/runtime/events.js"
+    },
+    "./runtime/hash": {
+      "types": "./types/runtime/hash.d.ts",
+      "default": "./src/runtime/hash.js"
+    },
+    "./runtime/html": {
+      "types": "./types/runtime/html.d.ts",
+      "default": "./src/runtime/html.js"
+    },
+    "./runtime/language-helpers": {
+      "types": "./types/runtime/language-helpers.d.ts",
+      "default": "./src/runtime/language-helpers.js"
+    },
+    "./runtime/iterable": {
+      "types": "./types/runtime/iterable.d.ts",
+      "default": "./src/runtime/iterable.js"
     },
-    "./runtime/*": "./src/runtime/*.js",
     "./test-harness/source-mappings": "./tests/shared/source-mappings.js",
     "./test-harness/compile": "./tests/shared/compile.js",
     "./test-harness/runtime/*": "./tests/shared/runtime/*.js",
@@ -67,10 +82,10 @@
     "vscode-languageserver-types": "^3.17.5",
     "vue": "3.6.0-beta.10",
     "vue-jsx-vapor": "^3.2.12",
-    "@tsrx/preact": "0.1.6",
-    "@tsrx/react": "0.2.6",
-    "@tsrx/solid": "0.1.6",
-    "@tsrx/vue": "0.1.6"
+    "@tsrx/preact": "0.1.7",
+    "@tsrx/react": "0.2.7",
+    "@tsrx/solid": "0.1.7",
+    "@tsrx/vue": "0.1.7"
   },
   "files": [
     "src",

package/src/index.js

@@ -88,6 +88,7 @@ export {
 	is_class_node as isClassNode,
 	is_component_node as isComponentNode,
 	is_function_node as isFunctionNode,
+	is_function_or_component_node as isFunctionOrComponentNode,
 	is_inside_component as isInsideComponent,
 } from './utils/ast.js';
 
@@ -205,11 +206,9 @@ export {
 export {
 	create_lazy_context as createLazyContext,
 	collect_lazy_bindings as collectLazyBindings,
-	collect_lazy_bindings_from_component as collectLazyBindingsFromComponent,
 	collect_lazy_bindings_from_statements as collectLazyBindingsFromStatements,
 	preallocate_lazy_ids as preallocateLazyIds,
 	apply_lazy_transforms as applyLazyTransforms,
-	replace_lazy_params as replaceLazyParams,
 } from './transform/lazy.js';
 export {
 	find_first_top_level_await as findFirstTopLevelAwait,

package/src/runtime/events.js

@@ -0,0 +1,10 @@
+export {
+	event_name_from_capture,
+	get_attribute_event_name,
+	get_original_event_name,
+	is_capture_event,
+	is_event_attribute,
+	is_non_delegated,
+	is_passive_event,
+	normalize_event_name,
+} from '../utils/events.js';

package/src/runtime/hash.js

@@ -0,0 +1 @@
+export { simple_hash, strong_hash } from '../utils/hashing.js';

package/src/runtime/html.js

@@ -0,0 +1,3 @@
+export { is_boolean_attribute } from '../utils/dom.js';
+export { escape, escape_script } from '../utils/escaping.js';
+export { normalize_css_property_name } from '../utils/normalize_css_property_name.js';

package/src/transform/jsx/index.js

@@ -34,12 +34,7 @@ import {
 	jsx_id as build_jsx_id,
 } from '../../utils/builders.js';
 import * as b from '../../utils/builders.js';
-import {
-	apply_lazy_transforms,
-	collect_lazy_bindings_from_component,
-	preallocate_lazy_ids,
-	replace_lazy_params,
-} from '../lazy.js';
+import { apply_lazy_transforms, preallocate_lazy_ids } from '../lazy.js';
 import { find_first_top_level_await_in_component_body } from '../await.js';
 import { prepare_stylesheet_for_render, annotate_component_with_hash } from '../scoping.js';
 import {
@@ -50,7 +45,7 @@ import {
 	validate_component_return_statement,
 	validate_component_unsupported_loop_statement,
 } from '../../analyze/validation.js';
-import { get_component_from_path } from '../../utils/ast.js';
+import { get_component_from_path, is_function_or_component_node } from '../../utils/ast.js';
 import {
 	is_interleaved_body as is_interleaved_body_core,
 	is_capturable_jsx_child,
@@ -646,15 +641,6 @@ export function component_to_function_declaration(component, transform_context,
 	// Collect param bindings from original patterns (lazy patterns still intact).
 	const param_bindings = collect_param_bindings(params);
 
-	// Collect lazy binding info WITHOUT mutating patterns. Stores lazy_id on metadata
-	// for later replacement. Body bindings (count, setCount, etc.) are still in the
-	// original patterns, so collect_statement_bindings during build will find them.
-	// In type-only mode the lazy rewrite is skipped entirely so destructuring
-	// patterns survive into the virtual TSX and TypeScript can flow real types.
-	const lazy_bindings = transform_context.typeOnly
-		? new Map()
-		: collect_lazy_bindings_from_component(params, body, transform_context);
-
 	// Save and set context for this component scope
 	const saved_helper_state = transform_context.helper_state;
 	const saved_bindings = transform_context.available_bindings;
@@ -662,16 +648,7 @@ export function component_to_function_declaration(component, transform_context,
 	transform_context.available_bindings = new Map(param_bindings);
 
 	const body_statements = build_component_statements(body, transform_context);
-
-	// Replace lazy param patterns with generated identifiers
-	const final_params = lazy_bindings.size > 0 ? replace_lazy_params(params) : params;
-
-	// Wrap body_statements in a BlockStatement so that apply_lazy_transforms
-	// runs collect_block_shadowed_names and detects body-level declarations
-	// (e.g. `const name = ...`) that shadow lazy binding names.
 	const body_block = b.block(body_statements);
-	const final_body =
-		lazy_bindings.size > 0 ? apply_lazy_transforms(body_block, lazy_bindings) : body_block;
 
 	/** @type {AST.FunctionDeclaration | AST.FunctionExpression | AST.ArrowFunctionExpression} */
 	let fn;
@@ -679,18 +656,38 @@ export function component_to_function_declaration(component, transform_context,
 	if (component.id) {
 		fn = b.function_declaration(
 			component.id,
-			final_params,
-			final_body,
+			params,
+			body_block,
 			is_async_component,
 			component.typeParameters,
 		);
 	} else if (component.metadata?.arrow) {
-		fn = b.arrow(final_params, final_body, is_async_component, component.typeParameters);
+		fn = b.arrow(params, body_block, is_async_component, component.typeParameters);
 	} else {
-		fn = b.function(null, final_params, final_body, is_async_component, component.typeParameters);
+		fn = b.function(null, params, body_block, is_async_component, component.typeParameters);
 	}
 	/** @type {any} */ (fn.metadata).is_component = true;
 
+	// `preallocate_lazy_ids` stamped `has_lazy_descendants` on the source
+	// `Component` node; the freshly-built `fn` shares the same params/body
+	// subtree, so the flag is equally applicable. Propagating it lets
+	// `apply_lazy_transforms` honor its constant-time early-return path.
+	if (/** @type {any} */ (component).metadata?.has_lazy_descendants) {
+		/** @type {any} */ (fn.metadata).has_lazy_descendants = true;
+	}
+
+	// Apply lazy `&{}` / `&[]` rewrites end-to-end: the function-handler in
+	// `apply_lazy_transforms` collects param bindings, merges with body bindings
+	// discovered by the BlockStatement handler, replaces lazy params with their
+	// `__lazyN` ids, and rewrites every reference. Constant-time fast-path for
+	// functions whose subtrees contain no lazy patterns (flagged ahead of time
+	// by `preallocate_lazy_ids`). In type-only mode the rewrite is skipped so
+	// destructuring patterns survive into the virtual TSX and TypeScript can
+	// flow real types.
+	if (!transform_context.typeOnly) {
+		fn = /** @type {typeof fn} */ (apply_lazy_transforms(fn, new Map()));
+	}
+
 	// Restore context
 	transform_context.helper_state = saved_helper_state;
 	transform_context.available_bindings = saved_bindings;
@@ -2689,7 +2686,7 @@ function validate_hook_outer_assignments_in_node(
 		return;
 	}
 
-	if (is_function_like_node(node)) {
+	if (is_function_or_component_node(node)) {
 		return;
 	}
 
@@ -2831,7 +2828,7 @@ function validate_hook_outer_assignments_in_node(
 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_like_node(argument)) {
+		if (!is_function_or_component_node(argument)) {
 			continue;
 		}
 		const callback_shadowed_names = create_function_like_shadowed_names(argument, shadowed_names);
@@ -2844,21 +2841,6 @@ function validate_hook_callback_outer_mutations(call_node, shadowed_names, trans
 	}
 }
 
-/**
- * @param {any} node
- * @returns {boolean}
- */
-function is_function_like_node(node) {
-	return (
-		node.type === 'FunctionDeclaration' ||
-		node.type === 'FunctionExpression' ||
-		node.type === 'ArrowFunctionExpression' ||
-		// this is just in case but we should already
-		// have a component replaced with a function node
-		node.type === 'Component'
-	);
-}
-
 /**
  * @param {any} node
  * @param {Set<string>} shadowed_names
@@ -2906,7 +2888,7 @@ function validate_hook_callback_outer_mutations_in_node(
 		return;
 	}
 
-	if (is_function_like_node(node)) {
+	if (is_function_or_component_node(node)) {
 		validate_hook_callback_outer_mutations_in_node(
 			node.body,
 			create_function_like_shadowed_names(node, shadowed_names),

package/src/transform/lazy.js

@@ -1,24 +1,27 @@
 /** @import * as AST from 'estree' */
 
 import * as b from '../utils/builders.js';
+import { is_function_or_component_node } from '../utils/ast.js';
 
 /**
  * Lazy destructuring transform — framework-agnostic.
  *
- * Shared between `@tsrx/react` and `@tsrx/solid`. Walks an AST and rewrites
- * references to names introduced by `&{ ... }` / `&[ ... ]` destructuring
- * patterns into member-expression accesses on a generated source identifier.
+ * Shared between `@tsrx/react`, `@tsrx/preact`, `@tsrx/solid`, and `@tsrx/vue`.
+ * Walks an AST and rewrites references to names introduced by `&{ ... }` /
+ * `&[ ... ]` destructuring patterns into member-expression accesses on a
+ * generated source identifier.
  *
  * Usage:
  *   1. Create a context with `createLazyContext()` (or provide any object with
  *      a `lazy_next_id: number` field).
  *   2. Run `preallocateLazyIds(root, context)` once over the full program to
- *      assign stable `metadata.lazy_id` values to every lazy pattern.
- *   3. For each function/component scope, collect bindings with
- *      `collectLazyBindingsFromComponent(params, body, context)` and pass the
- *      resulting map into `applyLazyTransforms(body, map)`.
- *   4. If a component declares lazy params, pass its params through
- *      `replaceLazyParams(params)` before emitting.
+ *      assign stable `metadata.lazy_id` values to every lazy pattern and to
+ *      flag function-like nodes whose subtree contains any lazy pattern via
+ *      `metadata.has_lazy_descendants`.
+ *   3. After converting components to functions, call `applyLazyTransforms(fn,
+ *      new Map())` on each top-level function. The function-handler walks the
+ *      whole subtree, collects param + body bindings, replaces lazy patterns
+ *      with their generated identifiers, and rewrites every reference.
  *
  * The transform is purely AST-to-AST and has no framework-specific knowledge.
  */
@@ -196,33 +199,60 @@ function set_lazy_param_binding_mappings(lazy_id, pattern) {
  * Collect lazy bindings from a destructuring pattern.
  *
  * For `&{ name, age }` on source `S`, maps `name` → `S.name`, `age` → `S.age`.
- * For `&[a, b]` on source `S`, maps `a` → `S[0]`, `b` → `S[1]`. Handles nested
- * `AssignmentPattern` (default values); skips `RestElement`.
+ * For `&[a, b]` on source `S`, maps `a` → `S[0]`, `b` → `S[1]`. Recurses into
+ * nested `ObjectPattern` / `ArrayPattern` values so that `&{ outer: &{ inner } }`
+ * on source `S` maps `inner` → `S.outer.inner`, and `&{ pair: &[first, second] }`
+ * maps `first` → `S.pair[0]`. Handles `AssignmentPattern` (default values lost,
+ * but the binding still resolves to the member chain). Skips `RestElement`.
  *
  * @param {any} pattern
  * @param {string} source_name
  * @param {Map<string, LazyBinding>} lazy_bindings
  */
 export function collect_lazy_bindings(pattern, source_name, lazy_bindings) {
+	collect_lazy_bindings_at(
+		pattern,
+		source_name,
+		() => create_generated_identifier(source_name),
+		lazy_bindings,
+	);
+}
+
+/**
+ * Walk a destructure pattern and register a `LazyBinding` for each leaf
+ * `Identifier`, where `build_parent` produces the AST expression that reaches
+ * this pattern's value from the synthesized source identifier. Each nested
+ * level composes its accessor onto `build_parent`, so leaves get the full
+ * member chain (e.g. `source.outer.inner` for `&{ outer: &{ inner } }`).
+ *
+ * @param {any} pattern
+ * @param {string} source_name
+ * @param {(reference?: any) => any} build_parent
+ * @param {Map<string, LazyBinding>} lazy_bindings
+ */
+function collect_lazy_bindings_at(pattern, source_name, build_parent, lazy_bindings) {
 	if (pattern.type === 'ObjectPattern') {
 		for (const prop of pattern.properties || []) {
 			if (prop.type === 'RestElement') continue;
 			const value = prop.value;
 			const actual = value.type === 'AssignmentPattern' ? value.left : value;
+			const key = prop.key;
+			const computed = prop.computed || key.type !== 'Identifier';
+
+			/** @type {(reference?: any) => any} */
+			const build_self = (reference) =>
+				b.member(
+					build_parent(),
+					computed || key.type !== 'Identifier'
+						? { ...key }
+						: create_generated_identifier(key.name, reference, reference?.name),
+					computed,
+				);
+
 			if (actual.type === 'Identifier') {
-				const key = prop.key;
-				const computed = prop.computed || key.type !== 'Identifier';
-				lazy_bindings.set(actual.name, {
-					source_name,
-					read: (reference) =>
-						b.member(
-							create_generated_identifier(source_name),
-							computed || key.type !== 'Identifier'
-								? { ...key }
-								: create_generated_identifier(key.name, reference, reference?.name),
-							computed,
-						),
-				});
+				lazy_bindings.set(actual.name, { source_name, read: build_self });
+			} else if (actual.type === 'ObjectPattern' || actual.type === 'ArrayPattern') {
+				collect_lazy_bindings_at(actual, source_name, build_self, lazy_bindings);
 			}
 		}
 	} else if (pattern.type === 'ArrayPattern') {
@@ -231,48 +261,18 @@ export function collect_lazy_bindings(pattern, source_name, lazy_bindings) {
 			if (!element) continue;
 			if (element.type === 'RestElement') continue;
 			const actual = element.type === 'AssignmentPattern' ? element.left : element;
-			if (actual.type === 'Identifier') {
-				const index = i;
-				lazy_bindings.set(actual.name, {
-					source_name,
-					read: () => b.member(create_generated_identifier(source_name), b.literal(index), true),
-				});
-			}
-		}
-	}
-}
+			const index = i;
 
-/**
- * Collect lazy bindings from a component's params and top-level body declarations.
- * Mutates each lazy pattern's `metadata.lazy_id` in place (idempotent if already set).
- *
- * @param {any[]} params
- * @param {any[]} body
- * @param {LazyContext} context
- * @returns {Map<string, LazyBinding>}
- */
-export function collect_lazy_bindings_from_component(params, body, context) {
-	/** @type {Map<string, LazyBinding>} */
-	const lazy_bindings = new Map();
-
-	for (const param of params) {
-		const pattern = param.type === 'AssignmentPattern' ? param.left : param;
-		if ((pattern.type === 'ObjectPattern' || pattern.type === 'ArrayPattern') && pattern.lazy) {
-			const lazy_name = pattern.metadata?.lazy_id || generate_lazy_id(context);
-			if (!pattern.metadata?.lazy_id) {
-				pattern.metadata = { ...pattern.metadata, lazy_id: lazy_name };
+			/** @type {() => any} */
+			const build_self = () => b.member(build_parent(), b.literal(index), true);
+
+			if (actual.type === 'Identifier') {
+				lazy_bindings.set(actual.name, { source_name, read: build_self });
+			} else if (actual.type === 'ObjectPattern' || actual.type === 'ArrayPattern') {
+				collect_lazy_bindings_at(actual, source_name, build_self, lazy_bindings);
 			}
-			collect_lazy_bindings(pattern, lazy_name, lazy_bindings);
 		}
 	}
-
-	// VariableDeclaration lazy patterns already have their `lazy_id` assigned
-	// by `preallocate_lazy_ids` (run once over the whole program by the target
-	// transforms), so `collect_lazy_bindings_from_statements` handles them
-	// alongside the expression-statement assignment form.
-	collect_lazy_bindings_from_statements(body, lazy_bindings);
-
-	return lazy_bindings;
 }
 
 /**
@@ -288,61 +288,164 @@ export function collect_lazy_bindings_from_statements(statements, lazy_bindings)
 	for (const stmt of statements || []) {
 		if (stmt.type === 'VariableDeclaration') {
 			for (const declarator of stmt.declarations || []) {
-				const pattern = declarator.id;
-				if (
-					(pattern?.type === 'ObjectPattern' || pattern?.type === 'ArrayPattern') &&
-					pattern.lazy &&
-					pattern.metadata?.lazy_id &&
-					!lazy_bindings_contains(lazy_bindings, pattern)
-				) {
-					collect_lazy_bindings(pattern, pattern.metadata.lazy_id, lazy_bindings);
-				}
+				visit_topmost_lazy_patterns(declarator.id, (lazy) => {
+					if (!lazy.metadata?.lazy_id) return;
+					collect_lazy_bindings(lazy, lazy.metadata.lazy_id, lazy_bindings);
+				});
 			}
 		} else if (
 			stmt.type === 'ExpressionStatement' &&
 			stmt.expression?.type === 'AssignmentExpression' &&
-			stmt.expression.operator === '=' &&
-			(stmt.expression.left?.type === 'ObjectPattern' ||
-				stmt.expression.left?.type === 'ArrayPattern') &&
-			stmt.expression.left.lazy &&
-			stmt.expression.left.metadata?.lazy_id
+			stmt.expression.operator === '='
 		) {
-			collect_lazy_bindings(
-				stmt.expression.left,
-				stmt.expression.left.metadata.lazy_id,
-				lazy_bindings,
-			);
+			visit_topmost_lazy_patterns(stmt.expression.left, (lazy) => {
+				if (!lazy.metadata?.lazy_id) return;
+				collect_lazy_bindings(lazy, lazy.metadata.lazy_id, lazy_bindings);
+			});
 		}
 	}
 }
 
 /**
- * @param {Map<string, LazyBinding>} lazy_bindings
+ * Walk a destructure pattern tree, calling `visit` on every *topmost-lazy*
+ * descendant — a lazy `ObjectPattern` / `ArrayPattern` with no lazy ancestor
+ * within the same pattern tree. Descends through `AssignmentPattern`,
+ * `RestElement`, and non-lazy `ObjectPattern` / `ArrayPattern`. Stops at lazy
+ * patterns: their inner leaves are reached via accessor chains rooted at the
+ * lazy pattern's synthesized id, not by further descent here.
+ *
  * @param {any} pattern
- * @returns {boolean}
+ * @param {(node: any) => void} visit
  */
-function lazy_bindings_contains(lazy_bindings, pattern) {
+function visit_topmost_lazy_patterns(pattern, visit) {
+	if (!pattern || typeof pattern !== 'object') return;
+	if (pattern.type === 'AssignmentPattern') {
+		visit_topmost_lazy_patterns(pattern.left, visit);
+		return;
+	}
+	if (pattern.type === 'RestElement') {
+		visit_topmost_lazy_patterns(pattern.argument, visit);
+		return;
+	}
+	if (pattern.type !== 'ObjectPattern' && pattern.type !== 'ArrayPattern') return;
+
+	if (pattern.lazy) {
+		visit(pattern);
+		return;
+	}
+
 	if (pattern.type === 'ObjectPattern') {
 		for (const prop of pattern.properties || []) {
-			if (prop.type === 'RestElement') continue;
-			const value = prop.value;
-			const actual = value?.type === 'AssignmentPattern' ? value.left : value;
-			if (actual?.type === 'Identifier' && lazy_bindings.has(actual.name)) return true;
+			if (prop.type === 'RestElement') visit_topmost_lazy_patterns(prop.argument, visit);
+			else visit_topmost_lazy_patterns(prop.value, visit);
 		}
-	} else if (pattern.type === 'ArrayPattern') {
+	} else {
 		for (const element of pattern.elements || []) {
-			if (!element || element.type === 'RestElement') continue;
-			const actual = element.type === 'AssignmentPattern' ? element.left : element;
-			if (actual?.type === 'Identifier' && lazy_bindings.has(actual.name)) return true;
+			if (element) visit_topmost_lazy_patterns(element, visit);
 		}
 	}
-	return false;
+}
+
+/**
+ * Build the replacement identifier for a lazy pattern. When `is_top` is true
+ * (the pattern is itself a function parameter) we attach the original
+ * `typeAnnotation`, synthesize an object-shaped annotation for untyped object
+ * params so TypeScript sees prop names, and register source-mapping info.
+ * Nested replacements (inside a non-lazy outer destructure) can't carry an
+ * inline type annotation — that's not valid syntax — so they get a plain
+ * identifier with just source-range info.
+ *
+ * @param {any} pattern
+ * @param {boolean} is_top
+ * @returns {any}
+ */
+function build_lazy_id_for_pattern(pattern, is_top) {
+	const pattern_range = get_lazy_pattern_mapping_range(pattern);
+	const lazy_id = pattern_range
+		? create_generated_identifier(
+				pattern.metadata.lazy_id,
+				pattern_range,
+				undefined,
+				pattern_range.source_length,
+			)
+		: create_generated_identifier(pattern.metadata.lazy_id);
+	if (!is_top) return lazy_id;
+	if (pattern.typeAnnotation) {
+		lazy_id.typeAnnotation = pattern.typeAnnotation;
+	} else {
+		const type_annotation = create_lazy_object_type_annotation(pattern);
+		if (type_annotation) lazy_id.typeAnnotation = type_annotation;
+	}
+	set_lazy_param_binding_mappings(lazy_id, pattern);
+	return lazy_id;
+}
+
+/**
+ * Walk a destructure pattern tree and replace every topmost-lazy pattern with
+ * its synthesized id identifier. Non-lazy outer patterns are preserved so a
+ * source like `{ pair: &[a, b] }` becomes `{ pair: __lazy0 }`. The `is_top`
+ * flag is true only when the caller is invoking on a position that itself
+ * binds a single param (so a directly-lazy pattern can carry param-level type
+ * info); recursive descent into child patterns passes `false`.
+ *
+ * @param {any} pattern
+ * @param {boolean} [is_top]
+ * @returns {any}
+ */
+function replace_lazy_in_pattern(pattern, is_top = true) {
+	if (!pattern || typeof pattern !== 'object') return pattern;
+
+	if (pattern.type === 'AssignmentPattern') {
+		const new_left = replace_lazy_in_pattern(pattern.left, is_top);
+		return new_left === pattern.left ? pattern : { ...pattern, left: new_left };
+	}
+	if (pattern.type === 'RestElement') {
+		const new_arg = replace_lazy_in_pattern(pattern.argument, false);
+		return new_arg === pattern.argument ? pattern : { ...pattern, argument: new_arg };
+	}
+	if (pattern.type !== 'ObjectPattern' && pattern.type !== 'ArrayPattern') return pattern;
+
+	if (pattern.lazy && pattern.metadata?.lazy_id) {
+		return build_lazy_id_for_pattern(pattern, is_top);
+	}
+
+	if (pattern.type === 'ObjectPattern') {
+		let changed = false;
+		const new_properties = (pattern.properties || []).map((/** @type {any} */ prop) => {
+			if (prop.type === 'RestElement') {
+				const new_arg = replace_lazy_in_pattern(prop.argument, false);
+				if (new_arg === prop.argument) return prop;
+				changed = true;
+				return { ...prop, argument: new_arg };
+			}
+			const new_value = replace_lazy_in_pattern(prop.value, false);
+			if (new_value === prop.value) return prop;
+			changed = true;
+			return { ...prop, value: new_value };
+		});
+		return changed ? { ...pattern, properties: new_properties } : pattern;
+	}
+
+	let changed = false;
+	const new_elements = (pattern.elements || []).map((/** @type {any} */ element) => {
+		if (!element) return element;
+		const new_element = replace_lazy_in_pattern(element, false);
+		if (new_element !== element) changed = true;
+		return new_element;
+	});
+	return changed ? { ...pattern, elements: new_elements } : pattern;
 }
 
 /**
  * Walk the AST and pre-allocate `lazy_id` metadata on every lazy destructuring
  * pattern: function/component params, variable declarator ids, and statement-level
- * assignment LHS. Idempotent: skips patterns that already have a `lazy_id`.
+ * assignment LHS. Walks into non-lazy outer patterns to find nested lazy ones,
+ * e.g. `{ pair: &[a, b] }` allocates an id for the inner `&[a, b]`. Idempotent:
+ * skips patterns that already have a `lazy_id`.
+ *
+ * Also stamps `metadata.has_lazy_descendants = true` on every function-like
+ * node whose subtree contains any lazy pattern, so `apply_lazy_transforms`
+ * can take a constant-time early-return path for purely non-lazy functions.
  *
  * @param {any} root
  * @param {LazyContext} context
@@ -350,32 +453,29 @@ function lazy_bindings_contains(lazy_bindings, pattern) {
 export function preallocate_lazy_ids(root, context) {
 	/** @param {any} pattern */
 	const assign_id = (pattern) => {
-		if (
-			(pattern?.type === 'ObjectPattern' || pattern?.type === 'ArrayPattern') &&
-			pattern.lazy &&
-			!pattern.metadata?.lazy_id
-		) {
-			pattern.metadata = {
-				...pattern.metadata,
-				lazy_id: generate_lazy_id(context),
-			};
-		}
+		visit_topmost_lazy_patterns(pattern, (lazy) => {
+			if (lazy.metadata?.lazy_id) return;
+			lazy.metadata = { ...lazy.metadata, lazy_id: generate_lazy_id(context) };
+		});
 	};
 
-	/** @param {any} node */
+	/**
+	 * @param {any} node
+	 * @returns {boolean} true if `node`'s subtree contains any lazy pattern.
+	 */
 	const visit = (node) => {
-		if (!node || typeof node !== 'object') return;
+		if (!node || typeof node !== 'object') return false;
 		if (Array.isArray(node)) {
-			for (const child of node) visit(child);
-			return;
+			let found = false;
+			for (const child of node) {
+				if (visit(child)) found = true;
+			}
+			return found;
 		}
 
-		if (
-			node.type === 'FunctionDeclaration' ||
-			node.type === 'FunctionExpression' ||
-			node.type === 'ArrowFunctionExpression' ||
-			node.type === 'Component'
-		) {
+		const is_function_like = is_function_or_component_node(node);
+
+		if (is_function_like) {
 			for (const param of node.params || []) {
 				assign_id(param?.type === 'AssignmentPattern' ? param.left : param);
 			}
@@ -393,10 +493,19 @@ export function preallocate_lazy_ids(root, context) {
 			assign_id(node.expression.left);
 		}
 
+		let found =
+			(node.type === 'ObjectPattern' || node.type === 'ArrayPattern') && node.lazy === true;
+
 		for (const key of Object.keys(node)) {
 			if (key === 'loc' || key === 'start' || key === 'end' || key === 'metadata') continue;
-			visit(node[key]);
+			if (visit(node[key])) found = true;
 		}
+
+		if (is_function_like && found) {
+			node.metadata = { ...node.metadata, has_lazy_descendants: true };
+		}
+
+		return found;
 	};
 
 	visit(root);
@@ -439,15 +548,11 @@ export function apply_lazy_transforms(node, lazy_bindings) {
 		const own_bindings = new Map();
 		let had_lazy_param = false;
 		for (const param of node.params || []) {
-			const pattern = param?.type === 'AssignmentPattern' ? param.left : param;
-			if (
-				(pattern?.type === 'ObjectPattern' || pattern?.type === 'ArrayPattern') &&
-				pattern.lazy &&
-				pattern.metadata?.lazy_id
-			) {
+			visit_topmost_lazy_patterns(param, (lazy) => {
+				if (!lazy.metadata?.lazy_id) return;
 				had_lazy_param = true;
-				collect_lazy_bindings(pattern, pattern.metadata.lazy_id, own_bindings);
-			}
+				collect_lazy_bindings(lazy, lazy.metadata.lazy_id, own_bindings);
+			});
 		}
 
 		// Own bindings override any outer binding with the same name.
@@ -456,10 +561,20 @@ export function apply_lazy_transforms(node, lazy_bindings) {
 				? new Map([...outer_minus_shadow, ...own_bindings])
 				: outer_minus_shadow;
 
-		if (inner_bindings.size === 0 && !params_changed && !had_lazy_param) return node;
+		if (
+			inner_bindings.size === 0 &&
+			!params_changed &&
+			!had_lazy_param &&
+			!node.metadata?.has_lazy_descendants
+		) {
+			return node;
+		}
 
-		const new_body =
-			inner_bindings.size > 0 ? apply_lazy_transforms(node.body, inner_bindings) : node.body;
+		// Past the early-return: either we have active lazy bindings, lazy
+		// params to replace, defaults referencing outer lazy, or the body
+		// contains lazy descendants the BlockStatement handler will collect.
+		// In every case the body needs to be walked.
+		const new_body = apply_lazy_transforms(node.body, inner_bindings);
 
 		const final_params_src = params_changed ? new_params : node.params;
 		const final_params = had_lazy_param ? replace_lazy_params(final_params_src) : final_params_src;
@@ -599,6 +714,30 @@ export function apply_lazy_transforms(node, lazy_bindings) {
 		return b.const(lazy_id, init);
 	}
 
+	// Non-lazy outer assignment whose LHS contains nested lazy patterns:
+	// `{ pair: &[a, b] } = obj` → `{ pair: __lazy0 } = obj`. JS reference
+	// semantics carry writes from `__lazy0[0] = x` back into `obj.pair[0]`.
+	if (
+		node.type === 'ExpressionStatement' &&
+		node.expression?.type === 'AssignmentExpression' &&
+		node.expression.operator === '=' &&
+		(node.expression.left?.type === 'ObjectPattern' ||
+			node.expression.left?.type === 'ArrayPattern') &&
+		!node.expression.left.lazy
+	) {
+		const new_left = replace_lazy_in_pattern(node.expression.left);
+		if (new_left !== node.expression.left) {
+			return {
+				...node,
+				expression: {
+					...node.expression,
+					left: new_left,
+					right: apply_lazy_transforms(node.expression.right, lazy_bindings),
+				},
+			};
+		}
+	}
+
 	// AssignmentExpression / UpdateExpression whose target is a lazy identifier.
 	if (
 		node.type === 'AssignmentExpression' &&
@@ -633,6 +772,23 @@ export function apply_lazy_transforms(node, lazy_bindings) {
 		};
 	}
 
+	// Non-lazy outer declarator whose id contains nested lazy patterns:
+	// `let { pair: &[a, b] } = data` → `let { pair: __lazy0 } = data`.
+	if (
+		node.type === 'VariableDeclarator' &&
+		(node.id?.type === 'ObjectPattern' || node.id?.type === 'ArrayPattern') &&
+		!node.id.lazy
+	) {
+		const new_id = replace_lazy_in_pattern(node.id);
+		if (new_id !== node.id) {
+			return {
+				...node,
+				id: new_id,
+				init: apply_lazy_transforms(node.init, lazy_bindings),
+			};
+		}
+	}
+
 	// Shorthand object properties `{ name }` → `{ name: __lazy0.name }`.
 	if (node.type === 'Property' && node.shorthand && node.value?.type === 'Identifier') {
 		const binding = lazy_bindings.get(node.value.name);
@@ -758,38 +914,19 @@ function remove_shadowed(lazy_bindings, shadowed) {
 
 /**
  * Replace any lazy `&{}` / `&[]` patterns in a parameter list with their
- * generated lazy identifiers. Leaves non-lazy params untouched.
+ * generated lazy identifiers, including patterns nested inside non-lazy outer
+ * patterns. For `({ pair: &[a, b] })` returns `({ pair: __lazy0 })`. Leaves
+ * params without any lazy descendants untouched.
  *
  * @param {any[]} params
  * @returns {any[]}
  */
 export function replace_lazy_params(params) {
 	return params.map((param) => {
-		const pattern = param.type === 'AssignmentPattern' ? param.left : param;
-		if (
-			(pattern.type === 'ObjectPattern' || pattern.type === 'ArrayPattern') &&
-			pattern.lazy &&
-			pattern.metadata?.lazy_id
-		) {
-			const pattern_range = get_lazy_pattern_mapping_range(pattern);
-			const lazy_id = pattern_range
-				? create_generated_identifier(
-						pattern.metadata.lazy_id,
-						pattern_range,
-						undefined,
-						pattern_range.source_length,
-					)
-				: create_generated_identifier(pattern.metadata.lazy_id);
-			if (pattern.typeAnnotation) {
-				lazy_id.typeAnnotation = pattern.typeAnnotation;
-			} else {
-				const type_annotation = create_lazy_object_type_annotation(pattern);
-				if (type_annotation) lazy_id.typeAnnotation = type_annotation;
-			}
-			set_lazy_param_binding_mappings(lazy_id, pattern);
-			if (param.type === 'AssignmentPattern') return { ...param, left: lazy_id };
-			return lazy_id;
+		if (param.type === 'AssignmentPattern') {
+			const new_left = replace_lazy_in_pattern(param.left);
+			return new_left === param.left ? param : { ...param, left: new_left };
 		}
-		return param;
+		return replace_lazy_in_pattern(param);
 	});
 }

package/src/utils/ast.js

@@ -32,6 +32,19 @@ export function is_function_node(node) {
 	);
 }
 
+/**
+ * @param {AST.Node} node
+ * @returns {boolean}
+ */
+export function is_function_or_component_node(node) {
+	return (
+		node.type === 'FunctionDeclaration' ||
+		node.type === 'FunctionExpression' ||
+		node.type === 'ArrowFunctionExpression' ||
+		node.type === 'Component'
+	);
+}
+
 /**
  * @param {AST.Node} node
  * @returns {boolean}

package/src/utils/dom.js

@@ -0,0 +1,158 @@
+const VOID_ELEMENT_NAMES = [
+	'area',
+	'base',
+	'br',
+	'col',
+	'command',
+	'embed',
+	'hr',
+	'img',
+	'input',
+	'keygen',
+	'link',
+	'meta',
+	'param',
+	'source',
+	'track',
+	'wbr',
+];
+
+/**
+ * Returns true if name is a void element
+ * @param {string} name
+ * @returns {boolean}
+ */
+export function is_void_element(name) {
+	return VOID_ELEMENT_NAMES.includes(name) || name.toLowerCase() === '!doctype';
+}
+
+const RESERVED_WORDS = [
+	'arguments',
+	'await',
+	'break',
+	'case',
+	'catch',
+	'class',
+	'const',
+	'continue',
+	'debugger',
+	'default',
+	'delete',
+	'do',
+	'else',
+	'enum',
+	'eval',
+	'export',
+	'extends',
+	'false',
+	'finally',
+	'for',
+	'function',
+	'if',
+	'implements',
+	'import',
+	'in',
+	'instanceof',
+	'interface',
+	'let',
+	'new',
+	'null',
+	'package',
+	'private',
+	'protected',
+	'public',
+	'return',
+	'static',
+	'super',
+	'switch',
+	'this',
+	'throw',
+	'true',
+	'try',
+	'typeof',
+	'var',
+	'void',
+	'while',
+	'with',
+	'yield',
+];
+
+/**
+ * Returns true if word is a reserved JS keyword
+ * @param {string} word
+ * @returns {boolean}
+ */
+export function is_reserved(word) {
+	return RESERVED_WORDS.includes(word);
+}
+
+/**
+ * Attributes that are boolean, i.e. they are present or not present.
+ */
+const DOM_BOOLEAN_ATTRIBUTES = [
+	'allowfullscreen',
+	'async',
+	'autofocus',
+	'autoplay',
+	'checked',
+	'controls',
+	'default',
+	'disabled',
+	'formnovalidate',
+	'hidden',
+	'indeterminate',
+	'inert',
+	'ismap',
+	'loop',
+	'multiple',
+	'muted',
+	'nomodule',
+	'novalidate',
+	'open',
+	'playsinline',
+	'readonly',
+	'required',
+	'reversed',
+	'seamless',
+	'selected',
+	'webkitdirectory',
+	'defer',
+	'disablepictureinpicture',
+	'disableremoteplayback',
+];
+
+/**
+ * Returns true if name is a boolean DOM attribute
+ * @param {string} name
+ * @returns {boolean}
+ */
+export function is_boolean_attribute(name) {
+	return DOM_BOOLEAN_ATTRIBUTES.includes(name);
+}
+
+const DOM_PROPERTIES = [
+	...DOM_BOOLEAN_ATTRIBUTES,
+	'formNoValidate',
+	'isMap',
+	'noModule',
+	'playsInline',
+	'readOnly',
+	'value',
+	'volume',
+	'defaultValue',
+	'defaultChecked',
+	'srcObject',
+	'noValidate',
+	'allowFullscreen',
+	'disablePictureInPicture',
+	'disableRemotePlayback',
+];
+
+/**
+ * Returns true if name is a DOM property
+ * @param {string} name
+ * @returns {boolean}
+ */
+export function is_dom_property(name) {
+	return DOM_PROPERTIES.includes(name);
+}

package/src/utils.js

@@ -4,162 +4,9 @@
  */
 
 export { simple_hash, strong_hash } from './utils/hashing.js';
-
-const VOID_ELEMENT_NAMES = [
-	'area',
-	'base',
-	'br',
-	'col',
-	'command',
-	'embed',
-	'hr',
-	'img',
-	'input',
-	'keygen',
-	'link',
-	'meta',
-	'param',
-	'source',
-	'track',
-	'wbr',
-];
-
-/**
- * Returns true if name is a void element
- * @param {string} name
- * @returns {boolean}
- */
-export function is_void_element(name) {
-	return VOID_ELEMENT_NAMES.includes(name) || name.toLowerCase() === '!doctype';
-}
-
-const RESERVED_WORDS = [
-	'arguments',
-	'await',
-	'break',
-	'case',
-	'catch',
-	'class',
-	'const',
-	'continue',
-	'debugger',
-	'default',
-	'delete',
-	'do',
-	'else',
-	'enum',
-	'eval',
-	'export',
-	'extends',
-	'false',
-	'finally',
-	'for',
-	'function',
-	'if',
-	'implements',
-	'import',
-	'in',
-	'instanceof',
-	'interface',
-	'let',
-	'new',
-	'null',
-	'package',
-	'private',
-	'protected',
-	'public',
-	'return',
-	'static',
-	'super',
-	'switch',
-	'this',
-	'throw',
-	'true',
-	'try',
-	'typeof',
-	'var',
-	'void',
-	'while',
-	'with',
-	'yield',
-];
-
-/**
- * Returns true if word is a reserved JS keyword
- * @param {string} word
- * @returns {boolean}
- */
-export function is_reserved(word) {
-	return RESERVED_WORDS.includes(word);
-}
-
-/**
- * Attributes that are boolean, i.e. they are present or not present.
- */
-const DOM_BOOLEAN_ATTRIBUTES = [
-	'allowfullscreen',
-	'async',
-	'autofocus',
-	'autoplay',
-	'checked',
-	'controls',
-	'default',
-	'disabled',
-	'formnovalidate',
-	'hidden',
-	'indeterminate',
-	'inert',
-	'ismap',
-	'loop',
-	'multiple',
-	'muted',
-	'nomodule',
-	'novalidate',
-	'open',
-	'playsinline',
-	'readonly',
-	'required',
-	'reversed',
-	'seamless',
-	'selected',
-	'webkitdirectory',
-	'defer',
-	'disablepictureinpicture',
-	'disableremoteplayback',
-];
-
-/**
- * Returns true if name is a boolean DOM attribute
- * @param {string} name
- * @returns {boolean}
- */
-export function is_boolean_attribute(name) {
-	return DOM_BOOLEAN_ATTRIBUTES.includes(name);
-}
-
-const DOM_PROPERTIES = [
-	...DOM_BOOLEAN_ATTRIBUTES,
-	'formNoValidate',
-	'isMap',
-	'noModule',
-	'playsInline',
-	'readOnly',
-	'value',
-	'volume',
-	'defaultValue',
-	'defaultChecked',
-	'srcObject',
-	'noValidate',
-	'allowFullscreen',
-	'disablePictureInPicture',
-	'disableRemotePlayback',
-];
-
-/**
- * Returns true if name is a DOM property
- * @param {string} name
- * @returns {boolean}
- */
-export function is_dom_property(name) {
-	return DOM_PROPERTIES.includes(name);
-}
+export {
+	is_boolean_attribute,
+	is_dom_property,
+	is_reserved,
+	is_void_element,
+} from './utils/dom.js';

package/types/index.d.ts

@@ -92,6 +92,7 @@ interface FunctionMetaData extends BaseNodeMetaData {
 	is_component?: boolean;
 	is_method?: boolean;
 	tracked?: boolean;
+	has_lazy_descendants?: boolean;
 }
 
 // Strip parent, loc, and range from TSESTree nodes to match @sveltejs/acorn-typescript output

package/types/jsx-platform.d.ts

@@ -306,8 +306,10 @@ export interface JsxPlatform {
 		 * Module to import the `map_iterable` runtime helper (and the
 		 * `IterationValue` type) from when compiling `for ... of` bodies whose
 		 * source can be any `Iterable` — not just an array. React and Preact
-		 * use `'@tsrx/core/runtime'`. Solid and Vue lower for-of via their own
-		 * iteration components and leave this unset.
+		 * use target-owned paths like `'@tsrx/react/runtime/iterable'` and
+		 * `'@tsrx/preact/runtime/iterable'`, which re-export from
+		 * `'@tsrx/core/runtime/iterable'`. Solid and Vue lower for-of via their
+		 * own iteration components and leave this unset.
 		 */
 		forOfIterableHelper?: string;
 	};

package/types/runtime/events.d.ts

@@ -0,0 +1,11 @@
+export function event_name_from_capture(event_name: string): string;
+export function get_attribute_event_name(
+	name: string,
+	handler: EventListener | { customName?: string },
+): string;
+export function get_original_event_name(name: string): string;
+export function is_capture_event(event_name: string): boolean;
+export function is_event_attribute(attr: string): boolean;
+export function is_non_delegated(event_name: string): boolean;
+export function is_passive_event(name: string): boolean;
+export function normalize_event_name(name: string): string;

package/types/runtime/hash.d.ts

@@ -0,0 +1,2 @@
+export function simple_hash(str: string): string;
+export function strong_hash(str: string): string;

package/types/runtime/html.d.ts

@@ -0,0 +1,4 @@
+export function escape<V>(value: V, is_attr?: boolean): string;
+export function escape_script(str: string): string;
+export function is_boolean_attribute(name: string): boolean;
+export function normalize_css_property_name(str: string): string;

package/types/runtime/language-helpers.d.ts

@@ -0,0 +1,17 @@
+export const get_descriptor: typeof Object.getOwnPropertyDescriptor;
+export const get_descriptors: typeof Object.getOwnPropertyDescriptors;
+export const array_from: typeof Array.from;
+export const is_array: typeof Array.isArray;
+export const define_property: typeof Object.defineProperty;
+export const get_prototype_of: typeof Object.getPrototypeOf;
+export const object_values: typeof Object.values;
+export const object_entries: typeof Object.entries;
+export const object_keys: typeof Object.keys;
+export const get_own_property_symbols: typeof Object.getOwnPropertySymbols;
+export const structured_clone: typeof structuredClone;
+export const object_prototype: typeof Object.prototype;
+export const array_prototype: typeof Array.prototype;
+export const has_own_property: typeof Object.prototype.hasOwnProperty;
+
+export function has_prototype_accessor(value: object, key: PropertyKey): boolean;
+export function array_slice(array_like: ArrayLike<any>, ...args: number[]): any[];