octane 0.2.7 → 0.2.8

package/dist/compiler/strong-mode.js

@@ -53,9 +53,98 @@ const NO_RETURN_VALUE = Symbol('no return value');
 const OTHER_BINDING = { kind: 'other' };
 const SNAPSHOT_BINDING = { kind: 'snapshot' };
 const ARRAY_SNAPSHOT_BINDING = { kind: 'snapshot', array: true };
-const STATE_TUPLE_BINDING = { kind: 'state-tuple', snapshot: SNAPSHOT_BINDING };
-const ARRAY_STATE_TUPLE_BINDING = { kind: 'state-tuple', snapshot: ARRAY_SNAPSHOT_BINDING };
+const STATE_GETTER_BINDING = { kind: 'getter' };
+const STATE_TUPLE_BINDING = {
+	kind: 'state-tuple',
+	snapshot: SNAPSHOT_BINDING,
+	getter: STATE_GETTER_BINDING,
+};
+const ARRAY_STATE_TUPLE_BINDING = {
+	kind: 'state-tuple',
+	snapshot: ARRAY_SNAPSHOT_BINDING,
+	getter: STATE_GETTER_BINDING,
+};
 const UNDEFINED_BINDING = { kind: 'constant', value: UNDEFINED_VALUE, primitive: undefined };
+const GLOBAL_OBJECT_BINDING = { kind: 'global-object' };
+const AMBIENT_GLOBAL_BINDINGS = new Map(
+	[
+		'window',
+		'document',
+		'localStorage',
+		'sessionStorage',
+		'navigator',
+		'location',
+		'matchMedia',
+	].map((name) => [name, { kind: 'ambient', name }]),
+);
+// Reading a standard language builtin is permitted here. Its calls still
+// follow the separate clock/randomness rules; this is not a purity whitelist.
+const LANGUAGE_GLOBALS = new Set([
+	'undefined',
+	'NaN',
+	'Infinity',
+	'globalThis',
+	'Object',
+	'Function',
+	'Boolean',
+	'Symbol',
+	'Error',
+	'AggregateError',
+	'EvalError',
+	'RangeError',
+	'ReferenceError',
+	'SyntaxError',
+	'TypeError',
+	'URIError',
+	'Number',
+	'BigInt',
+	'Math',
+	'Date',
+	'String',
+	'RegExp',
+	'Array',
+	'Int8Array',
+	'Uint8Array',
+	'Uint8ClampedArray',
+	'Int16Array',
+	'Uint16Array',
+	'Int32Array',
+	'Uint32Array',
+	'BigInt64Array',
+	'BigUint64Array',
+	'Float16Array',
+	'Float32Array',
+	'Float64Array',
+	'Map',
+	'Set',
+	'WeakMap',
+	'WeakSet',
+	'ArrayBuffer',
+	'SharedArrayBuffer',
+	'DataView',
+	'Atomics',
+	'JSON',
+	'Promise',
+	'Reflect',
+	'Proxy',
+	'WeakRef',
+	'FinalizationRegistry',
+	'Intl',
+	'Iterator',
+	'AsyncIterator',
+	'DisposableStack',
+	'AsyncDisposableStack',
+	'isFinite',
+	'isNaN',
+	'parseFloat',
+	'parseInt',
+	'decodeURI',
+	'decodeURIComponent',
+	'encodeURI',
+	'encodeURIComponent',
+	'escape',
+	'unescape',
+]);
 const SKIP_KEYS = new Set([
 	'type',
 	'start',
@@ -72,8 +161,12 @@ const SKIP_KEYS = new Set([
 ]);
 
 export const STRONG_RENDER_STATE_UPDATE = 'OCTANE_STRONG_RENDER_STATE_UPDATE';
+export const STRONG_RENDER_STATE_GETTER_CALL = 'OCTANE_STRONG_RENDER_STATE_GETTER_CALL';
+export const STRONG_RENDER_MODULE_STATE_READ = 'OCTANE_STRONG_RENDER_MODULE_STATE_READ';
+export const STRONG_RENDER_AMBIENT_READ = 'OCTANE_STRONG_RENDER_AMBIENT_READ';
 export const STRONG_EFFECT_STATE_UPDATE = 'OCTANE_STRONG_EFFECT_STATE_UPDATE';
 export const STRONG_RENDER_REF_WRITE = 'OCTANE_STRONG_RENDER_REF_WRITE';
+export const STRONG_RENDER_REF_READ = 'OCTANE_STRONG_RENDER_REF_READ';
 export const STRONG_RENDER_SNAPSHOT_MUTATION = 'OCTANE_STRONG_RENDER_SNAPSHOT_MUTATION';
 export const STRONG_RETAINED_ROW_MUTATION = 'OCTANE_STRONG_RETAINED_ROW_MUTATION';
 export const STRONG_RENDER_IMPURE_CALL = 'OCTANE_STRONG_RENDER_IMPURE_CALL';
@@ -1200,6 +1293,40 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 		return reassignedBindings.has(identifier);
 	}
 	const moduleScope = createScope(null, 'module', ast.body ?? [], [], isReassigned);
+	const mutableModuleDeclarations = new Map();
+	const reassignedModuleNames = new Map();
+	const moduleAmbientAliases = new Map();
+	const activeAmbientAliases = new Set();
+	function recordModuleAmbientAliases(pattern, initializer, properties = []) {
+		if (pattern?.type === 'Identifier') {
+			moduleAmbientAliases.set(pattern.name, { initializer, properties });
+		} else if (pattern?.type === 'AssignmentPattern') {
+			recordModuleAmbientAliases(pattern.left, initializer, properties);
+		} else if (pattern?.type === 'ObjectPattern') {
+			for (const property of pattern.properties ?? []) {
+				if (property.type === 'Property') {
+					recordModuleAmbientAliases(property.value, initializer, [...properties, property]);
+				}
+			}
+		}
+	}
+	function recordMutableModulePattern(pattern) {
+		if (pattern?.type === 'Identifier') {
+			let declarations = mutableModuleDeclarations.get(pattern.name);
+			if (declarations === undefined) {
+				mutableModuleDeclarations.set(pattern.name, (declarations = []));
+			}
+			declarations.push(pattern);
+		} else if (pattern?.type === 'AssignmentPattern' || pattern?.type === 'RestElement') {
+			recordMutableModulePattern(pattern.left ?? pattern.argument);
+		} else if (pattern?.type === 'ArrayPattern') {
+			for (const element of pattern.elements ?? []) recordMutableModulePattern(element);
+		} else if (pattern?.type === 'ObjectPattern') {
+			for (const property of pattern.properties ?? []) {
+				recordMutableModulePattern(property.argument ?? property.value);
+			}
+		}
+	}
 	const activeCallbacks = new Set();
 	const activeReturnCallbacks = new Set();
 	const callResults = new WeakMap();
@@ -1251,7 +1378,23 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 	for (const statement of ast.body ?? []) {
 		const declaration = declarationOf(statement);
 		if (declaration?.type === 'VariableDeclaration') {
+			if (declaration.kind === 'let' && declaration.declare !== true) {
+				for (const binding of declaration.declarations ?? []) {
+					recordMutableModulePattern(binding.id);
+				}
+			}
 			for (const binding of declaration.declarations ?? []) {
+				const initial = unwrap(binding.init);
+				if (
+					declaration.kind === 'const' &&
+					(initial?.type === 'Identifier' ||
+						initial?.type === 'MemberExpression' ||
+						initial?.type === 'Literal' ||
+						initial?.type === 'TemplateLiteral' ||
+						initial?.type === 'BinaryExpression')
+				) {
+					recordModuleAmbientAliases(binding.id, initial);
+				}
 				if (binding.id?.type === 'Identifier') {
 					addNamedRenderRoot(unwrap(binding.init), binding.id.name);
 				}
@@ -1266,6 +1409,7 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 	let returnCycles = 0;
 	let currentFunctionIsAsync = false;
 	let currentFunctionChecksImpureCalls = false;
+	let currentFunctionChecksRenderReads = false;
 	let currentRetainedRowScope = null;
 
 	function predeclareHoistedVars(node, scope) {
@@ -1296,6 +1440,9 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 				if (value.type === 'VariableDeclaration' && value.kind === 'var') {
 					for (const declaration of value.declarations ?? []) {
 						addPatternNames(declaration.id, names, OTHER_BINDING);
+						if (scope === moduleScope && value.declare !== true) {
+							recordMutableModulePattern(declaration.id);
+						}
 					}
 				}
 				for (const key in value) {
@@ -1328,6 +1475,170 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 		report(code, node, message, [{ hook: 'useLinkedState' }]);
 	}
 
+	function reportStateGetterCall(node) {
+		report(
+			STRONG_RENDER_STATE_GETTER_CALL,
+			node,
+			'Strong mode does not allow calling a state getter during render. Render from the state tuple snapshot; call the getter in an event, effect, or deferred callback for the latest scheduled state.',
+		);
+	}
+
+	function reportModuleStateRead(node) {
+		report(
+			STRONG_RENDER_MODULE_STATE_READ,
+			node,
+			'Strong mode does not allow reading a reassigned module variable during render. Move the value into state or context, or pass an immutable snapshot as a prop.',
+		);
+	}
+
+	function reportAmbientRead(node) {
+		report(
+			STRONG_RENDER_AMBIENT_READ,
+			node,
+			'Strong mode does not allow reading browser globals during render. Use useSyncExternalStore with a server snapshot for live browser state, or read it in an effect or a lazy state initializer. Lazy initializers still need to handle server rendering.',
+		);
+	}
+
+	function ambientMemberBinding(object, key) {
+		if (object === GLOBAL_OBJECT_BINDING || object === AMBIENT_GLOBAL_BINDINGS.get('window')) {
+			if (key === 'globalThis') return GLOBAL_OBJECT_BINDING;
+			return AMBIENT_GLOBAL_BINDINGS.get(key) ?? null;
+		}
+		return null;
+	}
+
+	function ambientKeyValue(expression, scope) {
+		const node = unwrap(expression);
+		if (node?.type !== 'Identifier' || resolveScope(scope, node.name) !== moduleScope)
+			return UNKNOWN_PRIMITIVE;
+		const alias = moduleAmbientAliases.get(node.name);
+		if (
+			alias === undefined ||
+			alias.properties.length !== 0 ||
+			activeAmbientAliases.has(node.name)
+		) {
+			return UNKNOWN_PRIMITIVE;
+		}
+		// A render root can appear before the module constant used as its key.
+		activeAmbientAliases.add(node.name);
+		try {
+			return staticPrimitiveValue(alias.initializer, moduleScope, true);
+		} finally {
+			activeAmbientAliases.delete(node.name);
+		}
+	}
+
+	function ambientPropertyKey(property, scope) {
+		const key = property.type === 'Property' ? property.key : property.property;
+		return property.computed ? staticPrimitiveValue(key, scope, true) : (key?.name ?? key?.value);
+	}
+
+	function ambientReference(expression, scope) {
+		const node = unwrap(expression);
+		if (node?.type === 'Identifier' || node?.type === 'JSXIdentifier') {
+			const binding = resolve(scope, node.name);
+			if (binding?.kind === 'ambient' || binding === GLOBAL_OBJECT_BINDING) return binding;
+			if (binding === null) {
+				return node.name === 'globalThis'
+					? GLOBAL_OBJECT_BINDING
+					: (AMBIENT_GLOBAL_BINDINGS.get(node.name) ?? null);
+			}
+			const alias = moduleAmbientAliases.get(node.name);
+			if (
+				alias !== undefined &&
+				resolveScope(scope, node.name) === moduleScope &&
+				!activeAmbientAliases.has(node.name)
+			) {
+				// Module functions can precede their const aliases. Resolve only
+				// browser handles, never taint a copied scalar module snapshot.
+				activeAmbientAliases.add(node.name);
+				try {
+					let value = ambientReference(alias.initializer, moduleScope);
+					for (const property of alias.properties) {
+						value = ambientMemberBinding(value, ambientPropertyKey(property, moduleScope));
+					}
+					return value;
+				} finally {
+					activeAmbientAliases.delete(node.name);
+				}
+			}
+			return null;
+		}
+		if (node?.type === 'MemberExpression' || node?.type === 'JSXMemberExpression') {
+			const object = ambientReference(node.object, scope);
+			return object === GLOBAL_OBJECT_BINDING || object === AMBIENT_GLOBAL_BINDINGS.get('window')
+				? ambientMemberBinding(object, ambientPropertyKey(node, scope))
+				: null;
+		}
+		return null;
+	}
+
+	function isAmbientMemberRead(node, scope) {
+		const value = unwrap(node);
+		if (value?.type !== 'MemberExpression' && value?.type !== 'JSXMemberExpression') return false;
+		return (
+			ambientReference(value.object, scope) === GLOBAL_OBJECT_BINDING &&
+			!LANGUAGE_GLOBALS.has(ambientPropertyKey(value, scope))
+		);
+	}
+
+	function bindAmbientPattern(pattern, value, scope, bind) {
+		if (value !== GLOBAL_OBJECT_BINDING && value?.kind !== 'ambient') return;
+		if (pattern?.type === 'Identifier') {
+			bind(pattern, value);
+		} else if (pattern?.type === 'AssignmentPattern') {
+			bindAmbientPattern(pattern.left, value, scope, bind);
+		} else if (pattern?.type === 'ObjectPattern') {
+			for (const property of pattern.properties ?? []) {
+				if (property.type !== 'Property') continue;
+				bindAmbientPattern(
+					property.value,
+					ambientMemberBinding(value, ambientPropertyKey(property, scope)),
+					scope,
+					bind,
+				);
+			}
+		}
+	}
+
+	function mutableModuleRead(name, scope) {
+		const declarations = mutableModuleDeclarations.get(name);
+		if (declarations === undefined || resolveScope(scope, name) !== moduleScope) {
+			return false;
+		}
+		let reassigned = reassignedModuleNames.get(name);
+		if (reassigned === undefined) {
+			reassigned = declarations.some(isReassigned);
+			reassignedModuleNames.set(name, reassigned);
+		}
+		return reassigned;
+	}
+
+	function definitelySkippedOptionalContinuation(expression, scope) {
+		let node = expression;
+		while (node != null) {
+			// Grouping ends the chain; the caller decides whether a grouped
+			// undefined value is itself behind an optional access.
+			if (node.type === 'ChainExpression') return false;
+			if (TRANSPARENT_EXPRESSIONS.has(node.type)) {
+				node = node.expression;
+				continue;
+			}
+			if (node.type !== 'CallExpression' && node.type !== 'MemberExpression') return false;
+			const target = node.type === 'CallExpression' ? node.callee : node.object;
+			if (node.optional === true && definitelyNullishOptionalValue(target, scope)) return true;
+			node = target;
+		}
+		return false;
+	}
+
+	function definitelyNullishOptionalValue(expression, scope) {
+		return (
+			(staticExpressionValue(expression, scope) & ~NULLISH_VALUE) === 0 ||
+			definitelySkippedOptionalContinuation(unwrap(expression), scope)
+		);
+	}
+
 	function reportRef(node) {
 		report(
 			STRONG_RENDER_REF_WRITE,
@@ -1336,6 +1647,32 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 		);
 	}
 
+	function reportRefRead(node) {
+		report(
+			STRONG_RENDER_REF_READ,
+			node,
+			'Strong mode does not allow reading useRef.current during render. Read the ref in an event or effect, or use state or useLinkedState for values that drive render output.',
+		);
+	}
+
+	function isRefObject(value, scope) {
+		const object = unwrap(value);
+		if (object?.type === 'Identifier') return resolve(scope, object.name)?.kind === 'ref';
+		if (object?.type === 'SequenceExpression') {
+			return isRefObject(object.expressions?.[object.expressions.length - 1], scope);
+		}
+		return object?.type === 'CallExpression' && importedHook(object.callee, scope) === 'useRef';
+	}
+
+	function readCurrentRef(member, scope) {
+		const value = unwrap(member);
+		if (value?.type !== 'MemberExpression') return false;
+		const isCurrent = value.computed
+			? staticPrimitiveValue(value.property, scope) === 'current'
+			: value.property?.type === 'Identifier' && value.property.name === 'current';
+		return isCurrent && isRefObject(value.object, scope);
+	}
+
 	function reportSnapshotMutation(node) {
 		report(
 			STRONG_RENDER_SNAPSHOT_MUTATION,
@@ -1770,6 +2107,7 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 	}
 
 	function definitelyDefined(value) {
+		if (value === GLOBAL_OBJECT_BINDING) return true;
 		if (value?.kind === 'constant' && value.primitive !== UNKNOWN_PRIMITIVE) {
 			return value.primitive !== undefined;
 		}
@@ -1784,6 +2122,11 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 	function visitParameters(node, parentScope, phase, args) {
 		const parameters = node.params ?? [];
 		const parameterScope = createScope(parentScope, 'function', [], parameters);
+		function bindGetter(identifier, binding) {
+			if (identifier?.type === 'Identifier' && !isReassigned(identifier)) {
+				parameterScope.bindings.set(identifier.name, binding);
+			}
+		}
 		if (
 			node.type === 'FunctionExpression' &&
 			node.id?.name &&
@@ -1796,17 +2139,38 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 			if (parameter.type === 'TSParameterProperty') parameter = parameter.parameter;
 			let value = args === null ? OTHER_BINDING : (args[index] ?? UNDEFINED_BINDING);
 			if (parameter.type === 'AssignmentPattern') {
-				visitPatternExpressions(parameter.left, parameterScope, phase);
-				if (!definitelyDefined(value)) visit(parameter.right, parameterScope, phase);
+				const usesDefault = !definitelyDefined(value);
+				if (usesDefault) visit(parameter.right, parameterScope, phase);
+				const defaultValue = usesDefault
+					? expressionBinding(parameter.right, parameterScope)
+					: null;
 				value =
 					value.kind === 'constant' && value.primitive === undefined
-						? expressionBinding(parameter.right, parameterScope)
+						? defaultValue
 						: definitelyDefined(value)
 							? value
-							: OTHER_BINDING;
+							: defaultValue?.kind === 'getter' ||
+								  defaultValue?.kind === 'state-tuple' ||
+								  defaultValue === GLOBAL_OBJECT_BINDING ||
+								  defaultValue?.kind === 'ambient'
+								? defaultValue
+								: OTHER_BINDING;
+				visitPatternExpressions(
+					parameter.left,
+					parameterScope,
+					usesDefault ? phaseAfter(parameter.right, phase) : phase,
+					parameter.left.type === 'ObjectPattern' &&
+						(value?.kind === 'ref' ||
+							(usesDefault && isRefObject(parameter.right, parameterScope))),
+					value,
+				);
+				bindStateGetterPattern(parameter.left, value, parameterScope, bindGetter);
+				bindAmbientPattern(parameter.left, value, parameterScope, bindGetter);
 				parameter = parameter.left;
 			} else {
-				visitPatternExpressions(parameter, parameterScope, phase);
+				visitPatternExpressions(parameter, parameterScope, phase, value?.kind === 'ref', value);
+				bindStateGetterPattern(parameter, value, parameterScope, bindGetter);
+				bindAmbientPattern(parameter, value, parameterScope, bindGetter);
 			}
 			if (parameter.type === 'Identifier' && !isReassigned(parameter)) {
 				parameterScope.bindings.set(parameter.name, value);
@@ -1818,11 +2182,12 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 	function visitFunction(node, parentScope, phase, args = null) {
 		const enclosingFunctionIsAsync = currentFunctionIsAsync;
 		const enclosingFunctionChecksImpureCalls = currentFunctionChecksImpureCalls;
+		const enclosingFunctionChecksRenderReads = currentFunctionChecksRenderReads;
 		currentFunctionIsAsync = node.async === true;
 		if (phase === 'render' && !activeCallbacks.has(node)) {
 			// Ordinary module helpers may be used only by events. Check their
 			// standard calls when a known render root invokes them synchronously.
-			currentFunctionChecksImpureCalls =
+			currentFunctionChecksImpureCalls = currentFunctionChecksRenderReads =
 				renderRoots.has(node) || node.body?.type === 'JSXCodeBlock';
 		}
 		try {
@@ -1854,38 +2219,74 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 		} finally {
 			currentFunctionIsAsync = enclosingFunctionIsAsync;
 			currentFunctionChecksImpureCalls = enclosingFunctionChecksImpureCalls;
+			currentFunctionChecksRenderReads = enclosingFunctionChecksRenderReads;
 		}
 	}
 
-	function visitPatternExpressions(pattern, scope, phase) {
+	function visitPatternExpressions(pattern, scope, phase, refSource = false, ambientSource = null) {
 		let executionPhase = phase;
 		if (pattern?.type === 'TSParameterProperty') {
-			return visitPatternExpressions(pattern.parameter, scope, phase);
+			return visitPatternExpressions(pattern.parameter, scope, phase, refSource, ambientSource);
 		} else if (pattern?.type === 'Identifier') {
 			if (executionPhase === 'render') reportRetainedRowMutation(pattern, scope);
 		} else if (pattern?.type === 'AssignmentPattern') {
-			executionPhase = visitPatternExpressions(pattern.left, scope, executionPhase);
+			executionPhase = visitPatternExpressions(
+				pattern.left,
+				scope,
+				executionPhase,
+				refSource,
+				ambientSource,
+			);
 			visit(pattern.right, scope, executionPhase);
 		} else if (pattern?.type === 'ArrayPattern') {
 			for (const element of pattern.elements ?? []) {
 				executionPhase = visitPatternExpressions(element, scope, executionPhase);
 			}
 		} else if (pattern?.type === 'ObjectPattern') {
+			let currentExcluded = false;
 			for (const property of pattern.properties ?? []) {
 				if (property.computed) {
 					visit(property.key, scope, executionPhase);
 					executionPhase = phaseAfter(property.key, executionPhase);
 				}
+				if (
+					ambientSource === GLOBAL_OBJECT_BINDING &&
+					executionPhase === 'render' &&
+					currentFunctionChecksImpureCalls &&
+					(property.type === 'RestElement' ||
+						!LANGUAGE_GLOBALS.has(ambientPropertyKey(property, scope)))
+				) {
+					reportAmbientRead(property.type === 'RestElement' ? property : property.key);
+				}
+				const currentProperty =
+					refSource &&
+					property.type === 'Property' &&
+					(property.computed
+						? staticPrimitiveValue(property.key, scope)
+						: (property.key?.name ?? property.key?.value)) === 'current';
+				if (
+					refSource &&
+					executionPhase === 'render' &&
+					currentFunctionChecksRenderReads &&
+					(currentProperty || (property.type === 'RestElement' && !currentExcluded))
+				) {
+					reportRefRead(currentProperty ? property.key : property);
+				}
+				if (currentProperty) currentExcluded = true;
 				executionPhase = visitPatternExpressions(
 					property.argument ?? property.value,
 					scope,
 					executionPhase,
+					false,
+					ambientSource === null
+						? null
+						: ambientMemberBinding(ambientSource, ambientPropertyKey(property, scope)),
 				);
 			}
 		} else if (pattern?.type === 'RestElement') {
 			executionPhase = visitPatternExpressions(pattern.argument, scope, executionPhase);
 		} else if (pattern?.type === 'MemberExpression') {
-			visit(pattern, scope, executionPhase);
+			visit(pattern, scope, executionPhase, false);
 			executionPhase = phaseAfter(pattern, executionPhase, true);
 			if (executionPhase === 'render') {
 				reportSnapshotWrite(pattern, scope);
@@ -1895,6 +2296,26 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 		return executionPhase;
 	}
 
+	function bindStateGetterPattern(pattern, tuple, scope, bind) {
+		if (tuple?.kind !== 'state-tuple') return;
+		if (pattern?.type === 'ArrayPattern') {
+			const element = pattern.elements?.[2];
+			bind(element?.type === 'AssignmentPattern' ? element.left : element, tuple.getter);
+		} else if (pattern?.type === 'ObjectPattern') {
+			for (const property of pattern.properties ?? []) {
+				if (property.type !== 'Property') continue;
+				const key = property.computed
+					? staticPrimitiveValue(property.key, scope)
+					: property.key?.type === 'Identifier'
+						? property.key.name
+						: property.key?.value;
+				if (key !== 2 && key !== '2') continue;
+				const value = property.value;
+				bind(value?.type === 'AssignmentPattern' ? value.left : value, tuple.getter);
+			}
+		}
+	}
+
 	function bindDeclarationValue(declaration, declarationKind, scope) {
 		const target = declarationScope(scope, declarationKind);
 		const initial = unwrap(declaration.init);
@@ -1905,6 +2326,11 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 				declarationKind === 'const' || !isReassigned(identifier) ? value : OTHER_BINDING,
 			);
 		}
+		const ambient = ambientReference(initial, scope);
+		if (ambient !== null) {
+			bindAmbientPattern(declaration.id, ambient, scope, bind);
+			return;
+		}
 		const stateTuple = stateTupleBinding(initial, scope);
 		const snapshot =
 			stateTuple === null && declarationKind === 'const' ? snapshotBinding(initial, scope) : null;
@@ -1913,6 +2339,7 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 			const element = declaration.id.elements?.[1];
 			const setter = element?.type === 'AssignmentPattern' ? element.left : element;
 			bind(setter, { kind: 'setter' });
+			bindStateGetterPattern(declaration.id, stateTuple, scope, bind);
 		} else if (declaration.id?.type === 'ObjectPattern' && stateTuple) {
 			for (const property of declaration.id.properties ?? []) {
 				if (property.type !== 'Property') continue;
@@ -1929,6 +2356,7 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 					bindSnapshotPattern(value, stateTuple.snapshot, bind);
 				}
 			}
+			bindStateGetterPattern(declaration.id, stateTuple, scope, bind);
 		} else if (declaration.id?.type === 'Identifier') {
 			if (stateTuple) {
 				bind(declaration.id, stateTuple);
@@ -1939,12 +2367,15 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 				bind(declaration.id, { kind: 'ref' });
 			} else if (declarationKind === 'const' && stateTupleUpdater(initial, scope)) {
 				target.bindings.set(declaration.id.name, { kind: 'setter' });
+			} else if (declarationKind === 'const' && stateTupleGetter(initial, scope)) {
+				target.bindings.set(declaration.id.name, STATE_GETTER_BINDING);
 			} else if (snapshot !== null) {
 				target.bindings.set(declaration.id.name, snapshot);
 			} else if (declarationKind === 'const' && initial?.type === 'Identifier') {
 				const value = resolve(scope, initial.name);
 				if (
 					value?.kind === 'setter' ||
+					value?.kind === 'getter' ||
 					value?.kind === 'ref' ||
 					value?.kind === 'callback' ||
 					value?.kind === 'callback-choice' ||
@@ -2038,7 +2469,13 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 	function bindDeclaration(declaration, declarationKind, scope, phase) {
 		bindDeclarationValue(declaration, declarationKind, scope);
 		visit(declaration.init, scope, phase);
-		return visitPatternExpressions(declaration.id, scope, phaseAfter(declaration.init, phase));
+		return visitPatternExpressions(
+			declaration.id,
+			scope,
+			phaseAfter(declaration.init, phase),
+			declaration.id?.type === 'ObjectPattern' && isRefObject(declaration.init, scope),
+			declaration.id?.type === 'ObjectPattern' ? ambientReference(declaration.init, scope) : null,
+		);
 	}
 
 	function visitCallback(node, parentScope, phase, args = null) {
@@ -2063,7 +2500,17 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 		);
 	}
 
-	function staticPrimitiveValue(value, scope) {
+	function stateTupleGetter(value, scope) {
+		const member = unwrap(value);
+		if (member?.type !== 'MemberExpression' || member.computed !== true) return false;
+		const key = staticPrimitiveValue(member.property, scope);
+		return (
+			(key === 2 || key === '2') &&
+			stateTupleBinding(member.object, scope)?.getter === STATE_GETTER_BINDING
+		);
+	}
+
+	function staticPrimitiveValue(value, scope, moduleConstantKeys = false) {
 		const expression = unwrap(value);
 		if (expression?.type === 'CallExpression') {
 			const result = callResult(expression, scope);
@@ -2075,7 +2522,7 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 			if (binding?.kind === 'linked-key') return binding.value;
 			if (binding?.kind === 'constant') return binding.primitive;
 			if (binding == null && expression.name === 'undefined') return undefined;
-			return UNKNOWN_PRIMITIVE;
+			return moduleConstantKeys ? ambientKeyValue(expression, scope) : UNKNOWN_PRIMITIVE;
 		}
 		if (expression?.type === 'TemplateLiteral') {
 			let result = '';
@@ -2084,7 +2531,11 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 				if (text == null) return UNKNOWN_PRIMITIVE;
 				result += text;
 				if (index < (expression.expressions?.length ?? 0)) {
-					const part = staticPrimitiveValue(expression.expressions[index], scope);
+					const part = staticPrimitiveValue(
+						expression.expressions[index],
+						scope,
+						moduleConstantKeys,
+					);
 					if (
 						part === UNKNOWN_PRIMITIVE ||
 						(part !== null && typeof part === 'object') ||
@@ -2099,8 +2550,8 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 			return result;
 		}
 		if (expression?.type === 'BinaryExpression' && expression.operator === '+') {
-			const left = staticPrimitiveValue(expression.left, scope);
-			const right = staticPrimitiveValue(expression.right, scope);
+			const left = staticPrimitiveValue(expression.left, scope, moduleConstantKeys);
+			const right = staticPrimitiveValue(expression.right, scope, moduleConstantKeys);
 			if (
 				left === UNKNOWN_PRIMITIVE ||
 				right === UNKNOWN_PRIMITIVE ||
@@ -2125,7 +2576,7 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 		}
 		if (expression?.type === 'UnaryExpression') {
 			if (expression.operator === 'void') return undefined;
-			const argument = staticPrimitiveValue(expression.argument, scope);
+			const argument = staticPrimitiveValue(expression.argument, scope, moduleConstantKeys);
 			if (expression.operator === '!') {
 				if (argument !== UNKNOWN_PRIMITIVE) return !argument;
 				const value = staticExpressionValue(expression.argument, scope);
@@ -2151,22 +2602,22 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 		}
 		if (expression?.type === 'SequenceExpression') {
 			const expressions = expression.expressions ?? [];
-			return staticPrimitiveValue(expressions[expressions.length - 1], scope);
+			return staticPrimitiveValue(expressions[expressions.length - 1], scope, moduleConstantKeys);
 		}
 		if (expression?.type === 'ConditionalExpression') {
 			const branches = conditionalExpressionBranches(expression, scope);
 			return branches === 1
-				? staticPrimitiveValue(expression.consequent, scope)
+				? staticPrimitiveValue(expression.consequent, scope, moduleConstantKeys)
 				: branches === 2
-					? staticPrimitiveValue(expression.alternate, scope)
+					? staticPrimitiveValue(expression.alternate, scope, moduleConstantKeys)
 					: UNKNOWN_PRIMITIVE;
 		}
 		if (expression?.type === 'LogicalExpression') {
 			const branches = logicalExpressionBranches(expression, scope);
 			return branches === 1
-				? staticPrimitiveValue(expression.left, scope)
+				? staticPrimitiveValue(expression.left, scope, moduleConstantKeys)
 				: branches === 2
-					? staticPrimitiveValue(expression.right, scope)
+					? staticPrimitiveValue(expression.right, scope, moduleConstantKeys)
 					: UNKNOWN_PRIMITIVE;
 		}
 		return UNKNOWN_PRIMITIVE;
@@ -2188,7 +2639,8 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 			FUNCTION_TYPES.has(expression?.type) ||
 			expression?.type === 'ObjectExpression' ||
 			expression?.type === 'ArrayExpression' ||
-			stateTupleUpdater(expression, scope)
+			stateTupleUpdater(expression, scope) ||
+			stateTupleGetter(expression, scope)
 		) {
 			return TRUTHY_VALUE;
 		} else if (
@@ -2207,6 +2659,7 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 				binding?.kind === 'callback' ||
 				binding?.kind === 'effect-event' ||
 				binding?.kind === 'setter' ||
+				binding?.kind === 'getter' ||
 				binding?.kind === 'ref' ||
 				binding?.kind === 'state-tuple' ||
 				binding?.kind === 'linked-key' ||
@@ -2305,7 +2758,8 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 			value?.kind === 'callback' ||
 			value?.kind === 'callback-choice' ||
 			value?.kind === 'effect-event' ||
-			value?.kind === 'setter'
+			value?.kind === 'setter' ||
+			value?.kind === 'getter'
 		);
 	}
 
@@ -2332,7 +2786,8 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 				if (scopes === undefined) functions.set(callback.node, (scopes = new Set()));
 				scopes.add(callback.scope);
 			} else {
-				const identity = callback.kind === 'setter' ? 'setter' : callback;
+				const identity =
+					callback.kind === 'setter' || callback.kind === 'getter' ? callback.kind : callback;
 				if (seen.has(identity)) return;
 				seen.add(identity);
 			}
@@ -2396,6 +2851,7 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 			return isCallableValue(binding) ? binding : null;
 		}
 		if (stateTupleUpdater(node, scope)) return { kind: 'setter' };
+		if (stateTupleGetter(node, scope)) return STATE_GETTER_BINDING;
 		if (node?.type === 'SequenceExpression') {
 			return callableValue(node.expressions?.[node.expressions.length - 1], scope);
 		}
@@ -2498,6 +2954,8 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 
 	function expressionBinding(expression, scope) {
 		const node = unwrap(expression);
+		const ambient = ambientReference(node, scope);
+		if (ambient !== null) return ambient;
 		if (node?.type === 'Identifier') {
 			const binding = resolve(scope, node.name);
 			if (
@@ -2681,12 +3139,14 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 			else if (phase === 'effect') visitCallable(value.callback, origin, phase, args);
 		} else if (value?.kind === 'setter' && (phase === 'render' || phase === 'effect')) {
 			reportSetter(origin, phase);
+		} else if (value?.kind === 'getter' && phase === 'render' && currentFunctionChecksRenderReads) {
+			reportStateGetterCall(origin);
 		}
 	}
 
 	function visitSynchronousHookCallback(value, scope, phase, stateInitializer = false) {
 		const checkImpureCalls = currentFunctionChecksImpureCalls;
-		// Lazy state initialization may read a clock or randomness. Keep its
+		// Lazy state initialization may read a clock, randomness, or browser state. Keep its
 		// existing state/ref/Effect Event checks at the synchronous render phase.
 		if (stateInitializer) currentFunctionChecksImpureCalls = false;
 		try {
@@ -2853,26 +3313,92 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 		}
 	}
 
-	function visit(node, scope, phase) {
+	function visit(node, scope, phase, readAccess = true) {
 		if (node == null || typeof node !== 'object') return;
 		if (Array.isArray(node)) {
 			for (const child of node) visit(child, scope, phase);
 			return;
 		}
 		if (TRANSPARENT_EXPRESSIONS.has(node.type)) {
-			visit(node.expression, scope, phase);
+			visit(node.expression, scope, phase, readAccess);
 			return;
 		}
 		if (node.type?.startsWith('TS')) return;
 
 		switch (node.type) {
 			case 'ImportDeclaration':
-			case 'Identifier':
+			case 'MetaProperty':
+			case 'BreakStatement':
+			case 'ContinueStatement':
 			case 'JSXIdentifier':
 			case 'Literal':
 			case 'ThisExpression':
 			case 'Super':
 				return;
+			case 'Identifier':
+				if (
+					readAccess &&
+					phase === 'render' &&
+					currentFunctionChecksImpureCalls &&
+					ambientReference(node, scope)?.kind === 'ambient'
+				) {
+					reportAmbientRead(node);
+				}
+				if (
+					readAccess &&
+					phase === 'render' &&
+					currentFunctionChecksRenderReads &&
+					mutableModuleRead(node.name, scope)
+				) {
+					reportModuleStateRead(node);
+				}
+				return;
+			case 'JSXOpeningElement': {
+				let name = node.name;
+				const member = name?.type === 'JSXMemberExpression';
+				let ambientMember;
+				while (name?.type === 'JSXMemberExpression') {
+					if (
+						phase === 'render' &&
+						currentFunctionChecksImpureCalls &&
+						isAmbientMemberRead(name, scope)
+					) {
+						ambientMember = name;
+					}
+					name = name.object;
+				}
+				if (
+					name?.type === 'JSXIdentifier' &&
+					(member || (!/^[a-z]/.test(name.name) && !name.name.includes('-'))) &&
+					phase === 'render' &&
+					currentFunctionChecksImpureCalls
+				) {
+					const reference = ambientReference(name, scope);
+					if (reference?.kind === 'ambient' || ambientMember) {
+						reportAmbientRead(ambientMember ?? name);
+					}
+				}
+				if (
+					name?.type === 'JSXIdentifier' &&
+					(member || (!/^[a-z]/.test(name.name) && !name.name.includes('-'))) &&
+					phase === 'render' &&
+					currentFunctionChecksRenderReads &&
+					mutableModuleRead(name.name, scope)
+				) {
+					reportModuleStateRead(name);
+				}
+				break;
+			}
+			case 'JSXSpreadAttribute':
+				visit(node.argument, scope, phase);
+				if (
+					currentFunctionChecksImpureCalls &&
+					phaseAfter(node.argument, phase) === 'render' &&
+					ambientReference(node.argument, scope) === GLOBAL_OBJECT_BINDING
+				) {
+					reportAmbientRead(node);
+				}
+				return;
 			case 'ExportNamedDeclaration':
 			case 'ExportDefaultDeclaration':
 				visit(node.declaration, scope, phase);
@@ -2882,6 +3408,25 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 			case 'ArrowFunctionExpression':
 				visitFunction(node, scope, phase === 'module' ? 'render' : 'deferred');
 				return;
+			case 'ClassDeclaration':
+			case 'ClassExpression': {
+				const classScope = createScope(scope, 'block', [], node.id ? [node.id] : []);
+				visit(node.decorators, scope, phase);
+				visit(node.superClass, classScope, phase);
+				visit(node.body, classScope, phase);
+				return;
+			}
+			case 'MethodDefinition':
+			case 'PropertyDefinition':
+			case 'AccessorProperty':
+				visit(node.decorators, scope, phase);
+				if (node.computed) visit(node.key, scope, phase);
+				visit(
+					node.value,
+					scope,
+					node.type === 'MethodDefinition' || node.static ? phase : 'deferred',
+				);
+				return;
 			case 'BlockStatement':
 			case 'JSXCodeBlock': {
 				if (node.type === 'JSXCodeBlock') hasNestedCodeBlock = true;
@@ -2930,7 +3475,22 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 				for (const property of node.properties ?? []) {
 					if (property.type === 'SpreadElement') {
 						visit(property.argument, scope, executionPhase);
-						executionPhase = phaseAfter(property.argument, executionPhase);
+						const spreadPhase = phaseAfter(property.argument, executionPhase);
+						if (
+							spreadPhase === 'render' &&
+							currentFunctionChecksImpureCalls &&
+							ambientReference(property.argument, scope) === GLOBAL_OBJECT_BINDING
+						) {
+							reportAmbientRead(property);
+						}
+						if (
+							spreadPhase === 'render' &&
+							currentFunctionChecksRenderReads &&
+							isRefObject(property.argument, scope)
+						) {
+							reportRefRead(property);
+						}
+						executionPhase = spreadPhase;
 						continue;
 					}
 					if (property.computed === true) {
@@ -2946,14 +3506,62 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 			}
 			case 'MemberExpression': {
 				visit(node.object, scope, phase);
+				if (
+					node.optional === true
+						? definitelyNullishOptionalValue(node.object, scope)
+						: definitelySkippedOptionalContinuation(node.object, scope)
+				) {
+					return;
+				}
 				if (node.computed === true) {
-					visit(node.property, scope, phaseAfter(node.object, phase, true, node.optional === true));
+					const propertyPhase = phaseAfter(node.object, phase, true, node.optional === true);
+					visit(node.property, scope, propertyPhase);
+					if (
+						readAccess &&
+						propertyPhase === 'render' &&
+						currentFunctionChecksRenderReads &&
+						readCurrentRef(node, scope) &&
+						phaseAfter(node.property, propertyPhase) === 'render'
+					) {
+						reportRefRead(node);
+					}
+				} else if (
+					readAccess &&
+					phase === 'render' &&
+					currentFunctionChecksRenderReads &&
+					readCurrentRef(node, scope) &&
+					phaseAfter(node.object, phase, true, node.optional === true) === 'render'
+				) {
+					reportRefRead(node);
+				}
+				if (
+					readAccess &&
+					phase === 'render' &&
+					currentFunctionChecksImpureCalls &&
+					isAmbientMemberRead(node, scope)
+				) {
+					const propertyPhase = phaseAfter(node.object, phase, true, node.optional === true);
+					if (phaseAfter(node.computed ? node.property : null, propertyPhase) === 'render') {
+						reportAmbientRead(node);
+					}
 				}
 				return;
 			}
 			case 'LabeledStatement':
 				visit(node.body, scope, phase);
 				return;
+			case 'JSXSwitchExpression': {
+				visit(node.discriminant, scope, phase);
+				let searchPhase = phaseAfter(node.discriminant, phase);
+				for (const branch of node.cases ?? []) {
+					visit(branch.test, scope, searchPhase);
+					searchPhase = phaseAfter(branch.test, searchPhase);
+					const caseScope = createScope(scope, 'function', branch.consequent ?? []);
+					predeclareHoistedVars(branch.consequent, caseScope);
+					visitStatements(branch.consequent, caseScope, searchPhase);
+				}
+				return;
+			}
 			case 'SwitchStatement': {
 				visit(node.discriminant, scope, phase);
 				const initialPhase =
@@ -3016,6 +3624,13 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 				if (!FUNCTION_TYPES.has(callee?.type)) {
 					visit(node.callee, scope, phase);
 				}
+				if (
+					node.optional === true
+						? definitelyNullishOptionalValue(node.callee, scope)
+						: definitelySkippedOptionalContinuation(node.callee, scope)
+				) {
+					return;
+				}
 				let executionPhase = phaseAfter(node.callee, phase, true, node.optional === true);
 				const synchronousCallbackIndex =
 					hook === 'useLinkedState'
@@ -3075,11 +3690,14 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 					// memo owns a component callback. lazy also accepts a module
 					// loader, so require JSX evidence before treating it as a render.
 					const checkImpureCalls = currentFunctionChecksImpureCalls;
+					const checkRenderReads = currentFunctionChecksRenderReads;
 					currentFunctionChecksImpureCalls = true;
+					currentFunctionChecksRenderReads = true;
 					try {
 						visitCallback(component.node, component.scope, 'render');
 					} finally {
 						currentFunctionChecksImpureCalls = checkImpureCalls;
+						currentFunctionChecksRenderReads = checkRenderReads;
 					}
 					return;
 				}
@@ -3110,7 +3728,9 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 							callback,
 							callee,
 							executionPhase,
-							callback.kind === 'setter' ? null : argumentValues(node.arguments, scope),
+							callback.kind === 'setter' || callback.kind === 'getter'
+								? null
+								: argumentValues(node.arguments, scope),
 						);
 					}
 				}
@@ -3185,11 +3805,27 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 			case 'AssignmentExpression': {
 				if (node.left?.type === 'ArrayPattern' || node.left?.type === 'ObjectPattern') {
 					visit(node.right, scope, phase);
-					visitPatternExpressions(node.left, scope, phaseAfter(node.right, phase));
+					visitPatternExpressions(
+						node.left,
+						scope,
+						phaseAfter(node.right, phase),
+						node.left.type === 'ObjectPattern' && isRefObject(node.right, scope),
+						node.left.type === 'ObjectPattern' ? ambientReference(node.right, scope) : null,
+					);
 					return;
 				}
-				visit(node.left, scope, phase);
+				visit(node.left, scope, phase, false);
 				const rightPhase = phaseAfter(node.left, phase, true);
+				if (
+					node.operator !== '=' &&
+					rightPhase === 'render' &&
+					currentFunctionChecksImpureCalls &&
+					(isAmbientMemberRead(node.left, scope) ||
+						(unwrap(node.left)?.type === 'Identifier' &&
+							ambientReference(node.left, scope)?.kind === 'ambient'))
+				) {
+					reportAmbientRead(unwrap(node.left));
+				}
 				visit(node.right, scope, rightPhase);
 				const executionPhase = phaseAfter(node.right, rightPhase);
 				if (executionPhase === 'render') {
@@ -3197,18 +3833,55 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 					reportSnapshotWrite(node.left, scope);
 					reportRetainedRowMutation(node.left, scope);
 				}
+				// Compound and logical assignments read the old value before the
+				// right side, even when an await defers the eventual write.
+				if (
+					node.operator !== '=' &&
+					rightPhase === 'render' &&
+					currentFunctionChecksRenderReads &&
+					(executionPhase !== 'render' || !currentRef(node.left, scope)) &&
+					readCurrentRef(node.left, scope)
+				) {
+					reportRefRead(node.left);
+				}
+				if (
+					node.operator !== '=' &&
+					phase === 'render' &&
+					currentFunctionChecksRenderReads &&
+					unwrap(node.left)?.type === 'Identifier' &&
+					mutableModuleRead(unwrap(node.left).name, scope)
+				) {
+					reportModuleStateRead(unwrap(node.left));
+				}
 				return;
 			}
 			case 'UpdateExpression':
+				if (
+					phaseAfter(node.argument, phase) === 'render' &&
+					currentFunctionChecksImpureCalls &&
+					(isAmbientMemberRead(node.argument, scope) ||
+						(unwrap(node.argument)?.type === 'Identifier' &&
+							ambientReference(node.argument, scope)?.kind === 'ambient'))
+				) {
+					reportAmbientRead(unwrap(node.argument));
+				}
+				if (
+					phase === 'render' &&
+					currentFunctionChecksRenderReads &&
+					unwrap(node.argument)?.type === 'Identifier' &&
+					mutableModuleRead(unwrap(node.argument).name, scope)
+				) {
+					reportModuleStateRead(unwrap(node.argument));
+				}
 				if (phase === 'render' && currentRef(node.argument, scope)) reportRef(node.argument);
-				visit(node.argument, scope, phase);
+				visit(node.argument, scope, phase, false);
 				if (phaseAfter(node.argument, phase, true) === 'render') {
 					reportSnapshotWrite(node.argument, scope);
 					reportRetainedRowMutation(node.argument, scope);
 				}
 				return;
 			case 'UnaryExpression':
-				visit(node.argument, scope, phase);
+				visit(node.argument, scope, phase, node.operator !== 'delete');
 				if (node.operator === 'delete' && phaseAfter(node.argument, phase, true) === 'render') {
 					reportSnapshotWrite(node.argument, scope);
 					reportRetainedRowMutation(node.argument, scope);
@@ -3291,7 +3964,11 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 					(alwaysAwaits(node.right) || (node.type === 'ForOfStatement' && node.await === true))
 						? 'deferred'
 						: phase;
-				visit(node.left, loop, executionPhase);
+				if (node.left?.type === 'ArrayPattern' || node.left?.type === 'ObjectPattern') {
+					visitPatternExpressions(node.left, loop, executionPhase);
+				} else {
+					visit(node.left, loop, executionPhase, false);
+				}
 				visit(node.body, loop, executionPhase);
 				return;
 			}