octane 0.2.4 → 0.2.6

package/dist/runtime.js

@@ -1,5 +1,8 @@
 import {
   SUSPENSE_SCRIPT_ATTR,
+  SUSPENSE_RESOLVED_COMMENT,
+  SUSPENSE_RESOLVED_SEED_ATTR,
+  SUSPENSE_RESOLVED_NATIVE_ATTR,
   HYDRATE_STATIC_ID_COUNT_PREFIX,
   HYDRATE_STATIC_END,
   HYDRATE_ID_ATTR,
@@ -1253,6 +1256,8 @@ function journalRootRange(parent, before, after) {
   for (let node = before === null ? parent.firstChild : before.nextSibling; node !== null && node !== after; node = node.nextSibling)
     nodes.push(node);
   journalUndo(() => {
+    if (before !== null && before.parentNode !== parent || after !== null && after.parentNode !== parent)
+      return;
     let node = before !== null && before.parentNode === parent ? before.nextSibling : parent.firstChild;
     const anchor = after !== null && after.parentNode === parent ? after : null;
     const retained = new Set(nodes);
@@ -1631,23 +1636,45 @@ function journalForSlot(state) {
     TRANSITION_JOURNAL_BAGS.delete(state);
   });
 }
+function journalForOwnedListClear(state) {
+  const seen = TRANSITION_JOURNAL_BAGS;
+  const oldItems = state.items;
+  seen.set(state, TRANSITION_JOURNAL.length);
+  const snapshot = {
+    head: state.head,
+    tail: state.tail,
+    size: state.size,
+    empty: state.emptyBlock,
+    entries: oldItems
+  };
+  journalUndo(() => {
+    restoreForSlot(state, snapshot, null);
+    seen.delete(state);
+  });
+  state.items = /* @__PURE__ */ new Map();
+}
 function restoreForSlot(state, snapshot, chain) {
-  const kept = /* @__PURE__ */ new Set();
-  for (let i = 0; i < chain.length; i++) kept.add(chain[i][0]);
+  const preservedMap = chain === null ? snapshot.entries : null;
+  const kept = chain === null ? null : /* @__PURE__ */ new Set();
+  if (chain !== null) 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 (preservedMap !== null || !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];
+  if (preservedMap !== null) state.items = preservedMap;
+  else {
+    const originalChain = chain;
+    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 < originalChain.length; i++) {
+      originalChain[i][0].nextSibling = originalChain[i][1];
+      originalChain[i][0].prevSibling = originalChain[i][2];
+    }
   }
   const nodes = [];
   for (let b = state.head; b !== null; b = b.nextSibling) {
@@ -2108,6 +2135,12 @@ function reapplyFragmentBindings() {
 }
 let IS_OCTANE_ACT_ENVIRONMENT = false;
 let actScopeDepth = 0;
+let actCallbackDepth = 0;
+let asyncActCallbackDepth = 0;
+let actErrors = null;
+function isInActScope() {
+  return actCallbackDepth !== 0 || asyncActCallbackDepth !== 0;
+}
 function setIsOctaneActEnvironment(value) {
   IS_OCTANE_ACT_ENVIRONMENT = value;
 }
@@ -2434,8 +2467,13 @@ function flush() {
       __devtoolsNotifyFlush();
     return;
   }
-  if (VIEW_TRANSITION_DRIVER?.routeFlush() === true) return;
-  flushWork();
+  try {
+    if (VIEW_TRANSITION_DRIVER?.routeFlush() === true) return;
+    flushWork();
+  } catch (error) {
+    if (actScopeDepth === 0) throw error;
+    (actErrors ??= []).push(error);
+  }
 }
 function activeElementForDocument(doc) {
   try {
@@ -2722,6 +2760,17 @@ function captureFocusedMovement(parent, snapshots) {
   }
   (renderingFocusMoves ??= []).push({ snapshot, ancestors });
 }
+function drainLayoutUpdates(pendingError) {
+  for (let guard = 0; (QUEUE.length > 0 || ROOT_RENDER_TRANSACTIONS.length > 0) && guard < LAYOUT_CASCADE_LIMIT; guard++) {
+    drainPassivesBeforeRender();
+    const focused = QUEUE.length === 0 ? null : captureQueuedFocusSelection();
+    const error = drainQueueWithFocus(focused);
+    if (focused !== null) restoreQueuedFocusSelection(focused);
+    if (error !== null && pendingError === null) pendingError = error;
+    commitEffects();
+  }
+  return pendingError;
+}
 function flushWork() {
   inFlush = true;
   const clearRetainedTransitionUpdates = FLUSHED_TRANSITION_UPDATES.length > 0;
@@ -2730,9 +2779,11 @@ function flushWork() {
   try {
     if (QUEUE.length > 0) drainPassivesBeforeRender();
     const focused = QUEUE.length === 0 ? null : captureQueuedFocusSelection();
-    const pendingError = drainQueueWithFocus(focused);
+    let pendingError = drainQueueWithFocus(focused);
     if (focused !== null) restoreQueuedFocusSelection(focused);
     commitEffects();
+    if (QUEUE.length > 0 || ROOT_RENDER_TRANSACTIONS.length > 0)
+      pendingError = drainLayoutUpdates(pendingError);
     if (pendingError !== null) throw pendingError.err;
   } finally {
     inFlush = false;
@@ -2957,24 +3008,7 @@ function flushSync(fn) {
       if (focused !== null) restoreQueuedFocusSelection(focused);
       commitEffects();
       if (QUEUE.length > 0 || ROOT_RENDER_TRANSACTIONS.length > 0) {
-        const seen = new Set(QUEUE);
-        let defer = false;
-        for (let guard = 0; (QUEUE.length > 0 || ROOT_RENDER_TRANSACTIONS.length > 0) && !defer && guard < LAYOUT_CASCADE_LIMIT; guard++) {
-          drainPassivesBeforeRender();
-          const focused2 = QUEUE.length === 0 ? null : captureQueuedFocusSelection();
-          const err = drainQueueWithFocus(focused2);
-          if (focused2 !== null) restoreQueuedFocusSelection(focused2);
-          if (err !== null && pendingError === null) pendingError = err;
-          commitEffects();
-          for (let i = 0; i < QUEUE.length; i++) {
-            const b = QUEUE[i];
-            if (seen.has(b)) {
-              defer = true;
-              break;
-            }
-            seen.add(b);
-          }
-        }
+        pendingError = drainLayoutUpdates(pendingError);
       }
     } finally {
       inFlush = false;
@@ -3114,6 +3148,35 @@ function drainRefAttaches() {
     }
   }
 }
+let refStateUpdates = null;
+let collectingRefStateUpdates = false;
+function drainCommitRefs() {
+  const previousUpdates = refStateUpdates;
+  const previousCollecting = collectingRefStateUpdates;
+  refStateUpdates = null;
+  collectingRefStateUpdates = true;
+  try {
+    drainRefDetaches();
+    drainRefAttaches();
+  } finally {
+    const updates = refStateUpdates;
+    refStateUpdates = previousUpdates;
+    collectingRefStateUpdates = previousCollecting;
+    if (updates !== null) {
+      REF_CALLBACK_DEPTH++;
+      try {
+        for (const [state, update] of updates) {
+          if (update.block.disposed || Object.is(state.value, update.previous)) continue;
+          if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__)
+            __profileSchedule(update.block, "state", update.profileSlot);
+          scheduleRender(update.block);
+        }
+      } finally {
+        REF_CALLBACK_DEPTH--;
+      }
+    }
+  }
+}
 function blockSubtreeDisposed(block) {
   let b = block;
   while (b !== null) {
@@ -3160,8 +3223,7 @@ function commitEffects() {
     const caughtReports = drainEffectEventCommitActions();
     drainControlledSyncs();
     const mutationBatch = drainMutationEffects();
-    drainRefDetaches();
-    drainRefAttaches();
+    drainCommitRefs();
     reapplyFragmentBindings();
     if (mutationBatch !== null) runLayoutEffects(mutationBatch);
     if (caughtReports !== null) publishInlineCaughtErrorReports(caughtReports);
@@ -3208,35 +3270,77 @@ function drainEffectEventUpdates() {
     entry.cell.impl = entry.nextImpl;
   }
 }
+function throwPendingActErrors() {
+  const errors = actErrors;
+  actErrors = null;
+  if (errors !== null)
+    throw errors.length === 1 ? errors[0] : new AggregateError(errors, formatClientError(64));
+}
+function mergePendingActErrors(error) {
+  const errors = actErrors;
+  actErrors = null;
+  return errors === null ? error : new AggregateError([...errors, error], formatClientError(64));
+}
+function actCheckpoint() {
+  return new Promise((resolve) => {
+    const channel = new MessageChannel();
+    channel.port1.onmessage = () => {
+      channel.port1.close();
+      channel.port2.close();
+      resolve();
+    };
+    channel.port2.postMessage(null);
+  });
+}
 function act(fn) {
+  const nested = isInActScope();
   actScopeDepth++;
+  actCallbackDepth++;
   let result;
   try {
     result = fn();
   } catch (err) {
     actScopeDepth--;
-    return Promise.reject(err);
+    return Promise.reject(mergePendingActErrors(err));
+  } finally {
+    actCallbackDepth--;
   }
   if (result !== null && typeof result === "object" && typeof result.then === "function") {
+    asyncActCallbackDepth++;
     return (async () => {
       try {
-        const value = await result;
+        let value;
+        try {
+          value = await result;
+        } finally {
+          asyncActCallbackDepth--;
+        }
+        if (nested) return value;
         for (let i = 0; i < ACT_DRAIN_LIMIT; i++) {
-          for (let j = 0; j < 5; j++) await Promise.resolve();
+          await actCheckpoint();
+          throwPendingActErrors();
+          const hadWork = hasPendingWork();
           drainPassiveEffects();
-          if (!hasPendingWork()) return value;
+          if (!hadWork && !hasPendingWork()) return value;
         }
         throw new Error(formatClientError(14, ACT_DRAIN_LIMIT));
+      } catch (error) {
+        throw mergePendingActErrors(error);
       } finally {
         actScopeDepth--;
       }
     })();
   }
+  if (nested) {
+    actScopeDepth--;
+    return Promise.resolve(result);
+  }
   try {
     for (let i = 0; i < ACT_DRAIN_LIMIT; i++) {
       if (VIEW_TRANSITION_DRIVER?.wouldWrap() === true) flush();
       else flushSync(() => {
       });
+      throwPendingActErrors();
       drainPassiveEffects();
       if (!hasPendingWork()) break;
       if (i === ACT_DRAIN_LIMIT - 1) {
@@ -3245,16 +3349,20 @@ function act(fn) {
     }
   } catch (err) {
     actScopeDepth--;
-    return Promise.reject(err);
+    return Promise.reject(mergePendingActErrors(err));
   }
   return (async () => {
     try {
       for (let i = 0; i < ACT_DRAIN_LIMIT; i++) {
-        for (let j = 0; j < 5; j++) await Promise.resolve();
+        await actCheckpoint();
+        throwPendingActErrors();
+        const hadWork = hasPendingWork();
         drainPassiveEffects();
-        if (!hasPendingWork()) return result;
+        if (!hadWork && !hasPendingWork()) return result;
       }
       throw new Error(formatClientError(14, ACT_DRAIN_LIMIT));
+    } catch (error) {
+      throw mergePendingActErrors(error);
     } finally {
       actScopeDepth--;
     }
@@ -3709,19 +3817,51 @@ function createBlock(kind, parentBlock, parentNode, startMarker, endMarker, body
   }
   return block;
 }
+let renderPhaseOwner = null;
+let renderPhaseUpdates = null;
+function captureRenderPhaseUpdate(cell, key) {
+  const updates = renderPhaseUpdates ??= /* @__PURE__ */ new Map();
+  if (!updates.has(cell)) updates.set(cell, { value: cell.value, queue: cell[key]?.slice(), key });
+}
 function renderBlock(block) {
   const hydration = activeHydration();
   if (hydration !== null && !hydration.owns(block)) {
     hydration.suspend(() => renderBlock(block));
     return;
   }
-  let retries = 0;
-  while (renderBlockInner(block)) {
-    if (block.nestedUpdateError) {
-      block.nestedUpdateError = false;
-      throw maximumUpdateDepthError();
+  const previousOwner = renderPhaseOwner;
+  let previousUpdates = renderPhaseUpdates;
+  renderPhaseOwner = block;
+  renderPhaseUpdates = null;
+  try {
+    let retries = 0;
+    while (renderBlockInner(block)) {
+      if (block.nestedUpdateError) {
+        block.nestedUpdateError = false;
+        throw maximumUpdateDepthError();
+      }
+      if (++retries > RENDER_PHASE_UPDATE_LIMIT) throw new Error(formatClientError(9));
+    }
+    const updates = renderPhaseUpdates;
+    if (updates !== null && previousOwner !== null && blockIsAncestorOf(previousOwner, block)) {
+      previousUpdates ??= /* @__PURE__ */ new Map();
+      for (const [cell, snapshot] of updates) {
+        if (!previousUpdates.has(cell)) previousUpdates.set(cell, snapshot);
+      }
+    }
+  } catch (error) {
+    const updates = renderPhaseUpdates;
+    if (updates !== null) {
+      for (const [cell, snapshot] of updates) {
+        cell.value = snapshot.value;
+        cell[snapshot.key] = snapshot.queue;
+      }
+      if (!block.crossRenderUpdate) block.pending = false;
     }
-    if (++retries > RENDER_PHASE_UPDATE_LIMIT) throw new Error(formatClientError(9));
+    throw error;
+  } finally {
+    renderPhaseOwner = previousOwner;
+    renderPhaseUpdates = previousUpdates;
   }
 }
 function enqueueEffectEventUpdate(entry) {
@@ -4401,6 +4541,9 @@ function manualHook(fn, name) {
   Object.defineProperty(provider, "length", { value: fn.length, configurable: true });
   return provider;
 }
+function callWithReceiver(fn, receiver, ...args) {
+  return NATIVE_REFLECT_APPLY(fn, receiver, args);
+}
 function withSlot(sym, fn, ...args) {
   const driver = MANUAL_HOOK_DRIVER;
   const pending = driver?.pending;
@@ -4466,6 +4609,7 @@ function useState(initial, slot) {
         if (s.pendingActionBatch !== void 0 && transitionActionBatchForUpdate() === null)
           recordUrgentActionUpdate(s, next);
         if ((s.updates !== void 0 || s.renderTransition !== void 0 || typeof next === "function" && TRANSITION_PENDING_COUNT > 0 && TRANSITION_SWAP_DRIVER?.hasHeld(s, block) || block.pending && typeof next === "function") && transitionActionBatchForUpdate() === null) {
+          if (CURRENT_BLOCK === block) captureRenderPhaseUpdate(s, "updates");
           (s.updates ??= []).push(next);
           scheduleRender(block);
           return;
@@ -4477,6 +4621,7 @@ function useState(initial, slot) {
           computed = typeof next === "function" ? next(previous) : next;
         } catch {
           if (transitionActionBatchForUpdate() === null) {
+            if (CURRENT_BLOCK === block) captureRenderPhaseUpdate(s, "updates");
             (s.updates ??= []).push(next);
             scheduleRender(block);
             return;
@@ -4503,6 +4648,19 @@ function useState(initial, slot) {
           }
           return;
         }
+        if (collectingRefStateUpdates && REF_CALLBACK_DEPTH > 0 && !forceRender) {
+          const updates = refStateUpdates ??= /* @__PURE__ */ new Map();
+          const state = s;
+          if (!updates.has(state)) {
+            const update2 = { block, previous: s.value };
+            if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__)
+              update2.profileSlot = slot;
+            updates.set(state, update2);
+          }
+          s.value = computed;
+          return;
+        }
+        if (CURRENT_BLOCK === block) captureRenderPhaseUpdate(s, "updates");
         s.value = computed;
         if (!block.disposed && typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__)
           __profileSchedule(block, "state", slot);
@@ -4835,6 +4993,7 @@ function useReducer(reducer, initialArg, initOrSlot, slot) {
       dispatch: (action) => {
         if (block.disposed) return;
         if (CURRENT_BLOCK === block || transitionActionBatchForUpdate() === null) {
+          if (CURRENT_BLOCK === block) captureRenderPhaseUpdate(s, "renderPhaseActions");
           if (s.pendingActionBatch !== void 0 && transitionActionBatchForUpdate() === null)
             recordUrgentActionUpdate(s, (value) => s.reducer(value, action));
           const actions = s.renderPhaseActions ??= [];
@@ -7810,6 +7969,7 @@ class HydrationCapability {
     this.rootBlock = rootBlock;
     this.node = node;
     this.seeds = seeds;
+    initialSuspenseHydrationRenderer = renderInitialSuspenseHydration;
   }
   rootBlock;
   node;
@@ -10819,6 +10979,10 @@ function buildDelegatedPath(event, listener, path = event.composedPath()) {
   }
 }
 function fireEventSlot(slot, event) {
+  const previousScope = CURRENT_SCOPE;
+  const previousBlock = CURRENT_BLOCK;
+  CURRENT_SCOPE = null;
+  CURRENT_BLOCK = null;
   try {
     if (typeof slot === "function") {
       slot(event);
@@ -10849,6 +11013,9 @@ function fireEventSlot(slot, event) {
     invokeInvalidEventListener(`${event.type} event`, slot, event);
   } catch (err) {
     reportListenerError(err);
+  } finally {
+    CURRENT_SCOPE = previousScope;
+    CURRENT_BLOCK = previousBlock;
   }
 }
 function invokeInvalidEventListener(label, listener, event) {
@@ -10877,7 +11044,7 @@ function reportListenerError(err) {
 }
 function maybeFlushDiscrete(type) {
   if (_dispatchDepth === 0 && DISCRETE_EVENTS.has(type) && pendingRestores.length > 0) {
-    if (hasPendingWork()) {
+    if (!inFlush && hasPendingWork()) {
       if (VIEW_TRANSITION_DRIVER?.queueAllTransition() === true) flush();
       else flushSync(noop);
     }
@@ -15884,6 +16051,7 @@ function releaseHiddenText(text, restore = true) {
   }
 }
 function teardownTrySlot(state, detachDom) {
+  initialSuspenseHydrations?.delete(state);
   cancelSuspenseRetry(state);
   HIDDEN_REVEAL_ACTIONS?.delete(state);
   if (state.block !== null) unmountBlock(state.block, detachDom);
@@ -16355,6 +16523,15 @@ function tryBlock(parentScope, slotKey, domParent, tryBody, catchBody, pendingBo
     state.env = env;
   }
   const s = state;
+  let initial = initialSuspenseHydrations?.get(s);
+  if (initial === void 0 && hydration !== null && s.branch === -1 && !s.propagateSuspense) {
+    initial = takeInitialSuspenseHydration(s, hydration) ?? void 0;
+    if (initial !== void 0) (initialSuspenseHydrations ??= /* @__PURE__ */ new WeakMap()).set(s, initial);
+  }
+  if (initial !== void 0) {
+    initialSuspenseHydrationRenderer(s, initial);
+    return s.reset;
+  }
   if (s.passthrough) {
     renderPassthroughTry(s);
     return s.reset;
@@ -16472,6 +16649,184 @@ function mountHiddenTryBody(state) {
   hideTryBlock(state);
   return block;
 }
+let initialSuspenseHydrations = null;
+let initialStreamedPayloads = null;
+let initialSuspenseHydrationRenderer = null;
+function takeInitialSuspenseHydration(state, hydration) {
+  const marker = state.start.nextSibling;
+  if (marker?.nodeType !== 8) return null;
+  const text = marker.data;
+  if (text.startsWith(STREAM_SEED_COMMENT)) {
+    const boundaryId = text.slice(STREAM_SEED_COMMENT.length);
+    const start = marker.nextSibling;
+    if (!hydration.isOpen(start)) return null;
+    const end2 = hydration.close(start);
+    const stash = typeof window !== "undefined" ? window.$OCTS : void 0;
+    const owner = marker;
+    let payload = initialStreamedPayloads?.get(owner);
+    if (payload === void 0) {
+      payload = {
+        seedRaw: typeof stash?.[boundaryId] === "string" ? stash[boundaryId] : null,
+        nativeRaw: typeof stash?.[boundaryId + "$signals"] === "string" ? stash[boundaryId + "$signals"] : null
+      };
+      (initialStreamedPayloads ??= /* @__PURE__ */ new WeakMap()).set(owner, payload);
+      if (stash !== void 0) {
+        delete stash[boundaryId];
+        delete stash[boundaryId + "$signals"];
+      }
+    }
+    state.idState = {
+      prefix: state.parentBlock.idState.prefix + "b" + boundaryId + "-",
+      next: 0,
+      renderOwner: state.parentBlock.idState.renderOwner
+    };
+    return {
+      metadata: [marker],
+      start,
+      end: end2,
+      idStart: 0,
+      ...payload,
+      consume: () => {
+        initialStreamedPayloads?.delete(owner);
+      }
+    };
+  }
+  if (!text.startsWith(SUSPENSE_RESOLVED_COMMENT)) return null;
+  const rawCount = text.slice(SUSPENSE_RESOLVED_COMMENT.length);
+  if (!/^(?:0|[1-9]\d*)$/.test(rawCount)) return null;
+  const count = Number(rawCount);
+  if (!Number.isSafeInteger(count)) return null;
+  let cursor = marker.nextSibling;
+  let seedRaw = null;
+  let nativeRaw = null;
+  const sidecars = [];
+  for (const attr of [SUSPENSE_RESOLVED_SEED_ATTR, SUSPENSE_RESOLVED_NATIVE_ATTR]) {
+    if (cursor?.nodeType !== 1) continue;
+    const script = cursor;
+    if (script.localName !== "script" || script.getAttribute("type") !== "application/json" || !script.hasAttribute(attr))
+      continue;
+    if (attr === SUSPENSE_RESOLVED_SEED_ATTR) seedRaw = script.textContent;
+    else nativeRaw = script.textContent;
+    sidecars.push(script);
+    cursor = script.nextSibling;
+  }
+  if (!hydration.isOpen(cursor)) return null;
+  const end = hydration.close(cursor);
+  const rootIds = state.idState;
+  const idStart = rootIds.next;
+  reserveHydrationIds(rootIds, count);
+  state.idState = {
+    prefix: rootIds.prefix,
+    next: idStart,
+    limit: idStart + count,
+    overflow: rootIds,
+    renderOwner: rootIds.renderOwner
+  };
+  return {
+    metadata: [marker, ...sidecars],
+    start: cursor,
+    end,
+    idStart,
+    seedRaw,
+    nativeRaw
+  };
+}
+function finishInitialSuspenseHydration(initial, hydration) {
+  for (const node of initial.metadata) node.remove();
+  initial.consume?.();
+  if (hydration.hasAdjacentRangePair) hydration.coalesce();
+}
+function renderInitialSuspenseHydration(state, initial) {
+  state.pendingThenable = null;
+  state.idState.next = initial.idStart;
+  const block = createTryBody(state, initial.start, initial.end);
+  state.block = block;
+  setTryBranch(state, 1);
+  const hydration = new HydrationCapability(block, initial.start.nextSibling, null);
+  if (initial.seedRaw !== null) hydration.seeds = hydration.parseSeeds(initial.seedRaw);
+  hydration.claimRootRemainder(initial.end);
+  hydration.protectRootAnchor(initial.end);
+  const previousHydration = currentHydration;
+  const previousCapture = WIP_CAPTURE;
+  const capture = createOffscreenCapture();
+  currentHydration = hydration;
+  WIP_CAPTURE = capture;
+  const previousNative = setNativeAdoptionResolver(null);
+  let suspended = null;
+  let failed = false;
+  let failure;
+  try {
+    if (initial.nativeRaw !== null) {
+      hydration.nativeAdoption = ownNativeAdoption(
+        block,
+        parseNativeSignalManifest(initial.nativeRaw)
+      );
+      setNativeAdoptionResolver(hydration.nativeAdoption.resolve);
+    }
+    renderBlock(block);
+    drainHydrationRenderPhaseUpdates(block);
+    hydration.flushClassWrites();
+    hydration.flushTextWarnings();
+    state.hasResolved = true;
+  } catch (error) {
+    failed = true;
+    failure = error;
+    if (isSuspenseException(error)) suspended = error.thenable;
+    const refs = [];
+    collectVisibleSubtreeRefs(block, refs);
+    withRefDetachSuppression(refs, () => unmountBlock(block, false));
+    state.block = null;
+    state.tryBlock = null;
+    discardOffscreenCapture(capture);
+  } finally {
+    setNativeAdoptionResolver(previousNative);
+    WIP_CAPTURE = previousCapture;
+    currentHydration = previousHydration;
+    if (previousHydration !== null) previousHydration.node = state.end;
+  }
+  if (!failed) {
+    initialSuspenseHydrations?.delete(state);
+    (capture.renderCleanups ??= []).push((discarded) => {
+      if (discarded) return;
+      finishInitialSuspenseHydration(initial, hydration);
+    });
+    spliceOffscreenCapture(capture);
+    return;
+  }
+  if (suspended !== null) {
+    state.pendingThenable = suspended;
+    const resume = () => {
+      if (state.parentBlock.disposed || state.pendingThenable !== suspended || initialSuspenseHydrations?.get(state) !== initial)
+        return;
+      scheduleRender(state.parentBlock);
+    };
+    suspended.then(resume, resume);
+    return;
+  }
+  initialSuspenseHydrations?.delete(state);
+  if (failure instanceof NativeAdoptionMiss || isHostContextRequest(failure)) throw failure;
+  const adoptServerCatch = hydration.isRejection(failure);
+  if (!adoptServerCatch) removeRange(initial.start.nextSibling, initial.end);
+  const outerHydration = currentHydration;
+  if (adoptServerCatch) currentHydration = hydration;
+  try {
+    switchToCatch(
+      state,
+      failure,
+      true,
+      adoptServerCatch ? initial.start : void 0,
+      adoptServerCatch ? initial.end : void 0
+    );
+    if (WIP_CAPTURE === null) finishInitialSuspenseHydration(initial, hydration);
+    else
+      (WIP_CAPTURE.renderCleanups ??= []).push((discarded) => {
+        if (!discarded) finishInitialSuspenseHydration(initial, hydration);
+      });
+  } finally {
+    currentHydration = outerHydration;
+    if (outerHydration !== null) outerHydration.node = state.end;
+  }
+}
 function mountTry(state) {
   cancelSuspenseRetry(state);
   HIDDEN_REVEAL_ACTIONS?.delete(state);
@@ -17999,6 +18354,9 @@ function switchToCatchInner(state, err, reportInline, adoptedStart, adoptedEnd)
   );
   b.idState = state.idState;
   state.block = b;
+  if (adopting && hydration !== null && hydration.rootBlock.disposed && hydration.rootBlock.startMarker === bStart && hydration.rootBlock.endMarker === bEnd) {
+    hydration.rootBlock = b;
+  }
   try {
     if (!adopting && hydration !== null) hydration.suspend(() => renderBlock(b));
     else renderBlock(b);
@@ -19069,8 +19427,9 @@ function switchBlock(parentScope, slotKey, domParent, discriminant, cases, defau
   }
   renderBranchSlot(parentScope, slotKey, state, domParent, nextIdx, body, "switch", env);
 }
-function forBlock(parentScope, slotKey, domParent, items, getKey, itemBody, flags, deps, emptyBody, anchor, ownEnd) {
+function forBlock(parentScope, slotKey, domParent, inputItems, getKey, itemBody, flags, deps, emptyBody, anchor, ownEnd) {
   if (CURRENT_BLOCK?.pending && !CURRENT_BLOCK.crossRenderUpdate) return;
+  const items = Array.isArray(inputItems) ? inputItems : Array.from(inputItems);
   const parentBlock = parentScope.block;
   const hydration = activeHydration();
   let state = parentScope.slots[slotKey];
@@ -19645,8 +20004,11 @@ function reconcileKeyed(parentBlock, state, items, getKey, itemBody, pure, singl
   }
   if (process.env.NODE_ENV !== "production") getKey = checkedListKey(getKey);
   if (newLen === 0) {
-    if (journalShape) journalForSlot(state);
-    batchClearItems(state, oldItems);
+    const ownedRootClear = journalShape && canDeferRootOwnedListClear(state);
+    if (ownedRootClear && (TRANSITION_JOURNAL_BAGS.get(state) ?? -1) < TRANSITION_JOURNAL_CHECKPOINT)
+      journalForOwnedListClear(state);
+    else if (journalShape) journalForSlot(state);
+    batchClearItems(state, ownedRootClear ? state.items : oldItems, ownedRootClear);
     state.head = null;
     state.tail = null;
     state.size = 0;
@@ -19975,8 +20337,76 @@ function reconcileKeyed(parentBlock, state, items, getKey, itemBody, pure, singl
   }
 }
 const RANGE_CLEAR_MIN_ITEMS = 512;
-function batchClearItems(state, oldItems) {
+function canDeferRootOwnedListClear(state) {
+  const transaction = ROOT_RENDER_TRANSACTION;
+  const parent = state.start.parentNode;
+  if (transaction === null || transaction.aborted || ROOT_RENDER_ROLLBACK || transaction.hydrating === true || state.adopt !== null || state.size < 16 || parent === null || parent.nodeType !== 1 && parent.nodeType !== 11 || state.end.parentNode !== parent || state.start.previousSibling !== null || state.end.nextSibling !== null)
+    return false;
+  const oldHead = state.head;
+  for (let block = oldHead; block !== null; block = block.nextSibling) {
+    if (!block.mounted || block.idState.renderOwner !== transaction.owner || block.startMarker === null || block.startMarker !== block.endMarker || block.hooks !== null || block.effectSlots !== null || block.cleanups !== null || block.children !== null || block._slots !== null || block.refFields !== null || block.deoptNode !== null || block.vt !== null)
+      return false;
+  }
+  return true;
+}
+function deferRootOwnedListClear(state, certified = false) {
+  if (!certified && !canDeferRootOwnedListClear(state)) return false;
+  const transaction = ROOT_RENDER_TRANSACTION;
+  const parent = state.start.parentNode;
+  const oldHead = state.head;
+  const retired = transaction.retired ??= /* @__PURE__ */ new Set();
+  const newlyRetired = [];
+  for (let block = oldHead; block !== null; block = block.nextSibling) {
+    if (!retired.has(block)) {
+      retired.add(block);
+      newlyRetired.push(block);
+    }
+    if (block.pending) {
+      journalRootProperty(block, "pending");
+      block.pending = false;
+    }
+  }
+  let cancelled = false;
+  journalUndo(() => {
+    cancelled = true;
+    for (let i = 0; i < newlyRetired.length; i++) retired.delete(newlyRetired[i]);
+  });
+  const start = state.start;
+  const end = state.end;
+  (transaction.commit ??= []).push(() => {
+    if (cancelled) return;
+    let wholeParent = state.size === 0 && start.parentNode === parent && end.parentNode === parent && start.previousSibling === null && end.nextSibling === null;
+    if (wholeParent) {
+      let node = start.nextSibling;
+      for (let block = oldHead; block !== null; block = block.nextSibling) {
+        if (node !== block.startMarker) {
+          wholeParent = false;
+          break;
+        }
+        node = node.nextSibling;
+      }
+      if (node !== end) wholeParent = false;
+    }
+    for (let block = oldHead; block !== null; block = block.nextSibling) block.disposed = true;
+    if (wholeParent) {
+      parent.textContent = "";
+      parent.appendChild(start);
+      parent.appendChild(end);
+    } else {
+      for (let block = oldHead; block !== null; block = block.nextSibling) {
+        const node = block.startMarker;
+        if (node.parentNode !== null) node.parentNode.removeChild(node);
+      }
+    }
+  });
+  return true;
+}
+function batchClearItems(state, oldItems, ownedRootClear = false) {
   if (forSlotParkable(state)) {
+    if (deferRootOwnedListClear(state, ownedRootClear)) {
+      oldItems.clear();
+      return;
+    }
     let next;
     for (let b = state.head; b !== null; b = next) {
       next = b.nextSibling;
@@ -21678,6 +22108,7 @@ export {
   beginNativeReadScope,
   beginNativeReadWitness,
   bindRendererRegionOwner,
+  callWithReceiver,
   child,
   childSlot,
   childTextHole,
@@ -21747,6 +22178,7 @@ export {
   injectStyle,
   invokeManualHook,
   isChildrenBlock,
+  isInActScope,
   isValidElement,
   keyedForBlock,
   lazy,