octane 0.15.0 → 0.16.0

package/dist/cjs/dom-focused-move.cjs

@@ -18,54 +18,83 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var dom_focused_move_exports = {};
 __export(dom_focused_move_exports, {
+  isChildOf: () => isChildOf,
   moveNativeNodeBefore: () => moveNativeNodeBefore
 });
 module.exports = __toCommonJS(dom_focused_move_exports);
 function moveNativeNodeBefore(parent, node, anchor, focused, contentEditable) {
-  let containsFocused = node === focused;
-  if (!containsFocused && focused !== null && node.nodeType === 1) {
-    let candidate = focused;
-    do {
-      if (node.contains(candidate)) {
-        containsFocused = true;
-        break;
-      }
-      const root = candidate.getRootNode();
-      candidate = root.nodeType === 11 ? root.host : void 0;
-    } while (candidate !== void 0);
-  }
-  if (!containsFocused) {
-    parent.insertBefore(node, anchor);
+  const move = nativeMove(parent);
+  if (move !== null && node.isConnected === true && parent.ownerDocument === node.ownerDocument && !(contentEditable && containsFocus(node, focused))) {
+    move.call(parent, node, anchor);
     return;
   }
-  const moveBefore = parent.moveBefore;
-  if (!contentEditable && typeof moveBefore === "function" && parent.isConnected && node.isConnected && parent.ownerDocument === node.ownerDocument) {
-    moveBefore.call(parent, node, anchor);
+  if (!containsFocus(node, focused)) {
+    parent.insertBefore(node, anchor);
     return;
   }
-  if (node.parentNode !== parent || anchor !== null && anchor.parentNode !== parent) {
+  if (!isChildOf(node, parent) || anchor !== null && !isChildOf(anchor, parent)) {
     parent.insertBefore(node, anchor);
     return;
   }
-  if (node === anchor || node.nextSibling === anchor) return;
-  if (anchor === null || (node.compareDocumentPosition(anchor) & Node.DOCUMENT_POSITION_FOLLOWING) !== 0) {
-    let cursor = node.nextSibling;
-    while (cursor !== anchor) {
-      const next = cursor.nextSibling;
-      parent.insertBefore(cursor, node);
-      cursor = next;
-    }
-  } else {
-    const end = node.nextSibling;
-    let cursor = anchor;
-    while (cursor !== node) {
-      const next = cursor.nextSibling;
-      parent.insertBefore(cursor, end);
-      cursor = next;
+  if (node === anchor || nextOf(node) === anchor) return;
+  const forward = anchor === null || // 4 is Node.DOCUMENT_POSITION_FOLLOWING.
+  (nodeProto(node).compareDocumentPosition.call(node, anchor) & 4) !== 0;
+  const siblings = [];
+  for (let cursor = forward ? nextOf(node) : anchor; cursor !== null && cursor !== (forward ? anchor : node); cursor = nextOf(cursor))
+    siblings.push(cursor);
+  const rotate = move ?? parent.insertBefore;
+  let after = node;
+  for (let i = 0; i < siblings.length; i++) {
+    const sibling = siblings[i];
+    if (!isChildOf(sibling, parent)) continue;
+    if (forward) rotate.call(parent, sibling, node);
+    else {
+      rotate.call(parent, sibling, nextOf(after));
+      if (isChildOf(sibling, parent)) after = sibling;
     }
   }
 }
+let NODE_PROTO;
+let parentNodeGetter;
+let nextSiblingGetter;
+function nodeProto(node) {
+  if (NODE_PROTO === void 0) {
+    let proto = Object.getPrototypeOf(node);
+    while (!Object.prototype.hasOwnProperty.call(proto, "nextSibling"))
+      proto = Object.getPrototypeOf(proto);
+    NODE_PROTO = proto;
+  }
+  return NODE_PROTO;
+}
+function nodeGetter(node, name) {
+  return Object.getOwnPropertyDescriptor(nodeProto(node), name).get;
+}
+function isChildOf(node, parent) {
+  parentNodeGetter ??= nodeGetter(node, "parentNode");
+  return parentNodeGetter.call(node) === parent;
+}
+function nextOf(node) {
+  nextSiblingGetter ??= nodeGetter(node, "nextSibling");
+  return nextSiblingGetter.call(node);
+}
+function nativeMove(parent) {
+  if (parent.isConnected !== true) return null;
+  const move = parent.moveBefore;
+  return typeof move === "function" ? move : null;
+}
+function containsFocus(node, focused) {
+  if (node === focused) return true;
+  if (focused === null || node.nodeType !== 1) return false;
+  let candidate = focused;
+  do {
+    if (nodeProto(node).contains.call(node, candidate)) return true;
+    const root = candidate.getRootNode();
+    candidate = root.nodeType === 11 ? root.host : void 0;
+  } while (candidate !== void 0);
+  return false;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  isChildOf,
   moveNativeNodeBefore
 });

package/dist/cjs/hydration/dev-values.cjs

@@ -77,7 +77,7 @@ function unpatchedHTML(pass, el, next) {
   let client;
   if (el.localName === "script") {
     server = el.textContent ?? "";
-    client = next.replace(
+    client = String(next).replace(
       INLINE_SCRIPT_TOKEN,
       (_match, prefix, s, suffix) => `${prefix}${s === "s" ? "\\u0073" : "\\u0053"}${suffix}`
     ).replace(SCRIPT_DATA_NORMALIZATION, (match) => match === "\0" ? "\uFFFD" : "\n");

package/dist/cjs/index.cjs

@@ -44,6 +44,7 @@ __export(index_exports, {
   __runOnCatch: () => import_runtime.__runOnCatch,
   __s: () => import_runtime.markSingleRoot,
   __serverRpc: () => import_server_rpc_client.__serverRpc,
+  __serverRpcStream: () => import_server_rpc_client.__serverRpcStream,
   __useCommittedState: () => import_runtime.__useCommittedState,
   __useLinkedStateWithGetter: () => import_runtime.__useLinkedStateWithGetter,
   __useReducerWithGetter: () => import_runtime.__useReducerWithGetter,
@@ -302,6 +303,7 @@ var import_method_dep = require("./method-dep.cjs");
   __runOnCatch,
   __s,
   __serverRpc,
+  __serverRpcStream,
   __useCommittedState,
   __useLinkedStateWithGetter,
   __useReducerWithGetter,

package/dist/cjs/runtime/actions.cjs

@@ -44,6 +44,7 @@ var import_hydration = require("./hydration.cjs");
 var import_portals = require("./portals.cjs");
 var import_suspense = require("./suspense.cjs");
 var import_render = require("./render.cjs");
+var import_commit = require("./commit.cjs");
 var import_host_props = require("./host-props.cjs");
 var import_events = require("./events.cjs");
 var import_forms = require("./forms.cjs");
@@ -405,33 +406,38 @@ function useOptimistic(passthrough, updateFnOrSlot, slot) {
   const block = import_render.CURRENT_BLOCK;
   let s = scope.hooks?.get(slot);
   if (s === void 0) {
-    let unownedIndices = null;
-    const clear = (indices) => {
-      if (indices !== void 0 && unownedIndices !== indices) return;
-      unownedIndices = null;
-      const hadUpdates = slotRef.queue.length > 0;
-      if (indices === void 0) {
-        slotRef.armed = false;
-        slotRef.queue.length = 0;
-      } else {
-        let write = indices[0];
-        let skip = 0;
-        for (let read = write; read < slotRef.queue.length; read++) {
-          if (read === indices[skip]) skip++;
-          else slotRef.queue[write++] = slotRef.queue[read];
-        }
-        slotRef.queue.length = write;
+    const compact = (owner) => {
+      const queue2 = slotRef.queue;
+      const owners2 = slotRef.owners;
+      if (owners2 === null) {
+        if (owner !== null || queue2.length === 0) return false;
+        queue2.length = 0;
+        return true;
       }
-      if (hadUpdates && !block.disposed) {
-        if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__)
-          (0, import_profiling.__profileSchedule)(block, "optimistic-revert", slot);
-        if (indices === void 0) (0, import_engine.scheduleRender)(block);
-        else (0, import_engine.scheduleUrgentRender)(block);
+      let write = 0;
+      for (let read = 0; read < queue2.length; read++) {
+        if (owners2[read] === owner) continue;
+        queue2[write] = queue2[read];
+        owners2[write++] = owners2[read];
       }
+      const removed = write !== queue2.length;
+      queue2.length = write;
+      owners2.length = write;
+      if (slotRef.batches === null || slotRef.batches.size === 0) slotRef.owners = null;
+      return removed;
+    };
+    const revert = () => {
+      if (block.disposed) return;
+      if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__)
+        (0, import_profiling.__profileSchedule)(block, "optimistic-revert", slot);
+      (0, import_engine.scheduleHookPublication)(block);
     };
     const slotRef = {
       queue: [],
-      armed: false,
+      owners: null,
+      batches: null,
+      unownedPending: false,
+      compact,
       add: (value) => {
         const inAction = (0, import_engine.isTransitionUpdateContext)();
         if (__octaneDev && !inAction) {
@@ -440,13 +446,33 @@ function useOptimistic(passthrough, updateFnOrSlot, slot) {
           );
         }
         slotRef.queue.push(value);
-        if (inAction && import_engine.TRANSITION_PENDING_COUNT > 0) {
-          slotRef.armed = true;
+        const batch = inAction ? (0, import_transitions.transitionActionBatchForUpdate)() : null;
+        if (batch !== null) {
+          const owners2 = slotRef.owners ?? (slotRef.owners = new Array(slotRef.queue.length - 1).fill(null));
+          owners2.push(batch);
+          if (batch.finished) compact(batch);
+          else {
+            let batches = slotRef.batches;
+            if (batches === null) slotRef.batches = batches = /* @__PURE__ */ new Map();
+            if (!batches.has(batch))
+              batches.set(
+                batch,
+                (0, import_transitions.onTransitionBatchFinished)(batch, () => {
+                  batches.delete(batch);
+                  if (batches.size === 0) slotRef.batches = null;
+                  if (compact(batch)) revert();
+                })
+              );
+          }
         } else {
-          if (unownedIndices === null) {
-            const indices = unownedIndices = [slotRef.queue.length - 1];
-            queueMicrotask(() => clear(indices));
-          } else unownedIndices.push(slotRef.queue.length - 1);
+          slotRef.owners?.push(null);
+          if (!slotRef.unownedPending) {
+            slotRef.unownedPending = true;
+            queueMicrotask(() => {
+              slotRef.unownedPending = false;
+              if (compact(null)) revert();
+            });
+          }
         }
         if (!block.disposed) {
           if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__)
@@ -458,15 +484,28 @@ function useOptimistic(passthrough, updateFnOrSlot, slot) {
     };
     s = slotRef;
     (0, import_hooks.ensureHooks)(scope).set(slot, slotRef);
-    const listener = () => {
-      if (import_engine.TRANSITION_PENDING_COUNT === 0 && slotRef.armed) clear();
-    };
-    import_transitions.TRANSITION_LISTENERS.add(listener);
-    (0, import_hooks.registerHookCleanup)(scope, () => import_transitions.TRANSITION_LISTENERS.delete(listener));
+    (0, import_hooks.registerHookCleanup)(scope, () => {
+      const batches = slotRef.batches;
+      if (batches === null) return;
+      for (const unsubscribe of batches.values()) unsubscribe();
+      batches.clear();
+      slotRef.batches = null;
+    });
   }
   let optimistic = passthrough;
   const reduce = updateFn ?? basicOptimisticReducer;
-  for (let i = 0; i < s.queue.length; i++) optimistic = reduce(optimistic, s.queue[i]);
+  const queue = s.queue;
+  const owners = s.owners;
+  const transition = block.currentRenderMode === "transition";
+  let reverted = null;
+  for (let i = 0; i < queue.length; i++) {
+    const owner = owners === null ? null : owners[i];
+    if (owner !== null && import_drivers.TRANSITION_ROOT_DRIVER && (transition || ((0, import_transitions.rootTransitionBatch)(owner).pendingHolds ?? 0) !== 0) && import_drivers.TRANSITION_ROOT_DRIVER.fold(owner, transition, import_render.ROOT_RENDER_TRANSACTION)) {
+      if (reverted === null) reverted = [owner];
+      else if (reverted.indexOf(owner) === -1) reverted.push(owner);
+    } else optimistic = reduce(optimistic, queue[i]);
+  }
+  if (reverted !== null) for (const owner of reverted) (0, import_commit.atCommit)(s.compact, owner);
   return [optimistic, s.add];
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/runtime/child-slots.cjs

@@ -30,6 +30,7 @@ __export(child_slots_exports, {
   compilerCacheImmutableArrayFilter: () => compilerCacheImmutableArrayFilter,
   compilerCacheMappedArray: () => compilerCacheMappedArray,
   mapSlot: () => mapSlot,
+  renderSignalChildSlot: () => renderSignalChildSlot,
   textHole: () => textHole,
   textHoleUpdate: () => textHoleUpdate,
   textSlot: () => textSlot
@@ -267,6 +268,13 @@ function mapSlot(scopeOrItems, slotOrMethod, domParent, items, method, native, c
     }
   }
 }
+function renderSignalChildSlot(parentScope, slotKey, domParent, value, anchor, ownEnd, ownsHost, compactable, onlyChild, bindingMarker, cachedText) {
+  if (onlyChild) return childTextHole(parentScope, slotKey, domParent, value, cachedText);
+  if (bindingMarker === void 0)
+    childSlot(parentScope, slotKey, domParent, value, anchor, ownEnd, ownsHost, compactable);
+  else bindingChildSlot(parentScope, slotKey, domParent, value, bindingMarker, anchor, ownEnd);
+  return null;
+}
 function bindingChildSlot(parentScope, slotKey, domParent, value, marker, anchor, ownEnd) {
   const frame = import_hydration_flag.hydrationStarted ? import_hydration_presentation.PRESENTATION_HYDRATION : null;
   if (frame?.revision !== void 0) {
@@ -337,6 +345,7 @@ function childSlot(parentScope, slotKey, domParent, value, anchor, ownEnd, ownsH
   }
   if (import_drivers.SIGNAL_CHILD) {
     if ((0, import_drivers.SIGNAL_CHILD)(
+      renderSignalChildSlot,
       parentScope,
       slotKey,
       domParent,
@@ -349,6 +358,7 @@ function childSlot(parentScope, slotKey, domParent, value, anchor, ownEnd, ownsH
     ))
       return;
   } else if (import_read_protocol.nativeSignalHydration && (0, import_signal_bindings.bindImplicitSignalChild)(
+    renderSignalChildSlot,
     parentScope,
     slotKey,
     domParent,
@@ -1108,6 +1118,7 @@ function childTextHole(parentScope, slotKey, domParent, value, cachedNode) {
   compilerCacheImmutableArrayFilter,
   compilerCacheMappedArray,
   mapSlot,
+  renderSignalChildSlot,
   textHole,
   textHoleUpdate,
   textSlot

package/dist/cjs/runtime/commit.cjs

@@ -42,6 +42,7 @@ __export(commit_exports, {
   bagRecord: () => bagRecord,
   captureFocusSelection: () => captureFocusSelection,
   captureQueuedFocusSelection: () => captureQueuedFocusSelection,
+  commitQueuedBag: () => commitQueuedBag,
   defersRootUnmount: () => defersRootUnmount,
   discardMarker: () => discardMarker,
   dropRootOps: () => dropRootOps,
@@ -130,7 +131,7 @@ function bagRecord(s, next, cell, value, committed, bundle, a0, a1) {
       next[size] = s;
       next[size + 1] = transaction.ops.length;
       bag.$ = state | BAG_QUEUED;
-      transaction.ops.push(next[size + 2], bag);
+      transaction.ops.push(commitQueuedBag, bag);
     }
   }
   next[cell] = changed ? value : bag;
@@ -147,9 +148,19 @@ function bagResume(bag) {
     journalObjectOnce(next);
   return next;
 }
-function bagDone(s, bag, commit) {
-  bag.next[bag.$ & BAG_SIZE] = s;
-  commit(bag, import_render.TRANSITION_JOURNAL !== null || import_events._dispatchDepth !== 0 && import_events.CAPTURE_SLOTS.length !== 0);
+function bagDone(s, bag) {
+  const next = bag.next;
+  const size = bag.$ &= BAG_SIZE;
+  next[size] = s;
+  next[size + 2](
+    bag,
+    next,
+    import_render.TRANSITION_JOURNAL !== null || import_events._dispatchDepth !== 0 && import_events.CAPTURE_SLOTS.length !== 0
+  );
+}
+function commitQueuedBag(bag, careful) {
+  const next = bag.next;
+  next[(bag.$ &= BAG_SIZE) + 2](bag, next, careful);
 }
 function slotNext(slot) {
   const tx = import_render.ROOT_RENDER_TRANSACTION;
@@ -404,7 +415,7 @@ function dropRootOps(transaction, from, retired) {
   for (let i = from; i < ops.length; i += 2) {
     const target = ops[i + 1];
     if (ops[i] === applySlotNext) target.next = null;
-    else if (typeof target?.$ === "number") target.$ &= BAG_SIZE;
+    else if (ops[i] === commitQueuedBag) target.$ &= BAG_SIZE;
   }
   ops.length = from;
   const set = transaction.retired;
@@ -1061,6 +1072,7 @@ function withRegisteredRefDetachSuppression(entries, fn) {
   bagRecord,
   captureFocusSelection,
   captureQueuedFocusSelection,
+  commitQueuedBag,
   defersRootUnmount,
   discardMarker,
   dropRootOps,

package/dist/cjs/runtime/deopt.cjs

@@ -52,6 +52,7 @@ module.exports = __toCommonJS(deopt_exports);
 var import_branches = require("./branches.cjs");
 var import_hydration_flag = require("../hydration-flag.cjs");
 var import_has_own = require("../has-own.cjs");
+var import_dom_focused_move = require("../dom-focused-move.cjs");
 var import_shared_value_helpers = require("../shared-value-helpers.cjs");
 var import_profiling = require("../profiling.cjs");
 var import_error_codes_client_generated = require("../error-codes.client.generated.cjs");
@@ -795,7 +796,7 @@ function applyDeoptOrder(order) {
   }
   if (order.desc !== null) {
     if (order.owner === null) stampDeoptDesc(node, order.desc);
-    else (0, import_render.commitInScope)(order.owner, commitDeoptHost, node, order.desc);
+    else (0, import_render.commitInScope)((0, import_branches.owningBlock)(order.owner), commitDeoptHost, node, order.desc);
   }
   if (order.nodes !== null) placeDeoptChildren(node, order.nodes, true, false);
 }
@@ -810,7 +811,7 @@ function placeDeoptChildren(el, result, skip, adopt) {
     const want = result[i];
     const at = skip ? nextDeoptOwnedChild(cursor, adopt) : cursor;
     if (at !== want) {
-      if (import_engine.renderingFocus === null) el.insertBefore(want, at);
+      if (import_engine.renderingFocus === null) (0, import_dom_focused_move.moveNativeNodeBefore)(el, want, at, null, false);
       else {
         (0, import_engine.captureFocusedMovement)(el, import_engine.renderingFocus);
         (0, import_lists.moveFocusedNodeBefore)(el, want, at, import_engine.renderingFocus);

package/dist/cjs/runtime/engine.cjs

@@ -136,6 +136,7 @@ __export(engine_exports, {
   runEffectCleanupCallback: () => runEffectCleanupCallback,
   runEffectLifecycleCallback: () => runEffectLifecycleCallback,
   runTransition: () => runTransition,
+  scheduleHookPublication: () => scheduleHookPublication,
   scheduleNativeRead: () => scheduleNativeRead,
   scheduleRender: () => scheduleRender,
   scheduleRenderCleanup: () => scheduleRenderCleanup,
@@ -171,7 +172,7 @@ var import_error_codes_client_generated = require("../error-codes.client.generat
 var import_native_read_client = require("../signals/native-read-client.cjs");
 var import_transition_state = require("../signals/transition-state.cjs");
 var import_read_protocol = require("../signals/read-protocol.cjs");
-var import_native_read_seeds = require("../signals/native-read-seeds.cjs");
+var import_native_adoption = require("../signals/native-adoption.cjs");
 var import_owner_context = require("../signals/owner-context.cjs");
 var import_document_owner = require("../signals/document-owner.cjs");
 var import_profile_probes = require("./profile-probes.cjs");
@@ -235,16 +236,16 @@ function ownNativeAdoption(scope, manifest, consume) {
   const initial = renderOwner?.initialDocumentSignals;
   const signalOwner = renderOwner?.signalOwner;
   const initialScopeKey = (signalOwner?.documentOwner ?? signalOwner)?.scopeKey ?? "octane:document";
-  let state = import_read_protocol.nativeSignalHydration ? (0, import_native_read_seeds.createNativeAdoptionState)(
-    typeof manifest === "string" ? (0, import_native_read_seeds.parseNativeSignalManifest)(manifest) : manifest,
+  let state = import_read_protocol.nativeSignalHydration ? (0, import_native_adoption.createNativeAdoptionState)(
+    typeof manifest === "string" ? (0, import_native_adoption.parseNativeSignalManifest)(manifest) : manifest,
     initial,
     initialScopeKey
   ) : void 0;
   const adoption = state ?? {
     resolve(owner) {
       if (state === null || !import_read_protocol.nativeSignalHydration) return void 0;
-      state ??= (0, import_native_read_seeds.createNativeAdoptionState)(
-        typeof manifest === "string" ? (0, import_native_read_seeds.parseNativeSignalManifest)(manifest) : manifest,
+      state ??= (0, import_native_adoption.createNativeAdoptionState)(
+        typeof manifest === "string" ? (0, import_native_adoption.parseNativeSignalManifest)(manifest) : manifest,
         initial,
         initialScopeKey
       );
@@ -423,7 +424,15 @@ function unsuspendTransitionHolder(holder) {
       scheduleTransitionTask();
     }
 }
-let TRANSITION_LISTENER_PUBLISH_DEPTH = 0;
+let TRANSITION_HOOK_PUBLISH_DEPTH = 0;
+function scheduleHookPublication(block) {
+  TRANSITION_HOOK_PUBLISH_DEPTH++;
+  try {
+    scheduleUrgentRender(block);
+  } finally {
+    TRANSITION_HOOK_PUBLISH_DEPTH--;
+  }
+}
 let TRANSITION_ORIGIN = null;
 let TRANSITION_HARVEST = null;
 let TRANSITION_CELL_HARVEST = null;
@@ -821,19 +830,22 @@ function commitRootRenders() {
           try {
             for (let i = 0; i < ops.length; i += 2) {
               if (owner.disposed || owner.generation !== COMMITTING_GENERATION) break;
+              const op = ops[i];
               const target = ops[i + 1];
+              const bag = op === import_commit.commitQueuedBag;
               COMMIT_OP = i;
               try {
-                ops[i](
-                  target,
-                  import_render.TRANSITION_JOURNAL !== null || import_events._dispatchDepth !== 0 && import_events.CAPTURE_SLOTS.length !== 0
-                );
+                const careful = import_render.TRANSITION_JOURNAL !== null || import_events._dispatchDepth !== 0 && import_events.CAPTURE_SLOTS.length !== 0;
+                if (bag) {
+                  const next = target.next;
+                  next[(target.$ &= import_commit.BAG_SIZE) + 2](target, next, careful);
+                } else op(target, careful);
               } catch (error) {
-                if (typeof target?.$ !== "number") throw error;
+                if (!bag) throw error;
                 if (import_drivers.SIGNAL_COMMIT_RETRY ? !(0, import_drivers.SIGNAL_COMMIT_RETRY)(target, error) : true)
                   reportEffectError(target.next[target.$ & import_commit.BAG_SIZE].block, error);
               }
-              if (import_commit.BAG_POOL.length < 8 && target?.$ <= import_commit.BAG_SIZE) {
+              if (bag && import_commit.BAG_POOL.length < 8 && target.$ <= import_commit.BAG_SIZE) {
                 const next = target.next;
                 import_commit.BAG_POOL.push(next);
                 target.next = next[target.$ + 2];
@@ -1008,18 +1020,6 @@ function tickTransitionCount(delta) {
   if (TRANSITION_PENDING_COUNT < 0) TRANSITION_PENDING_COUNT = 0;
   if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__)
     (0, import_devtools_hook.__devtoolsSetTransitionCount)(TRANSITION_PENDING_COUNT);
-  TRANSITION_LISTENER_PUBLISH_DEPTH++;
-  try {
-    for (const fn of import_transitions.TRANSITION_LISTENERS) {
-      try {
-        fn();
-      } catch (err) {
-        console.error(err);
-      }
-    }
-  } finally {
-    TRANSITION_LISTENER_PUBLISH_DEPTH--;
-  }
 }
 const refAttachQueue = [];
 function attachLiveFragmentRef(instance) {
@@ -1167,7 +1167,7 @@ This ensures you're testing the behavior the user would see in the browser.`
     );
   }
   const renderPhaseSelf = import_render.CURRENT_BLOCK === block;
-  const renderPhaseOther = import_render.CURRENT_BLOCK !== null && (!renderPhaseSelf || import_render.CURRENT_SCOPE !== block) && TRANSITION_LISTENER_PUBLISH_DEPTH === 0 && EFFECT_EVENT_LIFECYCLE_DEPTH === 0;
+  const renderPhaseOther = import_render.CURRENT_BLOCK !== null && (!renderPhaseSelf || import_render.CURRENT_SCOPE !== block) && TRANSITION_HOOK_PUBLISH_DEPTH === 0 && EFFECT_EVENT_LIFECYCLE_DEPTH === 0;
   if (renderPhaseOther) {
     block.crossRenderUpdate = true;
     warnCrossComponentRenderUpdate(block, import_render.CURRENT_BLOCK);
@@ -3271,14 +3271,14 @@ function useTransition(slot) {
         hook.tentative = false;
         if (hook.isPending === pending || block.disposed) return;
         hook.isPending = pending;
-        TRANSITION_LISTENER_PUBLISH_DEPTH++;
+        TRANSITION_HOOK_PUBLISH_DEPTH++;
         try {
           if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__)
             (0, import_profiling.__profileSchedule)(block, "transition-pending", slot);
           if (pending) (0, import_transitions.markTransitionCue)(block);
           scheduleRender(block, false, pending);
         } finally {
-          TRANSITION_LISTENER_PUBLISH_DEPTH--;
+          TRANSITION_HOOK_PUBLISH_DEPTH--;
         }
       }
     };
@@ -3309,16 +3309,25 @@ function runDeferredSwaps() {
   DEFERRED_SWAPS = null;
   if (slots === null) return;
   TRANSITION_TASK_ACTIVE = true;
+  let roots = null;
   try {
-    for (let i = 0; i < slots.length; i++) swapDeferredValue(slots[i]);
+    for (let i = 0; i < slots.length; i++) {
+      const root = swapDeferredValue(slots[i]);
+      if (root !== null && !(roots ??= []).includes(root)) roots.push(root);
+    }
+    if (roots !== null) for (const root of roots) root.retry(true);
   } finally {
     TRANSITION_TASK_ACTIVE = false;
   }
 }
 function swapDeferredValue(s) {
-  if (!s.scheduled || s.block.disposed) return;
+  if (!s.scheduled) return null;
   s.scheduled = false;
-  if (Object.is(s.value, s.next)) return;
+  if (s.block.disposed) {
+    const owner = s.block.idState.renderOwner;
+    return owner !== void 0 && owner.wakeable !== null && (owner.current === null || owner.current.disposed) ? owner : null;
+  }
+  if (Object.is(s.value, s.next)) return null;
   (0, import_transitions.startTransition)(() => {
     DEFERRED_SPAWN = true;
     try {
@@ -3334,6 +3343,7 @@ function swapDeferredValue(s) {
       DEFERRED_SPAWN = false;
     }
   });
+  return null;
 }
 function hideActivityRefs(activity) {
   if (!activity.hasRefs) return;
@@ -3399,7 +3409,7 @@ function makeRoot(container, rootBlock, currentBody, currentKey, idState, output
     spareOps: []
   };
   idState.renderOwner = renderOwner;
-  const renderResolved = (body, props, nextKey, mode) => {
+  const renderResolved = (body, props, nextKey, mode, deferred = false) => {
     if (unmounted) return;
     (0, import_context_epoch.bumpContextEpoch)();
     if (rootBlock && !rootBlock.disposed && currentBody === body && Object.is(currentKey, nextKey)) {
@@ -3509,6 +3519,7 @@ function makeRoot(container, rootBlock, currentBody, currentKey, idState, output
       }
       const mountedRoot = rootBlock;
       mountedRoot.pendingMode = mode ?? null;
+      mountedRoot.pendingDeferred = deferred;
       try {
         (0, import_signal_owners.renderBlock)(mountedRoot);
         if (QUEUE.length > 0) drainHydrationRenderPhaseUpdates(mountedRoot);
@@ -3621,7 +3632,7 @@ function makeRoot(container, rootBlock, currentBody, currentKey, idState, output
       renderOwner.retryKey = null;
       renderOwner.request = null;
       if (renderOwner.transaction?.aborted === true) renderOwner.transaction = null;
-      renderOwner.retry = () => renderResolved(body, props, nextKey);
+      renderOwner.retry = (deferred) => renderResolved(body, props, nextKey, deferred ? "transition" : void 0, deferred);
       renderResolved(body, props, nextKey);
     },
     unmount() {
@@ -3812,6 +3823,7 @@ function makeRoot(container, rootBlock, currentBody, currentKey, idState, output
   runEffectCleanupCallback,
   runEffectLifecycleCallback,
   runTransition,
+  scheduleHookPublication,
   scheduleNativeRead,
   scheduleRender,
   scheduleRenderCleanup,