octane 0.4.2 → 0.4.3

package/dist/compiler/dom-binding-fixed-props.js

@@ -239,8 +239,18 @@ export function fixedBindingProps(fn, fixed, lexical, localDeclaration, isRefere
 			result.type === 'Property' &&
 			result.shorthand &&
 			result.value !== node.value
-		)
+		) {
+			// Expanding this shorthand must retain an own data property, not
+			// introduce the object-literal prototype setter syntax.
+			if (!node.computed && node.key.name === '__proto__')
+				return {
+					...result,
+					key: literal('__proto__', node.key),
+					computed: true,
+					shorthand: false,
+				};
 			return { ...result, shorthand: false };
+		}
 		return result;
 	};
 	return { fold, known, unknown: UNKNOWN, checks, literal };

package/dist/compiler/generated-origin.js

@@ -0,0 +1,46 @@
+const SKIP_KEYS = new Set(['type', 'loc', 'start', 'end', 'range', 'metadata', 'parent']);
+
+/**
+ * Give every location-less node under `root` the authored origin of `origin`,
+ * so generated scaffolding still maps into the source. Copy-on-write: adopted
+ * parser nodes are never mutated (tests deep-freeze them), and the returned
+ * tree must replace `root`. Stylesheet descendants use offsets into their own
+ * CSS source rather than JavaScript locations, so they are left intact.
+ */
+export function inheritGeneratedOrigin(root, origin) {
+	if (origin?.loc == null) return root;
+	const seen = new WeakMap();
+	const visit = (value) => {
+		if (!value || typeof value !== 'object') return value;
+		if (value.type === 'StyleSheet') return value;
+		if (seen.has(value)) return seen.get(value);
+		seen.set(value, value);
+		if (Array.isArray(value)) {
+			let output = null;
+			for (let index = 0; index < value.length; index++) {
+				const mapped = visit(value[index]);
+				if (output === null && mapped !== value[index]) output = value.slice(0, index);
+				if (output !== null) output.push(mapped);
+			}
+			const result = output ?? value;
+			seen.set(value, result);
+			return result;
+		}
+		let output = null;
+		if (typeof value.type === 'string' && value.loc == null) {
+			output = { ...value, start: origin.start, end: origin.end, loc: origin.loc };
+		}
+		for (const [key, child] of Object.entries(value)) {
+			if (SKIP_KEYS.has(key)) continue;
+			const mapped = visit(child);
+			if (mapped !== child) {
+				if (output === null) output = { ...value };
+				output[key] = mapped;
+			}
+		}
+		const result = output ?? value;
+		seen.set(value, result);
+		return result;
+	};
+	return visit(root);
+}

package/dist/compiler/hydrate-boundaries.js

@@ -8,6 +8,7 @@
  * intentionally instantiated afresh for every resource query.
  */
 import { builders as b, parseModule, strongHash } from '@tsrx/core';
+import { inheritGeneratedOrigin } from './generated-origin.js';
 import {
 	createLexicalAnalysis,
 	forEachRuntimeAstChild,
@@ -128,45 +129,6 @@ const TRANSPARENT_TS_EXPRESSIONS = new Set([
 	'TSTypeAssertion',
 ]);
 
-function inheritGeneratedOrigin(root, origin) {
-	const seen = new WeakMap();
-	const visit = (value) => {
-		if (!value || typeof value !== 'object') return value;
-		// Stylesheet descendants use offsets into their own CSS source and do
-		// not carry JavaScript locations. Keep that adopted grammar intact.
-		if (value.type === 'StyleSheet') return value;
-		if (seen.has(value)) return seen.get(value);
-		seen.set(value, value);
-		if (Array.isArray(value)) {
-			let output = null;
-			for (let index = 0; index < value.length; index++) {
-				const mapped = visit(value[index]);
-				if (output === null && mapped !== value[index]) output = value.slice(0, index);
-				if (output !== null) output.push(mapped);
-			}
-			const result = output ?? value;
-			seen.set(value, result);
-			return result;
-		}
-		let output = null;
-		if (typeof value.type === 'string' && value.loc == null && origin?.loc != null) {
-			output = { ...value, start: origin.start, end: origin.end, loc: origin.loc };
-		}
-		for (const [key, child] of Object.entries(value)) {
-			if (SKIP_KEYS.has(key)) continue;
-			const mapped = visit(child);
-			if (mapped !== child) {
-				if (output === null) output = { ...value };
-				output[key] = mapped;
-			}
-		}
-		const result = output ?? value;
-		seen.set(value, result);
-		return result;
-	};
-	return visit(root);
-}
-
 function mapAstCow(value, replace) {
 	if (!value || typeof value !== 'object') return value;
 	if (Array.isArray(value)) {
@@ -416,6 +378,7 @@ function collectImports(ast) {
 	const hydrateNames = new Set();
 	const hookNames = new Set();
 	const neverNames = new Set();
+	const conditionNames = new Set();
 	const importBindings = new Set();
 	const declarations = [];
 	for (const statement of ast.body ?? []) {
@@ -448,14 +411,16 @@ function collectImports(ast) {
 				statement.importKind !== 'type' &&
 				specifier.type === 'ImportSpecifier' &&
 				specifier.importKind !== 'type' &&
-				nameOf(specifier.imported) === 'never' &&
+				(nameOf(specifier.imported) === 'never' || nameOf(specifier.imported) === 'condition') &&
 				specifier.local?.name
 			) {
-				neverNames.add(specifier.local.name);
+				(nameOf(specifier.imported) === 'never' ? neverNames : conditionNames).add(
+					specifier.local.name,
+				);
 			}
 		}
 	}
-	return { declarations, hookNames, hydrateNames, neverNames, importBindings };
+	return { declarations, hookNames, hydrateNames, neverNames, conditionNames, importBindings };
 }
 
 function addRelevantBindings(pattern, shadowed, relevant) {
@@ -546,6 +511,41 @@ function literalIndependentEnabled(node, filename) {
 	return enabled;
 }
 
+/**
+ * An independent island activates without its lexical parent, so the client
+ * cannot re-evaluate `when`. The server serializes each built-in automatic
+ * strategy's parameters; reject the authored forms that need the parent:
+ * function-form `when` and `condition()`. Opaque values are checked at SSR.
+ */
+function assertIndependentWhen(node, conditionNames, shadowedImports, filename) {
+	for (const attribute of node.openingElement?.attributes ?? []) {
+		if (jsxAttributeName(attribute) !== 'when') continue;
+		const raw =
+			attribute.value?.type === 'JSXExpressionContainer'
+				? attribute.value.expression
+				: attribute.value;
+		const expression = unwrapExpression(raw);
+		const callee =
+			expression?.type === 'CallExpression' ? unwrapExpression(expression.callee) : null;
+		const kind =
+			expression?.type === 'ArrowFunctionExpression' || expression?.type === 'FunctionExpression'
+				? 'a function-form `when`'
+				: callee?.type === 'Identifier' &&
+					  conditionNames.has(callee.name) &&
+					  !shadowedImports.has(callee.name)
+					? '`condition()`'
+					: null;
+		if (kind !== null) {
+			throw extractionError(
+				'OCTANE_HYDRATE_INDEPENDENT_WHEN',
+				filename,
+				attribute,
+				`an independent boundary cannot use ${kind} because its lexical parent never runs on the client to re-evaluate it. Use load(), idle(), visible(), media(), interaction(), or never(), or remove \`independent\``,
+			);
+		}
+	}
+}
+
 /**
  * Recognize only the exact server-only form whose client subtree may be erased.
  * Spreads and indirect strategies stay on the ordinary persistent-wrapper path:
@@ -926,6 +926,7 @@ export function analyzeHydrateBoundaries(source, filename = 'unknown.tsrx', pars
 				const index = siblings.length;
 				const path = parentBoundary === null ? String(index) : `${parentBoundary.path}.${index}`;
 				const independent = literalIndependentEnabled(node, filename);
+				if (independent) assertIndependentWhen(node, imports.conditionNames, shadowed, filename);
 				boundary = {
 					children: [],
 					disabled: literalSplitDisabled(node),
@@ -1239,9 +1240,41 @@ function captureBindingScope(lexical, node, name) {
 	);
 }
 
+// A pattern binding's value is its declarator initializer or, when that part is
+// undefined, any default on the path to it (`const { value = new Map() } = props`).
+function recordPatternInitializers(pattern, scopeNode, values, record) {
+	if (!pattern) return;
+	if (pattern.type === 'TSParameterProperty') {
+		recordPatternInitializers(pattern.parameter, scopeNode, values, record);
+	} else if (pattern.type === 'Identifier') {
+		for (const value of values) record(pattern.name, scopeNode, value);
+		if (values.length === 0) record(pattern.name, scopeNode, null);
+	} else if (pattern.type === 'AssignmentPattern') {
+		recordPatternInitializers(pattern.left, scopeNode, [...values, pattern.right], record);
+	} else if (pattern.type === 'RestElement') {
+		recordPatternInitializers(pattern.argument, scopeNode, values, record);
+	} else if (pattern.type === 'ArrayPattern') {
+		for (const element of pattern.elements ?? []) {
+			recordPatternInitializers(element, scopeNode, values, record);
+		}
+	} else if (pattern.type === 'ObjectPattern') {
+		for (const property of pattern.properties ?? []) {
+			recordPatternInitializers(property.argument ?? property.value, scopeNode, values, record);
+		}
+	}
+}
+
 function bindingInitializers(ast, lexical) {
 	const initializers = new WeakMap();
 	const seen = new WeakSet();
+	const record = (name, node, value) => {
+		const scope = captureBindingScope(lexical, node, name);
+		let bindings = initializers.get(scope);
+		if (bindings === undefined) initializers.set(scope, (bindings = new Map()));
+		let values = bindings.get(name);
+		if (values === undefined) bindings.set(name, (values = []));
+		values.push(value);
+	};
 	const visit = (node) => {
 		if (!node || typeof node !== 'object' || seen.has(node)) return;
 		seen.add(node);
@@ -1250,16 +1283,18 @@ function bindingInitializers(ast, lexical) {
 			return;
 		}
 		if (node.type === 'VariableDeclarator') {
-			const names = new Set();
-			collectBindingNames(node.id, names);
-			for (const name of names) {
-				const scope = captureBindingScope(lexical, node, name);
-				let bindings = initializers.get(scope);
-				if (bindings === undefined) initializers.set(scope, (bindings = new Map()));
-				let values = bindings.get(name);
-				if (values === undefined) bindings.set(name, (values = []));
-				values.push(node.init ?? null);
-			}
+			recordPatternInitializers(node.id, node, [node.init ?? null], record);
+		} else if (
+			(node.type === 'FunctionDeclaration' || node.type === 'ClassDeclaration') &&
+			node.id?.type === 'Identifier'
+		) {
+			// A declaration is its own initializer: the parent creates that identity.
+			record(node.id.name, node, node);
+		}
+		if (isFunction(node)) {
+			// Parameter defaults run in the owner when the caller omits the value.
+			for (const param of node.params ?? [])
+				recordPatternInitializers(param, node.body, [], record);
 		}
 		for (const [key, child] of Object.entries(node)) {
 			if (!SKIP_KEYS.has(key)) visit(child);
@@ -1317,6 +1352,7 @@ function unsupportedIndependentInitializer(node, lexical, initializers, assigned
 		if (
 			isFunction(node) ||
 			node.type === 'ClassExpression' ||
+			node.type === 'ClassDeclaration' ||
 			node.type === 'NewExpression' ||
 			node.type === 'CallExpression' ||
 			node.type === 'OptionalCallExpression'

package/dist/compiler/plain-hook-memo.js

@@ -301,7 +301,11 @@ export function inlinePlainHookMemos(ast, source, id, options) {
 	if (!hasMemo || hasUse) return null;
 	const visitors = esrapTsx({
 		comments: collectComments(ast),
-		getLeadingComments: (node) => (node.__octanePure ? PURE_COMMENTS : undefined),
+		getLeadingComments: (node) =>
+			node.__octanePure ||
+			(node.type === 'CallExpression' && options.pureCalls?.get(node.start) === node.end)
+				? PURE_COMMENTS
+				: undefined,
 	});
 	if (!canPrintProgram(ast, visitors)) return null;
 	const state = {

package/dist/compiler/pure-factories.js

@@ -0,0 +1,66 @@
+// Octane factories whose runtime declarations carry `/* @__NO_SIDE_EFFECTS__ */`.
+//
+// Rollup (and so Vite) propagates that declaration annotation to call sites in
+// other modules, but esbuild deliberately does not: its tree-shaking decisions
+// are local to the file containing the call (esbuild CHANGELOG 0.18.1). An
+// unused module-scope `const Ctx = createContext(…)` therefore counts as a
+// side effect under esbuild and retains the whole client runtime through
+// createContext's provider body. The compiler owns every Octane module's
+// output, so it annotates these call sites with the portable `/* @__PURE__ */`
+// convention that every bundler honors.
+//
+// Only the client DOM runtime declares all four factories side-effect-free.
+// The server `createContext` registers the context, and universal renderers
+// ship their own factories, so those targets keep the `lazy`-only set.
+const CLIENT_DOM_PURE_FACTORIES = new Set(['createContext', 'createPortal', 'lazy', 'memo']);
+const PORTABLE_PURE_FACTORIES = new Set(['lazy']);
+
+/**
+ * @param {{ clientDom: boolean }} target
+ * @returns {ReadonlySet<string>}
+ */
+export function octanePureFactoryNames({ clientDom }) {
+	return clientDom ? CLIENT_DOM_PURE_FACTORIES : PORTABLE_PURE_FACTORIES;
+}
+
+/**
+ * Local names bound by `import { … } from 'octane'` to a pure factory.
+ * @param {any[]} body
+ * @param {ReadonlySet<string>} names
+ * @returns {Set<string>}
+ */
+export function collectPureFactoryLocals(body, names) {
+	const locals = new Set();
+	for (const node of body || []) {
+		if (node.type !== 'ImportDeclaration' || node.source?.value !== 'octane') continue;
+		if (node.importKind === 'type') continue;
+		for (const specifier of node.specifiers || []) {
+			if (
+				specifier.type === 'ImportSpecifier' &&
+				specifier.importKind !== 'type' &&
+				names.has(specifier.imported?.name ?? specifier.imported?.value) &&
+				specifier.local?.name
+			) {
+				locals.add(specifier.local.name);
+			}
+		}
+	}
+	return locals;
+}
+
+/** Whether `node` is a direct call to one of `locals`. */
+export function isPureFactoryCall(node, locals) {
+	return (
+		node?.type === 'CallExpression' &&
+		node.callee?.type === 'Identifier' &&
+		locals.has(node.callee.name)
+	);
+}
+
+// Authored annotations stay authoritative; never stack a second one.
+const AUTHORED_PURE_BEFORE = /\/\*\s*[#@]__PURE__\s*\*\/\s*$/;
+
+/** Whether authored source already annotates the call starting at `start`. */
+export function hasAuthoredPureAnnotation(source, start) {
+	return AUTHORED_PURE_BEFORE.test(source.slice(Math.max(0, start - 64), start));
+}

package/dist/compiler/register.js

@@ -131,9 +131,12 @@ function registerBunPlugin() {
 							? 'ts'
 							: 'js';
 				if (result === null || result.kind === 'none') return { contents: source, loader };
+				// Compiled `.ts`/`.tsx` output keeps TypeScript with runtime semantics
+				// (`enum`, value namespaces), exactly as Vite's own TS transform then
+				// consumes it, so it keeps its source loader. `.tsrx` output is JavaScript.
 				return {
 					contents: result.code,
-					loader: result.kind === 'slots' || result.kind === 'runtime-requests' ? loader : 'js',
+					loader: result.kind === 'compile' && path.endsWith('.tsrx') ? 'js' : loader,
 				};
 			});
 		},