octane 0.3.0 → 0.3.2

package/dist/compiler/dom-bindings.js

@@ -2300,6 +2300,11 @@ export function prepareDomBindings(ast, source, filename, selectedExport, helper
 			);
 		}
 		for (const [node, replacement] of rewritten) replacements.set(node, replacement);
+		if (!plan.hostHandoff)
+			replacements.set(node, {
+				...mapCow(node, rewritten),
+				_octaneScalarBindingClaims: true,
+			});
 		if (plan.hostHandoff)
 			replacements.set(node, {
 				...mapCow(node, rewritten),

package/dist/compiler/hydrate-boundaries.js

@@ -14,8 +14,110 @@ import {
 	isIdentifierReference,
 } from './compile-universal.js';
 
+import { findPrivateCompiledContextProofs } from './private-context.js';
+
 export const HYDRATE_QUERY_PARAM = 'octane-hydrate';
 
+// Only this extraction pass can certify the loader/child ABI. Keep provenance
+// off authored attributes and parser metadata; COW rewrites preserve tag nodes.
+const compiledSplitHydrateTags = new WeakMap();
+
+export function compiledSplitHydrateTagsForAst(ast) {
+	return compiledSplitHydrateTags.get(ast);
+}
+
+function isCompiledSplitHydrateBoundary(boundary) {
+	if (boundary.disabled || boundary.independent || boundary.permanentStatic) return false;
+	const opening = boundary.node.openingElement;
+	if (opening.name?.type !== 'JSXIdentifier') return false;
+	if (
+		(opening.attributes ?? []).some((attribute) => {
+			const name = attribute.name?.name;
+			return (
+				attribute.type !== 'JSXAttribute' ||
+				attribute.name?.type !== 'JSXIdentifier' ||
+				typeof name !== 'string' ||
+				name === 'children' ||
+				name === 'fallback' ||
+				name.startsWith('__')
+			);
+		})
+	)
+		return false;
+	return !(boundary.node.children ?? []).some((child) => {
+		const expression = unwrapExpression(
+			child.type === 'JSXExpressionContainer' ? child.expression : null,
+		);
+		return ['ArrowFunctionExpression', 'FunctionExpression'].includes(expression?.type);
+	});
+}
+
+// Generated captures preserve a proven private Context identity, not an authored
+// escape. Certificates belong only to this prepared AST and exact parser tags.
+const privateSplitContexts = new WeakMap();
+export function privateCompiledContextsForHydrateAst(ast) {
+	return privateSplitContexts.get(ast);
+}
+
+function privateContextCaptureBoundary(boundary) {
+	if (boundary.disabled || boundary.independent || boundary.permanentStatic) return false;
+	const opening = boundary.node.openingElement;
+	if (opening?.name?.type !== 'JSXIdentifier') return false;
+	return (opening.attributes ?? []).every((attribute) => {
+		const name = attribute.name?.name;
+		return (
+			attribute.type === 'JSXAttribute' &&
+			attribute.name?.type === 'JSXIdentifier' &&
+			typeof name === 'string' &&
+			name !== 'children' &&
+			!name.startsWith('__')
+		);
+	});
+}
+
+function originalSplitContextProofs(analysis, moduleMovePlan) {
+	const contexts = findPrivateCompiledContextProofs(analysis.ast);
+	if (contexts.size === 0) return contexts;
+	const captured = new Set();
+	for (const boundary of analysis.boundaries) {
+		if (boundary.disabled || hasPermanentStaticAncestor(boundary)) continue;
+		const moduleBindings = moduleMovePlan.bindingsByPath.get(boundary.path) ?? new Set();
+		const names = collectCaptures(
+			boundary.node.children,
+			analysis.imports.importBindings,
+			boundary.shadowedImports,
+			moduleBindings.size === 0 ? null : moduleBindings,
+		);
+		for (const name of names) {
+			if (!contexts.has(name)) continue;
+			if (!privateContextCaptureBoundary(boundary)) contexts.delete(name);
+			else captured.add(name);
+		}
+	}
+	return new Map([...contexts].filter(([name]) => captured.has(name)));
+}
+
+function certifySplitContexts(ast, contexts, captureBindings) {
+	if (contexts.size === 0) return;
+	const byId = new Map(),
+		byTag = new Map(),
+		present = new WeakSet();
+	for (const [name, context] of contexts) {
+		byId.set(context.id, context.callee);
+		for (const tag of context.providerTags) byTag.set(tag, captureBindings.get(name) ?? context.id);
+	}
+	const callees = new Set(),
+		providers = new Map();
+	mapAstCow(ast, (node) => {
+		present.add(node);
+		if (byId.has(node)) callees.add(byId.get(node));
+		if (byTag.has(node)) providers.set(node, byTag.get(node));
+		return undefined;
+	});
+	for (const [tag, binding] of providers) if (!present.has(binding)) providers.delete(tag);
+	if (callees.size > 0 || providers.size > 0) privateSplitContexts.set(ast, { callees, providers });
+}
+
 const SKIP_KEYS = new Set(['type', 'loc', 'start', 'end', 'range', 'metadata', 'parent']);
 const TRANSPARENT_TS_EXPRESSIONS = new Set([
 	'ParenthesizedExpression',
@@ -1755,6 +1857,7 @@ function extractedModuleAst(
 	request,
 	moduleBindingsByPath = new Map(),
 	moduleDeclarationsByPath = new Map(),
+	captureBindings = new Map(),
 ) {
 	if (boundary.disabled) {
 		throw extractionError(
@@ -1803,6 +1906,11 @@ function extractedModuleAst(
 						boundary.node,
 					),
 				];
+	if (setup.length > 0) {
+		const pattern = setup[0].declarations[0].id;
+		for (let index = 0; index < captures.length; index++)
+			captureBindings.set(captures[index], pattern.elements[index]);
+	}
 	const codeBlock = inheritGeneratedOrigin(
 		{
 			type: 'JSXCodeBlock',
@@ -2139,6 +2247,8 @@ export function prepareHydrateBoundaries(source, filename, boundaryPath = null,
 	}
 	const request = sameSourceRequest(filename);
 	const moduleMovePlan = createModuleMovePlanAst(analysis, request);
+	const contexts = originalSplitContextProofs(analysis, moduleMovePlan);
+	const captureBindings = new Map();
 	const independentWidgets = independentWidgetMetadata(analysis, filename, moduleMovePlan);
 	let independentIndex = 0;
 	for (const boundary of analysis.boundaries) {
@@ -2174,8 +2284,16 @@ export function prepareHydrateBoundaries(source, filename, boundaryPath = null,
 			request,
 			moduleMovePlan.bindingsByPath,
 			moduleMovePlan.declarationsByPath,
+			captureBindings,
 		);
 	}
+	const templateTags = new Set(
+		analysis.boundaries
+			.filter(isCompiledSplitHydrateBoundary)
+			.map((boundary) => boundary.node.openingElement.name),
+	);
+	if (templateTags.size > 0) compiledSplitHydrateTags.set(ast, templateTags);
+	certifySplitContexts(ast, contexts, captureBindings);
 	return {
 		ast,
 		boundaryPath,

package/dist/compiler/private-context.js

@@ -0,0 +1,160 @@
+import {
+	createLexicalAnalysis,
+	forEachRuntimeAstChild,
+	isIdentifierReference,
+} from './compile-universal.js';
+
+/** Only private contexts whose complete authored lifetime stays in template bodies. */
+export function findPrivateCompiledContexts(ast) {
+	return new Map(
+		[...findPrivateCompiledContextProofs(ast)].map(([name, context]) => [name, context.callee]),
+	);
+}
+
+/** Definition and exact provider tags accepted by the same closed-module proof. */
+export function findPrivateCompiledContextProofs(ast) {
+	const imports = new Map();
+	for (const statement of ast.body ?? []) {
+		if (
+			statement.type !== 'ImportDeclaration' ||
+			statement.source?.value !== 'octane' ||
+			statement.importKind === 'type'
+		)
+			continue;
+		for (const specifier of statement.specifiers ?? []) {
+			const name = specifier.imported?.name ?? specifier.imported?.value;
+			if (
+				specifier.type === 'ImportSpecifier' &&
+				specifier.importKind !== 'type' &&
+				['createContext', 'use', 'useContext'].includes(name)
+			)
+				imports.set(specifier.local.name, name);
+		}
+	}
+	if (![...imports.values()].includes('createContext')) return new Map();
+	if (
+		!(ast.body ?? []).some(
+			(statement) =>
+				statement.type === 'VariableDeclaration' &&
+				statement.kind === 'const' &&
+				statement.declarations.some(
+					(entry) => imports.get(entry.init?.callee?.name) === 'createContext',
+				),
+		)
+	)
+		return new Map();
+	const lexical = createLexicalAnalysis(ast);
+	const moduleBinding = (node) =>
+		node != null &&
+		lexical.resolveBinding(lexical.nodeScopes.get(node), node.name)?.scope === lexical.rootScope;
+	const contexts = new Map();
+	for (const statement of ast.body ?? []) {
+		if (statement.type !== 'VariableDeclaration' || statement.kind !== 'const') continue;
+		for (const entry of statement.declarations ?? []) {
+			const call = entry.init;
+			if (
+				entry.id?.type === 'Identifier' &&
+				call?.type === 'CallExpression' &&
+				call.optional !== true &&
+				call.callee?.type === 'Identifier' &&
+				imports.get(call.callee.name) === 'createContext' &&
+				moduleBinding(call.callee) &&
+				call.arguments.length === 1 &&
+				call.arguments[0].type !== 'SpreadElement'
+			)
+				contexts.set(entry.id.name, {
+					id: entry.id,
+					callee: call.callee,
+					providerTags: new Set(),
+					valid: true,
+				});
+		}
+	}
+	if (contexts.size === 0) return new Map();
+	let opaque = false;
+	const providerChildren = (element) =>
+		!(element.openingElement.attributes ?? []).some(
+			(attribute) =>
+				attribute.type === 'JSXSpreadAttribute' ||
+				attribute.name?.type !== 'JSXIdentifier' ||
+				attribute.name.name === 'children' ||
+				attribute.name.name.startsWith('__'),
+		) &&
+		!(element.children ?? []).some((child) => {
+			let expression = child.type === 'JSXExpressionContainer' ? child.expression : null;
+			while (
+				[
+					'TSAsExpression',
+					'TSTypeAssertion',
+					'TSSatisfiesExpression',
+					'TSNonNullExpression',
+					'TSInstantiationExpression',
+					'ParenthesizedExpression',
+				].includes(expression?.type)
+			)
+				expression = expression.expression;
+			return ['ArrowFunctionExpression', 'FunctionExpression'].includes(expression?.type);
+		});
+	const inspect = (node, parent, key, grandparent, direct = false) => {
+		if (node === null || typeof node !== 'object') return;
+		const identifier = node.type === 'Identifier';
+		const reference = identifier && isIdentifierReference(node, parent, key, lexical);
+		if (
+			node.type === 'WithStatement' ||
+			(reference && node.name === 'eval') ||
+			((node.type === 'CallExpression' || node.type === 'OptionalCallExpression') &&
+				['MemberExpression', 'OptionalMemberExpression'].includes(node.callee?.type) &&
+				(node.callee.property?.name ?? node.callee.property?.value) === 'eval')
+		)
+			opaque = true;
+		const context = contexts.get(node.name);
+		if (context !== undefined) {
+			// A module-wide name is used at emitted component calls. Any shadow
+			// declines that name rather than guessing a generated body's scope.
+			if (lexical.bindingNodes.has(node) && node !== context.id) context.valid = false;
+			const tag =
+				node.type === 'JSXIdentifier' &&
+				(((parent?.type === 'JSXOpeningElement' || parent?.type === 'JSXClosingElement') &&
+					key === 'name') ||
+					(parent?.type === 'JSXMemberExpression' && key === 'object'));
+			const exported = parent?.type === 'ExportSpecifier' && key === 'local';
+			if (reference || tag || exported) {
+				if (lexical.nodeScopes.get(node) === undefined) context.valid = false;
+				else if (moduleBinding(node)) {
+					const read =
+						reference &&
+						parent?.type === 'CallExpression' &&
+						parent.optional !== true &&
+						parent.arguments[0] === node &&
+						parent.arguments.length === 1 &&
+						parent.callee?.type === 'Identifier' &&
+						['use', 'useContext'].includes(imports.get(parent.callee.name)) &&
+						moduleBinding(parent.callee);
+					const provider =
+						tag &&
+						direct &&
+						(parent?.type === 'JSXOpeningElement' || parent?.type === 'JSXClosingElement') &&
+						grandparent?.type === 'JSXElement' &&
+						providerChildren(grandparent);
+					if (!read && !provider) context.valid = false;
+					if (provider) context.providerTags.add(node);
+				}
+			}
+		}
+		forEachRuntimeAstChild(node, (child, childKey) => {
+			const childDirect =
+				node.type === 'JSXCodeBlock'
+					? childKey === 'render'
+					: direct &&
+						((node.type === 'JSXElement' &&
+							['children', 'openingElement', 'closingElement'].includes(childKey)) ||
+							(node.type === 'JSXFragment' && childKey === 'children') ||
+							((node.type === 'JSXOpeningElement' || node.type === 'JSXClosingElement') &&
+								childKey === 'name'));
+			inspect(child, node, childKey, parent, childDirect);
+		});
+	};
+	inspect(ast);
+	if (opaque) return new Map();
+	return new Map([...contexts].filter(([, context]) => context.valid));
+}

package/dist/constants.d.ts

@@ -10,16 +10,13 @@
  *
  * The server emit (runtime.server `ssrBlock` and friends) writes these markers
  * around every dynamic site, and the client `hydrateRoot` cursor scans for them
- * to align with the server output. This module is the shared home both import.
+ * to align with the server output. This module is the public home both import;
+ * the marker payloads and boundary attribute names themselves are declared in
+ * `hydration-markers.js`, which stays off the `dom-tables.js` graph so the
+ * pre-root capture bundle can share them, and are re-exported here unchanged.
  */
-/** Single-character payload of a block-open comment. */
-export declare const HYDRATION_START = "[";
-/** Single-character payload of a block-close comment. */
-export declare const HYDRATION_END = "]";
-/** @for outer-open payload: the server rendered its @empty arm. */
-export declare const HYDRATION_FOR_EMPTY = "[f0";
-/** @for outer-open payload: the server rendered one or more direct-host items. */
-export declare const HYDRATION_FOR_ITEMS = "[f1";
+import { HYDRATION_START, HYDRATION_END, HYDRATION_FOR_EMPTY, HYDRATION_FOR_ITEMS } from './hydration-markers.js';
+export { HYDRATION_START, HYDRATION_END, HYDRATION_FOR_EMPTY, HYDRATION_FOR_ITEMS };
 /** Opens a hydratable block (component output / control-flow branch). */
 export declare const BLOCK_OPEN = "<!--[-->";
 /** Closes a hydratable block. */
@@ -87,17 +84,9 @@ export declare const HYDRATION_RANGE_BOUNDARY: unique symbol;
 export declare const HYDRATE_STATIC_ID_COUNT_PREFIX = "octane-static-hydrate:";
 /** Closing comment for a wrapper-free permanent-static range. */
 export declare const HYDRATE_STATIC_END = "/octane-static-hydrate";
-/** Stable id of a server-rendered deferred hydration boundary. */
-export declare const HYDRATE_ID_ATTR = "data-octane-hydrate-id";
-/** Serialized strategy kind (`visible`, `idle`, `dynamic`, …). */
-export declare const HYDRATE_WHEN_ATTR = "data-octane-hydrate-when";
-/** Number of `useId()` slots consumed while rendering the deferred child. */
-export declare const HYDRATE_ID_COUNT_ATTR = "data-octane-hydrate-id-count";
 /** Opaque renderer stream token authenticating pending descendants owned by this boundary. */
 export { HYDRATE_STREAM_TOKEN_ATTR } from './stream-protocol.js';
-/** Direct-child JSON script carrying this boundary's `use()` seed slice. */
-export declare const HYDRATE_SEED_ATTR = "data-octane-hydrate-seed";
-export { INDEPENDENT_HYDRATE_MANIFEST_ATTR, HYDRATE_INDEPENDENT_ATTR, HYDRATE_INPUT_ATTR, SIGNAL_CONTROL_ATTR, } from './hydration-markers.js';
+export { INDEPENDENT_HYDRATE_MANIFEST_ATTR, HYDRATE_INDEPENDENT_ATTR, HYDRATE_INPUT_ATTR, SIGNAL_CONTROL_ATTR, HYDRATE_ID_ATTR, HYDRATE_WHEN_ATTR, HYDRATE_ID_COUNT_ATTR, HYDRATE_SEED_ATTR, } from './hydration-markers.js';
 /** Sentinel <template> attribute marking a pending streamed boundary. */
 export { STREAM_BOUNDARY_ATTR } from './stream-protocol.js';
 /** Hidden segment container attribute carrying a completed boundary's content. */

package/dist/constants.js

@@ -1,7 +1,9 @@
-const HYDRATION_START = "[";
-const HYDRATION_END = "]";
-const HYDRATION_FOR_EMPTY = "[f0";
-const HYDRATION_FOR_ITEMS = "[f1";
+import {
+  HYDRATION_START,
+  HYDRATION_END,
+  HYDRATION_FOR_EMPTY,
+  HYDRATION_FOR_ITEMS
+} from "./hydration-markers.js";
 const BLOCK_OPEN = `<!--${HYDRATION_START}-->`;
 const BLOCK_CLOSE = `<!--${HYDRATION_END}-->`;
 const FOR_BLOCK_OPEN_EMPTY = `<!--${HYDRATION_FOR_EMPTY}-->`;
@@ -23,16 +25,16 @@ const HYDRATION_RANGE_BOUNDARY = /* @__PURE__ */ Symbol.for(
 );
 const HYDRATE_STATIC_ID_COUNT_PREFIX = "octane-static-hydrate:";
 const HYDRATE_STATIC_END = "/octane-static-hydrate";
-const HYDRATE_ID_ATTR = "data-octane-hydrate-id";
-const HYDRATE_WHEN_ATTR = "data-octane-hydrate-when";
-const HYDRATE_ID_COUNT_ATTR = "data-octane-hydrate-id-count";
 import { HYDRATE_STREAM_TOKEN_ATTR } from "./stream-protocol.js";
-const HYDRATE_SEED_ATTR = "data-octane-hydrate-seed";
 import {
   INDEPENDENT_HYDRATE_MANIFEST_ATTR,
   HYDRATE_INDEPENDENT_ATTR,
   HYDRATE_INPUT_ATTR,
-  SIGNAL_CONTROL_ATTR
+  SIGNAL_CONTROL_ATTR,
+  HYDRATE_ID_ATTR,
+  HYDRATE_WHEN_ATTR,
+  HYDRATE_ID_COUNT_ATTR,
+  HYDRATE_SEED_ATTR
 } from "./hydration-markers.js";
 import { STREAM_BOUNDARY_ATTR } from "./stream-protocol.js";
 const STREAM_SEGMENT_ATTR = "data-oct-s";

package/dist/css.d.ts

@@ -12,3 +12,10 @@ export declare function styleName(name: string): string;
 export declare function devWarnStyleProperty(name: string, value: unknown, server: boolean): void;
 /** @internal Development-only guidance after an existing CSS coercion fails. */
 export declare function devWarnStyleCoercion(name: string, value: unknown): void;
+/**
+ * The one stylesheet element-scoped `<ViewTransition>` needs. The client
+ * dedupes the injection by this id and the SSR serializer emits the same pair,
+ * so spelling either half twice ships the rule twice or drops it on one side.
+ */
+export declare const VIEW_TRANSITION_SCOPE_STYLE_ID = "octane-view-transition-scope";
+export declare const VIEW_TRANSITION_SCOPE_CSS = "[vt-scope=\"element\"]{view-transition-scope:all!important}";

package/dist/css.js

@@ -67,7 +67,11 @@ function devWarnStyleCoercion(name, value) {
     `The provided \`${name}\` CSS property is an unsupported type ${valueType}. This value must be coerced to a string before using it here.`
   );
 }
+const VIEW_TRANSITION_SCOPE_STYLE_ID = "octane-view-transition-scope";
+const VIEW_TRANSITION_SCOPE_CSS = '[vt-scope="element"]{view-transition-scope:all!important}';
 export {
+  VIEW_TRANSITION_SCOPE_CSS,
+  VIEW_TRANSITION_SCOPE_STYLE_ID,
   devWarnStyleCoercion,
   devWarnStyleProperty,
   mergeClass,

package/dist/dom-binding-program.js

@@ -5,7 +5,13 @@ import {
   __releaseBinding,
   __writeBinding
 } from "./dom-bindings.js";
-import { encodeBindingKey, parseBindingMarker } from "./dom-binding-protocol.js";
+import {
+  bindingRootMarker,
+  BINDING_OPEN_PREFIX,
+  encodeBindingKey,
+  parseBindingMarker
+} from "./dom-binding-protocol.js";
+import { HYDRATION_FOR_PREFIX } from "./hydration-markers.js";
 import { moveNativeNodeBefore } from "./dom-focused-move.js";
 import { rendererRangeClose } from "./stream-protocol.js";
 import {
@@ -527,7 +533,7 @@ function createFragment(definition, id, document, transaction) {
   const template = document.createElement("template");
   template.innerHTML = definition.ns === 1 ? `<svg>${definition.html}</svg>` : definition.html;
   const content = document.createDocumentFragment();
-  const start = document.createComment(`[b;${id};root`);
+  const start = document.createComment(bindingRootMarker(id));
   const end = document.createComment("]");
   content.appendChild(start);
   if (definition.ns === 1) {
@@ -875,7 +881,8 @@ function commitRegion(plan, id, transaction) {
         transaction
       );
   }
-  if (definition.kind === "if") region.range.start.data = `[b;${id};${region.site};${plan.arm}`;
+  if (definition.kind === "if")
+    region.range.start.data = `${BINDING_OPEN_PREFIX}${id};${region.site};${plan.arm}`;
 }
 function writeText(region, value) {
   if (region.text === null) {
@@ -1469,13 +1476,13 @@ function commitList(plan, id, transaction) {
     }
     let anchor = region.range.end;
     for (const [key, item] of [...plan.items].reverse()) {
-      item.instance.range.start.data = `[b;${id};${region.site};k;${key}`;
+      item.instance.range.start.data = `${BINDING_OPEN_PREFIX}${id};${region.site};k;${key}`;
       moveRange(item.instance.range, region.range.end.parentNode, anchor, transaction);
       if (transaction.disposed) return;
       anchor = item.instance.range.start;
     }
   }
-  region.range.start.data = `[f${plan.arm};b;${id};${region.site}`;
+  region.range.start.data = `${HYDRATION_FOR_PREFIX}${plan.arm};b;${id};${region.site}`;
   return;
 }
 function claimProgramControl(instance, index, node, transaction) {

package/dist/dom-binding-protocol.d.ts

@@ -1,5 +1,12 @@
-/** Compiler-owned DOM presentation markers. This leaf is shared by client and SSR. */
 export type BindingKey = string | number;
+/** Payload prefix opening a presentation-binding range. */
+export declare const BINDING_OPEN_PREFIX: string;
+/**
+ * Comment payload opening an authored presentation view's own component range.
+ * The client runtime and the SSR serializer both stamp this onto the view they
+ * bind, so the two must never spell it separately.
+ */
+export declare function bindingRootMarker(id: string): string;
 export declare function encodeBindingKey(key: BindingKey): string;
 export declare function decodeBindingKey(encoded: string): BindingKey;
 export interface BindingMarker {
@@ -11,3 +18,9 @@ export interface BindingMarker {
 }
 export declare function parseBindingMarker(data: string): BindingMarker | null;
 export declare function isBindingOpenComment(data: string): boolean;
+/**
+ * True when a binding-open payload carries an `@for` outer arm. The prefix test
+ * alone is not a decision: `isBindingOpenComment` still requires the full
+ * receipt, so this only spares callers from spelling the arm prefixes again.
+ */
+export declare function isForBindingOpenComment(data: string): boolean;

package/dist/dom-binding-protocol.js

@@ -1,3 +1,21 @@
+import {
+  HYDRATION_FOR_ARM_INDEX,
+  HYDRATION_FOR_EMPTY,
+  HYDRATION_FOR_ITEMS,
+  HYDRATION_FOR_PREFIX,
+  HYDRATION_START
+} from "./hydration-markers.js";
+const BINDING_OPEN_PREFIX = HYDRATION_START + "b;";
+const BINDING_RECEIPT = ";b;";
+const BINDING_FOR_EMPTY_PREFIX = HYDRATION_FOR_EMPTY + BINDING_RECEIPT;
+const BINDING_FOR_ITEMS_PREFIX = HYDRATION_FOR_ITEMS + BINDING_RECEIPT;
+const BINDING_FOR_ID_START = BINDING_FOR_EMPTY_PREFIX.length;
+const BINDING_ID_START = BINDING_OPEN_PREFIX.length;
+const BINDING_ROOT_SITE = "root";
+const BINDING_ROOT_SUFFIX = ";" + BINDING_ROOT_SITE;
+function bindingRootMarker(id) {
+  return BINDING_OPEN_PREFIX + id + BINDING_ROOT_SUFFIX;
+}
 function encodeBindingKey(key) {
   if (typeof key === "string")
     return "s:" + JSON.stringify(key).replace(/-/g, "\\u002d").replace(/</g, "\\u003c");
@@ -17,21 +35,22 @@ function decodeBindingKey(encoded) {
   throw new TypeError("A DOM presentation key has invalid serialized identity.");
 }
 function parseBindingMarker(data) {
-  if (data.startsWith("[f0;b;") || data.startsWith("[f1;b;")) {
-    const separator = data.indexOf(";", 6);
-    if (separator <= 6 || separator === data.length - 1) return null;
+  if (data.startsWith(BINDING_FOR_EMPTY_PREFIX) || data.startsWith(BINDING_FOR_ITEMS_PREFIX)) {
+    const separator = data.indexOf(";", BINDING_FOR_ID_START);
+    if (separator <= BINDING_FOR_ID_START || separator === data.length - 1) return null;
     return {
-      id: data.slice(6, separator),
+      id: data.slice(BINDING_FOR_ID_START, separator),
       site: data.slice(separator + 1),
       kind: "for",
-      arm: data.charCodeAt(2) - 48
+      arm: data.charCodeAt(HYDRATION_FOR_ARM_INDEX) - 48
     };
   }
-  if (!data.startsWith("[b;")) return null;
-  const idEnd = data.indexOf(";", 3);
-  if (idEnd <= 3 || idEnd === data.length - 1) return null;
-  const id = data.slice(3, idEnd);
-  if (data.slice(idEnd + 1) === "root") return { id, site: "root", kind: "root" };
+  if (!data.startsWith(BINDING_OPEN_PREFIX)) return null;
+  const idEnd = data.indexOf(";", BINDING_ID_START);
+  if (idEnd <= BINDING_ID_START || idEnd === data.length - 1) return null;
+  const id = data.slice(BINDING_ID_START, idEnd);
+  if (data.slice(idEnd + 1) === BINDING_ROOT_SITE)
+    return { id, site: BINDING_ROOT_SITE, kind: "root" };
   const siteEnd = data.indexOf(";", idEnd + 1);
   if (siteEnd <= idEnd + 1 || siteEnd === data.length - 1) return null;
   const site = data.slice(idEnd + 1, siteEnd);
@@ -56,13 +75,14 @@ function parseBindingMarker(data) {
   return null;
 }
 function isBindingOpenComment(data) {
-  const list = data.startsWith("[f0;b;") || data.startsWith("[f1;b;");
-  if (!list && !data.startsWith("[b;")) return false;
-  const idStart = list ? 6 : 3;
+  const list = data.startsWith(BINDING_FOR_EMPTY_PREFIX) || data.startsWith(BINDING_FOR_ITEMS_PREFIX);
+  if (!list && !data.startsWith(BINDING_OPEN_PREFIX)) return false;
+  const idStart = list ? BINDING_FOR_ID_START : BINDING_ID_START;
   const idEnd = data.indexOf(";", idStart);
   if (idEnd <= idStart || idEnd === data.length - 1) return false;
   if (list) return data.indexOf(";", idEnd + 1) === -1;
-  if (data.length - idEnd === 5 && data.endsWith(";root")) return true;
+  if (data.length - idEnd === BINDING_ROOT_SUFFIX.length && data.endsWith(BINDING_ROOT_SUFFIX))
+    return true;
   const siteEnd = data.indexOf(";", idEnd + 1);
   if (siteEnd <= idEnd + 1 || siteEnd === data.length - 1) return false;
   const tail = siteEnd + 1;
@@ -80,9 +100,15 @@ function isBindingOpenComment(data) {
   }
   return true;
 }
+function isForBindingOpenComment(data) {
+  return data.startsWith(HYDRATION_FOR_PREFIX) && isBindingOpenComment(data);
+}
 export {
+  BINDING_OPEN_PREFIX,
+  bindingRootMarker,
   decodeBindingKey,
   encodeBindingKey,
   isBindingOpenComment,
+  isForBindingOpenComment,
   parseBindingMarker
 };

package/dist/hydration/control-capture.d.ts

@@ -45,6 +45,8 @@ export interface HydrationControlCandidateValue {
  * the state changed while ownership was being transferred.
  */
 export declare function snapshotHydrationControl(control: Element): HydrationControlSnapshot | null;
+/** @internal Only unchanged server state may yield to an eventless textarea restore. */
+export declare function isRestoredHydrationTextarea(control: Element, value: unknown): boolean;
 /**
  * Capture the exact DOM/edit authority an async storage read is allowed to replace.
  * A focus, selection, composition, input (including clear), node replacement, or

package/dist/hydration/control-capture.js

@@ -1,4 +1,10 @@
-import { HYDRATE_INDEPENDENT_ATTR, HYDRATE_INPUT_ATTR } from "../hydration-markers.js";
+import {
+  HYDRATE_ID_ATTR,
+  HYDRATE_INDEPENDENT_ATTR,
+  HYDRATE_INPUT_ATTR,
+  HYDRATE_MARKER_SELECTOR,
+  HYDRATE_WHEN_ATTR
+} from "../hydration-markers.js";
 import {
   EARLY_HYDRATION_INTENTS_KEY,
   HYDRATE_INTERACTION_EVENTS_ATTR
@@ -9,10 +15,9 @@ import {
   publishHydrationControlSignalValues,
   readEarlyHydrationControlRevision
 } from "../signals/early-values.js";
-const HYDRATE_MARKER_SELECTOR = "[data-octane-hydrate-id]";
 const HYDRATE_CONTROL_DOCUMENTS = /* @__PURE__ */ new WeakSet();
 function isEarlyHydrationIntentCurrent([event, target, boundary, id, when, events], ownerDocument) {
-  return event.target === target && target.isConnected && boundary.isConnected && target.ownerDocument === ownerDocument && boundary.ownerDocument === ownerDocument && target.closest(`[${HYDRATE_INDEPENDENT_ATTR}]`) === boundary && boundary.getAttribute("data-octane-hydrate-id") === id && boundary.getAttribute("data-octane-hydrate-when") === when && boundary.getAttribute(HYDRATE_INTERACTION_EVENTS_ATTR) === events;
+  return event.target === target && target.isConnected && boundary.isConnected && target.ownerDocument === ownerDocument && boundary.ownerDocument === ownerDocument && target.closest(`[${HYDRATE_INDEPENDENT_ATTR}]`) === boundary && boundary.getAttribute(HYDRATE_ID_ATTR) === id && boundary.getAttribute(HYDRATE_WHEN_ATTR) === when && boundary.getAttribute(HYDRATE_INTERACTION_EVENTS_ATTR) === events;
 }
 function isHydrationElement(target) {
   return target !== null && target.nodeType === 1;
@@ -108,6 +113,13 @@ function snapshotHydrationControl(control) {
     composing: record?.composing ?? false
   };
 }
+function isRestoredHydrationTextarea(control, value) {
+  if (control.localName !== "textarea" || typeof value !== "string" || HYDRATE_CONTROL_RECORDS.get(control)?.composing === true)
+    return false;
+  const textarea = control;
+  const baseline = textarea.defaultValue.replace(/\r\n?/g, "\n");
+  return value.replace(/\r\n?/g, "\n") === baseline && textarea.value !== baseline;
+}
 function captureHydrationControlCandidate(control) {
   const snapshot = snapshotHydrationControl(control);
   if (snapshot === null) return null;
@@ -115,7 +127,7 @@ function captureHydrationControlCandidate(control) {
   return {
     control,
     bindingId: control.getAttribute(HYDRATE_INPUT_ATTR),
-    boundaryId: control.closest(HYDRATE_MARKER_SELECTOR)?.getAttribute("data-octane-hydrate-id") ?? null,
+    boundaryId: control.closest(HYDRATE_MARKER_SELECTOR)?.getAttribute(HYDRATE_ID_ATTR) ?? null,
     snapshot
   };
 }
@@ -130,7 +142,7 @@ function sameHydrationControlValue(left, right) {
 }
 function applyHydrationControlCandidate(candidate, value) {
   const control = candidate.control;
-  if (!control.isConnected || control.getAttribute(HYDRATE_INPUT_ATTR) !== candidate.bindingId || (control.closest(HYDRATE_MARKER_SELECTOR)?.getAttribute("data-octane-hydrate-id") ?? null) !== candidate.boundaryId) {
+  if (!control.isConnected || control.getAttribute(HYDRATE_INPUT_ATTR) !== candidate.bindingId || (control.closest(HYDRATE_MARKER_SELECTOR)?.getAttribute(HYDRATE_ID_ATTR) ?? null) !== candidate.boundaryId) {
     return false;
   }
   const current = snapshotHydrationControl(control);
@@ -219,5 +231,6 @@ export {
   consumeHydrationControl,
   initializeHydrationControlCapture,
   isEarlyHydrationIntentCurrent,
+  isRestoredHydrationTextarea,
   snapshotHydrationControl
 };