octane 0.13.2 → 0.13.3

package/dist/cjs/version.cjs

@@ -21,7 +21,7 @@ __export(version_exports, {
   version: () => version
 });
 module.exports = __toCommonJS(version_exports);
-const version = "0.13.2";
+const version = "0.13.3";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   version

package/dist/compiler/compile.js

@@ -3666,7 +3666,10 @@ function autoCalculationOf(expression, selfName, componentLocals, ctx, immutable
 	const init = unwrapTsExpr(expression);
 	// An arrow/function init is auto-callback's job, not ours.
 	if (FN_TYPES.has(init?.type)) return null;
-	if (!isPropCreationExpr(init, ctx)) return null;
+	const literal =
+		ctx.strongLiteralMemo === true &&
+		(init?.type === 'ObjectExpression' || init?.type === 'ArrayExpression');
+	if (!isPropCreationExpr(init, ctx, literal)) return null;
 	// Every call reached during render must satisfy the same projection contract
 	// the region cache uses. Compatibility-mode member calls fail closed.
 	const immutableProjection = immutableArrayProjection(init, immutableStates);
@@ -3693,7 +3696,7 @@ function autoCalculationOf(expression, selfName, componentLocals, ctx, immutable
 			return null;
 		}
 	}
-	return { init, deps, immutableProjection };
+	return { init, deps, immutableProjection, literal };
 }
 
 // The single-name `const` declarator a calculation can replace, or null.
@@ -3726,6 +3729,8 @@ function closeCalculationReads(
 	componentLocals,
 	ctx,
 	immutableStates = null,
+	literalReads = null,
+	renderRoots = [],
 ) {
 	if (renderReadNames.size === 0) return renderReadNames;
 	const declaredAt = new Map();
@@ -3750,6 +3755,24 @@ function closeCalculationReads(
 		if (decl === undefined) continue;
 		const calculation = autoCalculationOf(decl.init, name, componentLocals, ctx, immutableStates);
 		if (calculation === null) continue;
+		// An allocated local can still be mutated or escape during setup.
+		// Cache only literals read directly as eligible props/refs; other reads
+		// (including callback captures and alias creation) keep their JS lifetime.
+		if (calculation.literal) {
+			const allowed = literalReads?.get(name);
+			if (
+				!allowed ||
+				statements.some(
+					(statement) =>
+						statement.declarations?.[0] !== decl &&
+						collectFreeIdentifiers(statement, [], allowed).has(name),
+				) ||
+				collectFreeIdentifiers(renderRoots, [], allowed).has(name)
+			) {
+				forward.push(name);
+				continue;
+			}
+		}
 		const at = declaredAt.get(name);
 		if (calculation.deps.some((dependency) => declaredAt.get(dependency) > at)) {
 			forward.push(name);
@@ -3782,7 +3805,14 @@ function rewriteAutoCalculation(
 		immutableStates,
 	);
 	if (calculation === null) return stmt;
-	const { init, deps, immutableProjection } = calculation;
+	const { init, deps, immutableProjection, literal } = calculation;
+	// An unrelated update may supply a new props bag with the same fields.
+	// Literal identities depend on the inputs they read, not on that bag.
+	const dependencyNodes = literal
+		? collectDepPaths(init, null, moduleBoundCheckForDeps(ctx, init), () =>
+				requireRuntimeForContext(ctx, METHOD_DEP_IMPORT),
+			)
+		: deps.map((n) => b.id(n));
 	return {
 		...stmt,
 		declarations: [
@@ -3799,7 +3829,7 @@ function rewriteAutoCalculation(
 								: { _octaneImmutableArrayFilter: immutableProjection }),
 						},
 						b.arrow([], init),
-						b.array(deps.map((n) => b.id(n))),
+						b.array(dependencyNodes),
 					),
 					init,
 				),
@@ -3843,20 +3873,24 @@ const CALCULATION_VALUE_PROOFS = [
  * unobservable. Positions whose evaluation is conditional or deferred keep
  * their expression: directive arms, component children (the child decides
  * whether and when they render), and built-in boundaries. An expression holding
- * JSX keeps its list and descriptor lowering, and event handlers, refs, and
- * keys keep their wiring. A render tree that writes to anything keeps its whole
+ * JSX keeps its list and descriptor lowering, and event handlers and keys keep
+ * their wiring. Ref arrays use the same identity proof as props. A render tree that writes to anything keeps its whole
  * evaluation order.
  *
  * Returns null when nothing moves; otherwise the copy-on-write render nodes,
  * the declarations to append, and their names.
  */
 function hoistStrongRenderCalculations(jsxNodes, ctx, immutableStates) {
-	if (ctx.strongMemo !== true || ctx.nativeReads || !ctx.currentComponentLocals) return null;
+	if ((!ctx.strongMemo && !ctx.strongLiteralMemo) || ctx.nativeReads || !ctx.currentComponentLocals)
+		return null;
 	if (renderTreeWrites(jsxNodes)) return null;
 	const declarations = [];
 	const names = [];
+	const literalReads = new Map();
 	const nodes = mapNodes(jsxNodes, visitNode);
-	return declarations.length === 0 ? null : { jsxNodes: nodes, declarations, names };
+	return declarations.length === 0 && literalReads.size === 0
+		? null
+		: { jsxNodes: nodes, declarations, names, literalReads };
 
 	function visitNode(node) {
 		switch (node?.type) {
@@ -3894,7 +3928,10 @@ function hoistStrongRenderCalculations(jsxNodes, ctx, immutableStates) {
 				return attribute;
 			}
 			const name = attribute.name.name;
-			if (name === 'key' || name === 'ref' || name === 'children') return attribute;
+			if (name === 'key' || name === 'children') return attribute;
+			const inner = unwrapTsExpr(attribute.value?.expression);
+			if (name === 'ref' && inner?.type !== 'ArrayExpression' && inner?.type !== 'Identifier')
+				return attribute;
 			// The host handoff prepares unbound fields through the ordinary renderer.
 			// Hoisting one outside that preparation makes its writer ineligible.
 			if (
@@ -3905,7 +3942,7 @@ function hoistStrongRenderCalculations(jsxNodes, ctx, immutableStates) {
 				return attribute;
 			if (!component && /^on[A-Z]/.test(name)) return attribute;
 			if (attribute.value?.type !== 'JSXExpressionContainer') return attribute;
-			const value = visitContainer(attribute.value);
+			const value = visitContainer(attribute.value, true);
 			return value === attribute.value ? attribute : { ...attribute, value };
 		});
 		// Component children render inside the child, if at all.
@@ -3918,11 +3955,27 @@ function hoistStrongRenderCalculations(jsxNodes, ctx, immutableStates) {
 		};
 	}
 
-	function visitContainer(container) {
+	function visitContainer(container, prop = false) {
 		const expression = container.expression;
 		const inner = unwrapTsExpr(expression);
 		if (!inner || inner.type === 'JSXEmptyExpression' || containsJsxNode(inner)) return container;
-		if (autoCalculationOf(inner, null, ctx.currentComponentLocals, ctx, immutableStates) === null) {
+		if (prop && inner.type === 'Identifier') {
+			let nodes = literalReads.get(inner.name);
+			if (!nodes) literalReads.set(inner.name, (nodes = new Set()));
+			nodes.add(inner);
+		}
+		const calculation = autoCalculationOf(
+			inner,
+			null,
+			ctx.currentComponentLocals,
+			ctx,
+			immutableStates,
+		);
+		if (
+			calculation === null ||
+			(!ctx.strongMemo && !calculation.literal) ||
+			(calculation.literal && !prop)
+		) {
 			return container;
 		}
 		const name = allocCompilerName(ctx, '__calc');
@@ -3931,6 +3984,7 @@ function hoistStrongRenderCalculations(jsxNodes, ctx, immutableStates) {
 		// A child warm plan runs outside this body, so it keeps the authored prop.
 		(ctx.hoistedRenderCalculations ??= new Map()).set(name, expression);
 		const reference = b.id(name, inner);
+		if (prop) literalReads.set(name, new Set([reference]));
 		for (const proof of CALCULATION_VALUE_PROOFS) {
 			if (inner.metadata?.[proof] === true) reference.metadata[proof] = true;
 		}
@@ -3957,9 +4011,10 @@ function establishesRenderScope(statement) {
 // `return <jsx>` reached after the render-scope proof above gets the same
 // calculations, declared immediately before it. Returns null when nothing moves.
 function hoistStrongReturnCalculations(statements, ctx) {
-	if (ctx.strongMemo !== true || ctx.nativeReads) return null;
+	if ((!ctx.strongMemo && !ctx.strongLiteralMemo) || ctx.nativeReads) return null;
 	let out = null;
 	const names = [];
+	const literalReads = new Map();
 	let established = false;
 	for (let index = 0; index < statements.length; index++) {
 		const statement = statements[index];
@@ -3969,13 +4024,18 @@ function hoistStrongReturnCalculations(statements, ctx) {
 				out ??= statements.slice(0, index);
 				out.push(...hoisted.declarations, { ...statement, argument: hoisted.jsxNodes[0] });
 				names.push(...hoisted.names);
+				for (const [name, reads] of hoisted.literalReads) {
+					let nodes = literalReads.get(name);
+					if (!nodes) literalReads.set(name, (nodes = new Set()));
+					for (const read of reads) nodes.add(read);
+				}
 				continue;
 			}
 		}
 		out?.push(statement);
 		established ||= establishesRenderScope(statement);
 	}
-	return out === null ? null : { statements: out, names };
+	return out === null ? null : { statements: out, names, literalReads };
 }
 
 function mapNodes(nodes, map) {
@@ -4928,7 +4988,9 @@ const CALLBACK_IDENTITY_OWNING_HOOKS = new Set(
 );
 
 function hookOwnsCallbackIdentity(call) {
-	const name = hookShapedCalleeName(call);
+	// After dependency inference, use the resolved hook even when an import
+	// alias looks like a custom hook. Earlier passes still use the spelling.
+	const name = stableHookCallName(call) ?? hookShapedCalleeName(call);
 	return name !== null && CALLBACK_IDENTITY_OWNING_HOOKS.has(name);
 }
 
@@ -11776,6 +11838,14 @@ function compileInternal(
 		splitModuleFunctions,
 		autoMemo: autoMemoEnabled,
 		strongMemo: strongMemoEnabled,
+		// Ref and effect lifetimes must not churn on an unrelated dev/HMR render.
+		// Only proven literal props use these caches; region/call caching stays prod-only.
+		strongLiteralMemo:
+			strongModeEnabled &&
+			options?.autoMemo !== false &&
+			mode === 'client' &&
+			options?.__universal == null &&
+			options?.nativeReads !== true,
 		nativeReads: options?.nativeReads === true,
 		opaqueSignalHandles:
 			options?.opaqueSignalHandles === true || options?.__signalModuleImport === true,
@@ -17892,6 +17962,8 @@ function compileFunctionBody(node, ctx, name, parentNs = 'html', cssHash = null,
 				ctx.currentComponentLocals,
 				ctx,
 				immutableStateProvenance,
+				hoisted?.literalReads,
+				jsxNodes,
 			);
 			if (renderReadNames.size > 0) {
 				workingStatements = workingStatements.map((statement) => {
@@ -19270,8 +19342,8 @@ function isTrivialUseArg(n) {
 // the lowering passes) and hook-shaped calls (`use` / `use[A-Z]…` / a tracked
 // `use` import alias — their slot/occurrence bookkeeping must execute on the
 // body proper every pass, so they can never sit behind a cache hit).
-function isPropCreationExpr(expr, ctx) {
-	let found = false;
+function isPropCreationExpr(expr, ctx, includesLiteral = false) {
+	let found = includesLiteral;
 	let blocked = false;
 	walk(expr);
 	return found && !blocked;
@@ -19305,7 +19377,21 @@ function isPropCreationExpr(expr, ctx) {
 				blocked = true;
 				return;
 			}
-			if (FN_TYPES.has(n.type)) return; // does not run during render
+			if (FN_TYPES.has(n.type)) {
+				// A regular function can mutate a containing literal via its receiver,
+				// or retain per-render state on its own function object. Reuse the
+				// callback movement proof before stabilizing either kind of identity.
+				if (
+					includesLiteral &&
+					n.type !== 'ArrowFunctionExpression' &&
+					(!isMovableHookCallback(n) ||
+						hasInlineMemoDirectEval(n) ||
+						(n.id && collectFreeIdentifiers({ ...n, id: null }, []).has(n.id.name)))
+				) {
+					blocked = true;
+				}
+				return; // does not run during render
+			}
 			// Same render-time-call inventory as containsRenderCall: plain and
 			// optional calls, constructions, tagged templates, and dynamic
 			// import() (ESTree flavor; the Babel flavor is a CallExpression).
@@ -21973,6 +22059,9 @@ function compileReturnJsxFunction(node, ctx, options) {
 			collectRenderReadNames(renderedRoots, ctx),
 			ctx.currentComponentLocals,
 			ctx,
+			null,
+			hoisted?.literalReads,
+			renderedRoots,
 		);
 		let autoCalculatedDeclarations = null;
 		let renderScopeEstablished = false;

package/dist/compiler/hook-deps.js

@@ -2341,17 +2341,8 @@ export function analyzeStrongHookPolicies(ast, options = {}) {
 	for (const { call, scope } of analysis.calls) {
 		const name = callNames.get(call);
 		const config = DEPENDENCY_HOOKS.get(name);
-		if (config === undefined) continue;
-		if (name === 'useMemo' || name === 'useCallback') {
-			diagnostics.push({
-				code: 'OCTANE_STRONG_MANUAL_MEMO',
-				node: call,
-				hook: name,
-				severity: 'error',
-				message: `Strong mode owns calculation and callback caching. Replace ${name} with a const declaration and let the compiler track its inputs.`,
-			});
-			continue;
-		}
+		// Authored memo hooks own their dependencies; effect policies do not apply to them.
+		if (config === undefined || name === 'useMemo' || name === 'useCallback') continue;
 		const argument = call.arguments[config.deps];
 		if (argument === undefined || isUnshadowedUndefined(argument, scope)) {
 			// Inference would run this hook on every render, which is the

package/dist/compiler/strong-diagnostics.js

@@ -131,7 +131,7 @@ export const STRONG_DIAGNOSTICS = [
 		section: 'effects',
 		severity: 'error',
 		detects:
-			"An explicit dependency argument differs from the compiler's inferred inputs, or cannot be proven equivalent. An array the compiler proves equivalent is reported as a **hint** instead, and its authored behavior is preserved.",
+			"An effect or imperative handle dependency argument differs from the compiler's inferred inputs, or cannot be proven equivalent. An array the compiler proves equivalent is reported as a **hint** instead, and its authored behavior is preserved.",
 		replacement: 'Omit the dependency argument.',
 	},
 	{
@@ -139,18 +139,10 @@ export const STRONG_DIAGNOSTICS = [
 		section: 'effects',
 		severity: 'error',
 		detects:
-			'A built-in dependency hook receives `null` dependencies, or omits them while its callback reads a binding declared after the hook, or a variable the component assigns after the hook or from a nested function. Inference cannot read that value where the hook is called, so the hook would run on every render.',
+			'An effect or imperative handle receives `null` dependencies, or omits them while its callback reads a binding declared after the hook, or a variable the component assigns after the hook or from a nested function. Inference cannot read that value where the hook is called, so the hook would run on every render.',
 		replacement:
 			'Omit the argument so the compiler tracks reactive inputs. Declare and finish assigning what the hook reads before calling it, or keep a changing value in state or a ref.',
 	},
-	{
-		code: 'OCTANE_STRONG_MANUAL_MEMO',
-		section: 'effects',
-		severity: 'error',
-		detects: "A call to Octane's `useMemo` or `useCallback`, including known import aliases.",
-		replacement:
-			'Write a normal calculation or callback declaration and let Strong compilation cache eligible declarations. `octane analyze --fix` rewrites `useMemo(() => value, deps)` to `value` and `useCallback(fn, deps)` to `fn`.',
-	},
 	{
 		code: 'OCTANE_STRONG_EFFECT_EVENT_DEPENDENCY',
 		section: 'effects',
@@ -533,28 +525,6 @@ export function Label({ text }: { text: string }) {
 `,
 		note: 'A callback ref runs while the element commits, so a state update there renders the component a second time before paint. `useLayoutSnapshot` reads the element after layout on every commit and re-renders only when the measurement changes. To follow resizes that happen without a commit, attach a `ResizeObserver` from the ref or an effect; its callback may update state.',
 	},
-	{
-		id: 'manual-memo',
-		title: 'Drop useMemo and useCallback',
-		react: 'const total = useMemo(() => sum(items), [items]);',
-		strong: 'const total = sum(items);',
-		codes: ['OCTANE_STRONG_MANUAL_MEMO'],
-		before: `import { useCallback, useMemo } from 'octane';
-
-export function Total({ items, onPick }: { items: number[]; onPick: (total: number) => void }) {
-	const total = useMemo(() => items.reduce((sum, item) => sum + item, 0), [items]);
-	const pick = useCallback(() => onPick(total), [onPick, total]);
-	return <button onClick={pick}>{String(total)}</button>;
-}
-`,
-		after: `export function Total({ items, onPick }: { items: number[]; onPick: (total: number) => void }) {
-	const total = items.reduce((sum, item) => sum + item, 0);
-	const pick = () => onPick(total);
-	return <button onClick={pick}>{String(total)}</button>;
-}
-`,
-		note: 'Strong production builds memoize render calculations from their inputs, and eligible callbacks keep a stable identity in every build until their inferred inputs change. `octane analyze --fix` applies this rewrite.',
-	},
 	{
 		id: 'latest-ref',
 		title: 'Read the latest props from an effect',

package/dist/compiler/strong-fixes.js

@@ -244,69 +244,6 @@ export function lazyRefSuggestion(idiom, ast, source) {
 	return { ...suggestion, edits };
 }
 
-const PRIMARY_EXPRESSIONS = new Set([
-	'ArrayExpression',
-	'CallExpression',
-	'Identifier',
-	'JSXElement',
-	'JSXFragment',
-	'Literal',
-	'MemberExpression',
-	'ParenthesizedExpression',
-	'TaggedTemplateExpression',
-	'TemplateLiteral',
-]);
-
-/**
- * Replace `useMemo(() => value, deps)` with `value` and
- * `useCallback(fn, deps)` with `fn`. A block-bodied memo factory other than a
- * single `return` keeps its message only.
- *
- * @param {any} call
- * @param {'useMemo' | 'useCallback'} name
- * @param {string} source
- */
-export function manualMemoSuggestion(call, name, source) {
-	const callback = unwrap(call.arguments?.[0]);
-	const message =
-		name === 'useMemo'
-			? 'Write the calculation as a plain expression; Strong compilation caches it.'
-			: 'Pass the function directly; Strong compilation keeps its identity stable.';
-	if (callback == null || call.arguments.some((argument) => argument.type === 'SpreadElement')) {
-		return { message };
-	}
-	if (name === 'useCallback') {
-		return {
-			message,
-			edits: [
-				{ start: call.start, end: call.end, text: source.slice(callback.start, callback.end) },
-			],
-		};
-	}
-	if (
-		callback.type !== 'ArrowFunctionExpression' ||
-		callback.async === true ||
-		callback.params.length > 0
-	) {
-		return { message };
-	}
-	let body = callback.body;
-	if (body?.type === 'BlockStatement') {
-		const only = body.body?.length === 1 ? body.body[0] : null;
-		if (only?.type !== 'ReturnStatement' || only.argument == null) return { message };
-		body = only.argument;
-	}
-	const text = source.slice(body.start, body.end);
-	if (FUNCTION_SCOPE_WORDS.test(text)) return { message };
-	// The call was a primary expression, so anything that binds less tightly
-	// keeps that grouping in parentheses: `useMemo(() => !a, []).b` is `(!a).b`.
-	const parenthesize = !PRIMARY_EXPRESSIONS.has(body.type);
-	return {
-		message,
-		edits: [{ start: call.start, end: call.end, text: parenthesize ? `(${text})` : text }],
-	};
-}
-
 // Properties and calls that read the committed layout. A state update in an
 // effect that reads one of these is a measurement, which useLayoutSnapshot owns.
 const LAYOUT_PROPERTIES = new Set([

package/dist/compiler/strong-mode.js

@@ -21,7 +21,6 @@ import { createStrongRenderPolicy } from './strong-render-policy.js';
 import {
 	collectLazyRefIdioms,
 	lazyRefSuggestion,
-	manualMemoSuggestion,
 	readsLayout,
 	strongDocsUrl,
 } from './strong-fixes.js';
@@ -6259,12 +6258,8 @@ export function analyzeStrongMode(ast, source, filename, options = {}) {
 		...analyzeStrongExternalStore(ast, strongHookAnalysis, stateDiagnostic),
 	);
 	for (const policy of analyzeStrongHookPolicies(ast, options)) {
-		const suggestions =
-			policy.hook === 'useMemo' || policy.hook === 'useCallback'
-				? [manualMemoSuggestion(policy.node, policy.hook, source)]
-				: [];
 		diagnostics.push({
-			...diagnostic(policy.code, filename, policy.node, policy.message, suggestions),
+			...diagnostic(policy.code, filename, policy.node, policy.message),
 			severity: policy.severity,
 		});
 	}

package/dist/node/version.js

@@ -1,4 +1,4 @@
-const version = "0.13.2";
+const version = "0.13.3";
 export {
   version
 };

package/dist/version.js

@@ -1,4 +1,4 @@
-const version = "0.13.2";
+const version = "0.13.3";
 export {
   version
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "octane",
-  "version": "0.13.2",
+  "version": "0.13.3",
   "license": "MIT",
   "type": "module",
   "sideEffects": [