octane 0.3.0 → 0.3.2

package/dist/compiler/compile.js

@@ -56,6 +56,7 @@ import {
 	analyzeCallbackDependencies,
 	analyzeHookDependencies,
 	applyHookDependencies,
+	collectReassignedBindings,
 	isInvariantLiteral,
 } from './hook-deps.js';
 import {
@@ -83,6 +84,8 @@ import {
 	prepareServerRendererBoundaryRegions,
 } from './compile-renderer-boundaries.js';
 import {
+	compiledSplitHydrateTagsForAst,
+	privateCompiledContextsForHydrateAst,
 	hydrateBoundaryPathFromId,
 	prepareHydrateBoundaries,
 	prepareServerHydrateBoundaries,
@@ -125,6 +128,7 @@ import { assertNoLegacyContextProviders } from './context-provider.js';
 import { applyCssModuleConstants } from './css-module-constants.js';
 import { assertUniversalRuntimeTarget, normalizeUniversalRuntime } from './universal-runtime.js';
 import { findLocalVoidRootCallees } from './local-void-roots.js';
+import { findPrivateCompiledContexts } from './private-context.js';
 
 // DOM truth tables shared with the client/server runtimes (via constants.ts) —
 // static bakes and dynamic writes MUST agree on which attributes render, under
@@ -535,12 +539,17 @@ function attrBindingUpdateHelper(bind, inlineBindingGuards = false) {
 	}
 }
 
-function canCarryDirectSignalHandle(node, conservativeResult = false) {
+function canCarryDirectSignalHandle(
+	node,
+	conservativeResult = false,
+	retainLocalCapability = false,
+) {
 	if (
 		!node ||
 		node.metadata?.octane_string_child ||
 		node.metadata?.octane_primitive_text_child ||
-		node.metadata?.octane_primitive_value
+		(node.metadata?.octane_primitive_value &&
+			!(retainLocalCapability && node.metadata?.octane_primitive_local_value))
 	) {
 		return false;
 	}
@@ -551,22 +560,26 @@ function canCarryDirectSignalHandle(node, conservativeResult = false) {
 		node.type === 'ParenthesizedExpression' ||
 		node.type === 'ChainExpression'
 	) {
-		return canCarryDirectSignalHandle(node.expression, conservativeResult);
+		return canCarryDirectSignalHandle(node.expression, conservativeResult, retainLocalCapability);
 	}
 	if (node.type === 'ConditionalExpression') {
 		return (
-			canCarryDirectSignalHandle(node.consequent, conservativeResult) ||
-			canCarryDirectSignalHandle(node.alternate, conservativeResult)
+			canCarryDirectSignalHandle(node.consequent, conservativeResult, retainLocalCapability) ||
+			canCarryDirectSignalHandle(node.alternate, conservativeResult, retainLocalCapability)
 		);
 	}
 	if (node.type === 'LogicalExpression') {
 		return (
-			canCarryDirectSignalHandle(node.left, conservativeResult) ||
-			canCarryDirectSignalHandle(node.right, conservativeResult)
+			canCarryDirectSignalHandle(node.left, conservativeResult, retainLocalCapability) ||
+			canCarryDirectSignalHandle(node.right, conservativeResult, retainLocalCapability)
 		);
 	}
 	if (node.type === 'SequenceExpression') {
-		return canCarryDirectSignalHandle(node.expressions.at(-1), conservativeResult);
+		return canCarryDirectSignalHandle(
+			node.expressions.at(-1),
+			conservativeResult,
+			retainLocalCapability,
+		);
 	}
 	if (
 		!conservativeResult &&
@@ -652,7 +665,16 @@ function componentInvocationSite(ctx, node) {
 }
 
 function markDirectSignalBinding(binding, ctx, origin, kind) {
-	if (!canCarryDirectSignalHandle(binding.expr)) return binding;
+	if (!canCarryDirectSignalHandle(binding.expr)) {
+		// Newly certified locals still retain the prior potential capability:
+		// opaque events can import instance models after their first mount. A
+		// primitive result removes this adapter, not structural owner identity.
+		if (canCarryDirectSignalHandle(binding.expr, false, true)) {
+			ctx.signalBindingsUsed = true;
+			if (isDirectSignalHandleExpression(binding.expr)) ctx.signalBindingsEager = true;
+		}
+		return binding;
+	}
 	ctx.signalBindingsUsed = true;
 	if (isDirectSignalHandleExpression(binding.expr)) ctx.signalBindingsEager = true;
 	return {
@@ -664,6 +686,7 @@ function markDirectSignalBinding(binding, ctx, origin, kind) {
 
 function ssrSignalValue(node, ctx, origin, capability = false) {
 	if (!(capability ? canCarryDirectSignalHandle(node) : isDirectSignalHandleExpression(node))) {
+		if (capability && canCarryDirectSignalHandle(node, false, true)) ctx.signalBindingsUsed = true;
 		return node;
 	}
 	ctx.signalBindingsUsed = true;
@@ -1401,6 +1424,7 @@ const NATIVE_READ_RUNTIME_HELPERS = new Set([
 	'nativeCreateScopedElement',
 ]);
 const INTERNAL_CLIENT_RUNTIME_HELPERS = new Set([
+	'__createCompiledContext',
 	'isContext',
 	'bindPresentationView',
 	'beginPresentationHydration',
@@ -1420,6 +1444,7 @@ const INTERNAL_CLIENT_RUNTIME_HELPERS = new Set([
 	'bindSignalText',
 	'bindSignalChild',
 	'bindSignalAttribute',
+	'hydrateClaimedBindingCaches',
 	'bindSignalValue',
 	'bindSignalChecked',
 	'bindSignalHostPropSources',
@@ -9921,6 +9946,12 @@ function compileInternal(
 		options?.rendererBoundaries == null &&
 		options?.rendererRegistry == null;
 	const authoredVoidRootIds = new Set();
+	const privateCompiledContexts = localVoidRootsEnabled
+		? findPrivateCompiledContexts(ast)
+		: new Map();
+	const splitPrivateContexts = localVoidRootsEnabled
+		? privateCompiledContextsForHydrateAst(parsedAst)
+		: null;
 	if (
 		localVoidRootsEnabled &&
 		ast.body.some(
@@ -10066,6 +10097,9 @@ function compileInternal(
 		nativeChangeClassifications: nativeChangeAnalysis.classifications,
 		dev: devEnabled,
 		profile: profileEnabled,
+		compiledHydrateTemplates: localVoidRootsEnabled,
+		compiledSplitHydrateTags: compiledSplitHydrateTagsForAst(parsedAst),
+		privateSplitContextProviders: splitPrivateContexts?.providers,
 		autoMemo: autoMemoEnabled,
 		strongMemo: strongMemoEnabled,
 		nativeReads: options?.nativeReads === true,
@@ -10450,6 +10484,18 @@ function compileInternal(
 			);
 		}
 	}
+	if (privateCompiledContexts.size > 0 || splitPrivateContexts?.callees.size > 0) {
+		const helper = '__createCompiledContext';
+		const alias = allocCompilerName(ctx, rtAlias(helper));
+		(ctx.privateRuntimeAliases ??= new Map()).set(helper, alias);
+		ctx.runtimeNeeded.add(helper);
+		const callees = new Set([
+			...privateCompiledContexts.values(),
+			...(splitPrivateContexts?.callees ?? []),
+		]);
+		ast = mapAst(ast, (node) => (callees.has(node) ? { ...node, name: alias } : null));
+		ctx.privateCompiledContexts = new Set(privateCompiledContexts.keys());
+	}
 	// Return-based JSX functions never attach fetch-tree warm plans, and a sole
 	// same-module component already rejects a self-only warm edge below. Avoid a
 	// whole-module graph walk unless a compiled-void body can actually reach a
@@ -12719,8 +12765,10 @@ function ssrEmitElement(node, ctx, name, inlinedSubs, parentNs, cssHash, compone
 	);
 	const hostSignalSite = directSignalSite(ctx, node, 'binding');
 	let directSignalControlSite = null;
+	let directSignalControlValues = false;
 	const markDirectControl = (expression, origin) => {
-		if (!canCarryDirectSignalHandle(expression)) return expression;
+		const carriesHandle = canCarryDirectSignalHandle(expression);
+		if (!carriesHandle && !canCarryDirectSignalHandle(expression, false, true)) return expression;
 		const site = firstSpreadIdx === -1 ? directSignalSite(ctx, node, 'input') : hostSignalSite;
 		if (directSignalControlSite === null) {
 			if (directAttributeIdentities.has('data-octane-input')) {
@@ -12732,10 +12780,13 @@ function ssrEmitElement(node, ctx, name, inlinedSubs, parentNs, cssHash, compone
 			bakeLit(` data-octane-input="${escapeAttr(site)}"`, 'data-octane-input', null, null);
 		}
 		ctx.signalBindingsUsed = true;
+		if (!carriesHandle) return expression;
+		directSignalControlValues = true;
 		ctx.runtimeNeeded.add('ssrSignalControlValue');
 		return ssrCall('ssrSignalControlValue', [expression, b.literal(site)], origin);
 	};
 	if (firstSpreadIdx !== -1 && (tag === 'input' || tag === 'textarea' || tag === 'select')) {
+		directSignalControlValues = true;
 		directSignalControlSite = hostSignalSite;
 		if (directAttributeIdentities.has('data-octane-input')) {
 			throw new Error(
@@ -13414,7 +13465,7 @@ function ssrEmitElement(node, ctx, name, inlinedSubs, parentNs, cssHash, compone
 		parts.push(singleDirectAttribute);
 	}
 	let signalControlAttrs = null;
-	if (directSignalControlSite !== null) {
+	if (directSignalControlValues) {
 		ctx.runtimeNeeded.add('ssrSignalControlAttrs');
 		signalControlAttrs = ssrCall('ssrSignalControlAttrs', [b.array(formControlSources)], node);
 	}
@@ -15540,6 +15591,8 @@ function preparePresentationHydration(body, node, ctx, hostEnd) {
  * bodies. `cssHash` selects the enclosing scoped-style expression fallback.
  */
 function compileFunctionBody(node, ctx, name, parentNs = 'html', cssHash = null, options = null) {
+	const previousScalarBindingClaims = ctx.scalarBindingClaims;
+	ctx.scalarBindingClaims = node._octaneScalarBindingClaims;
 	const previousPresentationHydration = ctx.presentationHydration;
 	ctx.presentationHydration = node._octanePresentationHydration;
 	const returnedOutput = options?.returnedOutput === true;
@@ -16153,6 +16206,7 @@ function compileFunctionBody(node, ctx, name, parentNs = 'html', cssHash = null,
 		ctx,
 		presentationHostEnd,
 	);
+	ctx.scalarBindingClaims = previousScalarBindingClaims;
 	ctx.presentationHydration = previousPresentationHydration;
 	const emittedFunction = b.function_declaration(
 		b.id(name, node.id ?? node),
@@ -18299,7 +18353,12 @@ function buildWarmArtifacts(node, ctx, componentName, creations, warmChildren) {
 		inheritOriginLoc(
 			b.call(
 				warmChildAlias,
-				b.id(w.compName),
+				b.id(
+					ctx.compiledSplitHydrateTags?.has(w.origin.openingElement?.name) &&
+						isCompiledHydrateTemplate(w.origin, ctx, w.origin.openingElement.attributes)
+						? requireCompiledHydrateAlias(ctx)
+						: w.compName,
+				),
 				b.object(
 					w.props.map((p) =>
 						b.prop(
@@ -20107,13 +20166,22 @@ function memberProps(hn, src) {
 		// primitive value proofs separately from the renderer's text assertions:
 		// an authored `as string` still permits a signal handle at runtime.
 		...(isPrimitiveValueExpression(src)
-			? { metadata: { ...src?.metadata, octane_primitive_value: true } }
+			? {
+					metadata: {
+						...src?.metadata,
+						octane_primitive_value: true,
+						...(canCarryDirectSignalHandle(src, false, true) && !canCarryDirectSignalHandle(src)
+							? { octane_primitive_local_value: true }
+							: null),
+					},
+				}
 			: null),
 	};
 }
 
-function isPrimitiveValueExpression(node) {
+function isPrimitiveValueExpression(node, proveExpression = null) {
 	if (!node || typeof node !== 'object') return false;
+	if (proveExpression?.(node) === true) return true;
 	if (
 		node.type === 'TSAsExpression' ||
 		node.type === 'TSTypeAssertion' ||
@@ -20123,7 +20191,7 @@ function isPrimitiveValueExpression(node) {
 		node.type === 'ParenthesizedExpression' ||
 		node.type === 'ChainExpression'
 	) {
-		return isPrimitiveValueExpression(node.expression);
+		return isPrimitiveValueExpression(node.expression, proveExpression);
 	}
 	if (
 		node.metadata?.octane_string_child ||
@@ -20153,17 +20221,21 @@ function isPrimitiveValueExpression(node) {
 	}
 	if (node.type === 'ConditionalExpression') {
 		return (
-			isPrimitiveValueExpression(node.consequent) && isPrimitiveValueExpression(node.alternate)
+			isPrimitiveValueExpression(node.consequent, proveExpression) &&
+			isPrimitiveValueExpression(node.alternate, proveExpression)
 		);
 	}
 	if (node.type === 'LogicalExpression') {
-		return isPrimitiveValueExpression(node.left) && isPrimitiveValueExpression(node.right);
+		return (
+			isPrimitiveValueExpression(node.left, proveExpression) &&
+			isPrimitiveValueExpression(node.right, proveExpression)
+		);
 	}
 	if (node.type === 'SequenceExpression') {
-		return isPrimitiveValueExpression(node.expressions.at(-1));
+		return isPrimitiveValueExpression(node.expressions.at(-1), proveExpression);
 	}
 	if (node.type === 'AssignmentExpression') {
-		if (node.operator === '=') return isPrimitiveValueExpression(node.right);
+		if (node.operator === '=') return isPrimitiveValueExpression(node.right, proveExpression);
 		return node.operator === '+=' || NUMERIC_TEXT_OPERATORS.has(node.operator.slice(0, -1));
 	}
 	return false;
@@ -23384,10 +23456,12 @@ function applyStringChildProofs(ast, source, filename, facts) {
 		source.includes('BigInt') ||
 		source.includes('Date') ||
 		source.includes('\\u');
+	const inspectPrimitiveLocals = source.includes('const');
 	if (
 		(typedRanges === null || typedRanges.size === 0) &&
 		(primitiveRanges === null || primitiveRanges.size === 0) &&
-		!inspectIntrinsicCalls
+		!inspectIntrinsicCalls &&
+		!inspectPrimitiveLocals
 	) {
 		return ast;
 	}
@@ -23395,7 +23469,12 @@ function applyStringChildProofs(ast, source, filename, facts) {
 	const primitiveProofs = new Set();
 	const intrinsicCalls = [];
 	const writes = [];
+	let intrinsicMutationReference = false;
+	const intrinsicMutationReferences = [];
+	const intrinsicAliases = [];
 	const ambientIntrinsicValues = new Set();
+	const constantDeclarations = [];
+	const references = [];
 	const seen = new WeakSet();
 	const collect = (node, parent = null, key = null) => {
 		if (node === null || typeof node !== 'object') return;
@@ -23405,6 +23484,20 @@ function applyStringChildProofs(ast, source, filename, facts) {
 		}
 		if (seen.has(node)) return;
 		seen.add(node);
+		if (inspectPrimitiveLocals) {
+			if (
+				node.type === 'VariableDeclarator' &&
+				parent?.type === 'VariableDeclaration' &&
+				parent.kind === 'const' &&
+				parent.declare !== true &&
+				node.id?.type === 'Identifier' &&
+				node.init
+			) {
+				constantDeclarations.push(node);
+			} else if (node.type === 'Identifier') {
+				references.push({ node, parent, key });
+			}
+		}
 		if (
 			(typedRanges !== null || primitiveRanges !== null) &&
 			node.type === 'JSXExpressionContainer' &&
@@ -23421,9 +23514,43 @@ function applyStringChildProofs(ast, source, filename, facts) {
 			if (primitiveRanges?.delete(range)) primitiveProofs.add(expr);
 		}
 		if (inspectIntrinsicCalls) {
+			if (
+				node.type === 'MemberExpression' ||
+				(node.type === 'Property' && parent?.type === 'ObjectPattern')
+			) {
+				const property = node.type === 'MemberExpression' ? node.property : node.key;
+				const method = node.computed ? property?.value : (property?.name ?? property?.value);
+				if (
+					INTRINSIC_MUTATION_METHODS.has(method) ||
+					(node.computed && property?.type !== 'Literal')
+				) {
+					// Unknown computed references may extract a mutator or sit under a
+					// TypeScript/optional-chain wrapper before invocation. Decline the new
+					// intrinsic-local proof even for unrelated dynamic property reads;
+					// this is rejection only, not built-in name admission.
+					intrinsicMutationReference = true;
+				}
+			}
+			if (
+				node.type === 'VariableDeclarator' &&
+				parent?.type === 'VariableDeclaration' &&
+				parent.kind === 'const' &&
+				node.id?.type === 'Identifier' &&
+				node.init
+			) {
+				intrinsicAliases.push(node);
+			}
+			if (node.type === 'MemberExpression' && isPossibleIntrinsicMutator(node)) {
+				intrinsicMutationReferences.push([node.object, node, parent]);
+			} else if (node.type === 'VariableDeclarator' && node.id?.type === 'ObjectPattern') {
+				for (const property of node.id.properties || []) {
+					if (property.type === 'Property' && isPossibleIntrinsicMutator(property)) {
+						intrinsicMutationReferences.push([node.init, property]);
+					}
+				}
+			}
 			if (
 				node.type === 'CallExpression' &&
-				node.optional !== true &&
 				node.callee?.type === 'Identifier' &&
 				TEXT_INTRINSICS.has(node.callee.name)
 			) {
@@ -23469,7 +23596,8 @@ function applyStringChildProofs(ast, source, filename, facts) {
 	let lexical = null;
 	if (
 		intrinsicCalls.length > 0 ||
-		((stringProofs.size > 0 || primitiveProofs.size > 0) && writes.length > 0)
+		((stringProofs.size > 0 || primitiveProofs.size > 0) &&
+			(writes.length > 0 || intrinsicMutationReferences.length > 0))
 	) {
 		// The existing scope analysis understands var hoisting, parameter defaults,
 		// imports, catch bindings, and TSRX @for/@try scopes. Pay for it only when
@@ -23485,17 +23613,206 @@ function applyStringChildProofs(ast, source, filename, facts) {
 		}
 	}
 	if (lexical !== null) {
+		const aliases = new WeakMap();
+		for (const declaration of intrinsicAliases) {
+			const scope = lexical.resolveBinding(
+				lexical.nodeScopes.get(declaration.id),
+				declaration.id.name,
+			)?.scope;
+			if (scope === undefined) continue;
+			let values = aliases.get(scope);
+			if (values === undefined) aliases.set(scope, (values = new Map()));
+			values.set(declaration.id.name, declaration.init);
+		}
+		const initializer = (node) => {
+			const scope = lexical.resolveBinding(lexical.nodeScopes.get(node), node.name)?.scope;
+			return scope === undefined ? undefined : aliases.get(scope)?.get(node.name);
+		};
+		const intrinsicMemberName = (node) => {
+			const property = node.computed ? unwrapTsExpr(node.property) : node.property;
+			return node.computed
+				? property?.type === 'Literal' && typeof property.value === 'string'
+					? property.value
+					: null
+				: property?.type === 'Identifier'
+					? property.name
+					: null;
+		};
+		const globalOrigin = (expression, seen = new Set(), constructors = false) => {
+			const node = unwrapTsExpr(expression);
+			if (!node || seen.has(node)) return null;
+			seen.add(node);
+			if (node.type === 'Identifier') {
+				const scope = lexical.nodeScopes.get(node);
+				if (scope === undefined) return null;
+				if (!lexical.isBound(scope, node.name)) {
+					return INLINE_INTRINSIC_MUTATION_GLOBALS.has(node.name) ||
+						(constructors && TEXT_INTRINSICS.has(node.name))
+						? node.name
+						: null;
+				}
+				return globalOrigin(initializer(node), seen, constructors);
+			}
+			if (node.type === 'ChainExpression') return globalOrigin(node.expression, seen, constructors);
+			if (node.type === 'MemberExpression') {
+				const name = intrinsicMemberName(node);
+				if (name !== 'Object' && name !== 'Reflect' && !(constructors && TEXT_INTRINSICS.has(name)))
+					return null;
+				const origin = globalOrigin(node.object, seen);
+				return origin !== null && INLINE_INTRINSIC_GLOBAL_RECEIVERS.has(origin) ? name : null;
+			}
+			return null;
+		};
+		const freshTarget = (expression, seen = new Set()) => {
+			const node = unwrapTsExpr(expression);
+			if (!node || seen.has(node)) return false;
+			seen.add(node);
+			if (node.type === 'ObjectExpression' || node.type === 'ArrayExpression') return true;
+			return node.type === 'Identifier' && freshTarget(initializer(node), seen);
+		};
+		const visibleMutation =
+			intrinsicMutationReferences.some(([receiver, reference, parent]) => {
+				const origin = globalOrigin(receiver);
+				const key = reference.type === 'Property' ? reference.key : reference.property;
+				const property = reference.computed ? unwrapTsExpr(key) : key;
+				const method = reference.computed ? property?.value : (property?.name ?? property?.value);
+				if (origin === 'Object' || origin === 'Reflect') {
+					// A normal native call targeting a fresh literal cannot directly write
+					// a global constructor. Unknown getter/callback effects retain the
+					// existing builtin assumptions; wrapped/extracted calls fail closed.
+					const target = parent?.arguments?.[0];
+					return !(
+						parent?.type === 'CallExpression' &&
+						parent.optional !== true &&
+						parent.callee === reference &&
+						reference.optional !== true &&
+						INLINE_INTRINSIC_MUTATION_METHODS.has(method) &&
+						freshTarget(target)
+					);
+				}
+				return (
+					origin !== null &&
+					INLINE_INTRINSIC_GLOBAL_RECEIVERS.has(origin) &&
+					(method === '__defineGetter__' ||
+						method === '__defineSetter__' ||
+						(reference.computed && property?.type !== 'Literal'))
+				);
+			}) ||
+			writes.some((target) => {
+				const node = unwrapTsExpr(target);
+				if (node?.type !== 'MemberExpression') return false;
+				const name = node.computed ? node.property?.value : node.property?.name;
+				if (!TEXT_INTRINSICS.has(name) && !(node.computed && node.property?.type !== 'Literal'))
+					return false;
+				const origin = globalOrigin(node.object);
+				return origin !== null && INLINE_INTRINSIC_GLOBAL_RECEIVERS.has(origin);
+			});
+		const unsafeCalls = new WeakSet();
 		for (const call of intrinsicCalls) {
 			const name = call.callee.name;
 			if (ambientIntrinsicValues.has(name)) continue;
 			const scope = lexical.nodeScopes.get(call);
 			if (scope !== undefined && !lexical.isBound(scope, name)) {
+				if (visibleMutation) {
+					unsafeCalls.add(call);
+					continue;
+				}
+				if (call.optional === true) continue;
 				if (name === 'String' || name === 'Date') stringProofs.add(call);
 				else primitiveProofs.add(call);
 			}
 		}
+		if (visibleMutation) {
+			// TypeScript still describes the built-in return type after an asserted
+			// replacement. Drop only supplied proofs that depend on these calls;
+			// unrelated typed scalars and JavaScript's own coercion guarantees survive.
+			const unsafeProof = (node, seen = new WeakSet()) => {
+				if (!node || typeof node !== 'object' || seen.has(node)) return false;
+				seen.add(node);
+				if (unsafeCalls.has(node)) return true;
+				if (node.type === 'CallExpression') {
+					let callee = unwrapTsExpr(node.callee);
+					while (callee?.type === 'ChainExpression') callee = unwrapTsExpr(callee.expression);
+					if (callee?.type === 'MemberExpression') {
+						const method = intrinsicMemberName(callee);
+						if (method === 'call' || method === 'apply') callee = callee.object;
+					}
+					// Supplied facts may describe a saved constructor or its Function
+					// call/apply result. Invalidation grants no new primitive admission.
+					if (TEXT_INTRINSICS.has(globalOrigin(callee, new Set(), true))) return true;
+				}
+				if (node.type === 'Identifier' && unsafeProof(initializer(node), seen)) return true;
+				if (Array.isArray(node)) return node.some((child) => unsafeProof(child, seen));
+				for (const key in node) {
+					if (AST_WALK_SKIP_KEYS.has(key)) continue;
+					if (unsafeProof(node[key], seen)) return true;
+				}
+				return false;
+			};
+			for (const proofs of [stringProofs, primitiveProofs]) {
+				for (const proof of proofs) if (unsafeProof(proof)) proofs.delete(proof);
+			}
+		}
 	}
-	if (stringProofs.size === 0 && primitiveProofs.size === 0) return ast;
+	const valueProofs = new Set();
+	if (
+		constantDeclarations.length > 0 &&
+		(stringProofs.size > 0 ||
+			primitiveProofs.size > 0 ||
+			constantDeclarations.some((declaration) => isPrimitiveValueExpression(declaration.init)))
+	) {
+		lexical ??= createLexicalAnalysis(ast);
+		// A local alias can mutate a global constructor without spelling its
+		// global receiver. This check only declines new local intrinsic facts;
+		// operator/template primitives and existing child proofs remain.
+		const intrinsicLocalResultsSafe =
+			!intrinsicMutationReference && !writes.some(mayWriteTextIntrinsicMember);
+		const reassigned = collectReassignedBindings(ast);
+		const declarationsByScope = new Map();
+		for (const declaration of constantDeclarations) {
+			if (reassigned.has(declaration.id)) continue;
+			const scope = lexical.nodeScopes.get(declaration.id);
+			if (scope === undefined) continue;
+			const binding = lexical.resolveBinding(scope, declaration.id.name);
+			if (binding === null) continue;
+			let declarations = declarationsByScope.get(binding.scope);
+			if (declarations === undefined) {
+				declarations = new Map();
+				declarationsByScope.set(binding.scope, declarations);
+			}
+			declarations.set(declaration.id.name, declaration);
+		}
+		const proven = new Map();
+		const visiting = new Set();
+		const primitive = (node) => isPrimitiveValueExpression(node, proveLocal);
+		const proveLocal = (node) => {
+			if (intrinsicLocalResultsSafe && (stringProofs.has(node) || primitiveProofs.has(node))) {
+				return true;
+			}
+			if (node.type === 'Identifier') {
+				const scope = lexical.nodeScopes.get(node);
+				const binding = scope === undefined ? null : lexical.resolveBinding(scope, node.name);
+				const declaration = declarationsByScope.get(binding?.scope)?.get(node.name);
+				if (declaration === undefined || visiting.has(declaration)) return false;
+				if (proven.has(declaration)) return proven.get(declaration);
+				visiting.add(declaration);
+				const result = primitive(declaration.init);
+				visiting.delete(declaration);
+				proven.set(declaration, result);
+				return result;
+			}
+			return false;
+		};
+		// A value proof follows the lexical binding and its immutable initializer,
+		// never a TS annotation or a renderer's authored text assertion. Reads and
+		// throws still occur in setup; primitive results can contain native reads.
+		for (const { node, parent, key } of references) {
+			if (isIdentifierReference(node, parent, key, lexical) && primitive(node)) {
+				valueProofs.add(node);
+			}
+		}
+	}
+	if (stringProofs.size === 0 && primitiveProofs.size === 0 && valueProofs.size === 0) return ast;
 	const rewritten = new WeakMap();
 	const rewrite = (node) => {
 		if (node === null || typeof node !== 'object') return node;
@@ -23521,7 +23838,18 @@ function applyStringChildProofs(ast, source, filename, facts) {
 					out[key] = next;
 				}
 			}
-			if (stringProofs.has(node)) {
+			if (valueProofs.has(node)) {
+				out = {
+					...out,
+					metadata: {
+						...out.metadata,
+						octane_primitive_value: true,
+						octane_primitive_local_value: true,
+						...(stringProofs.has(node) ? { octane_string_child: true } : null),
+						...(primitiveProofs.has(node) ? { octane_primitive_text_child: true } : null),
+					},
+				};
+			} else if (stringProofs.has(node)) {
 				out = { ...out, metadata: { ...out.metadata, octane_string_child: true } };
 			} else if (primitiveProofs.has(node)) {
 				out = { ...out, metadata: { ...out.metadata, octane_primitive_text_child: true } };
@@ -23534,20 +23862,73 @@ function applyStringChildProofs(ast, source, filename, facts) {
 }
 
 const TEXT_INTRINSICS = new Set(['String', 'Number', 'BigInt', 'Date']);
+const INTRINSIC_MUTATION_METHODS = new Set([
+	'assign',
+	'defineProperty',
+	'defineProperties',
+	'set',
+	'__defineGetter__',
+	'__defineSetter__',
+	'setPrototypeOf',
+	'deleteProperty',
+]);
+
+function mayWriteTextIntrinsicMember(target) {
+	target = unwrapTsExpr(target);
+	if (!target || typeof target !== 'object') return false;
+	if (target.type === 'AssignmentPattern') return mayWriteTextIntrinsicMember(target.left);
+	if (target.type === 'MemberExpression') {
+		return target.computed
+			? target.property?.type !== 'Literal' || TEXT_INTRINSICS.has(target.property.value)
+			: TEXT_INTRINSICS.has(target.property?.name);
+	}
+	if (target.type === 'RestElement') return mayWriteTextIntrinsicMember(target.argument);
+	if (target.type === 'ArrayPattern') {
+		return (target.elements || []).some(mayWriteTextIntrinsicMember);
+	}
+	if (target.type === 'ObjectPattern') {
+		return (target.properties || []).some((property) =>
+			mayWriteTextIntrinsicMember(property.argument ?? property.value),
+		);
+	}
+	return false;
+}
+
+const INLINE_INTRINSIC_MUTATION_METHODS = new Set([
+	'assign',
+	'defineProperty',
+	'defineProperties',
+	'set',
+	'__defineGetter__',
+	'__defineSetter__',
+	'setPrototypeOf',
+	'deleteProperty',
+]);
+const INLINE_INTRINSIC_GLOBAL_RECEIVERS = new Set(['globalThis', 'window', 'self', 'global']);
+const INLINE_INTRINSIC_MUTATION_GLOBALS = new Set([
+	'Object',
+	'Reflect',
+	...INLINE_INTRINSIC_GLOBAL_RECEIVERS,
+]);
+
+// Inspect the reference itself: TS/optional wrappers and extracted methods may
+// hide its eventual call. Lexical receiver checks keep ordinary computed reads
+// and application .set methods from invalidating intrinsic-result proofs.
+function isPossibleIntrinsicMutator(node) {
+	const key = node.type === 'Property' ? node.key : node.property;
+	const property = node.computed ? unwrapTsExpr(key) : key;
+	const name = node.computed ? property?.value : (property?.name ?? property?.value);
+	return (
+		INLINE_INTRINSIC_MUTATION_METHODS.has(name) || (node.computed && property?.type !== 'Literal')
+	);
+}
 
 // A visible replacement of a global constructor invalidates inferred text
 // proofs for the module. Calls still evaluate the authored callee: a replacement
 // may return an element rather than the built-in's primitive result.
 function writesGlobalTextIntrinsic(target, lexical) {
+	target = unwrapTsExpr(target);
 	if (!target || typeof target !== 'object') return false;
-	if (
-		target.type === 'TSAsExpression' ||
-		target.type === 'TSTypeAssertion' ||
-		target.type === 'TSNonNullExpression' ||
-		target.type === 'ParenthesizedExpression'
-	) {
-		return writesGlobalTextIntrinsic(target.expression, lexical);
-	}
 	const unbound = (node, name) => {
 		const scope = lexical.nodeScopes.get(node);
 		return scope !== undefined && !lexical.isBound(scope, name);
@@ -25113,6 +25494,69 @@ function planJsx(
 		if (b.deferred) everyRenderLines.push(updateEmit);
 		else updateLines.push(updateEmit);
 	}
+	if (ctx.scalarBindingClaims) {
+		// Only opted-in scalar views can retain another writer's publication at
+		// hydration. Record their existing cache fields; ordinary output is unchanged.
+		const fields = [];
+		for (const binding of elementBindings) {
+			const key = binding.id;
+			const text = binding.kind === 'textOnlyChild' || binding.kind === 'text';
+			const host = text && !binding.signalDirect ? `_txt$${key}` : `_el$${key}`;
+			if (text && binding.signalDirect)
+				fields.push(bag.letter(`_sig$${key}`), bag.letter(host), '#text-token');
+			if (binding.kind === 'nativeStyle') {
+				fields.push(binding.slotIndex, bag.letter(host), 'style');
+			} else if (binding.kind === 'styleProperties') {
+				for (let i = 0; i < binding.properties.length; i++)
+					fields.push(
+						bag.letter(`_prev$${key}_${i}`),
+						bag.letter(host),
+						`style:${binding.properties[i].name}`,
+					);
+			} else if (binding.kind === 'style') {
+				fields.push(bag.letter(`_sty$${key}`), bag.letter(host), 'style');
+			} else if (
+				text ||
+				['attr', 'stringData', 'booleanAttr', 'ariaAttr', 'class', 'styleProperty'].includes(
+					binding.kind,
+				)
+			) {
+				const cache = binding.signalDirect && !text ? `_sig$${key}` : `_prev$${key}`;
+				fields.push(
+					bag.letter(cache),
+					bag.letter(host),
+					text
+						? '#text'
+						: binding.kind === 'styleProperty'
+							? `style:${binding.name}`
+							: binding.kind === 'class'
+								? 'class'
+								: ATTRIBUTE_ALIASES.get(binding.name) || binding.name,
+				);
+			}
+		}
+		if (fields.length) {
+			const name = `_claims$${ctx.nextHelperId++}`;
+			ctx.hoistedHelpers.push(
+				inheritOriginLoc(
+					b.const(name, b.array(fields.map((value) => b.literal(value)))),
+					planOrigin,
+				),
+			);
+			everyRenderLines.push(
+				inheritOriginLoc(
+					b.stmt(
+						b.call(
+							requireRuntimeForContext(ctx, 'hydrateClaimedBindingCaches'),
+							b.id('__s'),
+							b.id(name),
+						),
+					),
+					planOrigin,
+				),
+			);
+		}
+	}
 	if (keyedSelection !== null && single && !noTemplate) {
 		// Reuse the ordinary root-class write and its exact bag fields. Updating
 		// only the DOM would leave the normal row diff's previous value stale.
@@ -28113,11 +28557,13 @@ function emitElementHtml(
 		appendTemplatePart(attrTemplate, ` data-octane-input="${escapeAttr(site)}"`, 'attribute', null);
 	};
 	const markDirectControl = (binding, expression, origin) => {
-		if (!canCarryDirectSignalHandle(expression)) return binding;
+		const carriesHandle = canCarryDirectSignalHandle(expression);
+		if (!carriesHandle && !canCarryDirectSignalHandle(expression, false, true)) return binding;
 		const site = directSignalSite(ctx, node, 'input');
 		ensureDirectControlSite(site);
 		ctx.signalBindingsUsed = true;
 		if (isDirectSignalHandleExpression(expression)) ctx.signalBindingsEager = true;
+		if (!carriesHandle) return binding;
 		return { ...binding, signalDirect: true, signalSite: site };
 	};
 	const hostSignalSite = directSignalSite(ctx, node, 'binding');
@@ -30312,6 +30758,59 @@ function collectAutoMemoDependencyExpressions(nodes) {
 	};
 }
 
+function requireCompiledHydrateAlias(ctx) {
+	const helper = '__HydrateCompiled';
+	let alias = ctx.privateRuntimeAliases?.get(helper);
+	if (alias === undefined) {
+		alias = allocCompilerName(ctx, rtAlias(helper));
+		(ctx.privateRuntimeAliases ??= new Map()).set(helper, alias);
+	}
+	ctx.runtimeNeeded.add(helper);
+	return alias;
+}
+
+function isPrivateSplitContextProvider(node, ctx) {
+	const tag = node.openingElement?.name ?? node.id;
+	const binding = ctx.privateSplitContextProviders?.get(tag);
+	if (binding === undefined || tag.type !== 'JSXIdentifier' || tag.name !== binding.name)
+		return false;
+	const lexical = (ctx.activityLexical ??= createLexicalAnalysis(ctx.activityModuleAst));
+	if (!lexical.bindingNodes.has(binding)) return false;
+	const owner = lexical.resolveBinding(lexical.nodeScopes.get(binding), binding.name);
+	return (
+		owner !== null &&
+		lexical.resolveBinding(lexical.nodeScopes.get(tag), tag.name)?.scope === owner.scope
+	);
+}
+
+function isCompiledHydrateTemplate(node, ctx, attrs) {
+	if (!ctx.compiledHydrateTemplates || ctx._universalRuntimeUnit != null) return false;
+	const tag = node.openingElement?.name ?? node.id;
+	if (
+		(tag?.type !== 'Identifier' && tag?.type !== 'JSXIdentifier') ||
+		ctx.octaneImportLocals?.get(tag.name) !== 'Hydrate'
+	)
+		return false;
+	if (!ctx.compiledSplitHydrateTags?.has(tag)) {
+		for (const attr of attrs) {
+			if (attr.type !== 'Attribute' && attr.type !== 'JSXAttribute') return false;
+			const name = attr.name?.name ?? attr.name;
+			if (
+				typeof name !== 'string' ||
+				name === 'children' ||
+				name === 'fallback' ||
+				name.startsWith('__')
+			)
+				return false;
+		}
+	}
+	const lexical = (ctx.activityLexical ??= createLexicalAnalysis(ctx.activityModuleAst));
+	const scope = lexical.nodeScopes.get(tag);
+	if (scope === undefined) return false;
+	const binding = lexical.resolveBinding(scope, tag.name);
+	return binding?.scope === lexical.rootScope && binding.importSource?.value === 'octane';
+}
+
 function makeCompCall(
 	node,
 	ctx,
@@ -30330,7 +30829,7 @@ function makeCompCall(
 	const staticFragmentRenderer = node.openingElement?.metadata?.staticFragmentRenderer;
 	const activityDescriptor = isActivityLongForm(node, ctx);
 	const descriptorConfig = activityDescriptor || hasKeyedSpreadConfig(node);
-	const compNode = activityDescriptor
+	let compNode = activityDescriptor
 		? inheritOriginLoc(b.id(requireRuntimeForContext(ctx, 'Activity')), node)
 		: staticFragmentRenderer
 			? inheritOriginLoc(b.id(staticFragmentRenderer.name), node.openingElement?.name || node.id)
@@ -30403,6 +30902,7 @@ function makeCompCall(
 	// arrow while making its body printable. Whitespace-only JSXText around the
 	// arrow is ignored so source indentation doesn't defeat the detection.
 	const sourceChildren = node.children || [];
+	let compiledChildren = false;
 	const renderPropChild = soleRenderPropChild(sourceChildren);
 	if (renderPropChild) {
 		hasChildrenProp = true;
@@ -30434,6 +30934,7 @@ function makeCompCall(
 				propNodes.push(b.prop('init', b.literal('children'), childrenValue));
 			}
 		} else {
+			compiledChildren = true;
 			// Compile children as a render function: (scope) => { renders JSX into scope }.
 			// The function is inlined inside the parent component body so its closures
 			// capture the parent's locals (props, state, etc.).
@@ -30524,7 +31025,16 @@ function makeCompCall(
 	// elides iff the callee carries the definition-site `$$singleRoot` stamp
 	// (docs/comment-marker-elision-plan.md M1).
 	let maybeSingleRoot = false;
-	if (staticFragmentRenderer) {
+	if (
+		(compiledChildren || ctx.compiledSplitHydrateTags?.has(node.openingElement?.name ?? node.id)) &&
+		isCompiledHydrateTemplate(node, ctx, attrs)
+	) {
+		compNode = inheritOriginLoc(
+			b.id(requireCompiledHydrateAlias(ctx)),
+			node.openingElement?.name ?? node.id,
+		);
+		voidComponent = true;
+	} else if (staticFragmentRenderer) {
 		// The renderer is already a void, hookless component body. A memo boundary
 		// would force a full Block and could hide a hookful descendant's update.
 		liteEligible = true;
@@ -30638,6 +31148,11 @@ function makeCompCall(
 			maybeSingleRoot = callSiteOk;
 		}
 		const importedBinding = ctx.importedComponentBindings?.get(compName);
+		if (
+			!voidComponent &&
+			(ctx.privateCompiledContexts?.has(compName) || isPrivateSplitContextProvider(node, ctx))
+		)
+			voidComponent = true;
 		if (
 			!voidComponent &&
 			!ctx.hmr &&