octane 0.1.19 → 0.1.21

package/dist/runtime.js

@@ -315,6 +315,13 @@ function flushTransitionActionBatch(batch) {
       );
     scheduleRender(block);
   }
+  if (batch.updates.size > 0) {
+    const retained = [];
+    for (const update of batch.updates.values()) {
+      if (!update.block.disposed) retained.push(update);
+    }
+    if (retained.length > 0) FLUSHED_TRANSITION_UPDATES.push(retained);
+  }
   batch.updates.clear();
   if (IN_FLIGHT_TRANSITION_ACTION_BATCH === batch) {
     IN_FLIGHT_TRANSITION_ACTION_BATCH = null;
@@ -331,6 +338,410 @@ const HELD_TRANSITIONS = /* @__PURE__ */ new Set();
 const STAGED_REVEALS = /* @__PURE__ */ new Set();
 let flushingStagedReveals = false;
 let deferringStagedRevealEffects = false;
+let ACTIVE_TRANSITION_ATTEMPT = null;
+let FLUSHED_TRANSITION_UPDATES = [];
+let HELD_SYNC_TRANSITION = null;
+let PROMOTED_PU_SWAPS = null;
+let PROMOTED_WARM_HARVEST = null;
+function beginTransitionAttempt(block) {
+  if (block.pendingMode !== "transition" || ACTIVE_TRANSITION_ATTEMPT !== null) return null;
+  TRANSITION_JOURNAL ??= [];
+  TRANSITION_JOURNAL_BAGS ??= /* @__PURE__ */ new Set();
+  TRANSITION_JOURNAL_DEPTH++;
+  const attempt = {
+    origin: block,
+    journalCheckpoint: TRANSITION_JOURNAL.length,
+    effects: [effectQueues[0].length, effectQueues[1].length, effectQueues[2].length],
+    effectEvents: effectEventQueue.length,
+    effectEventActions: effectEventCommitActions.length,
+    stores: storeSyncQueue.length,
+    refAttach: refAttachQueue.length,
+    refDetach: refDetachQueue.length,
+    effectDeps: snapshotSubtreeEffectDeps(block),
+    heldSlots: null,
+    puSwaps: null
+  };
+  ACTIVE_TRANSITION_ATTEMPT = attempt;
+  return attempt;
+}
+function endTransitionAttempt(attempt) {
+  if (attempt === null) return;
+  ACTIVE_TRANSITION_ATTEMPT = null;
+  const held = attempt.heldSlots;
+  if (held === null || held.size === 0) {
+    PROMOTED_PU_SWAPS = null;
+    PROMOTED_WARM_HARVEST = null;
+  }
+  let entries = null;
+  if (held !== null && held.size > 0) {
+    entries = [];
+    for (let i = FLUSHED_TRANSITION_UPDATES.length - 1; i >= 0; i--) {
+      const group = FLUSHED_TRANSITION_UPDATES[i];
+      let single = true;
+      for (let k = 0; k < group.length; k++) {
+        if (group[k].block !== attempt.origin) {
+          single = false;
+          break;
+        }
+      }
+      if (!single) continue;
+      for (let k = 0; k < group.length; k++) entries.push(group[k]);
+      FLUSHED_TRANSITION_UPDATES.splice(i, 1);
+    }
+  }
+  if (held !== null && held.size > 0 && entries !== null && entries.length > 0) {
+    rollbackTransitionJournal(attempt.journalCheckpoint);
+    for (let phase = 0; phase < 3; phase++) {
+      effectQueues[phase].length = attempt.effects[phase];
+    }
+    effectEventQueue.length = attempt.effectEvents;
+    effectEventCommitActions.length = attempt.effectEventActions;
+    for (let i = attempt.stores; i < storeSyncQueue.length; i++) {
+      storeSyncQueue[i].queued = false;
+    }
+    storeSyncQueue.length = attempt.stores;
+    refAttachQueue.length = attempt.refAttach;
+    refDetachQueue.length = attempt.refDetach;
+    restoreSubtreeEffectDeps(attempt.origin, attempt.effectDeps);
+    const continuing = PROMOTED_PU_SWAPS !== null || PROMOTED_WARM_HARVEST !== null;
+    let puSwaps = attempt.puSwaps;
+    if (continuing) {
+      if (PROMOTED_PU_SWAPS !== null) {
+        puSwaps = puSwaps === null ? PROMOTED_PU_SWAPS : PROMOTED_PU_SWAPS.concat(puSwaps);
+        PROMOTED_PU_SWAPS = null;
+      }
+    } else if (puSwaps !== null) {
+      for (let i = puSwaps.length - 1; i >= 0; i--) {
+        const [hooks, slot, prev] = puSwaps[i];
+        if (prev === void 0) hooks.delete(slot);
+        else hooks.set(slot, prev);
+      }
+    }
+    for (let i = 0; i < entries.length; i++) {
+      entries[i].slot.value = entries[i].baseValue;
+    }
+    let warmHarvest = PROMOTED_WARM_HARVEST;
+    PROMOTED_WARM_HARVEST = null;
+    if (warmHarvest !== null) {
+      for (let i = 0; i < warmHarvest.length; i++) warmHarvest[i].taken = false;
+    }
+    const harvest = (scope) => {
+      const cache = scope.block.__warmCache;
+      if (cache !== void 0) {
+        for (const [slot, list] of cache) {
+          for (let i = 0; i < list.length; i++) {
+            const entry = list[i];
+            if (entry.available) {
+              (warmHarvest ??= []).push({
+                slot,
+                deps: entry.deps,
+                value: entry.value,
+                taken: false
+              });
+            }
+          }
+        }
+      }
+      forEachSubtreeChild(scope, harvest);
+    };
+    harvest(attempt.origin);
+    HELD_SYNC_TRANSITION = {
+      origin: attempt.origin,
+      entries,
+      puSwaps,
+      warmHarvest,
+      holders: new Set(held)
+    };
+    if (!continuing) scheduleRender(attempt.origin);
+  }
+  if (--TRANSITION_JOURNAL_DEPTH === 0) {
+    TRANSITION_JOURNAL = null;
+    TRANSITION_JOURNAL_BAGS = null;
+    flushParkedItems();
+  }
+}
+function journalPuEntry(scope, slot, next) {
+  const attempt = ACTIVE_TRANSITION_ATTEMPT;
+  if (attempt === null) return;
+  const hooks = ensureHooks(scope);
+  (attempt.puSwaps ??= []).push([hooks, slot, hooks.get(slot), next]);
+}
+function heldSyncCellsIntact(state) {
+  const held = HELD_SYNC_TRANSITION;
+  if (held === null || !held.holders.has(state)) return false;
+  for (let i = 0; i < held.entries.length; i++) {
+    const entry = held.entries[i];
+    if (!Object.is(entry.slot.value, entry.baseValue)) return false;
+  }
+  return true;
+}
+function promoteHeldSyncTransition() {
+  const held = HELD_SYNC_TRANSITION;
+  if (held === null) return false;
+  HELD_SYNC_TRANSITION = null;
+  const puSwaps = held.puSwaps;
+  if (puSwaps !== null) {
+    for (let i = 0; i < puSwaps.length; i++) {
+      const [hooks, slot, , next] = puSwaps[i];
+      hooks.set(slot, next);
+    }
+    PROMOTED_PU_SWAPS = PROMOTED_PU_SWAPS === null ? puSwaps : PROMOTED_PU_SWAPS.concat(puSwaps);
+  }
+  PROMOTED_WARM_HARVEST = held.warmHarvest;
+  const promoted = [];
+  TRANSITION_DEPTH++;
+  try {
+    for (let i = 0; i < held.entries.length; i++) {
+      const entry = held.entries[i];
+      if (!Object.is(entry.slot.value, entry.baseValue)) continue;
+      entry.slot.value = entry.value;
+      if (!entry.block.disposed) {
+        promoted.push(entry);
+        scheduleRender(entry.block);
+      }
+    }
+  } finally {
+    TRANSITION_DEPTH--;
+  }
+  if (promoted.length > 0) FLUSHED_TRANSITION_UPDATES.push(promoted);
+  return true;
+}
+function discardHeldSyncTransition(state) {
+  const held = HELD_SYNC_TRANSITION;
+  if (held === null || !held.holders.delete(state)) return;
+  if (held.holders.size === 0) {
+    HELD_SYNC_TRANSITION = null;
+    PROMOTED_PU_SWAPS = null;
+    PROMOTED_WARM_HARVEST = null;
+  }
+}
+const JOURNAL_TEXT = 0;
+const JOURNAL_ATTR = 1;
+const JOURNAL_BAG = 2;
+const JOURNAL_PROP = 3;
+const JOURNAL_FOR = 4;
+let TRANSITION_JOURNAL = null;
+let TRANSITION_JOURNAL_BAGS = null;
+let TRANSITION_JOURNAL_DEPTH = 0;
+function journalBag() {
+  const scope = CURRENT_SCOPE;
+  if (scope === null) return;
+  const bag = scope.slots[0];
+  if (bag === null || typeof bag !== "object" || bag.__kind !== void 0) return;
+  journalObjectOnce(bag);
+}
+function journalObjectOnce(obj) {
+  const seen = TRANSITION_JOURNAL_BAGS;
+  if (seen.has(obj)) return;
+  seen.add(obj);
+  const keys = Object.keys(obj);
+  const values = [];
+  for (let i = 0; i < keys.length; i++) values.push(obj[keys[i]]);
+  TRANSITION_JOURNAL.push(JOURNAL_BAG, obj, keys, values);
+}
+function journalControlled(el, prop, defaultProp) {
+  const log = TRANSITION_JOURNAL;
+  log.push(JOURNAL_PROP, el, prop, el[prop]);
+  log.push(JOURNAL_PROP, el, defaultProp, el[defaultProp]);
+  const ctrl = el.$$ctrl;
+  if (ctrl !== void 0) journalObjectOnce(ctrl);
+  const input = el;
+  if (prop === "checked" && input.type === "radio" && input.name !== "") journalRadioCousins(input);
+  journalBag();
+}
+function journalRadioCousins(input) {
+  const name = input.name;
+  const group = input.form !== null ? input.form.elements : typeof document !== "undefined" ? document.getElementsByName(name) : [];
+  for (let i = 0; i < group.length; i++) {
+    const other = group[i];
+    if (other === input || !other.checked || other.localName !== "input" || other.type !== "radio" || other.name !== name) {
+      continue;
+    }
+    TRANSITION_JOURNAL.push(JOURNAL_PROP, other, "checked", true);
+  }
+}
+function journalControlledOption(option, withDefault) {
+  TRANSITION_JOURNAL.push(JOURNAL_PROP, option, "selected", option.selected);
+  if (withDefault)
+    TRANSITION_JOURNAL.push(JOURNAL_PROP, option, "defaultSelected", option.defaultSelected);
+}
+let PARKED_ITEMS = null;
+function parkItemForHold(block) {
+  const nodes = [];
+  const start = block.startMarker;
+  const end = block.endMarker;
+  if (start && end) {
+    const parent = start.parentNode;
+    if (parent !== null) {
+      const exclusive = block.exclusiveMarkers;
+      let n = exclusive ? start.nextSibling : start;
+      const stop = exclusive ? end : end.nextSibling;
+      while (n !== null && n !== stop) {
+        const next = getNextSibling(n);
+        parent.removeChild(n);
+        nodes.push(n);
+        n = next;
+      }
+    }
+  }
+  (PARKED_ITEMS ??= []).push({ block, nodes });
+}
+function itemRemovalDefers() {
+  return TRANSITION_JOURNAL !== null;
+}
+function forSlotParkable(state) {
+  return TRANSITION_JOURNAL !== null && TRANSITION_JOURNAL_BAGS.has(state);
+}
+function journalForSlot(state) {
+  const seen = TRANSITION_JOURNAL_BAGS;
+  if (seen.has(state)) return;
+  seen.add(state);
+  const chain = [];
+  for (let b = state.head; b !== null; b = b.nextSibling) {
+    chain.push([b, b.nextSibling, b.prevSibling]);
+  }
+  TRANSITION_JOURNAL.push(
+    JOURNAL_FOR,
+    state,
+    {
+      head: state.head,
+      tail: state.tail,
+      size: state.size,
+      empty: state.emptyBlock,
+      entries: [...state.items]
+    },
+    chain
+  );
+}
+function restoreForSlot(state, snapshot, chain) {
+  const kept = /* @__PURE__ */ new Set();
+  for (let i = 0; i < chain.length; i++) kept.add(chain[i][0]);
+  for (let b = state.head; b !== null; b = b.nextSibling) {
+    if (!kept.has(b)) unmountBlock(b, false);
+  }
+  if (state.end.parentNode === null) return;
+  state.head = snapshot.head;
+  state.tail = snapshot.tail;
+  state.size = snapshot.size;
+  state.items.clear();
+  for (let i = 0; i < snapshot.entries.length; i++) {
+    state.items.set(snapshot.entries[i][0], snapshot.entries[i][1]);
+  }
+  for (let i = 0; i < chain.length; i++) {
+    chain[i][0].nextSibling = chain[i][1];
+    chain[i][0].prevSibling = chain[i][2];
+  }
+  const parent = state.end.parentNode;
+  const ranges = [];
+  for (let b = state.head; b !== null; b = b.nextSibling) {
+    ranges.push(takeParkedItem(b) ?? collectBlockRange(b));
+  }
+  let n = state.start.nextSibling;
+  while (n !== null && n !== state.end) {
+    const next = n.nextSibling;
+    parent.removeChild(n);
+    n = next;
+  }
+  for (let i = 0; i < ranges.length; i++) {
+    const nodes = ranges[i];
+    for (let k = 0; k < nodes.length; k++) parent.insertBefore(nodes[k], state.end);
+  }
+  if (state.emptyBlock !== snapshot.empty) {
+    if (state.emptyBlock !== null) unmountBlock(state.emptyBlock, false);
+    state.emptyBlock = snapshot.empty;
+  }
+  if (snapshot.empty !== null && state.end.parentNode !== null) {
+    const parkedEmpty = takeParkedItem(snapshot.empty);
+    const nodes = parkedEmpty ?? collectBlockRange(snapshot.empty);
+    for (let k = 0; k < nodes.length; k++) parent.insertBefore(nodes[k], state.end);
+  }
+}
+function takeParkedItem(block) {
+  const parked = PARKED_ITEMS;
+  if (parked === null) return null;
+  for (let i = 0; i < parked.length; i++) {
+    if (parked[i].block === block) {
+      const nodes = parked[i].nodes;
+      parked.splice(i, 1);
+      return nodes;
+    }
+  }
+  return null;
+}
+function collectBlockRange(block) {
+  const nodes = [];
+  const start = block.startMarker;
+  const end = block.endMarker;
+  if (!start || !end || start.parentNode === null) return nodes;
+  const exclusive = block.exclusiveMarkers;
+  let n = exclusive ? start.nextSibling : start;
+  const stop = exclusive ? end : end.nextSibling;
+  while (n !== null && n !== stop) {
+    nodes.push(n);
+    n = getNextSibling(n);
+  }
+  return nodes;
+}
+function journalText(node) {
+  TRANSITION_JOURNAL.push(JOURNAL_TEXT, node, node.nodeValue, null);
+  journalBag();
+}
+function journalAttr(el, name) {
+  TRANSITION_JOURNAL.push(JOURNAL_ATTR, el, name, el.getAttribute(name));
+  journalBag();
+}
+function armTransitionJournal(state) {
+  if (!state.hasResolved || state.hiddenDom !== null || !(state.transitionHeld || (state.tryBlock?.pendingMode ?? CURRENT_BLOCK?.currentRenderMode) === "transition"))
+    return -1;
+  TRANSITION_JOURNAL ??= [];
+  TRANSITION_JOURNAL_BAGS ??= /* @__PURE__ */ new Set();
+  TRANSITION_JOURNAL_DEPTH++;
+  return TRANSITION_JOURNAL.length;
+}
+function disarmTransitionJournal(checkpoint) {
+  if (checkpoint < 0) return;
+  if (--TRANSITION_JOURNAL_DEPTH === 0) {
+    TRANSITION_JOURNAL = null;
+    TRANSITION_JOURNAL_BAGS = null;
+    flushParkedItems();
+  }
+}
+function flushParkedItems() {
+  const parked = PARKED_ITEMS;
+  if (parked === null) return;
+  PARKED_ITEMS = null;
+  for (let i = 0; i < parked.length; i++) unmountBlock(parked[i].block, false);
+}
+function rollbackTransitionJournal(checkpoint) {
+  if (checkpoint < 0) return;
+  const log = TRANSITION_JOURNAL;
+  if (log === null) return;
+  for (let i = log.length - 4; i >= checkpoint; i -= 4) {
+    const target = log[i + 1];
+    const a = log[i + 2];
+    const b = log[i + 3];
+    switch (log[i]) {
+      case JOURNAL_TEXT:
+        target.nodeValue = a;
+        break;
+      case JOURNAL_ATTR:
+        if (b === null) target.removeAttribute(a);
+        else target.setAttribute(a, b);
+        break;
+      case JOURNAL_PROP:
+        target[a] = b;
+        break;
+      case JOURNAL_FOR:
+        restoreForSlot(target, a, b);
+        TRANSITION_JOURNAL_BAGS.delete(target);
+        break;
+      default:
+        for (let k = 0; k < a.length; k++) target[a[k]] = b[k];
+        TRANSITION_JOURNAL_BAGS.delete(target);
+    }
+  }
+  log.length = checkpoint;
+}
 class ViewTransitionPseudoElement {
   /** The pseudo-element selector, e.g. `::view-transition-new(hero)`. */
   selector;
@@ -780,7 +1191,12 @@ function drainQueue() {
         block.drainStamp = drainId;
         block.drainRenders = 1;
       }
-      renderBlock(block);
+      const attempt = beginTransitionAttempt(block);
+      try {
+        renderBlock(block);
+      } finally {
+        endTransitionAttempt(attempt);
+      }
     } catch (err) {
       try {
         handleRenderError(block, err);
@@ -813,6 +1229,7 @@ function flush() {
 }
 function flushWork() {
   inFlush = true;
+  const clearRetainedTransitionUpdates = FLUSHED_TRANSITION_UPDATES.length > 0;
   const viewTransitionDriver = VIEW_TRANSITION_DRIVER;
   const clearViewTransitionTypes = viewTransitionDriver?.shouldClearTypesAfterFlush() === true;
   try {
@@ -822,6 +1239,8 @@ function flushWork() {
     if (pendingError !== null) throw pendingError.err;
   } finally {
     inFlush = false;
+    if (clearRetainedTransitionUpdates || FLUSHED_TRANSITION_UPDATES.length > 0)
+      FLUSHED_TRANSITION_UPDATES.length = 0;
     if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__)
       __devtoolsNotifyFlush();
     if (clearViewTransitionTypes) viewTransitionDriver.clearTypes();
@@ -2539,16 +2958,19 @@ function useMemo(compute, deps, slot) {
   if (WARM_EVER && d !== void 0) {
     const adopted = adoptWarmValue(s, d);
     if (adopted !== WARM_MISS) {
-      ensureHooks(scope).set(s, {
+      const adoptedEntry = {
         deps: d,
         value: adopted,
         warmEpisode: CURRENT_WARM_EPISODE
-      });
+      };
+      if (ACTIVE_TRANSITION_ATTEMPT !== null) journalPuEntry(scope, s, adoptedEntry);
+      ensureHooks(scope).set(s, adoptedEntry);
       return adopted;
     }
   }
   const value = compute.apply(null, d ?? []);
   const entry = { deps: d, value };
+  if (ACTIVE_TRANSITION_ATTEMPT !== null) journalPuEntry(scope, s, entry);
   ensureHooks(scope).set(s, entry);
   if (d !== void 0 && recordRealWarmMemo(s, d, entry)) {
     entry.warmEpisode = CURRENT_WARM_EPISODE;
@@ -3558,7 +3980,7 @@ const ErrorBoundary = /* @__PURE__ */ markComponentFlags(
       ) : props.fallback;
       childSlot(s, 1, s.block.parentNode, fb, s.block.endMarker);
     };
-    tryBlock(
+    const reset = tryBlock(
       scope,
       0,
       block.parentNode,
@@ -3569,6 +3991,12 @@ const ErrorBoundary = /* @__PURE__ */ markComponentFlags(
       void 0,
       true
     );
+    const previousResetRef = scope.slots[1];
+    if (previousResetRef !== props.resetRef) {
+      if (previousResetRef?.current === reset) previousResetRef.current = null;
+      scope.slots[1] = props.resetRef;
+    }
+    if (props.resetRef) props.resetRef.current = reset;
   },
   COMPONENT_FLAG_BOUNDARY,
   "ErrorBoundary"
@@ -4099,6 +4527,16 @@ function adoptWarmValue(slot, deps) {
     }
     b = b.parentBlock;
   }
+  const harvestList = HELD_SYNC_TRANSITION?.warmHarvest ?? PROMOTED_WARM_HARVEST;
+  if (harvestList !== null && harvestList !== void 0) {
+    for (let i = 0; i < harvestList.length; i++) {
+      const entry = harvestList[i];
+      if (!entry.taken && entry.slot === slot && !depsChanged(entry.deps, deps)) {
+        entry.taken = true;
+        return entry.value;
+      }
+    }
+  }
   return WARM_MISS;
 }
 const puMiss = /* @__PURE__ */ Symbol("octane.pu.miss");
@@ -4111,11 +4549,13 @@ function puHit(slot, entry) {
 function puAdopt(slot, deps) {
   const adopted = adoptWarmValue(slot, deps);
   if (adopted === WARM_MISS) return puMiss;
-  ensureHooks(CURRENT_SCOPE).set(slot, {
+  const adoptedEntry = {
     deps,
     value: adopted,
     warmEpisode: CURRENT_WARM_EPISODE
-  });
+  };
+  if (ACTIVE_TRANSITION_ATTEMPT !== null) journalPuEntry(CURRENT_SCOPE, slot, adoptedEntry);
+  ensureHooks(CURRENT_SCOPE).set(slot, adoptedEntry);
   return adopted;
 }
 function puTake0(slot) {
@@ -4170,6 +4610,7 @@ function puTake4(slot, d0, d1, d2, d3) {
 }
 function puPub(slot, value, ...deps) {
   const entry = { deps, value };
+  if (ACTIVE_TRANSITION_ATTEMPT !== null) journalPuEntry(CURRENT_SCOPE, slot, entry);
   ensureHooks(CURRENT_SCOPE).set(slot, entry);
   if (recordRealWarmMemo(slot, deps, entry)) entry.warmEpisode = CURRENT_WARM_EPISODE;
   return value;
@@ -5057,6 +5498,7 @@ function sibling(node, n = 1) {
 }
 function setText(node, value) {
   VIEW_TRANSITION_DRIVER?.markDirty();
+  if (TRANSITION_JOURNAL !== null) journalText(node);
   node.nodeValue = coerceText(value);
 }
 function setScriptText(el, value) {
@@ -5713,6 +6155,7 @@ function setAttribute(el, name, value) {
   const hydration = activeHydration();
   if (hydration !== null && !hydration.allowAttribute(el, name, next)) return;
   const ns = attrNamespace(name);
+  if (TRANSITION_JOURNAL !== null) journalAttr(el, name);
   if (next === null) {
     if (ns) {
       const colon = name.indexOf(":");
@@ -5755,6 +6198,7 @@ function setStringData(el, name, value) {
   }
   const hydration = activeHydration();
   if (hydration !== null && !hydration.allowAttribute(el, name, next)) return;
+  if (TRANSITION_JOURNAL !== null) journalAttr(el, name);
   if (next === null) el.removeAttribute(name);
   else el.setAttribute(name, next);
 }
@@ -5763,6 +6207,7 @@ function setBooleanAttribute(el, name, value) {
   const next = !value || type === "function" || type === "symbol" ? null : "";
   const hydration = activeHydration();
   if (hydration !== null && !hydration.allowAttribute(el, name, next)) return;
+  if (TRANSITION_JOURNAL !== null) journalAttr(el, name);
   if (next === null) el.removeAttribute(name);
   else el.setAttribute(name, next);
 }
@@ -5770,6 +6215,7 @@ function setAriaAttribute(el, name, value) {
   const next = value == null ? null : String(value);
   const hydration = activeHydration();
   if (hydration !== null && !hydration.allowAttribute(el, name, next)) return;
+  if (TRANSITION_JOURNAL !== null) journalAttr(el, name);
   if (next === null) el.removeAttribute(name);
   else el.setAttribute(name, next);
 }
@@ -5852,6 +6298,7 @@ function setClassName(el, value) {
     hydration.queueClass(el, cls, true, false, value == null || value === false);
     return;
   }
+  if (TRANSITION_JOURNAL !== null) journalAttr(el, "class");
   if (value == null || value === false) el.removeAttribute("class");
   else el.className = cls;
 }
@@ -5862,6 +6309,7 @@ function setClassAttr(el, value) {
     hydration.queueClass(el, cls, false, true, cls === null);
     return;
   }
+  if (TRANSITION_JOURNAL !== null) journalAttr(el, "class");
   if (cls === null) el.removeAttribute("class");
   else el.setAttribute("class", cls);
 }
@@ -5877,6 +6325,7 @@ function setStyle(el, value, prev) {
   const style = el.style;
   const hydration = activeHydration();
   if (hydration !== null && hydration.applyStyle(el, value, prev)) return;
+  if (TRANSITION_JOURNAL !== null) journalAttr(el, "style");
   applyStyleValue(style, value, prev);
 }
 function applyStyleValue(style, value, prev) {
@@ -6980,6 +7429,7 @@ function setNativeChangeDiagnosticMetadata(el, value) {
 function setValue(el, value) {
   const input = el;
   const ctrl = armControlled(el);
+  if (TRANSITION_JOURNAL !== null) journalControlled(el, "value", "defaultValue");
   const first = !ctrl.sawV;
   ctrl.sawV = true;
   if (value == null) {
@@ -7047,14 +7497,22 @@ function inActivationWindow(input) {
   return input.type === "radio" && target.type === "radio" && input.name !== "" && input.name === target.name && input.form === target.form;
 }
 function setChecked(el, value) {
-  setCheckedState(el, value, armControlled(el));
+  const ctrl = armControlled(el);
+  if (TRANSITION_JOURNAL !== null) journalControlled(el, "checked", "defaultChecked");
+  setCheckedState(el, value, ctrl);
 }
 function setCheckedCheckable(el, value) {
-  setCheckedState(el, value, armControlledBase(el));
+  const ctrl = armControlledBase(el);
+  if (TRANSITION_JOURNAL !== null) journalControlled(el, "checked", "defaultChecked");
+  setCheckedState(el, value, ctrl);
 }
 function setSelectValue(el, value) {
   const sel = el;
   const ctrl = armControlled(el);
+  if (TRANSITION_JOURNAL !== null) {
+    journalObjectOnce(ctrl);
+    journalBag();
+  }
   const first = !ctrl.sawV;
   ctrl.sawV = true;
   if (value == null) {
@@ -7101,6 +7559,11 @@ function setSelectValue(el, value) {
 }
 function projectSelectValue(sel, sv, setDefaultSelected) {
   const options = sel.options;
+  if (TRANSITION_JOURNAL !== null) {
+    for (let i = 0; i < options.length; i++) {
+      journalControlledOption(options[i], setDefaultSelected);
+    }
+  }
   if (typeof sv !== "string") {
     for (let i = 0; i < options.length; i++) {
       const selected = sv.has(options[i].value);
@@ -8337,6 +8800,8 @@ function clearChildContent(state) {
       host.removeChild(n);
       n = next;
     }
+    state.start = null;
+    state.end = null;
   } else if (state.start !== null) {
     const parent = state.start.parentNode;
     if (parent !== null) {
@@ -9464,6 +9929,10 @@ function childSlot(parentScope, slotKey, domParent, value, anchor, ownEnd, ownsH
   if (preparedList !== null) {
     if (state.forSlot === null) {
       if (hydration === null && !upgradeArmed) clearChildContent(state);
+      if (state.end !== null && state.end.parentNode === null) {
+        state.end = null;
+        state.start = null;
+      }
       if (state.end === null) {
         state.end = document.createComment("");
         domParent.insertBefore(state.end, null);
@@ -10131,7 +10600,7 @@ function mountPassthroughCatch(state, error) {
     null,
     null,
     state.catchBody,
-    { err: error, reset: () => requestReset(state) },
+    { err: error, reset: state.reset },
     state.env
   );
   state.block = block;
@@ -10166,7 +10635,7 @@ function mountPassthroughPending(state, thenable) {
 function renderPassthroughTry(state) {
   if (state.branch === 0 && state.block !== null) {
     state.block.body = state.catchBody;
-    state.block.props = { err: state.err, reset: () => requestReset(state) };
+    state.block.props = { err: state.err, reset: state.reset };
     state.block.extra = state.env;
     renderBlock(state.block);
     return;
@@ -10247,7 +10716,8 @@ function tryBlock(parentScope, slotKey, domParent, tryBody, catchBody, pendingBo
       domParent.insertBefore(start, anchor ?? null);
       domParent.insertBefore(end, anchor ?? null);
     }
-    const newState = {
+    let newState;
+    newState = {
       __kind: "trySlotSlot",
       start,
       end,
@@ -10271,7 +10741,8 @@ function tryBlock(parentScope, slotKey, domParent, tryBody, catchBody, pendingBo
       domParent,
       parentBlock,
       idState: parentBlock.idState,
-      passthrough
+      passthrough,
+      reset: () => requestReset(newState)
     };
     parentScope.slots[slotKey] = newState;
     registerSlot(parentScope, newState);
@@ -10286,11 +10757,11 @@ function tryBlock(parentScope, slotKey, domParent, tryBody, catchBody, pendingBo
   const s = state;
   if (s.passthrough) {
     renderPassthroughTry(s);
-    return;
+    return s.reset;
   }
   if (s.branch === 0) {
     s.block.body = s.catchBody;
-    s.block.props = { err: s.err, reset: () => requestReset(s) };
+    s.block.props = { err: s.err, reset: s.reset };
     s.block.extra = s.env;
     renderBlock(s.block);
   } else if (s.branch === 2 && s.tryBlock && !s.tryBlock.disposed && s.hiddenDom) {
@@ -10301,20 +10772,26 @@ function tryBlock(parentScope, slotKey, domParent, tryBody, catchBody, pendingBo
   } else if (s.branch === 1 && s.tryBlock) {
     s.tryBlock.body = s.tryBody;
     s.tryBlock.extra = s.env;
+    const journalCheckpoint = armTransitionJournal(s);
     try {
       renderBlock(s.tryBlock);
-      releaseHeldTransition(s);
-      s.pendingThenable = null;
+      if (!heldSyncCellsIntact(s)) {
+        releaseHeldTransition(s);
+        s.pendingThenable = null;
+      }
     } catch (err) {
       if (isHostContextRequest(err)) throw err;
       if (isSuspenseException(err)) {
         if (s.propagateSuspense) throw err;
-        handleSuspense(s, err.thenable, s.tryBlock);
+        handleSuspense(s, err.thenable, s.tryBlock, journalCheckpoint);
       } else switchToCatch(s, err);
+    } finally {
+      disarmTransitionJournal(journalCheckpoint);
     }
   } else {
     mountTry(s);
   }
+  return s.reset;
 }
 function mountTry(state) {
   const hydration = activeHydration();
@@ -10527,6 +11004,7 @@ function showTryBlock(state) {
   }
 }
 function releaseHeldTransition(state) {
+  discardHeldSyncTransition(state);
   if (state.transitionHeld) {
     state.transitionHeld = false;
     tickTransitionCount(-1);
@@ -10537,9 +11015,13 @@ function releaseHeldTransition(state) {
     state.transitionTimeoutId = null;
   }
 }
-function handleSuspense(state, thenable, sourceBlock) {
+function handleSuspense(state, thenable, sourceBlock, journalCheckpoint = -1) {
   const isTransition = sourceBlock.currentRenderMode === "transition";
   if ((isTransition || state.transitionHeld) && state.hasResolved && state.branch === 1 && state.hiddenDom === null) {
+    rollbackTransitionJournal(journalCheckpoint);
+    if (ACTIVE_TRANSITION_ATTEMPT !== null) {
+      (ACTIVE_TRANSITION_ATTEMPT.heldSlots ??= /* @__PURE__ */ new Set()).add(state);
+    }
     if (!state.transitionHeld) {
       state.transitionHeld = true;
       tickTransitionCount(1);
@@ -10656,6 +11138,9 @@ function refreshPendingBody(state) {
 }
 function swapToPendingFallback(state) {
   if (!state.pendingBody || state.branch !== 1 || !state.tryBlock) return;
+  if (HELD_SYNC_TRANSITION !== null && HELD_SYNC_TRANSITION.holders.has(state)) {
+    promoteHeldSyncTransition();
+  }
   hideTryContentAndMountPending(state);
 }
 function commitResume(state) {
@@ -10700,6 +11185,7 @@ function commitResumeInner(state) {
         spliceOffscreenCapture(stagedCapture);
         state.hasResolved = true;
       } else {
+        const journalCheckpoint = armTransitionJournal(state);
         const resumeCapture = createOffscreenCapture();
         const effectDeps = snapshotSubtreeEffectDeps(tryBlock2);
         const previousCapture = WIP_CAPTURE;
@@ -10721,6 +11207,7 @@ function commitResumeInner(state) {
         } finally {
           WIP_CAPTURE = previousCapture;
           RESUME_REPLAY = prevReplay;
+          if (!didThrow) disarmTransitionJournal(journalCheckpoint);
         }
         if (!didThrow) {
           if (state.detachedRefs !== null) {
@@ -10730,13 +11217,17 @@ function commitResumeInner(state) {
           spliceOffscreenCapture(resumeCapture);
           state.hasResolved = true;
         } else {
-          refDetachQueue.splice(refDetachCheckpoint);
-          restoreSubtreeEffectDeps(tryBlock2, effectDeps);
-          discardOffscreenCapture(resumeCapture);
-          if (isSuspenseException(renderError)) {
-            handleSuspense(state, renderError.thenable, tryBlock2);
-          } else {
-            switchToCatch(state, renderError);
+          try {
+            refDetachQueue.splice(refDetachCheckpoint);
+            restoreSubtreeEffectDeps(tryBlock2, effectDeps);
+            discardOffscreenCapture(resumeCapture);
+            if (isSuspenseException(renderError)) {
+              handleSuspense(state, renderError.thenable, tryBlock2, journalCheckpoint);
+            } else {
+              switchToCatch(state, renderError);
+            }
+          } finally {
+            disarmTransitionJournal(journalCheckpoint);
           }
           if (state.parentBlock.disposed) return;
         }
@@ -11005,6 +11496,20 @@ function rebaseOffscreenCaptureSeq(capture) {
 }
 function flushStagedReveals() {
   if (flushingStagedReveals) return;
+  if (HELD_SYNC_TRANSITION !== null) {
+    let allVisible = true;
+    for (const holder of HELD_SYNC_TRANSITION.holders) {
+      if (holder.hiddenDom !== null) {
+        allVisible = false;
+        break;
+      }
+    }
+    if (allVisible && promoteHeldSyncTransition()) {
+      STAGED_REVEALS.clear();
+      flush();
+      return;
+    }
+  }
   flushingStagedReveals = true;
   try {
     const run = () => {
@@ -11407,6 +11912,7 @@ function useDeferredValue(value, ...rest) {
   return s.current;
 }
 function requestReset(state) {
+  if (state.parentBlock.disposed || state.branch !== 0) return;
   setTryBranch(state, -1);
   state.err = null;
   state.hasResolved = false;
@@ -11699,10 +12205,31 @@ function renderBranchSlot(parentScope, slotKey, state, domParent, next, body, ma
         let bStart;
         let bEnd;
         let borrowed = false;
+        let rebuild = false;
+        let inner = null;
+        let innerEnd = null;
         if (hydration !== null && hydration.isOpen(state.start.nextSibling)) {
-          bStart = state.start.nextSibling;
-          bEnd = hydration.close(bStart);
-          hydration.node = bStart.nextSibling;
+          inner = state.start.nextSibling;
+          innerEnd = hydration.close(inner);
+          if (innerEnd !== state.end && innerEnd.nextSibling !== state.end) {
+            if (process.env.NODE_ENV !== "production") {
+              const mmLoc = siteLoc(parentScope, slotKey);
+              if (mmLoc)
+                hydration.warnStructural(
+                  mmLoc,
+                  "a single branch range",
+                  hydration.describe(innerEnd.nextSibling)
+                );
+            }
+            removeRange(state.start.nextSibling, state.end);
+            inner = null;
+            rebuild = true;
+          }
+        }
+        if (inner !== null) {
+          bStart = inner;
+          bEnd = innerEnd;
+          hydration.node = inner.nextSibling;
         } else {
           bStart = state.start;
           bEnd = state.end;
@@ -11721,7 +12248,12 @@ function renderBranchSlot(parentScope, slotKey, state, domParent, next, body, ma
         );
         if (borrowed) b.exclusiveMarkers = true;
         state.block = b;
-        renderBlock(b);
+        if (rebuild) {
+          hydration.suspend(() => renderBlock(b));
+          hydration.node = state.end.nextSibling;
+        } else {
+          renderBlock(b);
+        }
       } else if (hydration !== null && state.start.nextSibling !== state.end) {
         if (process.env.NODE_ENV !== "production") {
           const mmLoc = siteLoc(parentScope, slotKey);
@@ -12059,7 +12591,9 @@ function deactivateScope(scope, disconnectPassive = true) {
     for (const slot of hooks.values()) {
       if (slot && slot.effect === true) {
         const e = slot;
-        if (e.phase === INSERTION || !disconnectPassive && e.phase === PASSIVE) continue;
+        if (e.phase === INSERTION || !disconnectPassive && e.phase === PASSIVE && e.connectedFn !== null) {
+          continue;
+        }
         if (typeof e.cleanup === "function") {
           const cleanup = e.cleanup;
           e.cleanup = void 0;
@@ -12200,7 +12734,10 @@ function forBlock(parentScope, slotKey, domParent, items, getKey, itemBody, flag
     return;
   }
   if (state.emptyBlock) {
-    unmountBlock(state.emptyBlock);
+    if (itemRemovalDefers()) {
+      journalForSlot(state);
+      parkItemForHold(state.emptyBlock);
+    } else unmountBlock(state.emptyBlock);
     state.emptyBlock = null;
   }
   if (!isEmpty && hydration !== null && (serverMarkerState === 0 || serverMarkerState === -1 && ((flags || 0) & 16) === 0 && state.start.nextSibling !== null && state.start.nextSibling !== state.end && !hydration.isOpen(state.start.nextSibling))) {
@@ -12293,6 +12830,7 @@ function updateSurvivor(block, newItem, newIdx, itemBody, pure, lite, indexIndep
 function mountItemsLinear(parentBlock, state, items, getKey, itemBody, singleRoot, ssrMarkerless) {
   const newLen = items.length;
   if (newLen === 0) return;
+  if (TRANSITION_JOURNAL !== null) journalForSlot(state);
   const oldItems = state.items;
   const parentNode = state.end.parentNode;
   const adopt = state.adopt;
@@ -12348,6 +12886,7 @@ function reconcileKeyed(parentBlock, state, items, getKey, itemBody, pure, singl
   const oldSize = state.size;
   const newLen = items.length;
   const parentNode = state.end.parentNode;
+  if (oldSize > 0 && TRANSITION_JOURNAL !== null) journalForSlot(state);
   if (oldSize === 0) {
     mountItemsLinear(parentBlock, state, items, getKey, itemBody, singleRoot, ssrMarkerless);
     return;
@@ -12435,7 +12974,8 @@ function reconcileKeyed(parentBlock, state, items, getKey, itemBody, pure, singl
     let removed = 0;
     while (cur2 !== afterMiddle) {
       const next = cur2.nextSibling;
-      unmountBlock(cur2);
+      if (itemRemovalDefers()) parkItemForHold(cur2);
+      else unmountBlock(cur2);
       oldItems.delete(cur2.key);
       cur2 = next;
       removed++;
@@ -12509,7 +13049,8 @@ function reconcileKeyed(parentBlock, state, items, getKey, itemBody, pure, singl
     const next = cur.nextSibling;
     const newRelIdx = newKeysToIdx.get(cur.key);
     if (newRelIdx === void 0) {
-      unmountBlock(cur);
+      if (itemRemovalDefers()) parkItemForHold(cur);
+      else unmountBlock(cur);
       oldItems.delete(cur.key);
       state.size--;
     } else {
@@ -12669,6 +13210,15 @@ function reconcileKeyed(parentBlock, state, items, getKey, itemBody, pure, singl
 }
 const RANGE_CLEAR_MIN_ITEMS = 512;
 function batchClearItems(state, oldItems) {
+  if (forSlotParkable(state)) {
+    let next;
+    for (let b = state.head; b !== null; b = next) {
+      next = b.nextSibling;
+      parkItemForHold(b);
+    }
+    oldItems.clear();
+    return;
+  }
   const p = state.start.parentNode;
   if (state.start.previousSibling === null && state.end.nextSibling === null) {
     p.textContent = "";