@octane-xplat/patches 0.0.1 → 0.10.0

package/patches/octane@0.6.3.patch

@@ -0,0 +1,1699 @@
+diff --git a/dist/cjs/runtime.cjs b/dist/cjs/runtime.cjs
+index 6f4f11cafea50ca0de062aace3426df371a44867..dc96ffaa91081ca81f904de35ed5db9a024daa96 100644
+--- a/dist/cjs/runtime.cjs
++++ b/dist/cjs/runtime.cjs
+@@ -354,6 +354,7 @@ var import_stream_protocol = require("./stream-protocol.cjs");
+ var import_renderer_bridge = require("./renderer-bridge.cjs");
+ var import_context_identity = require("./context-identity.cjs");
+ var import_native_read_client = require("./signals/native-read-client.cjs");
++var import_local_hook = require("./signals/local-hook.cjs");
+ var import_native_read_collector = require("./signals/native-read-collector.cjs");
+ var import_native_read_retry = require("./signals/native-read-retry.cjs");
+ var import_transition_state = require("./signals/transition-state.cjs");
+@@ -7604,6 +7605,7 @@ function nativeLocalHook(name, initialize, dispose, slot) {
+   }
+   return cell.nativeValue;
+ }
++(0, import_local_hook.registerLocalSignalHook)(() => CURRENT_SCOPE === null ? null : nativeLocalHook);
+ function useState(initial, slot) {
+   const s = readStateHook(initial, slot, arguments.length === 1);
+   return [s.value, s.setter];
+diff --git a/dist/cjs/signals/client.cjs b/dist/cjs/signals/client.cjs
+index 28e28444192dee7af64351cfe02d5dde96658832..af40518defca21eb88707eb76bb6fe10c1d266e7 100644
+--- a/dist/cjs/signals/client.cjs
++++ b/dist/cjs/signals/client.cjs
+@@ -23,13 +23,13 @@ __export(client_exports, {
+ });
+ module.exports = __toCommonJS(client_exports);
+ __reExport(client_exports, require("./index.cjs"), module.exports);
+-var import_runtime = require("../runtime.cjs");
+ var import_engine = require("./engine.cjs");
++var import_local_hook = require("./local-hook.cjs");
+ function disposeLocalSignal(cell) {
+   cell.scope.dispose();
+ }
+ function useSignal$(initial, slot) {
+-  const cell = (0, import_runtime.nativeLocalHook)(
++  const cell = (0, import_local_hook.localSignalHook)(
+     "useSignal$",
+     () => {
+       const value = typeof initial === "function" ? initial() : initial;
+diff --git a/dist/cjs/signals/document-owner.cjs b/dist/cjs/signals/document-owner.cjs
+index ea6b3040bcc3d1fe0c600894af33fece59711d4b..56a74394b0e40f0ca1dc9b1afb1b44e5a695994f 100644
+--- a/dist/cjs/signals/document-owner.cjs
++++ b/dist/cjs/signals/document-owner.cjs
+@@ -54,7 +54,9 @@ function enableSignalDocument(abi = 1) {
+   if (defaultInstalled)
+     return;
+   defaultInstalled = true;
+-  (0, import_owner_context.installDefaultSignalOwner)(() => typeof document === "undefined" ? null : documentSignalOwner(document));
++  if (typeof document === "undefined")
++    return;
++  (0, import_owner_context.installDefaultSignalOwner)(() => documentSignalOwner(document));
+ }
+ function installStreamedSignalOwnerActivator(activate) {
+   if (streamedSignalOwnerActivator !== void 0) {
+diff --git a/dist/cjs/signals/facade.cjs b/dist/cjs/signals/facade.cjs
+index 9da71c1a774d4764d6e34df12211a08ae2817d5c..02db86c39e23717e0fedb83eb7faf62e4cca7780 100644
+--- a/dist/cjs/signals/facade.cjs
++++ b/dist/cjs/signals/facade.cjs
+@@ -283,6 +283,8 @@ class Descriptor {
+     this.kind = kind;
+     this.create = create;
+     this.site = site;
++    // Instance declarations stay with their component across child templates and events.
++    this.instanceOwner = site?.startsWith("i:") ? (0, import_owner_context.currentSignalOwner)() : null;
+   }
+   key;
+   kind;
+@@ -292,7 +294,7 @@ class Descriptor {
+   cells = /* @__PURE__ */ new WeakMap();
+   [import_types.SIGNAL_OWNER_RESOLVE](owner) {
+     requireSite(this.site);
+-    return this.resolvedCell(resolveDescriptorOwner(this.site, owner));
++    return this.resolvedCell(resolveDescriptorOwner(this.site, this.instanceOwner ?? owner));
+   }
+   resolvedCell(target) {
+     let cell = this.cells.get(target);
+@@ -303,7 +305,7 @@ class Descriptor {
+     return cell;
+   }
+   resolve() {
+-    const token = requireOwner();
++    const token = this.instanceOwner ?? requireOwner();
+     const owner = resolveDescriptorOwner(this.site, token);
+     requireSite(this.site);
+     return this.resolvedCell(owner);
+@@ -334,7 +336,7 @@ class Descriptor {
+     return this.resolve().snapshot();
+   }
+   subscribe(notify) {
+-    const token = requireOwner();
++    const token = this.instanceOwner ?? requireOwner();
+     const scope = resolveDescriptorOwner(this.site, token);
+     const run = (0, import_owner_context.captureSignalOwner)(token);
+     return this[import_types.SIGNAL_OWNER_RESOLVE](scope).subscribe((0, import_read_protocol.forwardNativeTransitionConsumer)(notify, () => run(notify)));
+diff --git a/dist/cjs/signals/index.cjs b/dist/cjs/signals/index.cjs
+index 865afcf87d84f0cc319d65145b246c9c033927aa..08dd675a49a50c1621e5d3c5a26ca22f8cdbb31d 100644
+--- a/dist/cjs/signals/index.cjs
++++ b/dist/cjs/signals/index.cjs
+@@ -34,6 +34,7 @@ __export(signals_exports, {
+   __derivedAt: () => import_derived_facade.__derivedAt,
+   __derivedScalarAt: () => import_facade.__derivedScalarAt,
+   __enableSignalDocument: () => import_document_owner.enableSignalDocument,
++  __enableUniversalSignalDocument: () => import_universal_owner.enableUniversalSignalDocument,
+   __queryAt: () => import_query_facade.__queryAt,
+   __signalAt: () => import_facade.__signalAt,
+   __startSignalReads: () => import_facade.__startSignalReads,
+@@ -65,6 +66,7 @@ module.exports = __toCommonJS(signals_exports);
+ var import_engine = require("./engine.cjs");
+ var import_control_binding = require("./control-binding.cjs");
+ var import_document_owner = require("./document-owner.cjs");
++var import_universal_owner = require("./universal-owner.cjs");
+ var import_requests = require("./requests.cjs");
+ var import_actions = require("./actions.cjs");
+ var import_derived_facade = require("./derived-facade.cjs");
+@@ -92,6 +94,7 @@ var import_types = require("./types.cjs");
+   __derivedAt,
+   __derivedScalarAt,
+   __enableSignalDocument,
++  __enableUniversalSignalDocument,
+   __queryAt,
+   __signalAt,
+   __startSignalReads,
+diff --git a/dist/cjs/signals/local-hook.cjs b/dist/cjs/signals/local-hook.cjs
+new file mode 100644
+index 0000000000000000000000000000000000000000..4858595ce50e97284f18daa94c3b5ce6ab041dd4
+--- /dev/null
++++ b/dist/cjs/signals/local-hook.cjs
+@@ -0,0 +1,44 @@
++"use strict";
++var __defProp = Object.defineProperty;
++var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
++var __getOwnPropNames = Object.getOwnPropertyNames;
++var __hasOwnProp = Object.prototype.hasOwnProperty;
++var __export = (target, all) => {
++  for (var name in all)
++    __defProp(target, name, { get: all[name], enumerable: true });
++};
++var __copyProps = (to, from, except, desc) => {
++  if (from && typeof from === "object" || typeof from === "function") {
++    for (let key of __getOwnPropNames(from))
++      if (!__hasOwnProp.call(to, key) && key !== except)
++        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
++  }
++  return to;
++};
++var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
++var local_hook_exports = {};
++__export(local_hook_exports, {
++  localSignalHook: () => localSignalHook,
++  registerLocalSignalHook: () => registerLocalSignalHook
++});
++module.exports = __toCommonJS(local_hook_exports);
++const probes = [];
++function registerLocalSignalHook(probe) {
++  probes.push(probe);
++  return () => {
++    const index = probes.indexOf(probe);
++    if (index !== -1) probes.splice(index, 1);
++  };
++}
++function localSignalHook(name, initialize, dispose, slot) {
++  for (let index = probes.length - 1; index >= 0; index--) {
++    const hook = probes[index]();
++    if (hook !== null) return hook(name, initialize, dispose, slot);
++  }
++  throw new Error(`${name} requires an active Octane component render.`);
++}
++// Annotate the CommonJS export names for ESM import in node:
++0 && (module.exports = {
++  localSignalHook,
++  registerLocalSignalHook
++});
+diff --git a/dist/cjs/signals/universal-owner.cjs b/dist/cjs/signals/universal-owner.cjs
+new file mode 100644
+index 0000000000000000000000000000000000000000..00c323a8bd4453d566dbd002ab1222f03def2760
+--- /dev/null
++++ b/dist/cjs/signals/universal-owner.cjs
+@@ -0,0 +1,46 @@
++"use strict";
++var __defProp = Object.defineProperty;
++var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
++var __getOwnPropNames = Object.getOwnPropertyNames;
++var __hasOwnProp = Object.prototype.hasOwnProperty;
++var __export = (target, all) => {
++  for (var name in all)
++    __defProp(target, name, { get: all[name], enumerable: true });
++};
++var __copyProps = (to, from, except, desc) => {
++  if (from && typeof from === "object" || typeof from === "function") {
++    for (let key of __getOwnPropNames(from))
++      if (!__hasOwnProp.call(to, key) && key !== except)
++        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
++  }
++  return to;
++};
++var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
++var universal_owner_exports = {};
++__export(universal_owner_exports, {
++  enableUniversalSignalDocument: () => enableUniversalSignalDocument,
++  installUniversalSignalDocumentProvider: () => installUniversalSignalDocumentProvider,
++  universalSignalDocument: () => universalSignalDocument
++});
++module.exports = __toCommonJS(universal_owner_exports);
++var import_owner_context = require("./owner-context.cjs");
++let universalOwner;
++let provider;
++function installUniversalSignalDocumentProvider(next) {
++  provider = next;
++}
++function universalSignalDocument() {
++  return provider?.() ?? (universalOwner ??= Object.freeze({ scopeKey: "octane:universal" }));
++}
++function enableUniversalSignalDocument(abi = 1) {
++  if (abi !== 1) {
++    throw new TypeError("Unsupported universal signal owner ABI.");
++  }
++  (0, import_owner_context.installDefaultSignalOwner)(universalSignalDocument);
++}
++// Annotate the CommonJS export names for ESM import in node:
++0 && (module.exports = {
++  enableUniversalSignalDocument,
++  installUniversalSignalDocumentProvider,
++  universalSignalDocument
++});
+diff --git a/dist/compiler/compile-universal.js b/dist/compiler/compile-universal.js
+index fb05864726848fec0e680cc06de3cfe88f9930de..e1ae8e2314f2cc61a7a6cbd38ae0fadea8aa08bf 100644
+--- a/dist/compiler/compile-universal.js
++++ b/dist/compiler/compile-universal.js
+@@ -2658,6 +2658,15 @@ function hasOwnTemplateReturn(fn) {
+ }
+ 
+ function componentRender(fn, state, force = false) {
++	// Functions that are never invoked as components stay ordinary functions,
++	// so an async/generator helper only fails once it is actually compiled as
++	// one (the `@{ … }` form, a JSX-shaped return, or component usage).
++	const component =
++		fn.body?.type === 'JSXCodeBlock' ||
++		(fn.body?.type !== 'BlockStatement'
++			? force || isTemplateNode(fn.body)
++			: force || hasOwnTemplateReturn(fn) || state.componentNames.has(functionName(fn)));
++	if (!component) return null;
+ 	if (fn.async || fn.generator) {
+ 		throw universalError(
+ 			state.filename,
+@@ -2672,11 +2681,8 @@ function componentRender(fn, state, force = false) {
+ 		};
+ 	}
+ 	if (fn.body?.type !== 'BlockStatement') {
+-		if (!force && !isTemplateNode(fn.body)) return null;
+ 		return { setup: [], render: isTemplateNode(fn.body) ? fn.body : null, expression: fn.body };
+ 	}
+-	if (!force && !hasOwnTemplateReturn(fn) && !state.componentNames.has(functionName(fn)))
+-		return null;
+ 	return { setup: fn.body.body ?? [], render: null };
+ }
+ 
+diff --git a/dist/compiler/compile.js b/dist/compiler/compile.js
+index cdf5a08e96946bf06dd417dcfb87373e4be5f305..64a357159586e45774ff864f4478b204bb0dd7ab 100644
+--- a/dist/compiler/compile.js
++++ b/dist/compiler/compile.js
+@@ -2275,7 +2275,7 @@ function classifyViewTransitionOwnership(astBody, production, ownComponents) {
+ 
+ function hookRuntimeModulesForCompile(options, universalUnits = []) {
+ 	const modules = new Set(options?.__hookRuntimeModules || []);
+-	if (options?.nativeReads === true) {
++	if (options?.nativeReads === true || options?.__universalSignalReads === true) {
+ 		modules.add('octane/signals/client');
+ 		modules.add('octane/signals/server');
+ 	}
+@@ -10112,6 +10112,11 @@ function compileInternal(
+ 						universalRuntime: undefined,
+ 						rendererBoundaries: undefined,
+ 						rendererRegistry: undefined,
++						// Universal owners observe reads at render time; the inner
++						// compile must not emit the DOM native-read runtime helpers,
++						// but signal hook classification still applies.
++						nativeReads: false,
++						__universalSignalReads: options.nativeReads === true,
+ 						__hookRuntimeModules: [...(options?.__hookRuntimeModules || []), renderer.module],
+ 						__runtimeImportRoutes: [
+ 							...(options?.__runtimeImportRoutes ?? []),
+@@ -10360,6 +10365,10 @@ function compileInternal(
+ 		autoMemo: autoMemoEnabled,
+ 		strongMemo: strongMemoEnabled,
+ 		nativeReads: options?.nativeReads === true,
++		// Universal renders observe signal reads at runtime through the owner
++		// environment; hook classification still needs to know the module imports
++		// the signals runtime even though no DOM native-read helpers are emitted.
++		signalReads: options?.nativeReads === true || options?.__universalSignalReads === true,
+ 		nativeModuleStyles: options?.nativeReads === true && hasModuleStyleMaps(ast.body),
+ 		// A split Hydrate query module is invoked as the existing server-rendered
+ 		// boundary body. Its sole component child must therefore keep the server's
+@@ -11805,6 +11814,10 @@ function compileServer(
+ 		compilerNameSuffixes: null,
+ 		mode: 'server',
+ 		nativeReads: options?.nativeReads === true,
++		// Universal renders observe signal reads at runtime through the owner
++		// environment; hook classification still needs to know the module imports
++		// the signals runtime even though no DOM native-read helpers are emitted.
++		signalReads: options?.nativeReads === true || options?.__universalSignalReads === true,
+ 		nativeModuleStyles: options?.nativeReads === true && hasModuleStyleMaps(ast.body),
+ 		hmr: false, // SSR never hot-swaps in place; client/server production slot shapes stay aligned
+ 		dev: !!(options && options.dev),
+@@ -18960,7 +18973,7 @@ function slotKeyedHookName(n, ctx) {
+ 			ctx.foreignImportLocals?.has(local) === true;
+ 		if (
+ 			imported !== undefined &&
+-			(HOOK_NAMES.has(imported) || (ctx.nativeReads && NATIVE_SIGNAL_HOOK_NAMES.has(imported)))
++			(HOOK_NAMES.has(imported) || (ctx.signalReads && NATIVE_SIGNAL_HOOK_NAMES.has(imported)))
+ 		)
+ 			return imported;
+ 		if (!shadowsImport && HOOK_NAMES.has(local)) return local;
+@@ -18970,7 +18983,7 @@ function slotKeyedHookName(n, ctx) {
+ 	const imported = n._octaneImportedHook ?? n._octaneHookRuntimeImportedHook;
+ 	if (
+ 		imported !== undefined &&
+-		(HOOK_NAMES.has(imported) || (ctx.nativeReads && NATIVE_SIGNAL_HOOK_NAMES.has(imported)))
++		(HOOK_NAMES.has(imported) || (ctx.signalReads && NATIVE_SIGNAL_HOOK_NAMES.has(imported)))
+ 	) {
+ 		return imported;
+ 	}
+@@ -19817,7 +19830,7 @@ function rewriteHookCalls(node, ctx, componentName, localRoot = false) {
+ 			// enforced by rejectHookInJsLoop.
+ 			const isBuiltin =
+ 				(HOOK_NAMES.has(name) ||
+-					(ctx.nativeReads &&
++					(ctx.signalReads &&
+ 						hookRuntimeImportedName !== undefined &&
+ 						NATIVE_SIGNAL_HOOK_NAMES.has(name))) &&
+ 				(generated ||
+@@ -19946,7 +19959,7 @@ function rewriteHookCalls(node, ctx, componentName, localRoot = false) {
+ 		) {
+ 			const name = n._octaneImportedHook ?? n._octaneHookRuntimeImportedHook;
+ 			const isBuiltin =
+-				HOOK_NAMES.has(name) || (ctx.nativeReads && NATIVE_SIGNAL_HOOK_NAMES.has(name));
++				HOOK_NAMES.has(name) || (ctx.signalReads && NATIVE_SIGNAL_HOOK_NAMES.has(name));
+ 			const isServerUse = name === 'use' && ctx.mode === 'server';
+ 			if (isBuiltin || isServerUse) {
+ 				if (isBuiltin) {
+diff --git a/dist/compiler/native-read-diagnostics.js b/dist/compiler/native-read-diagnostics.js
+index 3ec74f384e5b34a8032c96646e9ba3faeee50e75..0816e98d66d5082d8d3bb337073c2123e6032c4c 100644
+--- a/dist/compiler/native-read-diagnostics.js
++++ b/dist/compiler/native-read-diagnostics.js
+@@ -87,9 +87,12 @@ export function assertNativeReadOptions(options) {
+ 	if (
+ 		options?.nativeReads === true &&
+ 		options.renderer?.target != null &&
+-		options.renderer.target !== 'dom'
++		options.renderer.target !== 'dom' &&
++		options.renderer.target !== 'universal'
+ 	) {
+-		throw new Error('Octane native signal reads support only the DOM client and server.');
++		throw new Error(
++			'Octane native signal reads support only the DOM client, DOM server, and universal renderers.',
++		);
+ 	}
+ }
+ 
+@@ -108,11 +111,11 @@ export function analyzeNativeReadDiagnostics(ast, source, filename, options = {}
+ 			filename,
+ 			rendererBoundaries: options.rendererBoundaries,
+ 		});
+-		const unsupported = boundaries.find(
+-			(boundary) =>
+-				boundary.childRenderer !== 'dom' &&
+-				options.rendererRegistry?.[boundary.childRenderer]?.target !== 'dom',
+-		);
++		const unsupported = boundaries.find((boundary) => {
++			if (boundary.childRenderer === 'dom') return false;
++			const target = options.rendererRegistry?.[boundary.childRenderer]?.target;
++			return target !== 'dom' && target !== 'universal';
++		});
+ 		if (unsupported)
+ 			return [
+ 				nativeReadDiagnostic(
+diff --git a/dist/compiler/slot-hooks.js b/dist/compiler/slot-hooks.js
+index 7b2f867538a166ebaf3d1a8aa6e7d910e3b0da12..2c1d36c9edb32c483a5e7ed736e51b0ca12cde30 100644
+--- a/dist/compiler/slot-hooks.js
++++ b/dist/compiler/slot-hooks.js
+@@ -1182,12 +1182,12 @@ function walk(node, owner, st) {
+ 		}
+ 		const imported =
+ 			node._octaneImportedHook ??
+-			(st.nativeReads ? node._octaneHookRuntimeImportedHook : undefined);
++			(st.signalReads ? node._octaneHookRuntimeImportedHook : undefined);
+ 		collectStateGetterEdit(node, imported, st);
+ 		if (
+ 			!st.manualSlots &&
+ 			imported &&
+-			(HOOK_NAMES.has(imported) || (st.nativeReads && NATIVE_SIGNAL_HOOK_NAMES.has(imported)))
++			(HOOK_NAMES.has(imported) || (st.signalReads && NATIVE_SIGNAL_HOOK_NAMES.has(imported)))
+ 		) {
+ 			const local =
+ 				node.callee?.type === 'Identifier'
+@@ -1398,7 +1398,11 @@ export function slotHooks(source, id, options) {
+ 			HOOK_NAMES.has(name),
+ 		);
+ 	const manualProviders = options?.manualSlots ? findManualHookProviders(ast) : new Map();
+-	const nativeReadActivation = options?.nativeReads === true && importsNativeRenderer(ast);
++	// Universal renderers observe reads at render time; the DOM collection
++	// driver and its activation helper only apply to dom targets.
++	const universalTarget = options?.renderer?.target === 'universal';
++	const nativeReadActivation =
++		options?.nativeReads === true && !universalTarget && importsNativeRenderer(ast);
+ 	const signalLowering = signalDeclarationSourceEdits(ast, id, source);
+ 	const pureCalls = collectPureFactoryCalls(
+ 		ast,
+@@ -1487,7 +1491,8 @@ export function slotHooks(source, id, options) {
+ 			]),
+ 		),
+ 		manualSlots: options?.manualSlots === true,
+-		nativeReads: options?.nativeReads === true,
++		nativeReads: options?.nativeReads === true && !universalTarget,
++		signalReads: options?.nativeReads === true,
+ 		locals: importInfo.locals,
+ 		source,
+ 		inferred,
+@@ -1590,7 +1595,9 @@ export function slotHooks(source, id, options) {
+ 				? 'enableServerSignalBindings'
+ 				: nativeReadActivation
+ 					? 'enableSignalBindings'
+-					: '__enableSignalDocument';
++					: universalTarget
++						? '__enableUniversalSignalDocument'
++						: '__enableSignalDocument';
+ 		const local = allocSlotName(st, `_$${imported}`);
+ 		let specifiers = signalHelperImports.get(request);
+ 		if (specifiers === undefined) signalHelperImports.set(request, (specifiers = []));
+diff --git a/dist/node/runtime.js b/dist/node/runtime.js
+index 21d10d95b6094ee07693a8b0757ca381d706b86e..2a0b4204dbcc6a0a749fcdbecfe93241d73dd768 100644
+--- a/dist/node/runtime.js
++++ b/dist/node/runtime.js
+@@ -162,6 +162,7 @@ import {
+ import { isRendererContext, registerClientRendererBridge } from "./renderer-bridge.js";
+ import { defineRemovedContextMembers, registerContext } from "./context-identity.js";
+ import { createNativeReadDriver } from "./signals/native-read-client.js";
++import { registerLocalSignalHook } from "./signals/local-hook.js";
+ import {
+   validateNativeReadWitness
+ } from "./signals/native-read-collector.js";
+@@ -7456,6 +7457,7 @@ function nativeLocalHook(name, initialize, dispose, slot) {
+   }
+   return cell.nativeValue;
+ }
++registerLocalSignalHook(() => CURRENT_SCOPE === null ? null : nativeLocalHook);
+ function useState(initial, slot) {
+   const s = readStateHook(initial, slot, arguments.length === 1);
+   return [s.value, s.setter];
+diff --git a/dist/node/signals/client.js b/dist/node/signals/client.js
+index 21a39c3ce9a28d2095e276fd647fd795e939a0bf..3f85700b57cbc3084c2df776ab3e6b5365f091a8 100644
+--- a/dist/node/signals/client.js
++++ b/dist/node/signals/client.js
+@@ -1,11 +1,11 @@
+ export * from "./index.js";
+-import { nativeLocalHook } from "../runtime.js";
+ import { createLocalScope } from "./engine.js";
++import { localSignalHook } from "./local-hook.js";
+ function disposeLocalSignal(cell) {
+   cell.scope.dispose();
+ }
+ function useSignal$(initial, slot) {
+-  const cell = nativeLocalHook(
++  const cell = localSignalHook(
+     "useSignal$",
+     () => {
+       const value = typeof initial === "function" ? initial() : initial;
+diff --git a/dist/node/signals/document-owner.js b/dist/node/signals/document-owner.js
+index 0decc9286f8d06e78dd15eaa16d0cc53cac44220..59a94863274839675c48880bf37018fddd00ec11 100644
+--- a/dist/node/signals/document-owner.js
++++ b/dist/node/signals/document-owner.js
+@@ -27,7 +27,9 @@ function enableSignalDocument(abi = 1) {
+   if (defaultInstalled)
+     return;
+   defaultInstalled = true;
+-  installDefaultSignalOwner(() => typeof document === "undefined" ? null : documentSignalOwner(document));
++  if (typeof document === "undefined")
++    return;
++  installDefaultSignalOwner(() => documentSignalOwner(document));
+ }
+ function installStreamedSignalOwnerActivator(activate) {
+   if (streamedSignalOwnerActivator !== void 0) {
+diff --git a/dist/node/signals/facade.js b/dist/node/signals/facade.js
+index 86c0233dad7013c6516912656e0e1b304351c1cb..594e697b59f19e95821ed09313835842a7afe33e 100644
+--- a/dist/node/signals/facade.js
++++ b/dist/node/signals/facade.js
+@@ -241,6 +241,8 @@ class Descriptor {
+     this.kind = kind;
+     this.create = create;
+     this.site = site;
++    // Instance declarations stay with their component across child templates and events.
++    this.instanceOwner = site?.startsWith("i:") ? currentSignalOwner() : null;
+   }
+   key;
+   kind;
+@@ -250,7 +252,7 @@ class Descriptor {
+   cells = /* @__PURE__ */ new WeakMap();
+   [SIGNAL_OWNER_RESOLVE](owner) {
+     requireSite(this.site);
+-    return this.resolvedCell(resolveDescriptorOwner(this.site, owner));
++    return this.resolvedCell(resolveDescriptorOwner(this.site, this.instanceOwner ?? owner));
+   }
+   resolvedCell(target) {
+     let cell = this.cells.get(target);
+@@ -261,7 +263,7 @@ class Descriptor {
+     return cell;
+   }
+   resolve() {
+-    const token = requireOwner();
++    const token = this.instanceOwner ?? requireOwner();
+     const owner = resolveDescriptorOwner(this.site, token);
+     requireSite(this.site);
+     return this.resolvedCell(owner);
+@@ -292,7 +294,7 @@ class Descriptor {
+     return this.resolve().snapshot();
+   }
+   subscribe(notify) {
+-    const token = requireOwner();
++    const token = this.instanceOwner ?? requireOwner();
+     const scope = resolveDescriptorOwner(this.site, token);
+     const run = captureSignalOwner(token);
+     return this[SIGNAL_OWNER_RESOLVE](scope).subscribe(forwardNativeTransitionConsumer(notify, () => run(notify)));
+diff --git a/dist/node/signals/index.js b/dist/node/signals/index.js
+index 8ae19e510a09e8144ae2ab66c0daf293a4a3f8f6..0bf09f5276e9e1a38ef67923b9cc2a441be2ce7f 100644
+--- a/dist/node/signals/index.js
++++ b/dist/node/signals/index.js
+@@ -1,6 +1,7 @@
+ import { createScope } from "./engine.js";
+ import { bindSignalControl } from "./control-binding.js";
+ import { enableSignalDocument } from "./document-owner.js";
++import { enableUniversalSignalDocument } from "./universal-owner.js";
+ import { createResource, query } from "./requests.js";
+ import { ActionUncertainError, action$, isActionUncertain, optimistic$ } from "./actions.js";
+ import { __derivedAt, derived$ } from "./derived-facade.js";
+@@ -58,6 +59,7 @@ export {
+   __derivedAt,
+   __derivedScalarAt,
+   enableSignalDocument as __enableSignalDocument,
++  enableUniversalSignalDocument as __enableUniversalSignalDocument,
+   __queryAt,
+   __signalAt,
+   __startSignalReads,
+diff --git a/dist/node/signals/local-hook.js b/dist/node/signals/local-hook.js
+new file mode 100644
+index 0000000000000000000000000000000000000000..77c63f5e2d931eb8dbd384ae027ee0f09935f9ce
+--- /dev/null
++++ b/dist/node/signals/local-hook.js
+@@ -0,0 +1,19 @@
++const probes = [];
++function registerLocalSignalHook(probe) {
++  probes.push(probe);
++  return () => {
++    const index = probes.indexOf(probe);
++    if (index !== -1) probes.splice(index, 1);
++  };
++}
++function localSignalHook(name, initialize, dispose, slot) {
++  for (let index = probes.length - 1; index >= 0; index--) {
++    const hook = probes[index]();
++    if (hook !== null) return hook(name, initialize, dispose, slot);
++  }
++  throw new Error(`${name} requires an active Octane component render.`);
++}
++export {
++  localSignalHook,
++  registerLocalSignalHook
++};
+diff --git a/dist/node/signals/universal-owner.js b/dist/node/signals/universal-owner.js
+new file mode 100644
+index 0000000000000000000000000000000000000000..ff5eb43e8f0ddcadbcf8e861f42788b389b4d99b
+--- /dev/null
++++ b/dist/node/signals/universal-owner.js
+@@ -0,0 +1,20 @@
++import { installDefaultSignalOwner } from "./owner-context.js";
++let universalOwner;
++let provider;
++function installUniversalSignalDocumentProvider(next) {
++  provider = next;
++}
++function universalSignalDocument() {
++  return provider?.() ?? (universalOwner ??= Object.freeze({ scopeKey: "octane:universal" }));
++}
++function enableUniversalSignalDocument(abi = 1) {
++  if (abi !== 1) {
++    throw new TypeError("Unsupported universal signal owner ABI.");
++  }
++  installDefaultSignalOwner(universalSignalDocument);
++}
++export {
++  enableUniversalSignalDocument,
++  installUniversalSignalDocumentProvider,
++  universalSignalDocument
++};
+diff --git a/dist/node/universal-core.js b/dist/node/universal-core.js
+index 4dbe2f938d039d415b44821bcb3be520172bcada..735a017364cd23bdb8972a04401385f0bde99062 100644
+--- a/dist/node/universal-core.js
++++ b/dist/node/universal-core.js
+@@ -17,6 +17,14 @@ import {
+ } from "./profiling.js";
+ import { getRendererHostFlusher } from "./renderer-bridge.js";
+ import { resolveLazyDefaultProps } from "./shared-value-helpers.js";
++import { universalSignalDocument } from "./signals/universal-owner.js";
++import { registerLocalSignalHook } from "./signals/local-hook.js";
++import { retireSignalOwnerIdentity, runWithSignalOwner } from "./signals/owner-context.js";
++import {
++  beginNativeWriteGuard,
++  endNativeWriteGuard,
++  setNativeReadObserver
++} from "./signals/read-protocol.js";
+ import { __methodDep } from "./method-dep.js";
+ const UNIVERSAL_PLAN = /* @__PURE__ */ Symbol.for("octane.universal.plan");
+ const UNIVERSAL_VALUE = /* @__PURE__ */ Symbol.for("octane.universal.value");
+@@ -474,6 +482,133 @@ function universalComponent(renderer, component, props = null, key = NO_KEY) {
+     hasKey: key !== NO_KEY || normalized.hasKey
+   };
+ }
++const NORMALIZED_CHILD_KEYS = new WeakMap();
++/** Normalize deferred JSX without mounting components or consuming their context.
++ * Structural owners (blocks, providers, boundaries and loops) remain renderables;
++ * only transparent child groups, plan ranges, slots and JS arrays are flattened.
++ */
++function universalChildEntries(children) {
++    const out = [];
++    const collectionKey = (child) => {
++        const key = renderableKey(child);
++        if (key !== null)
++            return key;
++        if (child?.$$kind !== UNIVERSAL_VALUE)
++            return null;
++        const { plan, values } = child;
++        let node = plan.root;
++        while (node.kind === 'range' && node.children.length === 1)
++            node = node.children[0];
++        if (node.kind === 'slot')
++            return collectionKey(values[node.slot]);
++        if (node.kind !== 'host' && node.kind !== 'component')
++            return null;
++        if (node.kind === 'component' && node.keySlot !== undefined)
++            return normalizeUniversalKey(values[node.keySlot]);
++        return normalizeUniversalKey(node.propsSlot === undefined ? node.kind === 'host' ? node.props?.key : null : normalizePropsValue(values[node.propsSlot]).key);
++    };
++    const visit = (child, path) => {
++        if (child == null || typeof child === 'boolean')
++            return;
++        if (typeof child === 'object') {
++            const normalizedKey = NORMALIZED_CHILD_KEYS.get(child);
++            if (normalizedKey !== undefined) {
++                out.push({ child, key: normalizedKey });
++                return;
++            }
++        }
++        if (Array.isArray(child)) {
++            child.forEach((item, index) => {
++                const key = collectionKey(item);
++                visit(item, [...path, key === null ? 'index' : 'key', key ?? index]);
++            });
++            return;
++        }
++        if (child?.$$kind === UNIVERSAL_CHILDREN) {
++            const children = child;
++            if (CURRENT_OWNER !== null && children.renderer !== currentAttempt().root.renderer) {
++                throw new Error('Universal renderer mismatch while normalizing children.');
++            }
++            visit(children.render(), path);
++            return;
++        }
++        if (child?.$$kind === UNIVERSAL_LIST) {
++            const list = child;
++            visit(list.values.length === 0 ? list.empty : list.values, path);
++            return;
++        }
++        if (child?.$$kind === UNIVERSAL_VALUE) {
++            const value = child;
++            if (CURRENT_OWNER !== null && value.plan.renderer !== currentAttempt().root.renderer) {
++                throw new Error('Universal renderer mismatch while normalizing children.');
++            }
++            if (value.key !== null) {
++                out.push({ child, key: JSON.stringify([...path, 'key', value.key]) });
++                return;
++            }
++            const visitNode = (node, nodePath) => {
++                if (node.kind === 'range') {
++                    node.children.forEach((item, index) => visitNode(item, [...nodePath, index]));
++                }
++                else if (node.kind === 'slot') {
++                    visit(value.values[node.slot], nodePath);
++                }
++                else if (node.kind === 'text') {
++                    visit((node.slot === undefined ? node.value : value.values[node.slot]), nodePath);
++                }
++                else {
++                    const key = node.kind === 'component'
++                        ? node.keySlot === undefined
++                            ? node.propsSlot === undefined ? null : normalizePropsValue(value.values[node.propsSlot]).key
++                            : value.values[node.keySlot]
++                        : node.kind === 'host'
++                            ? node.propsSlot === undefined ? node.props?.key ?? null : normalizePropsValue(value.values[node.propsSlot]).key
++                            : null;
++                    const item = universalValue(universalPlan(value.plan.renderer, node), value.values);
++                    out.push({ child: item, key: JSON.stringify(key == null ? nodePath : [...(node === value.plan.root ? path : nodePath.slice(0, -1)), 'key', key]) });
++                }
++            };
++            visitNode(value.plan.root, path);
++            return;
++        }
++        const key = renderableKey(child);
++        out.push({ child, key: JSON.stringify(key === null ? path : [...path, 'key', key]) });
++    };
++    visit(children, []);
++    return out;
++}
++/** Renderer-supported child collection operations. They never render a component
++ * to discover its output. Returned entries retain their keys when mapped into
++ * wrapper hosts, and are materialized normally at their eventual placement.
++ */
++function normalizedChild(key, child) {
++    const value = universalKey(key, child);
++    NORMALIZED_CHILD_KEYS.set(value, key);
++    return value;
++}
++const Children = {
++    toArray(children) {
++        return universalChildEntries(children).map(({ child, key }) => typeof child === 'object' ? normalizedChild(key, child) : child);
++    },
++    map(children, fn) {
++        const out = [];
++        universalChildEntries(children).forEach(({ child, key }, index) => {
++            const mapped = fn(child, index);
++            if (mapped == null || typeof mapped === 'boolean')
++                return;
++            if (Array.isArray(mapped)) {
++                for (const entry of universalChildEntries(mapped)) {
++                    out.push(normalizedChild(JSON.stringify([key, entry.key]), entry.child));
++                }
++            }
++            else {
++                out.push(normalizedChild(key, mapped));
++            }
++        });
++        return out;
++    },
++};
++
+ function universalChildren(renderer, render) {
+   assertRendererId(renderer, "universalChildren renderer");
+   if (typeof render !== "function") throw new TypeError("universalChildren expected a function.");
+@@ -842,6 +977,7 @@ function draftOwner(record, parent, replayPath) {
+     boundaryThenable: record.boundaryThenable,
+     isBoundary: record.isBoundary,
+     canHandleSuspense: record.canHandleSuspense,
++    signalReads: null,
+     visibility: parent?.visibility ?? record.visibility,
+     contextStable: null
+   };
+@@ -1012,6 +1148,7 @@ function executeOwner(owner, build, initialRenderCount = 0) {
+     owner.contextStable = null;
+     owner.needsRender = false;
+     owner.implicitSlot = 0;
++    owner.signalReads = NO_SIGNAL_READS;
+     const previousOwner = CURRENT_OWNER;
+     const previousAttemptOwner = attempt.owner;
+     CURRENT_OWNER = owner;
+@@ -1023,13 +1160,18 @@ function executeOwner(owner, build, initialRenderCount = 0) {
+     const profileFrame = typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__ && component !== null ? __profileBeginRender(owner.record, component, owner.record.mounted) : null;
+     let didThrow = false;
+     let thrown;
++    const signalOwner = universalSignalOwner(owner.record);
++    const previousReadObserver = setNativeReadObserver(observeUniversalSignalRead);
++    const writeGuard = beginNativeWriteGuard();
+     try {
+-      output = build();
++      output = runWithSignalOwner(signalOwner, build);
+     } catch (error) {
+       didThrow = true;
+-      thrown = error;
+-      throw error;
++      thrown = isThenable(error) ? new UniversalSuspense(error) : error;
++      throw thrown;
+     } finally {
++      endNativeWriteGuard(writeGuard);
++      setNativeReadObserver(previousReadObserver);
+       if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__) {
+         __profileEndRender(profileFrame, didThrow, thrown);
+       }
+@@ -1196,6 +1338,8 @@ function disposeUncommittedDraft(owner) {
+     owner.record.componentProps = null;
+     owner.record.range = null;
+     owner.record.updates.clear();
++    disposeUniversalSignalReads(owner.record);
++    disposeUniversalLocalHooks(owner.hooks);
+     for (const hook of owner.hooks.values()) {
+       if (hook.kind === "effect-event") hook.cell.active = false;
+     }
+@@ -3142,6 +3286,85 @@ function scheduleOwner(owner, slot) {
+   }
+   owner.root.scheduleOwned(owner);
+ }
++const UNIVERSAL_SIGNAL_OWNERS = /* @__PURE__ */ new WeakMap();
++function universalSignalOwner(record) {
++  let owner = UNIVERSAL_SIGNAL_OWNERS.get(record);
++  if (owner === void 0) {
++    const documentOwner = universalSignalDocument();
++    const identity = {
++      scopeKey: documentOwner.scopeKey,
++      documentOwner,
++      // The identity object itself is the opaque per-instance token — the
++      // same shape DOM scopes use, so identity maps never retain the record.
++      instanceOwner: null,
++      instanceKey: `u:${record.id}`
++    };
++    identity.instanceOwner = identity;
++    owner = Object.freeze(identity);
++    UNIVERSAL_SIGNAL_OWNERS.set(record, owner);
++  }
++  return owner;
++}
++const NO_SIGNAL_READS = /* @__PURE__ */ new Set();
++function observeUniversalSignalRead(source) {
++  const owner = CURRENT_OWNER;
++  if (owner === null) return;
++  if (owner.signalReads === NO_SIGNAL_READS) owner.signalReads = /* @__PURE__ */ new Set();
++  owner.signalReads.add(source);
++}
++function commitUniversalSignalReads(record, reads) {
++  if (reads === null) return;
++  let subscriptions = record.signalSubscriptions;
++  if (subscriptions !== void 0) {
++    for (const [source, unsubscribe] of subscriptions) {
++      if (!reads.has(source)) {
++        subscriptions.delete(source);
++        unsubscribe();
++      }
++    }
++  }
++  for (const source of reads) {
++    if (subscriptions?.has(source)) continue;
++    if (subscriptions === void 0) {
++      subscriptions = /* @__PURE__ */ new Map();
++      record.signalSubscriptions = subscriptions;
++    }
++    subscriptions.set(
++      source,
++      source.subscribe(() => {
++        if (!record.disposed) scheduleOwner(record);
++      })
++    );
++  }
++  if (subscriptions !== void 0 && subscriptions.size === 0) {
++    record.signalSubscriptions = void 0;
++  }
++}
++function disposeUniversalSignalReads(record) {
++  const subscriptions = record.signalSubscriptions;
++  if (subscriptions !== void 0) {
++    record.signalSubscriptions = void 0;
++    for (const unsubscribe of subscriptions.values()) unsubscribe();
++  }
++  const owner = UNIVERSAL_SIGNAL_OWNERS.get(record);
++  if (owner !== void 0) retireSignalOwnerIdentity(owner);
++}
++function disposeUniversalLocalHooks(hooks) {
++  for (const hook of hooks.values()) {
++    if (hook.kind === "local") hook.dispose(hook.value);
++  }
++}
++function universalLocalHook(_name, initialize, dispose, slot) {
++  const owner = currentDraftOwner();
++  const resolved = resolveHookSlot(slot);
++  let cell = owner.hooks.get(resolved);
++  if (cell === void 0) {
++    cell = { kind: "local", value: initialize(), dispose };
++    owner.hooks.set(resolved, cell);
++  }
++  return cell.value;
++}
++registerLocalSignalHook(() => CURRENT_OWNER === null ? null : universalLocalHook);
+ function currentDraftOwner() {
+   currentAttempt();
+   const owner = activateLazyLeafOwner();
+@@ -4142,15 +4365,35 @@ function use(usable) {
+ function useImperativeHandle(ref, create, deps, slot) {
+   useLayoutEffect(
+     () => {
+-      const value = create();
+-      if (typeof ref === "function") ref(value);
+-      else if (ref !== null) ref.current = value;
+-      return () => {
+-        if (typeof ref === "function") ref(null);
+-        else if (ref !== null) ref.current = null;
++      const cleanups = [];
++      let value;
++      let initialized = false;
++      const attach = (target) => {
++        if (target == null) return;
++        if (Array.isArray(target)) {
++          for (const entry of target) attach(entry);
++          return;
++        }
++        if (!initialized) {
++          value = create();
++          initialized = true;
++        }
++        if (typeof target === "function") {
++          const cleanup = target(value);
++          cleanups.push(typeof cleanup === "function" ? cleanup : () => target(null));
++        } else {
++          target.current = value;
++          cleanups.push(() => { target.current = null; });
++        }
+       };
++      try {
++        attach(ref);
++      } catch (error) {
++        try { runCommitTasks(cleanups); } finally { throw error; }
++      }
++      return () => runCommitTasks(cleanups);
+     },
+-    deps,
++    deps == null ? deps : [...deps, ref],
+     slot
+   );
+ }
+@@ -5520,9 +5763,9 @@ class UniversalRootImpl {
+     }
+     let result;
+     try {
+-      result = event.handler(payload);
++      result = runWithSignalOwner(universalSignalOwner(event.owner), () => event.handler(payload));
+     } catch (error) {
+-      if (!routeUniversalOwnerError(event.owner, error)) throw error;
++      if (!routeUniversalOwnerError(event.owner, error) && !reportUniversalUncaughtError(this, error)) throw error;
+     }
+     return result;
+   }
+@@ -6096,6 +6339,8 @@ class UniversalRootImpl {
+       draft.record.componentProps = null;
+       draft.record.range = null;
+       draft.record.updates.clear();
++      disposeUniversalSignalReads(draft.record);
++      disposeUniversalLocalHooks(draft.hooks);
+       for (const hook of draft.hooks.values()) {
+         if (hook.kind === "effect-event") hook.cell.active = false;
+       }
+@@ -6776,6 +7021,7 @@ class UniversalRootImpl {
+         owner.componentProps = draftOwner2.componentProps;
+         owner.componentRevision = draftOwner2.componentRevision;
+         owner.hooks = draftOwner2.hooks;
++        commitUniversalSignalReads(owner, draftOwner2.signalReads);
+         for (const [slot, applied] of draftOwner2.appliedUpdates) {
+           const queue = owner.updates.get(slot);
+           if (queue !== applied.queue || applied.lane) continue;
+@@ -6809,6 +7055,7 @@ class UniversalRootImpl {
+       record.componentRevision = draft.componentRevision;
+       record.parent = draft.parent?.record ?? null;
+       record.hooks = draft.hooks;
++      commitUniversalSignalReads(record, draft.signalReads);
+       record.effectOrder = [...draft.seenEffects];
+       for (let index = 0; index < draft.seenEffects.length; index++) {
+         draft.seenEffects[index].previous = null;
+@@ -8455,6 +8702,8 @@ class UniversalRootImpl {
+           owner.componentProps = null;
+           owner.range = null;
+           owner.updates.clear();
++          disposeUniversalSignalReads(owner);
++          disposeUniversalLocalHooks(owner.hooks);
+         }
+         for (const draft of draftOwnersParentFirst) {
+           const record = draft.record;
+@@ -8464,6 +8713,7 @@ class UniversalRootImpl {
+             record.parent = draft.parent?.record ?? null;
+           }
+           record.hooks = draft.hooks;
++          commitUniversalSignalReads(record, draft.signalReads);
+           record.effectOrder = [...draft.seenEffects];
+           for (let index = 0; index < draft.seenEffects.length; index++) {
+             draft.seenEffects[index].previous = null;
+@@ -8985,6 +9235,8 @@ class UniversalRootImpl {
+           owner.componentProps = null;
+           owner.range = null;
+           owner.updates.clear();
++          disposeUniversalSignalReads(owner);
++          disposeUniversalLocalHooks(owner.hooks);
+         }
+         const deactivatedRegionCells = /* @__PURE__ */ new Set();
+         for (const bridge of regionBridges) {
+@@ -9937,6 +10189,7 @@ function createObjectDriver(renderer = "object") {
+   };
+ }
+ export {
++  Children,
+   Activity,
+   UNIVERSAL_HMR,
+   UNIVERSAL_TRANSPORT_PROTOCOL_VERSION,
+diff --git a/dist/node/universal-native.js b/dist/node/universal-native.js
+index 55ac9b640dc8bbfd977bb2cbe0b7993c8ddb425a..3ff9a5750fb59cd91b63299aec3a3e0c030b4579 100644
+--- a/dist/node/universal-native.js
++++ b/dist/node/universal-native.js
+@@ -6,9 +6,11 @@ import {
+ import {
+   universalContext
+ } from "./universal-core.js";
++import { enableUniversalSignalDocument } from "./signals/universal-owner.js";
+ import { registerRendererContext, renderRendererContextProvider } from "./renderer-bridge.js";
+ import { CONTEXT_TAG } from "./runtime-tags.js";
+ import { registerContext } from "./context-identity.js";
++enableUniversalSignalDocument();
+ // @__NO_SIDE_EFFECTS__
+ function createContext(defaultValue) {
+   const context = ((props, scope) => scope === void 0 ? universalContext(context, props.value, props.children) : renderRendererContextProvider(context, props, scope));
+diff --git a/dist/node/universal.js b/dist/node/universal.js
+index 6427a0190c072e7e4629c379e42bedc03669dc6e..8049b7880824de607157091004a46c9d33a23484 100644
+--- a/dist/node/universal.js
++++ b/dist/node/universal.js
+@@ -8,6 +8,9 @@ import {
+   createUniversalHostBoundary,
+   registerUniversalHostBridge
+ } from "./universal-dom-boundary.js";
++import { documentSignalOwner } from "./signals/document-owner.js";
++import { installUniversalSignalDocumentProvider } from "./signals/universal-owner.js";
++installUniversalSignalDocumentProvider(() => documentSignalOwner(document));
+ export {
+   createContext,
+   createSubSlot,
+diff --git a/dist/runtime.js b/dist/runtime.js
+index ee2a2bdd0e0909921fc43ed073be0fbc7f6ec585..4f9f1b5b7782bc0e42799ddb847d22f617a4885f 100644
+--- a/dist/runtime.js
++++ b/dist/runtime.js
+@@ -161,6 +161,7 @@ import {
+ import { isRendererContext, registerClientRendererBridge } from "./renderer-bridge.js";
+ import { defineRemovedContextMembers, registerContext } from "./context-identity.js";
+ import { createNativeReadDriver } from "./signals/native-read-client.js";
++import { registerLocalSignalHook } from "./signals/local-hook.js";
+ import {
+   validateNativeReadWitness
+ } from "./signals/native-read-collector.js";
+@@ -7455,6 +7456,7 @@ function nativeLocalHook(name, initialize, dispose, slot) {
+   }
+   return cell.nativeValue;
+ }
++registerLocalSignalHook(() => CURRENT_SCOPE === null ? null : nativeLocalHook);
+ function useState(initial, slot) {
+   const s = readStateHook(initial, slot, arguments.length === 1);
+   return [s.value, s.setter];
+diff --git a/dist/signals/client.d.ts b/dist/signals/client.d.ts
+index 6388c2f98517884a13af720687fb81c1f18357be..f9e98624f159cccf02a379d79201751fc07694d8 100644
+--- a/dist/signals/client.d.ts
++++ b/dist/signals/client.d.ts
+@@ -1,4 +1,4 @@
+-/** Optional component hooks for the native-read DOM compiler mode. */
++/** Optional component hooks for the native-read compiler mode (DOM and universal). */
+ export * from './index.js';
+ import type { WritableSignal } from './types.js';
+ /** A writable signal owned by this compiler-assigned component hook slot. */
+diff --git a/dist/signals/client.js b/dist/signals/client.js
+index 21a39c3ce9a28d2095e276fd647fd795e939a0bf..3f85700b57cbc3084c2df776ab3e6b5365f091a8 100644
+--- a/dist/signals/client.js
++++ b/dist/signals/client.js
+@@ -1,11 +1,11 @@
+ export * from "./index.js";
+-import { nativeLocalHook } from "../runtime.js";
+ import { createLocalScope } from "./engine.js";
++import { localSignalHook } from "./local-hook.js";
+ function disposeLocalSignal(cell) {
+   cell.scope.dispose();
+ }
+ function useSignal$(initial, slot) {
+-  const cell = nativeLocalHook(
++  const cell = localSignalHook(
+     "useSignal$",
+     () => {
+       const value = typeof initial === "function" ? initial() : initial;
+diff --git a/dist/signals/document-owner.js b/dist/signals/document-owner.js
+index cd4e628f79d9fed839c089a89e711d446d2e18a4..078dcd31218022b69086238180e6b236e7d8224f 100644
+--- a/dist/signals/document-owner.js
++++ b/dist/signals/document-owner.js
+@@ -26,7 +26,9 @@ function enableSignalDocument(abi = 1) {
+   if (defaultInstalled)
+     return;
+   defaultInstalled = true;
+-  installDefaultSignalOwner(() => typeof document === "undefined" ? null : documentSignalOwner(document));
++  if (typeof document === "undefined")
++    return;
++  installDefaultSignalOwner(() => documentSignalOwner(document));
+ }
+ function installStreamedSignalOwnerActivator(activate) {
+   if (streamedSignalOwnerActivator !== void 0) {
+diff --git a/dist/signals/facade.js b/dist/signals/facade.js
+index 5ab4b73f2e8276b3ade5f04e8fa647efd76cb830..7b23010b7440b698ac4775b44cf16dc55625654d 100644
+--- a/dist/signals/facade.js
++++ b/dist/signals/facade.js
+@@ -240,6 +240,8 @@ class Descriptor {
+     this.kind = kind;
+     this.create = create;
+     this.site = site;
++    // Instance declarations stay with their component across child templates and events.
++    this.instanceOwner = site?.startsWith("i:") ? currentSignalOwner() : null;
+   }
+   key;
+   kind;
+@@ -249,7 +251,7 @@ class Descriptor {
+   cells = /* @__PURE__ */ new WeakMap();
+   [SIGNAL_OWNER_RESOLVE](owner) {
+     requireSite(this.site);
+-    return this.resolvedCell(resolveDescriptorOwner(this.site, owner));
++    return this.resolvedCell(resolveDescriptorOwner(this.site, this.instanceOwner ?? owner));
+   }
+   resolvedCell(target) {
+     let cell = this.cells.get(target);
+@@ -260,7 +262,7 @@ class Descriptor {
+     return cell;
+   }
+   resolve() {
+-    const token = requireOwner();
++    const token = this.instanceOwner ?? requireOwner();
+     const owner = resolveDescriptorOwner(this.site, token);
+     requireSite(this.site);
+     return this.resolvedCell(owner);
+@@ -291,7 +293,7 @@ class Descriptor {
+     return this.resolve().snapshot();
+   }
+   subscribe(notify) {
+-    const token = requireOwner();
++    const token = this.instanceOwner ?? requireOwner();
+     const scope = resolveDescriptorOwner(this.site, token);
+     const run = captureSignalOwner(token);
+     return this[SIGNAL_OWNER_RESOLVE](scope).subscribe(forwardNativeTransitionConsumer(notify, () => run(notify)));
+diff --git a/dist/signals/index.d.ts b/dist/signals/index.d.ts
+index 95f32a27af860c358714eeadfbdcbc18bc323d9d..98559855b07e84b61915dba198f357505d584175 100644
+--- a/dist/signals/index.d.ts
++++ b/dist/signals/index.d.ts
+@@ -3,6 +3,7 @@ export { createScope } from './engine.js';
+ export { bindSignalControl } from './control-binding.js';
+ export type { SignalControlBinding } from './control-handoff.js';
+ export { enableSignalDocument as __enableSignalDocument } from './document-owner.js';
++export { enableUniversalSignalDocument as __enableUniversalSignalDocument } from './universal-owner.js';
+ export { createResource, query } from './requests.js';
+ export { ActionUncertainError, action$, isActionUncertain, optimistic$ } from './actions.js';
+ export { __derivedAt, derived$ } from './derived-facade.js';
+diff --git a/dist/signals/index.js b/dist/signals/index.js
+index 8ae19e510a09e8144ae2ab66c0daf293a4a3f8f6..0bf09f5276e9e1a38ef67923b9cc2a441be2ce7f 100644
+--- a/dist/signals/index.js
++++ b/dist/signals/index.js
+@@ -1,6 +1,7 @@
+ import { createScope } from "./engine.js";
+ import { bindSignalControl } from "./control-binding.js";
+ import { enableSignalDocument } from "./document-owner.js";
++import { enableUniversalSignalDocument } from "./universal-owner.js";
+ import { createResource, query } from "./requests.js";
+ import { ActionUncertainError, action$, isActionUncertain, optimistic$ } from "./actions.js";
+ import { __derivedAt, derived$ } from "./derived-facade.js";
+@@ -58,6 +59,7 @@ export {
+   __derivedAt,
+   __derivedScalarAt,
+   enableSignalDocument as __enableSignalDocument,
++  enableUniversalSignalDocument as __enableUniversalSignalDocument,
+   __queryAt,
+   __signalAt,
+   __startSignalReads,
+diff --git a/dist/signals/local-hook.d.ts b/dist/signals/local-hook.d.ts
+new file mode 100644
+index 0000000000000000000000000000000000000000..d6c1770fc22b738e0e107b6616f60eaf676d853e
+--- /dev/null
++++ b/dist/signals/local-hook.d.ts
+@@ -0,0 +1,16 @@
++/**
++ * Renderer-provided slots for optional signal hooks.
++ *
++ * `useSignal$` allocates a component-local signal cell, but the cell itself
++ * lives in whichever renderer is currently rendering — DOM hook slots on the
++ * client/server, universal owner slots under `target: 'universal'` renderers.
++ * `octane/signals` cannot import either runtime (both import the signal
++ * engine), so each renderer registers a probe at module evaluation; the probe
++ * answers only while one of its own owners is executing, which also settles
++ * nesting (a universal boundary inside a DOM render probes last and wins).
++ */
++export type LocalSignalHook = <T>(name: string, initialize: () => T, dispose: (value: T) => void, slot?: symbol | number) => T;
++/** @internal Renderer runtimes register once, at module evaluation. */
++export declare function registerLocalSignalHook(probe: () => LocalSignalHook | null): () => void;
++/** @internal Dispatch to the innermost renderer that currently owns a render. */
++export declare function localSignalHook<T>(name: string, initialize: () => T, dispose: (value: T) => void, slot?: symbol | number): T;
+diff --git a/dist/signals/local-hook.js b/dist/signals/local-hook.js
+new file mode 100644
+index 0000000000000000000000000000000000000000..77c63f5e2d931eb8dbd384ae027ee0f09935f9ce
+--- /dev/null
++++ b/dist/signals/local-hook.js
+@@ -0,0 +1,19 @@
++const probes = [];
++function registerLocalSignalHook(probe) {
++  probes.push(probe);
++  return () => {
++    const index = probes.indexOf(probe);
++    if (index !== -1) probes.splice(index, 1);
++  };
++}
++function localSignalHook(name, initialize, dispose, slot) {
++  for (let index = probes.length - 1; index >= 0; index--) {
++    const hook = probes[index]();
++    if (hook !== null) return hook(name, initialize, dispose, slot);
++  }
++  throw new Error(`${name} requires an active Octane component render.`);
++}
++export {
++  localSignalHook,
++  registerLocalSignalHook
++};
+diff --git a/dist/signals/universal-owner.d.ts b/dist/signals/universal-owner.d.ts
+new file mode 100644
+index 0000000000000000000000000000000000000000..0e57f3a79115c858355f863434c6e3423570067b
+--- /dev/null
++++ b/dist/signals/universal-owner.d.ts
+@@ -0,0 +1,10 @@
++import type { SignalOwner } from './types.js';
++/**
++ * @internal A DOM runtime aliases the ambient owner so universal-boundary and
++ * DOM renders resolve the same document scope.
++ */
++export declare function installUniversalSignalDocumentProvider(next: () => SignalOwner): void;
++/** @internal Process-wide signal document for host-neutral renderers. */
++export declare function universalSignalDocument(): SignalOwner;
++/** @internal Compiler capability for ambient signal reads under universal renderers. */
++export declare function enableUniversalSignalDocument(abi?: number): void;
+diff --git a/dist/signals/universal-owner.js b/dist/signals/universal-owner.js
+new file mode 100644
+index 0000000000000000000000000000000000000000..ff5eb43e8f0ddcadbcf8e861f42788b389b4d99b
+--- /dev/null
++++ b/dist/signals/universal-owner.js
+@@ -0,0 +1,20 @@
++import { installDefaultSignalOwner } from "./owner-context.js";
++let universalOwner;
++let provider;
++function installUniversalSignalDocumentProvider(next) {
++  provider = next;
++}
++function universalSignalDocument() {
++  return provider?.() ?? (universalOwner ??= Object.freeze({ scopeKey: "octane:universal" }));
++}
++function enableUniversalSignalDocument(abi = 1) {
++  if (abi !== 1) {
++    throw new TypeError("Unsupported universal signal owner ABI.");
++  }
++  installDefaultSignalOwner(universalSignalDocument);
++}
++export {
++  enableUniversalSignalDocument,
++  installUniversalSignalDocumentProvider,
++  universalSignalDocument
++};
+diff --git a/dist/universal-core.d.ts b/dist/universal-core.d.ts
+index 7e60feece0d3ded5f088bf4e4044516bef588663..3e4cfc19341496009be773b80562476ffd04f2d2 100644
+--- a/dist/universal-core.d.ts
++++ b/dist/universal-core.d.ts
+@@ -764,9 +764,8 @@ export declare function lazy<C extends UniversalComponent<any>>(load: () => Prom
+     default: C;
+ } | C>): C;
+ export declare function use<T>(usable: UniversalContext<T> | PromiseLike<T>): T;
+-export declare function useImperativeHandle<T>(ref: {
+-    current: T | null;
+-} | ((value: T | null) => void) | null, create: () => T, deps?: readonly unknown[] | null, slot?: unknown): void;
++type UniversalImperativeRef<T> = { current: T | null } | ((value: T | null) => void | (() => void)) | readonly UniversalImperativeRef<T>[] | null | undefined;
++export declare function useImperativeHandle<T>(ref: UniversalImperativeRef<T>, create: () => T, deps?: readonly unknown[] | null, slot?: unknown): void;
+ export declare function useEffectEvent<T extends (...args: any[]) => any>(fn: T, slot?: unknown): T;
+ export declare function useDebugValue(): void;
+ export declare function startTransition(fn: () => void | Promise<unknown>): void;
+@@ -817,3 +816,5 @@ export interface ObjectHostContainer {
+ }
+ export declare function createObjectContainer(renderer?: string): ObjectHostContainer;
+ export declare function createObjectDriver(renderer?: string): UniversalHostDriver<ObjectHostContainer, ObjectHostInstance>;
++
++export declare const Children: { toArray(children: UniversalRenderable): UniversalRenderable[]; map(children: UniversalRenderable, fn: (child: UniversalRenderable, index: number) => UniversalRenderable): UniversalRenderable[]; };
+diff --git a/dist/universal-core.js b/dist/universal-core.js
+index 4dbe2f938d039d415b44821bcb3be520172bcada..735a017364cd23bdb8972a04401385f0bde99062 100644
+--- a/dist/universal-core.js
++++ b/dist/universal-core.js
+@@ -17,6 +17,14 @@ import {
+ } from "./profiling.js";
+ import { getRendererHostFlusher } from "./renderer-bridge.js";
+ import { resolveLazyDefaultProps } from "./shared-value-helpers.js";
++import { universalSignalDocument } from "./signals/universal-owner.js";
++import { registerLocalSignalHook } from "./signals/local-hook.js";
++import { retireSignalOwnerIdentity, runWithSignalOwner } from "./signals/owner-context.js";
++import {
++  beginNativeWriteGuard,
++  endNativeWriteGuard,
++  setNativeReadObserver
++} from "./signals/read-protocol.js";
+ import { __methodDep } from "./method-dep.js";
+ const UNIVERSAL_PLAN = /* @__PURE__ */ Symbol.for("octane.universal.plan");
+ const UNIVERSAL_VALUE = /* @__PURE__ */ Symbol.for("octane.universal.value");
+@@ -474,6 +482,133 @@ function universalComponent(renderer, component, props = null, key = NO_KEY) {
+     hasKey: key !== NO_KEY || normalized.hasKey
+   };
+ }
++const NORMALIZED_CHILD_KEYS = new WeakMap();
++/** Normalize deferred JSX without mounting components or consuming their context.
++ * Structural owners (blocks, providers, boundaries and loops) remain renderables;
++ * only transparent child groups, plan ranges, slots and JS arrays are flattened.
++ */
++function universalChildEntries(children) {
++    const out = [];
++    const collectionKey = (child) => {
++        const key = renderableKey(child);
++        if (key !== null)
++            return key;
++        if (child?.$$kind !== UNIVERSAL_VALUE)
++            return null;
++        const { plan, values } = child;
++        let node = plan.root;
++        while (node.kind === 'range' && node.children.length === 1)
++            node = node.children[0];
++        if (node.kind === 'slot')
++            return collectionKey(values[node.slot]);
++        if (node.kind !== 'host' && node.kind !== 'component')
++            return null;
++        if (node.kind === 'component' && node.keySlot !== undefined)
++            return normalizeUniversalKey(values[node.keySlot]);
++        return normalizeUniversalKey(node.propsSlot === undefined ? node.kind === 'host' ? node.props?.key : null : normalizePropsValue(values[node.propsSlot]).key);
++    };
++    const visit = (child, path) => {
++        if (child == null || typeof child === 'boolean')
++            return;
++        if (typeof child === 'object') {
++            const normalizedKey = NORMALIZED_CHILD_KEYS.get(child);
++            if (normalizedKey !== undefined) {
++                out.push({ child, key: normalizedKey });
++                return;
++            }
++        }
++        if (Array.isArray(child)) {
++            child.forEach((item, index) => {
++                const key = collectionKey(item);
++                visit(item, [...path, key === null ? 'index' : 'key', key ?? index]);
++            });
++            return;
++        }
++        if (child?.$$kind === UNIVERSAL_CHILDREN) {
++            const children = child;
++            if (CURRENT_OWNER !== null && children.renderer !== currentAttempt().root.renderer) {
++                throw new Error('Universal renderer mismatch while normalizing children.');
++            }
++            visit(children.render(), path);
++            return;
++        }
++        if (child?.$$kind === UNIVERSAL_LIST) {
++            const list = child;
++            visit(list.values.length === 0 ? list.empty : list.values, path);
++            return;
++        }
++        if (child?.$$kind === UNIVERSAL_VALUE) {
++            const value = child;
++            if (CURRENT_OWNER !== null && value.plan.renderer !== currentAttempt().root.renderer) {
++                throw new Error('Universal renderer mismatch while normalizing children.');
++            }
++            if (value.key !== null) {
++                out.push({ child, key: JSON.stringify([...path, 'key', value.key]) });
++                return;
++            }
++            const visitNode = (node, nodePath) => {
++                if (node.kind === 'range') {
++                    node.children.forEach((item, index) => visitNode(item, [...nodePath, index]));
++                }
++                else if (node.kind === 'slot') {
++                    visit(value.values[node.slot], nodePath);
++                }
++                else if (node.kind === 'text') {
++                    visit((node.slot === undefined ? node.value : value.values[node.slot]), nodePath);
++                }
++                else {
++                    const key = node.kind === 'component'
++                        ? node.keySlot === undefined
++                            ? node.propsSlot === undefined ? null : normalizePropsValue(value.values[node.propsSlot]).key
++                            : value.values[node.keySlot]
++                        : node.kind === 'host'
++                            ? node.propsSlot === undefined ? node.props?.key ?? null : normalizePropsValue(value.values[node.propsSlot]).key
++                            : null;
++                    const item = universalValue(universalPlan(value.plan.renderer, node), value.values);
++                    out.push({ child: item, key: JSON.stringify(key == null ? nodePath : [...(node === value.plan.root ? path : nodePath.slice(0, -1)), 'key', key]) });
++                }
++            };
++            visitNode(value.plan.root, path);
++            return;
++        }
++        const key = renderableKey(child);
++        out.push({ child, key: JSON.stringify(key === null ? path : [...path, 'key', key]) });
++    };
++    visit(children, []);
++    return out;
++}
++/** Renderer-supported child collection operations. They never render a component
++ * to discover its output. Returned entries retain their keys when mapped into
++ * wrapper hosts, and are materialized normally at their eventual placement.
++ */
++function normalizedChild(key, child) {
++    const value = universalKey(key, child);
++    NORMALIZED_CHILD_KEYS.set(value, key);
++    return value;
++}
++const Children = {
++    toArray(children) {
++        return universalChildEntries(children).map(({ child, key }) => typeof child === 'object' ? normalizedChild(key, child) : child);
++    },
++    map(children, fn) {
++        const out = [];
++        universalChildEntries(children).forEach(({ child, key }, index) => {
++            const mapped = fn(child, index);
++            if (mapped == null || typeof mapped === 'boolean')
++                return;
++            if (Array.isArray(mapped)) {
++                for (const entry of universalChildEntries(mapped)) {
++                    out.push(normalizedChild(JSON.stringify([key, entry.key]), entry.child));
++                }
++            }
++            else {
++                out.push(normalizedChild(key, mapped));
++            }
++        });
++        return out;
++    },
++};
++
+ function universalChildren(renderer, render) {
+   assertRendererId(renderer, "universalChildren renderer");
+   if (typeof render !== "function") throw new TypeError("universalChildren expected a function.");
+@@ -842,6 +977,7 @@ function draftOwner(record, parent, replayPath) {
+     boundaryThenable: record.boundaryThenable,
+     isBoundary: record.isBoundary,
+     canHandleSuspense: record.canHandleSuspense,
++    signalReads: null,
+     visibility: parent?.visibility ?? record.visibility,
+     contextStable: null
+   };
+@@ -1012,6 +1148,7 @@ function executeOwner(owner, build, initialRenderCount = 0) {
+     owner.contextStable = null;
+     owner.needsRender = false;
+     owner.implicitSlot = 0;
++    owner.signalReads = NO_SIGNAL_READS;
+     const previousOwner = CURRENT_OWNER;
+     const previousAttemptOwner = attempt.owner;
+     CURRENT_OWNER = owner;
+@@ -1023,13 +1160,18 @@ function executeOwner(owner, build, initialRenderCount = 0) {
+     const profileFrame = typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__ && component !== null ? __profileBeginRender(owner.record, component, owner.record.mounted) : null;
+     let didThrow = false;
+     let thrown;
++    const signalOwner = universalSignalOwner(owner.record);
++    const previousReadObserver = setNativeReadObserver(observeUniversalSignalRead);
++    const writeGuard = beginNativeWriteGuard();
+     try {
+-      output = build();
++      output = runWithSignalOwner(signalOwner, build);
+     } catch (error) {
+       didThrow = true;
+-      thrown = error;
+-      throw error;
++      thrown = isThenable(error) ? new UniversalSuspense(error) : error;
++      throw thrown;
+     } finally {
++      endNativeWriteGuard(writeGuard);
++      setNativeReadObserver(previousReadObserver);
+       if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__) {
+         __profileEndRender(profileFrame, didThrow, thrown);
+       }
+@@ -1196,6 +1338,8 @@ function disposeUncommittedDraft(owner) {
+     owner.record.componentProps = null;
+     owner.record.range = null;
+     owner.record.updates.clear();
++    disposeUniversalSignalReads(owner.record);
++    disposeUniversalLocalHooks(owner.hooks);
+     for (const hook of owner.hooks.values()) {
+       if (hook.kind === "effect-event") hook.cell.active = false;
+     }
+@@ -3142,6 +3286,85 @@ function scheduleOwner(owner, slot) {
+   }
+   owner.root.scheduleOwned(owner);
+ }
++const UNIVERSAL_SIGNAL_OWNERS = /* @__PURE__ */ new WeakMap();
++function universalSignalOwner(record) {
++  let owner = UNIVERSAL_SIGNAL_OWNERS.get(record);
++  if (owner === void 0) {
++    const documentOwner = universalSignalDocument();
++    const identity = {
++      scopeKey: documentOwner.scopeKey,
++      documentOwner,
++      // The identity object itself is the opaque per-instance token — the
++      // same shape DOM scopes use, so identity maps never retain the record.
++      instanceOwner: null,
++      instanceKey: `u:${record.id}`
++    };
++    identity.instanceOwner = identity;
++    owner = Object.freeze(identity);
++    UNIVERSAL_SIGNAL_OWNERS.set(record, owner);
++  }
++  return owner;
++}
++const NO_SIGNAL_READS = /* @__PURE__ */ new Set();
++function observeUniversalSignalRead(source) {
++  const owner = CURRENT_OWNER;
++  if (owner === null) return;
++  if (owner.signalReads === NO_SIGNAL_READS) owner.signalReads = /* @__PURE__ */ new Set();
++  owner.signalReads.add(source);
++}
++function commitUniversalSignalReads(record, reads) {
++  if (reads === null) return;
++  let subscriptions = record.signalSubscriptions;
++  if (subscriptions !== void 0) {
++    for (const [source, unsubscribe] of subscriptions) {
++      if (!reads.has(source)) {
++        subscriptions.delete(source);
++        unsubscribe();
++      }
++    }
++  }
++  for (const source of reads) {
++    if (subscriptions?.has(source)) continue;
++    if (subscriptions === void 0) {
++      subscriptions = /* @__PURE__ */ new Map();
++      record.signalSubscriptions = subscriptions;
++    }
++    subscriptions.set(
++      source,
++      source.subscribe(() => {
++        if (!record.disposed) scheduleOwner(record);
++      })
++    );
++  }
++  if (subscriptions !== void 0 && subscriptions.size === 0) {
++    record.signalSubscriptions = void 0;
++  }
++}
++function disposeUniversalSignalReads(record) {
++  const subscriptions = record.signalSubscriptions;
++  if (subscriptions !== void 0) {
++    record.signalSubscriptions = void 0;
++    for (const unsubscribe of subscriptions.values()) unsubscribe();
++  }
++  const owner = UNIVERSAL_SIGNAL_OWNERS.get(record);
++  if (owner !== void 0) retireSignalOwnerIdentity(owner);
++}
++function disposeUniversalLocalHooks(hooks) {
++  for (const hook of hooks.values()) {
++    if (hook.kind === "local") hook.dispose(hook.value);
++  }
++}
++function universalLocalHook(_name, initialize, dispose, slot) {
++  const owner = currentDraftOwner();
++  const resolved = resolveHookSlot(slot);
++  let cell = owner.hooks.get(resolved);
++  if (cell === void 0) {
++    cell = { kind: "local", value: initialize(), dispose };
++    owner.hooks.set(resolved, cell);
++  }
++  return cell.value;
++}
++registerLocalSignalHook(() => CURRENT_OWNER === null ? null : universalLocalHook);
+ function currentDraftOwner() {
+   currentAttempt();
+   const owner = activateLazyLeafOwner();
+@@ -4142,15 +4365,35 @@ function use(usable) {
+ function useImperativeHandle(ref, create, deps, slot) {
+   useLayoutEffect(
+     () => {
+-      const value = create();
+-      if (typeof ref === "function") ref(value);
+-      else if (ref !== null) ref.current = value;
+-      return () => {
+-        if (typeof ref === "function") ref(null);
+-        else if (ref !== null) ref.current = null;
++      const cleanups = [];
++      let value;
++      let initialized = false;
++      const attach = (target) => {
++        if (target == null) return;
++        if (Array.isArray(target)) {
++          for (const entry of target) attach(entry);
++          return;
++        }
++        if (!initialized) {
++          value = create();
++          initialized = true;
++        }
++        if (typeof target === "function") {
++          const cleanup = target(value);
++          cleanups.push(typeof cleanup === "function" ? cleanup : () => target(null));
++        } else {
++          target.current = value;
++          cleanups.push(() => { target.current = null; });
++        }
+       };
++      try {
++        attach(ref);
++      } catch (error) {
++        try { runCommitTasks(cleanups); } finally { throw error; }
++      }
++      return () => runCommitTasks(cleanups);
+     },
+-    deps,
++    deps == null ? deps : [...deps, ref],
+     slot
+   );
+ }
+@@ -5520,9 +5763,9 @@ class UniversalRootImpl {
+     }
+     let result;
+     try {
+-      result = event.handler(payload);
++      result = runWithSignalOwner(universalSignalOwner(event.owner), () => event.handler(payload));
+     } catch (error) {
+-      if (!routeUniversalOwnerError(event.owner, error)) throw error;
++      if (!routeUniversalOwnerError(event.owner, error) && !reportUniversalUncaughtError(this, error)) throw error;
+     }
+     return result;
+   }
+@@ -6096,6 +6339,8 @@ class UniversalRootImpl {
+       draft.record.componentProps = null;
+       draft.record.range = null;
+       draft.record.updates.clear();
++      disposeUniversalSignalReads(draft.record);
++      disposeUniversalLocalHooks(draft.hooks);
+       for (const hook of draft.hooks.values()) {
+         if (hook.kind === "effect-event") hook.cell.active = false;
+       }
+@@ -6776,6 +7021,7 @@ class UniversalRootImpl {
+         owner.componentProps = draftOwner2.componentProps;
+         owner.componentRevision = draftOwner2.componentRevision;
+         owner.hooks = draftOwner2.hooks;
++        commitUniversalSignalReads(owner, draftOwner2.signalReads);
+         for (const [slot, applied] of draftOwner2.appliedUpdates) {
+           const queue = owner.updates.get(slot);
+           if (queue !== applied.queue || applied.lane) continue;
+@@ -6809,6 +7055,7 @@ class UniversalRootImpl {
+       record.componentRevision = draft.componentRevision;
+       record.parent = draft.parent?.record ?? null;
+       record.hooks = draft.hooks;
++      commitUniversalSignalReads(record, draft.signalReads);
+       record.effectOrder = [...draft.seenEffects];
+       for (let index = 0; index < draft.seenEffects.length; index++) {
+         draft.seenEffects[index].previous = null;
+@@ -8455,6 +8702,8 @@ class UniversalRootImpl {
+           owner.componentProps = null;
+           owner.range = null;
+           owner.updates.clear();
++          disposeUniversalSignalReads(owner);
++          disposeUniversalLocalHooks(owner.hooks);
+         }
+         for (const draft of draftOwnersParentFirst) {
+           const record = draft.record;
+@@ -8464,6 +8713,7 @@ class UniversalRootImpl {
+             record.parent = draft.parent?.record ?? null;
+           }
+           record.hooks = draft.hooks;
++          commitUniversalSignalReads(record, draft.signalReads);
+           record.effectOrder = [...draft.seenEffects];
+           for (let index = 0; index < draft.seenEffects.length; index++) {
+             draft.seenEffects[index].previous = null;
+@@ -8985,6 +9235,8 @@ class UniversalRootImpl {
+           owner.componentProps = null;
+           owner.range = null;
+           owner.updates.clear();
++          disposeUniversalSignalReads(owner);
++          disposeUniversalLocalHooks(owner.hooks);
+         }
+         const deactivatedRegionCells = /* @__PURE__ */ new Set();
+         for (const bridge of regionBridges) {
+@@ -9937,6 +10189,7 @@ function createObjectDriver(renderer = "object") {
+   };
+ }
+ export {
++  Children,
+   Activity,
+   UNIVERSAL_HMR,
+   UNIVERSAL_TRANSPORT_PROTOCOL_VERSION,
+diff --git a/dist/universal-native.js b/dist/universal-native.js
+index 55ac9b640dc8bbfd977bb2cbe0b7993c8ddb425a..3ff9a5750fb59cd91b63299aec3a3e0c030b4579 100644
+--- a/dist/universal-native.js
++++ b/dist/universal-native.js
+@@ -6,9 +6,11 @@ import {
+ import {
+   universalContext
+ } from "./universal-core.js";
++import { enableUniversalSignalDocument } from "./signals/universal-owner.js";
+ import { registerRendererContext, renderRendererContextProvider } from "./renderer-bridge.js";
+ import { CONTEXT_TAG } from "./runtime-tags.js";
+ import { registerContext } from "./context-identity.js";
++enableUniversalSignalDocument();
+ // @__NO_SIDE_EFFECTS__
+ function createContext(defaultValue) {
+   const context = ((props, scope) => scope === void 0 ? universalContext(context, props.value, props.children) : renderRendererContextProvider(context, props, scope));
+diff --git a/dist/universal.js b/dist/universal.js
+index 6427a0190c072e7e4629c379e42bedc03669dc6e..8049b7880824de607157091004a46c9d33a23484 100644
+--- a/dist/universal.js
++++ b/dist/universal.js
+@@ -8,6 +8,9 @@ import {
+   createUniversalHostBoundary,
+   registerUniversalHostBridge
+ } from "./universal-dom-boundary.js";
++import { documentSignalOwner } from "./signals/document-owner.js";
++import { installUniversalSignalDocumentProvider } from "./signals/universal-owner.js";
++installUniversalSignalDocumentProvider(() => documentSignalOwner(document));
+ export {
+   createContext,
+   createSubSlot,