octane 0.2.7 → 0.2.8

package/dist/compiler/compile.js

@@ -92,6 +92,7 @@ import {
 	wrapNativeWarmScope,
 } from './native-read-codegen.js';
 import { createTextTypeFactsLookup } from './text-type-facts.js';
+import { collectProvenContextBindings, isProvenContextUse } from './context-use.js';
 import { applyCssModuleConstants } from './css-module-constants.js';
 import { assertUniversalRuntimeTarget, normalizeUniversalRuntime } from './universal-runtime.js';
 
@@ -5110,7 +5111,9 @@ function collectImmutableModuleFunctions(body) {
 	const declared = new Map();
 	for (const statement of body) {
 		const declaration =
-			statement.type === 'ExportNamedDeclaration' ? statement.declaration : statement;
+			statement.type === 'ExportNamedDeclaration' || statement.type === 'ExportDefaultDeclaration'
+				? statement.declaration
+				: statement;
 		if (declaration?.type === 'FunctionDeclaration' && declaration.id?.type === 'Identifier') {
 			declared.set(declaration.id.name, declaration);
 		}
@@ -5125,10 +5128,31 @@ function collectImmutableModuleFunctions(body) {
 		}
 		if (seen.has(n)) return;
 		seen.add(n);
-		if (n.type === 'AssignmentExpression' && n.left?.type === 'Identifier') {
-			declared.delete(n.left.name);
-		} else if (n.type === 'UpdateExpression' && n.argument?.type === 'Identifier') {
-			declared.delete(n.argument.name);
+		const writeTarget =
+			n.type === 'AssignmentExpression'
+				? n.left
+				: n.type === 'UpdateExpression'
+					? n.argument
+					: n.type === 'VariableDeclarator'
+						? n.id
+						: (n.type === 'ForOfStatement' || n.type === 'ForInStatement') &&
+							  n.left?.type !== 'VariableDeclaration'
+							? n.left
+							: null;
+		if (writeTarget?.type === 'Identifier') {
+			declared.delete(writeTarget.name);
+		} else if (writeTarget !== null) {
+			const names = new Set();
+			collectPatternNames(unwrapTsExpr(writeTarget), names);
+			for (const name of names) declared.delete(name);
+		} else if (
+			n.type === 'CallExpression' &&
+			unwrapTsExpr(n.callee)?.type === 'Identifier' &&
+			unwrapTsExpr(n.callee).name === 'eval'
+		) {
+			// Direct eval can write a module function binding without a visible
+			// assignment node. Exclude those names from identity proofs.
+			declared.clear();
 		}
 		for (const key in n) {
 			if (AST_WALK_SKIP_KEYS.has(key)) continue;
@@ -9185,6 +9209,7 @@ function compileInternal(
 		ctx.octaneImportLocals = imports.locals;
 		ctx.octaneImportNamespaces = imports.namespaces;
 		ctx.foreignImportLocals = imports.foreignLocals;
+		ctx.provenContextBindings = collectProvenContextBindings(ast);
 		ctx.activityModuleAst = ast;
 	}
 	if (ctx.dev) {
@@ -10456,6 +10481,7 @@ function compileServer(
 		ctx.octaneImportLocals = imports.locals;
 		ctx.octaneImportNamespaces = imports.namespaces;
 		ctx.foreignImportLocals = imports.foreignLocals;
+		ctx.provenContextBindings = collectProvenContextBindings(ast);
 		ctx.activityModuleAst = ast;
 	}
 	// M3 inherit-range exclusion set — must match the client compile's
@@ -14036,6 +14062,7 @@ function compileFunctionBody(node, ctx, name, parentNs = 'html', cssHash = null,
 		ctx.inlineHookMemo && ctx.mode !== 'server' && ctx._universalRuntimeUnit == null;
 	ctx._puInlineLowering = inlineLowering;
 	let warmThunk = null;
+	let staticChildOnly = false;
 	if (options && options.autoCallback) {
 		const creations = [];
 		const warmChildren = [];
@@ -14094,9 +14121,21 @@ function compileFunctionBody(node, ctx, name, parentNs = 'html', cssHash = null,
 		jsxNodes = parallelUseWalkJsx(jsxNodes, ctx, name, creations, warmChildren, [], new Set());
 		const warm = buildWarmArtifacts(node, ctx, name, creations, warmChildren);
 		warmThunk = warm.thunk;
+		staticChildOnly = warm.staticChildOnly === true;
 		ctx._pendingWarm = warm.warmNode;
 	}
-	workingStatements = rewriteParallelUse(workingStatements, ctx, name, warmThunk);
+	workingStatements = rewriteParallelUse(
+		workingStatements,
+		ctx,
+		name,
+		warmThunk,
+		staticChildOnly &&
+			ctx.mode !== 'server' &&
+			ctx._universalRuntimeUnit == null &&
+			ctx.moduleFunctionDeclarations.get(name)?.start === node.start
+			? staticChildWarmPlanProps(node, name)
+			: null,
+	);
 
 	// De-callback the hook memo tier (production client compile). Authored and
 	// auto-generated useMemo/useCallback declarations become inline flat-cache
@@ -14822,6 +14861,7 @@ function transformUniversalParallelUse(ast, ctx, metadata) {
 // Names bound by a binding pattern (params, declarator ids). Mirrors the
 // pattern handling of collectFreeIdentifiers' collectBindings.
 function collectPatternNames(pat, into) {
+	pat = unwrapTsExpr(pat);
 	if (!pat) return into;
 	switch (pat.type) {
 		case 'Identifier':
@@ -16121,8 +16161,61 @@ function isWarmSafeExpr(expr, paramNames, componentLocals, armLocals) {
 	return true;
 }
 
+// The registration records props now and invokes the already-attached module
+// plan only if a descendant suspends. A reassigned parameter would differ from
+// the old thunk's live lexical capture, including writes in JSX expressions or
+// nested callbacks. A same-name write in a shadowed scope merely declines the
+// optimization. Dynamic bindings are conservatively excluded as well.
+function staticChildWarmPlanProps(node, componentName) {
+	const params = node.params || [];
+	if (params.length > 1 || (params.length === 1 && params[0].type !== 'Identifier')) {
+		return null;
+	}
+	const name = params[0]?.name ?? null;
+	if (name === componentName) return null;
+	const seen = new WeakSet();
+	const bindsName = (pattern, binding) => {
+		if (binding === null || pattern === null) return false;
+		if (pattern.type === 'Identifier') return pattern.name === binding;
+		const names = new Set();
+		collectPatternNames(unwrapTsExpr(pattern), names);
+		return names.has(binding);
+	};
+	const unsafe = (value) => {
+		if (value === null || typeof value !== 'object') return false;
+		if (Array.isArray(value)) return value.some(unsafe);
+		if (seen.has(value)) return false;
+		seen.add(value);
+		if (
+			(value.type === 'AssignmentExpression' && bindsName(value.left, name)) ||
+			(value.type === 'UpdateExpression' && bindsName(value.argument, name)) ||
+			(value.type === 'VariableDeclarator' &&
+				(bindsName(value.id, name) || bindsName(value.id, componentName))) ||
+			((value.type === 'FunctionDeclaration' || value.type === 'ClassDeclaration') &&
+				value.id?.name === componentName) ||
+			(value.type === 'CatchClause' && bindsName(value.param, componentName)) ||
+			((value.type === 'ForOfStatement' || value.type === 'ForInStatement') &&
+				bindsName(value.left, name)) ||
+			(value.type === 'CallExpression' &&
+				unwrapTsExpr(value.callee)?.type === 'Identifier' &&
+				unwrapTsExpr(value.callee).name === 'eval') ||
+			(value.type === 'Identifier' && value.name === 'arguments') ||
+			value.type === 'ThisExpression' ||
+			value.type === 'Super' ||
+			value.type === 'MetaProperty'
+		) {
+			return true;
+		}
+		for (const key in value) {
+			if (!AST_WALK_SKIP_KEYS.has(key) && unsafe(value[key])) return true;
+		}
+		return false;
+	};
+	return unsafe(node.body) ? null : name === null ? b.unary('void', b.literal(0, '0')) : b.id(name);
+}
+
 // ── Pass B: run detection + hoist + batch ───────────────────────────────────
-function rewriteParallelUse(statements, ctx, componentName, warmThunk) {
+function rewriteParallelUse(statements, ctx, componentName, warmThunk, staticPlanProps = null) {
 	let firstBatch = true;
 	const output = transformList(statements);
 	if (warmThunk) {
@@ -16132,17 +16225,57 @@ function rewriteParallelUse(statements, ctx, componentName, warmThunk) {
 		// setup preserves early-return reachability: an alternate returned tree must
 		// not activate the final template's plan. The first direct batch receives the
 		// same thunk below so it can still warm before setup reaches this registration.
-		const batchHelper = ctx.mode === 'server' ? 'puBatch' : 'useBatch';
-		const batchAlias = requireRuntimeForContext(ctx, batchHelper);
-		const registration = inheritOriginLoc(
-			b.stmt(b.call(batchAlias, b.array([]), warmThunk)),
+		// Only the DOM client has registerWarmPlan. Its two-argument form pushes
+		// the same block, thunk, and undefined props as an empty useBatch call,
+		// without creating an array on every render. Server and universal units
+		// continue to use their own batch helpers.
+		const fallbackHelper =
+			ctx.mode === 'client' && ctx._universalRuntimeUnit == null
+				? 'registerWarmPlan'
+				: ctx.mode === 'server'
+					? 'puBatch'
+					: 'useBatch';
+		const fallback = inheritOriginLoc(
+			b.stmt(
+				fallbackHelper === 'registerWarmPlan'
+					? b.call(
+							requireRuntimeForContext(ctx, fallbackHelper),
+							warmThunk,
+							b.unary('void', b.literal(0, '0')),
+						)
+					: b.call(requireRuntimeForContext(ctx, fallbackHelper), b.array([]), warmThunk),
+			),
 			warmThunk,
 		);
+		let registration = [fallback];
+		if (staticPlanProps !== null) {
+			// Hoisted functions can render before the module-tail markWarm stamp,
+			// and route extraction can leave that stamp behind. Only the common
+			// attached-plan path may omit the in-body closure and array.
+			const planName = allocCompilerName(ctx, '__warmPlan');
+			registration = [
+				inheritOriginLoc(b.const(planName, b.member(b.id(componentName), '__warm')), warmThunk),
+				inheritOriginLoc(
+					b.if(
+						b.binary('===', b.unary('typeof', b.id(planName)), b.literal('function', "'function'")),
+						b.stmt(
+							b.call(
+								requireRuntimeForContext(ctx, 'registerWarmPlan'),
+								b.id(planName),
+								staticPlanProps,
+							),
+						),
+						fallback,
+					),
+					warmThunk,
+				),
+			];
+		}
 		const finalIndex =
 			output.length > 0 && output[output.length - 1].type === 'ReturnStatement'
 				? output.length - 1
 				: output.length;
-		output.splice(finalIndex, 0, registration);
+		output.splice(finalIndex, 0, ...registration);
 	}
 	return output;
 
@@ -16236,6 +16369,19 @@ function rewriteParallelUse(statements, ctx, componentName, warmThunk) {
 			for (const m of run.members) out.push(m.stmt);
 			return;
 		}
+		if (
+			uses.every(
+				(m) =>
+					m.call._octaneImportedHook === 'use' &&
+					isProvenContextUse(m.creation, ctx.provenContextBindings),
+			)
+		) {
+			// Context reads cannot suspend. Preserve the authored statements in
+			// their original order, and leave the first warm thunk available for
+			// the next real data batch. The trailing child-only registration stays.
+			for (const m of run.members) out.push(m.stmt);
+			return;
+		}
 		// Hoist each creation into a temp, batch, then re-emit the original
 		// statements with creations swapped for the temps. Unwrap order (and
 		// hydration-seed order with it) is untouched.
@@ -16426,7 +16572,19 @@ function buildWarmArtifacts(node, ctx, componentName, creations, warmChildren) {
 			node,
 		);
 	}
-	return { thunk, warmNode };
+	return {
+		thunk,
+		warmNode,
+		// The module plan contains own creations before child calls. Reuse it
+		// for this component's registration only when it is child-only like the
+		// original thunk; otherwise a descendant suspend could refetch its own
+		// earlier memo. Memoized child props stay on the existing path too.
+		staticChildOnly:
+			warmNode !== null &&
+			thunk !== null &&
+			warmMemos.length === 0 &&
+			warmKids.every((child) => child.props.every((prop) => prop.memo == null)),
+	};
 }
 
 // ===========================================================================

package/dist/compiler/context-use.js

@@ -0,0 +1,154 @@
+// A direct module const initialized by Octane's createContext is the only
+// context identity we can prove without following values between modules.
+// Reject a name if any nested scope binds it: both compiler pipelines can
+// then use this module-wide proof without guessing which scope owns a use().
+export function collectProvenContextBindings(ast) {
+	const factories = new Set();
+	for (const statement of ast.body || []) {
+		if (
+			statement.type !== 'ImportDeclaration' ||
+			statement.importKind === 'type' ||
+			statement.source?.value !== 'octane'
+		)
+			continue;
+		for (const specifier of statement.specifiers || []) {
+			if (
+				specifier.type === 'ImportSpecifier' &&
+				specifier.importKind !== 'type' &&
+				(specifier.imported?.name ?? specifier.imported?.value) === 'createContext' &&
+				specifier.local?.name
+			)
+				factories.add(specifier.local.name);
+		}
+	}
+	if (factories.size === 0) return new Set();
+
+	const contexts = new Set();
+	for (const original of ast.body || []) {
+		const declaration = unwrapExport(original);
+		if (declaration?.type !== 'VariableDeclaration' || declaration.kind !== 'const') continue;
+		for (const entry of declaration.declarations || []) {
+			if (
+				entry.id?.type === 'Identifier' &&
+				entry.init?.type === 'CallExpression' &&
+				entry.init.optional !== true &&
+				entry.init.callee?.type === 'Identifier' &&
+				factories.has(entry.init.callee.name)
+			)
+				contexts.add(entry.id.name);
+		}
+	}
+	if (contexts.size === 0) return contexts;
+
+	const shadowed = new Set();
+	const seen = new WeakSet();
+	const bind = (pattern) => {
+		if (!pattern) return;
+		switch (pattern.type) {
+			case 'Identifier':
+				if (contexts.has(pattern.name)) shadowed.add(pattern.name);
+				break;
+			case 'ArrayPattern':
+				for (const item of pattern.elements || []) bind(item);
+				break;
+			case 'ObjectPattern':
+				for (const item of pattern.properties || [])
+					bind(item.type === 'RestElement' ? item.argument : item.value);
+				break;
+			case 'AssignmentPattern':
+				bind(pattern.left);
+				break;
+			case 'RestElement':
+				bind(pattern.argument);
+				break;
+			case 'TSParameterProperty':
+				bind(pattern.parameter);
+				break;
+		}
+	};
+	const scan = (node) => {
+		if (!node || typeof node !== 'object') return;
+		if (Array.isArray(node)) {
+			for (const item of node) scan(item);
+			return;
+		}
+		if (seen.has(node)) return;
+		seen.add(node);
+		if (node.type === 'ImportDeclaration') return;
+		switch (node.type) {
+			case 'VariableDeclarator':
+				bind(node.id);
+				break;
+			case 'FunctionDeclaration':
+			case 'FunctionExpression':
+			case 'ArrowFunctionExpression':
+			case 'TSDeclareFunction':
+				bind(node.id);
+				for (const param of node.params || []) bind(param);
+				break;
+			case 'ClassDeclaration':
+			case 'ClassExpression':
+			case 'TSEnumDeclaration':
+			case 'TSModuleDeclaration':
+				bind(node.id);
+				break;
+			case 'CatchClause':
+				bind(node.param);
+				break;
+			case 'JSXForExpression':
+				if (node.left?.type !== 'VariableDeclaration') bind(node.left);
+				bind(node.index);
+				break;
+			case 'JSXTryExpression':
+				bind(node.handler?.param);
+				bind(node.handler?.resetParam);
+				break;
+		}
+		for (const key in node) {
+			if (
+				key === 'loc' ||
+				key === 'start' ||
+				key === 'end' ||
+				key === 'range' ||
+				key === 'parent' ||
+				key === 'metadata' ||
+				key.startsWith('_octane')
+			)
+				continue;
+			scan(node[key]);
+		}
+	};
+	for (const original of ast.body || []) {
+		if (original.type === 'ImportDeclaration') continue;
+		const declaration = unwrapExport(original);
+		if (declaration?.type === 'VariableDeclaration') {
+			// These IDs belong to the module itself, including the proven
+			// contexts. Their initializers can still contain nested shadows.
+			for (const entry of declaration.declarations || []) scan(entry.init);
+		} else {
+			scan(declaration);
+		}
+	}
+	for (const name of shadowed) contexts.delete(name);
+	return contexts;
+}
+
+export function isProvenContextUse(argument, contexts) {
+	let value = argument;
+	while (
+		value?.type === 'TSAsExpression' ||
+		value?.type === 'TSTypeAssertion' ||
+		value?.type === 'TSSatisfiesExpression' ||
+		value?.type === 'TSNonNullExpression' ||
+		value?.type === 'TSInstantiationExpression' ||
+		value?.type === 'ParenthesizedExpression'
+	)
+		value = value.expression;
+	return value?.type === 'Identifier' && contexts.has(value.name);
+}
+
+function unwrapExport(node) {
+	return node?.type === 'ExportNamedDeclaration' || node?.type === 'ExportDefaultDeclaration'
+		? node.declaration
+		: node;
+}

package/dist/compiler/hook-deps.js

@@ -178,6 +178,7 @@ function collectHoistedVars(node, functionScope, root = true, bindingsOnly = fal
 	if (
 		bindingsOnly &&
 		(isFunction(node) ||
+			node.type === 'JSXSwitchExpression' ||
 			(!root && node.type === 'StaticBlock') ||
 			node.type === 'ClassDeclaration' ||
 			node.type === 'ClassExpression' ||
@@ -479,7 +480,22 @@ function buildScopes(ast, onlyImported, hookRuntimeModules, bindingsOnly = false
 			return;
 		}
 
-		if (node.type === 'SwitchStatement' || (bindingsOnly && node.type === 'JSXSwitchExpression')) {
+		if (bindingsOnly && node.type === 'JSXSwitchExpression') {
+			// Each template arm is a separate callback. Its `var` declarations
+			// belong to that callback, rather than to the enclosing function or
+			// another arm with a declaration of the same name.
+			walk(node.discriminant, scope);
+			for (const switchCase of node.cases || []) {
+				walk(switchCase.test, scope);
+				const caseScope = createScope(scope, 'function');
+				collectHoistedVars(switchCase.consequent, caseScope, true, true);
+				predeclareDirect(switchCase.consequent, caseScope, hookRuntimeModules, true);
+				for (const statement of switchCase.consequent || []) walk(statement, caseScope);
+			}
+			return;
+		}
+
+		if (node.type === 'SwitchStatement') {
 			// A switch body is one lexical scope shared by every unbraced case.
 			// Predeclare the direct case statements together so let/const/function
 			// captures resolve even when their declaration appears in a case list

package/dist/compiler/native-read-diagnostics.js

@@ -1,4 +1,4 @@
-import { createLexicalAnalysis, forEachRuntimeAstChild } from './compile-universal.js';
+import { createLexicalAnalysis } from './compile-universal.js';
 import { analyzeRendererBoundaries } from './renderer-boundaries.js';
 import { NATIVE_SIGNAL_NAME, NATIVE_MEMO_READ, nativeReadDiagnostic } from './native-read-facts.js';
 export { NATIVE_SIGNAL_NAME, NATIVE_MEMO_READ } from './native-read-facts.js';
@@ -65,40 +65,19 @@ function propertyName(node, computed = false) {
 }
 
 /**
- * Signal capabilities are part of authored source, not build configuration.
- * A `$` capability can arrive through props, a namespace, or an imported helper;
- * do not require a direct signals import or proof of the eventual read target.
- * Once selected, the entire module captures actual reads, including opaque calls.
- * Inspect runtime syntax rather than text so erased types, comments, and string
- * contents do not opt an ordinary module into native memoization and its adapter.
+ * Native reads are an explicit module capability. A runtime signals import,
+ * including a bare import for opaque readers, opts the entire module into
+ * capturing actual reads. Type-only imports and `$` names alone do not.
  */
 export function nativeReadOptions(ast, options) {
-	let nativeReads = false;
-	function visit(node) {
-		if (nativeReads || !node || typeof node !== 'object') return;
-		if (node.importKind === 'type' || node.exportKind === 'type') return;
-		if (
+	const nativeReads = ast.body.some(
+		(node) =>
 			node.type === 'ImportDeclaration' &&
-			node.specifiers.length > 0 &&
-			node.specifiers.every((specifier) => specifier.importKind === 'type')
-		) {
-			return;
-		}
-		if (
-			((node.type === 'Identifier' || node.type === 'JSXIdentifier') && node.name.endsWith('$')) ||
-			(node.type === 'ImportDeclaration' &&
-				(node.source?.value === SIGNALS_MODULE || LOCAL_MODULES.has(node.source?.value))) ||
-			((node.type === 'MemberExpression' || node.type === 'OptionalMemberExpression') &&
-				String(propertyName(node.property, node.computed) ?? '').endsWith('$')) ||
-			(node.type === 'Property' &&
-				String(propertyName(node.key, node.computed) ?? '').endsWith('$'))
-		) {
-			nativeReads = true;
-			return;
-		}
-		forEachRuntimeAstChild(node, visit);
-	}
-	visit(ast);
+			node.importKind !== 'type' &&
+			(node.source?.value === SIGNALS_MODULE || LOCAL_MODULES.has(node.source?.value)) &&
+			(node.specifiers.length === 0 ||
+				node.specifiers.some((specifier) => specifier.importKind !== 'type')),
+	);
 	return { ...options, nativeReads };
 }
 

package/dist/compiler/slot-hooks.js

@@ -24,6 +24,7 @@ import { assertNativeReadDiagnostics, nativeReadOptions } from './native-read-di
 import { nativeReadActivationIndex } from './native-read-codegen.js';
 import { findManualHookProviders, manualHookWrapperParameters } from './manual-hooks.js';
 import { findLeadingJsxImportSourcePragma } from './pragma.js';
+import { collectProvenContextBindings, isProvenContextUse } from './context-use.js';
 import {
 	hookMethodName,
 	hasHookMethods,
@@ -868,6 +869,10 @@ function requireParallelHelper(st, imported) {
 
 function emitParallelUseRun(run, owner, st) {
 	if (run.uses.length === 0) return;
+	if (run.uses.every((entry) => isProvenContextUse(entry.arg, st.provenContextBindings))) {
+		// Leave plain source untouched when every read is a proven context.
+		return;
+	}
 	const memoName = st.nativeReads
 		? 'nativePuMemo'
 		: st.environment === 'server'
@@ -1396,6 +1401,7 @@ export function slotHooks(source, id, options) {
 		edits: [],
 		decls: [],
 		parallelHelpers: new Map(),
+		provenContextBindings: collectProvenContextBindings(ast),
 		usedNames: collectIdentifierNames(ast),
 		slotBaseName: null,
 		hookSlotsName: null,