octane 0.3.2 → 0.3.3

package/dist/cjs/version.cjs

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

package/dist/compiler/compile.js

@@ -30634,7 +30634,7 @@ function autoMemoDependencyOrderKey(original) {
 	return astStructuralKey(node);
 }
 
-function collectAutoMemoDependencyExpressions(nodes) {
+function collectAutoMemoDependencyExpressions(nodes, templateControlFlow = false) {
 	const dependencies = new Set();
 	const dependencyNodes = new Map();
 	const dependencyOrder = new Map();
@@ -30693,6 +30693,19 @@ function collectAutoMemoDependencyExpressions(nodes) {
 			node.type === 'LogicalExpression' ||
 			node.type === 'ConditionalExpression' ||
 			node.type === 'ChainExpression' ||
+			(templateControlFlow &&
+				(node.type === 'JSXIfExpression' ||
+					node.type === 'JSXForExpression' ||
+					node.type === 'JSXSwitchExpression' ||
+					node.type === 'JSXTryExpression' ||
+					node.type === 'IfStatement' ||
+					node.type === 'ForStatement' ||
+					node.type === 'ForOfStatement' ||
+					node.type === 'ForInStatement' ||
+					node.type === 'SwitchStatement' ||
+					node.type === 'TryStatement' ||
+					node.type === 'WhileStatement' ||
+					node.type === 'DoWhileStatement')) ||
 			((node.type === 'MemberExpression' ||
 				node.type === 'OptionalMemberExpression' ||
 				node.type === 'CallExpression' ||
@@ -30769,6 +30782,38 @@ function requireCompiledHydrateAlias(ctx) {
 	return alias;
 }
 
+function hydrateDiagnosticChildrenCaptures(node, children, ctx) {
+	if (!ctx.dev || ctx.mode === 'server') return undefined;
+	const tag = node.openingElement?.name ?? node.id;
+	if (tag?.type !== 'JSXIdentifier' || ctx.octaneImportLocals?.get(tag.name) !== 'Hydrate')
+		return undefined;
+	const lexical = (ctx.activityLexical ??= createLexicalAnalysis(ctx.activityModuleAst));
+	const binding = lexical.resolveBinding(lexical.nodeScopes.get(tag), tag.name);
+	if (binding?.scope !== lexical.rootScope || binding.importSource?.value !== 'octane')
+		return undefined;
+	const plan = collectAutoMemoDependencyExpressions(children, true);
+	if (!plan.safe || mapCallbackCapturesLexicalReceiver(children)) return null;
+	const free = collectFreeIdentifiers(children, []);
+	const local = collectSubtreeBindings(children, new Set());
+	// A child-local shadow with the same spelling cannot be read from the
+	// enclosing closure. Decline the certificate rather than invent a witness.
+	for (const name of free) if (local.has(name)) return null;
+	const captures = [];
+	const covered = new Set();
+	const dependencyNode = depNodeFor({ autoMemoDepNodes: plan.dependencyNodes });
+	for (const dependency of plan.dependencies) {
+		const expression = dependencyNode(dependency);
+		const roots = collectFreeIdentifiers(expression, []);
+		if (roots.size === 0 || [...roots].some((name) => !free.has(name))) continue;
+		captures.push(expression);
+		for (const name of roots) covered.add(name);
+	}
+	for (const name of free) if (!covered.has(name)) captures.push(b.id(name));
+	// Property reads stay deferred until activation; collecting diagnostic data
+	// must not evaluate a dormant child's getters or call its render function.
+	return inheritOriginLoc(b.arrow([], b.array(captures)), node);
+}
+
 function isPrivateSplitContextProvider(node, ctx) {
 	const tag = node.openingElement?.name ?? node.id;
 	const binding = ctx.privateSplitContextProviders?.get(tag);
@@ -30958,7 +31003,8 @@ function makeCompCall(
 			ctx.runtimeNeeded.add('markChildrenBlock');
 			hasChildrenProp = true;
 			const childrenArgs = [b.id(childrenHelperName)];
-			if (ctx.autoMemo && ctx.mode !== 'server') {
+			const diagnosticCaptures = hydrateDiagnosticChildrenCaptures(node, children, ctx);
+			if ((ctx.autoMemo && ctx.mode !== 'server') || diagnosticCaptures !== undefined) {
 				// These functions close over parent locals and are recreated on every
 				// render. A module-owned token distinguishes a real Provider body
 				// handoff from fresh captures without invalidating ordinary cache hits.
@@ -30966,6 +31012,8 @@ function makeCompCall(
 				ctx.hoistedHelpers.push(inheritOriginLoc(b.const(bodyIdentity, b.object([])), node));
 				childrenArgs.push(b.id(bodyIdentity));
 			}
+			if (diagnosticCaptures !== undefined)
+				childrenArgs.push(diagnosticCaptures ?? b.literal(null));
 			let childrenValue = b.call('_$markChildrenBlock', ...childrenArgs);
 			if (ctx.presentationHydration?.structural && node._octaneBindingSite)
 				childrenValue = b.call(

package/dist/runtime.d.ts

@@ -996,7 +996,7 @@ export declare function markSingleRoot<T extends Function>(component: T): T;
  * Returns the function for inline use (`{ children: markChildrenBlock(__children$N) }`).
  * @internal
  */
-export declare function markChildrenBlock<T>(fn: T, body?: object): T;
+export declare function markChildrenBlock<T>(fn: T, body?: object, captures?: (() => readonly unknown[]) | null): T;
 /**
  * Marks a component binding whose authored JSX children must remain inspectable
  * element descriptors. The compiler consumes the call; runtime identity is unchanged.
@@ -1009,6 +1009,36 @@ export declare function descriptorChildren<T>(component: T): T;
  * `<C><D/></C>` (render it): `typeof children === 'function' && !isChildrenBlock(children)`.
  */
 export declare function isChildrenBlock(value: unknown): boolean;
+type HydrateLoadResult = ComponentBody | {
+    default: ComponentBody;
+};
+type InternalHydrateProps = HydrateProps & {
+    /** Compiler-injected split-child loader. */
+    __load?: () => Promise<HydrateLoadResult>;
+    /** Latest lexical values consumed by the compiler-generated split child. */
+    __data?: unknown[];
+    /** Compiler-owned independent island descriptor; the document bootstrap owns activation. */
+    __independent?: unknown;
+    /** Bundler graph edge only. Runtime must never evaluate the lexical parent through it. */
+    __independentLoad?: () => Promise<unknown>;
+};
+interface HydrateAttributeSnapshot {
+    props: InternalHydrateProps;
+    ids: RootIdState;
+    contexts: Map<Context<any>, any> | null;
+}
+interface InitialHydrateAttribute {
+    server: string | null;
+    next: string | null;
+    suppressed: boolean;
+    checked: boolean;
+}
+interface HydrateAttributeProbe {
+    document: Document;
+    originals: WeakMap<Element, Element>;
+    attributes: WeakMap<Element, Map<string, InitialHydrateAttribute>>;
+    boundaries: WeakMap<Element, HydrateAttributeSnapshot>;
+}
 export declare const Hydrate: ComponentBody<HydrateProps>;
 /** Compiler-owned template children with no authored fallback; never a descriptor entry point. */
 export declare const __HydrateCompiled: ComponentBody<HydrateProps>;
@@ -1289,6 +1319,7 @@ declare class HydrationCapability {
     rootBlock: Block;
     node: Node | null;
     seeds: unknown[] | null;
+    attributeBaselines?: HydrateAttributeProbe;
     depth: number;
     seedCursor: number;
     hasAdjacentRangePair: boolean;