octane 0.2.1 → 0.2.3

package/dist/runtime.js

@@ -27,6 +27,7 @@ import {
   SVG_ONLY_TAGS,
   VOID_ELEMENTS
 } from "./constants.js";
+import { isDelegatedEventProp } from "./event-names.js";
 import { hasOwnProp } from "./has-own.js";
 import { headOwnershipKey } from "./head-ownership.js";
 import { resourceHintWarning } from "./resource-hint-diagnostics.js";
@@ -176,15 +177,22 @@ function beginActiveNativeReadScope(scope) {
   const block = CURRENT_BLOCK;
   return block === null ? -1 : NATIVE_READ_DRIVER.beginScope(scope, block);
 }
+function scheduleNativeRead(target) {
+  invalidateRender(target, target);
+  const retainPriority = SCHEDULED_VISIBILITY_DRIVER?.holdsNativeRead(target) === true;
+  if (retainPriority) TRANSITION_DEPTH++;
+  try {
+    scheduleRender(target);
+  } finally {
+    if (retainPriority) TRANSITION_DEPTH--;
+  }
+}
 function ensureNativeReadDriver() {
   if (NATIVE_READ_DRIVER !== null) return NATIVE_READ_DRIVER;
   NATIVE_READ_DRIVER = createNativeReadDriver({
     capture: () => WIP_CAPTURE,
     cleanup: registerHookCleanup,
-    schedule: (target) => {
-      invalidateRender(target, target);
-      scheduleRender(target);
-    },
+    schedule: scheduleNativeRead,
     suspended: retainNativeRetryReads,
     replayRefs: (capture, owner) => replayNativeUnpublishedRefs(capture, owner),
     refDisposed: (entry) => blockSubtreeDisposed(entry.block)
@@ -273,10 +281,7 @@ function retainNativeRetryReads(block, reads) {
       if (retry2 === void 0) {
         const owner2 = current;
         retry2 = createNativeReadRetry(() => {
-          if (!owner2.disposed) {
-            invalidateRender(owner2, owner2);
-            scheduleRender(owner2);
-          }
+          if (!owner2.disposed) scheduleNativeRead(owner2);
         });
         retries.set(owner2, retry2);
         const owned = retry2;
@@ -473,6 +478,9 @@ const RENDERER_REGION_DOM_OWNERS = /* @__PURE__ */ new WeakMap();
 const RENDERER_REGION_DOM_BINDINGS = /* @__PURE__ */ new WeakMap();
 const DOM_ROOT_DISPOSERS = /* @__PURE__ */ new WeakMap();
 let EFFECT_BODY_DEPTH = 0;
+let CURRENT_EFFECT_PHASE = -1;
+let EFFECT_COMMIT_DEPTH = 0;
+let COMMIT_PHASE_ERRORS = null;
 let REF_CALLBACK_DEPTH = 0;
 let STORE_SYNC_DEPTH = 0;
 let EFFECT_EVENT_LIFECYCLE_DEPTH = 0;
@@ -486,12 +494,15 @@ function runEffectLifecycleCallback(callback) {
     EFFECT_EVENT_LIFECYCLE_DEPTH--;
   }
 }
-function runEffectCleanupCallback(callback) {
+function runEffectCleanupCallback(callback, phase = -1) {
+  const previousPhase = CURRENT_EFFECT_PHASE;
+  CURRENT_EFFECT_PHASE = phase;
   EFFECT_BODY_DEPTH++;
   try {
     runEffectLifecycleCallback(callback);
   } finally {
     EFFECT_BODY_DEPTH--;
+    CURRENT_EFFECT_PHASE = previousPhase;
   }
 }
 const QUEUE = [];
@@ -510,17 +521,31 @@ function ensureTransitionSwapDriver() {
     splice: spliceWipCapture,
     begin: beginTransitionAttempt,
     end: endTransitionAttempt,
+    beginUrgent: beginUrgentTransitionRender,
+    endUrgent: endUrgentTransitionRender,
     holdRoot: holdRootTransition,
     retryRoot: retryRootTransition,
     commitRoot: commitRootTransition,
     discardRoot: discardRootTransition,
-    keepsRoot: keepsRootTransition
+    keepsRoot: keepsRootTransition,
+    cancelEqual: cancelHeldTransitionUpdate,
+    hasHeld: hasHeldTransitionUpdate,
+    heldUpdate: getHeldTransitionUpdate,
+    rebaseHeld: rebaseHeldTransitionUpdate
   };
 }
 let ACTIVE_TRANSITION_ACTION_BATCH = null;
 let IN_FLIGHT_TRANSITION_ACTION_BATCH = null;
 function createTransitionActionBatch() {
-  return { updates: /* @__PURE__ */ new Map(), pendingActions: 0, closed: false, flushed: false };
+  return {
+    updates: /* @__PURE__ */ new Map(),
+    pendingActions: 0,
+    closed: false,
+    flushed: false,
+    hook: null,
+    hooks: null,
+    hooksPending: false
+  };
 }
 function transitionActionBatchForUpdate() {
   if (ACTIVE_TRANSITION_ACTION_BATCH !== null) return ACTIVE_TRANSITION_ACTION_BATCH;
@@ -528,6 +553,7 @@ function transitionActionBatchForUpdate() {
   return IN_FLIGHT_TRANSITION_ACTION_BATCH;
 }
 function rebaseTransitionActionUpdate(update) {
+  if (update.state !== void 0 || update.reducer !== void 0) return update.value;
   if (Object.is(update.baseValue, update.slot.value)) return update.value;
   let value = update.slot.value;
   for (const operation of update.operations) value = operation(value);
@@ -536,26 +562,31 @@ function rebaseTransitionActionUpdate(update) {
   if (update.slot.pendingActionBatch !== void 0) update.slot.pendingActionValue = value;
   return value;
 }
-function stagedTransitionValue(slot) {
+function stagedTransitionValue(slot, block) {
   const batch = transitionActionBatchForUpdate();
   if (batch === null) return slot.value;
   const update = batch.updates.get(slot);
-  return update === void 0 ? slot.value : rebaseTransitionActionUpdate(update);
+  if (update !== void 0) return rebaseTransitionActionUpdate(update);
+  if (slot.renderTransition !== void 0) return slot.renderTransition.value;
+  const held = block === void 0 ? void 0 : TRANSITION_SWAP_DRIVER?.heldUpdate(slot, block);
+  return held === void 0 ? slot.value : held.value;
 }
 function stageTransitionValue(slot, block, operation, value, forceRender = false) {
   const batch = transitionActionBatchForUpdate();
-  if (batch === null) return false;
+  if (batch === null) return null;
   const replay = typeof operation === "function" ? operation : () => operation;
-  const current = batch.updates.get(slot);
+  let current = batch.updates.get(slot);
   if (current === void 0) {
-    batch.updates.set(slot, {
+    current = {
+      batch,
       slot,
       block,
       operations: [replay],
       baseValue: slot.value,
       value,
       forceRender
-    });
+    };
+    batch.updates.set(slot, current);
   } else {
     current.operations.push(replay);
     current.value = value;
@@ -563,23 +594,36 @@ function stageTransitionValue(slot, block, operation, value, forceRender = false
   }
   slot.pendingActionBatch = batch;
   slot.pendingActionValue = value;
-  return true;
+  return current;
 }
 function flushTransitionActionBatch(batch) {
   if (batch.flushed) return;
   batch.flushed = true;
   for (const update of batch.updates.values()) {
     const { slot, block, forceRender } = update;
-    const value = rebaseTransitionActionUpdate(update);
+    const value = update.state === void 0 && update.reducer === void 0 ? rebaseTransitionActionUpdate(update) : update.value;
     if (slot.pendingActionBatch === batch) {
       slot.pendingActionBatch = void 0;
       slot.pendingActionValue = void 0;
     }
     if (block.disposed) continue;
+    const state = update.state;
+    const reducer = update.reducer;
+    const previous = state?.renderTransition ?? reducer?.renderTransition;
+    if (state !== void 0 || reducer !== void 0) {
+      update.baseValue = previous === void 0 ? slot.value : previous.baseValue;
+      if (state !== void 0) {
+        state.updates = void 0;
+      } else if (reducer !== void 0) {
+        reducer.renderPhaseActions = void 0;
+      }
+    }
     const changed = !Object.is(slot.value, value);
-    if (!changed && !forceRender) continue;
+    if (!changed && !forceRender && update.previous === void 0) continue;
     if (changed) slot.value = value;
-    if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__)
+    if (update.reducer !== void 0) update.reducer.renderTransition = update;
+    if (update.state !== void 0) update.state.renderTransition = update;
+    if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__ && (changed || update.profileType !== "state"))
       __profileSchedule(
         block,
         update.profileType ?? (forceRender ? "reducer" : "state"),
@@ -605,6 +649,74 @@ function flushTransitionActionBatchIfReady(batch) {
 let DEFERRED_SPAWN = false;
 let TRANSITION_PENDING_COUNT = 0;
 const TRANSITION_LISTENERS = /* @__PURE__ */ new Set();
+let TRANSITION_HOOK_HOLDERS = null;
+function addTransitionHookToBatch(batch, hook) {
+  if (batch.hook === null) batch.hook = hook;
+  else if (batch.hook !== hook) {
+    const hooks = batch.hooks;
+    if (hooks === null) batch.hooks = [hook];
+    else if (hooks.includes(hook)) return;
+    else hooks.push(hook);
+  } else return;
+  if (batch.hooksPending) {
+    hook.pendingBatches++;
+    hook.publish(true);
+  }
+}
+function publishTransitionHookBatch(batch) {
+  const hook = batch.hook;
+  if (hook === null || batch.hooksPending) return;
+  batch.hooksPending = true;
+  hook.pendingBatches++;
+  hook.publish(true);
+  const hooks = batch.hooks;
+  if (hooks !== null) {
+    for (let i = 0; i < hooks.length; i++) {
+      hooks[i].pendingBatches++;
+      hooks[i].publish(true);
+    }
+  }
+}
+function finishTransitionHookBatch(batch) {
+  if (!batch.workComplete || batch.pendingActions !== 0 || (batch.pendingHolds ?? 0) !== 0) return;
+  if (!batch.hooksPending) return;
+  batch.hooksPending = false;
+  const hook = batch.hook;
+  if (--hook.pendingBatches === 0) hook.publish(false);
+  const hooks = batch.hooks;
+  if (hooks !== null) {
+    for (let i = 0; i < hooks.length; i++) {
+      if (--hooks[i].pendingBatches === 0) hooks[i].publish(false);
+    }
+  }
+}
+function holdTransitionHookBatch(holder, batch) {
+  if (batch.hook === null) return;
+  const holders = TRANSITION_HOOK_HOLDERS ??= /* @__PURE__ */ new WeakMap();
+  let batches = holders.get(holder);
+  if (batches === void 0) holders.set(holder, batches = /* @__PURE__ */ new Set());
+  if (batches.has(batch)) return;
+  batches.add(batch);
+  batch.pendingHolds = (batch.pendingHolds ?? 0) + 1;
+  publishTransitionHookBatch(batch);
+}
+function releaseTransitionHookHolder(holder) {
+  const batches = TRANSITION_HOOK_HOLDERS?.get(holder);
+  if (batches === void 0) return;
+  TRANSITION_HOOK_HOLDERS.delete(holder);
+  for (const batch of batches) {
+    batch.pendingHolds--;
+    finishTransitionHookBatch(batch);
+  }
+}
+function holdTransitionHooksForBlock(holder, block) {
+  for (const entries of FLUSHED_TRANSITION_UPDATES) {
+    for (const entry of entries) {
+      if (entry.batch !== void 0 && blockIsAncestor(entry.block, block))
+        holdTransitionHookBatch(holder, entry.batch);
+    }
+  }
+}
 let TRANSITION_LISTENER_PUBLISH_DEPTH = 0;
 const HELD_TRANSITIONS = /* @__PURE__ */ new Set();
 const STAGED_REVEALS = /* @__PURE__ */ new Set();
@@ -613,6 +725,111 @@ let deferringStagedRevealEffects = false;
 let ACTIVE_TRANSITION_ATTEMPT = null;
 let FLUSHED_TRANSITION_UPDATES = [];
 let HELD_SYNC_TRANSITION = null;
+function urgentTransitionCellUpdate(block) {
+  return TRANSITION_DEPTH === 0 && !(CURRENT_BLOCK === block && block.currentRenderMode === "transition") && (syncFlush || _dispatchDepth > 0 || ASYNC_TRANSITION_COUNT === 0);
+}
+function latestHeldTransitionUpdate(entry) {
+  while (entry.next?.batch?.flushed === true && !entry.next.superseded) entry = entry.next;
+  return entry;
+}
+function findHeldTransitionUpdate(slot, block) {
+  if (!urgentTransitionCellUpdate(block)) return;
+  return getHeldTransitionUpdate(slot, block);
+}
+function getHeldTransitionUpdate(slot, block) {
+  if (block.disposed) return;
+  const rootHeld = block.idState.renderOwner?.transition;
+  if (HELD_SYNC_TRANSITION === null && rootHeld === void 0 && FLUSHED_TRANSITION_UPDATES.length === 0)
+    return;
+  const groups = [HELD_SYNC_TRANSITION?.entries, rootHeld?.entries];
+  for (const entries of groups) {
+    if (entries === void 0) continue;
+    for (let i = entries.length - 1; i >= 0; i--) {
+      const entry = entries[i];
+      if (entry.slot === slot && !entry.superseded && Object.is(slot.value, entry.baseValue))
+        return latestHeldTransitionUpdate(entry);
+    }
+  }
+  for (let i = FLUSHED_TRANSITION_UPDATES.length - 1; i >= 0; i--) {
+    const entries = FLUSHED_TRANSITION_UPDATES[i];
+    for (let j = entries.length - 1; j >= 0; j--) {
+      const entry = entries[j];
+      if (entry.slot === slot && !entry.superseded && Object.is(slot.value, entry.baseValue) && // A completed hook render clears this pointer before the flush's
+      // retained-entry list is released. Returning to an old base value
+      // must not turn that completed update into pending work again.
+      (entry.state === void 0 && entry.reducer === void 0 || slot.renderTransition !== void 0))
+        return latestHeldTransitionUpdate(entry);
+    }
+  }
+}
+function hasHeldTransitionUpdate(slot, block) {
+  return findHeldTransitionUpdate(slot, block) !== void 0;
+}
+function cancelHeldTransitionUpdate(slot, block) {
+  if (!urgentTransitionCellUpdate(block)) return false;
+  const rootHeld = block.idState.renderOwner?.transition;
+  if (HELD_SYNC_TRANSITION === null && rootHeld === void 0 && FLUSHED_TRANSITION_UPDATES.length === 0)
+    return false;
+  let cancelled = false;
+  const cancel = (entries) => {
+    if (entries === void 0) return;
+    for (const entry of entries) {
+      if (entry.slot === slot && !entry.superseded) {
+        entry.superseded = true;
+        cancelled = true;
+      }
+    }
+  };
+  cancel(HELD_SYNC_TRANSITION?.entries);
+  cancel(rootHeld?.entries);
+  for (const entries of FLUSHED_TRANSITION_UPDATES) cancel(entries);
+  return cancelled;
+}
+function rebaseHeldTransitionUpdate(slot, block, actions, reducer) {
+  const entry = findHeldTransitionUpdate(slot, block);
+  if (entry === void 0) return;
+  if (slot.pendingActionBatch?.flushed === false) return;
+  let value = entry.value;
+  for (const action of actions) {
+    value = reducer ? reducer(value, action) : typeof action === "function" ? action(value) : action;
+  }
+  if (Object.is(value, entry.baseValue)) {
+    cancelHeldTransitionUpdate(slot, block);
+    return;
+  }
+  const changed = !Object.is(value, entry.value);
+  for (let current = entry; current; current = current.previous)
+    current.value = value;
+  for (const action of actions) {
+    entry.operations.push(
+      reducer ? (previous) => reducer(previous, action) : typeof action === "function" ? action : () => action
+    );
+  }
+  if (changed) scheduleHeldTransitionReplay(entry, block);
+}
+function scheduleHeldTransitionReplay(entry, block) {
+  const held = HELD_SYNC_TRANSITION;
+  if (held !== null && held.entries.includes(entry)) {
+    if (held.replayScheduled) return;
+    held.replayScheduled = true;
+    queueMicrotask(() => {
+      if (HELD_SYNC_TRANSITION !== held) return;
+      held.replayScheduled = false;
+      promoteHeldSyncTransition();
+    });
+    return;
+  }
+  const owner = block.idState.renderOwner;
+  const rootHeld = owner?.transition;
+  if (rootHeld === void 0 || !rootHeld.entries.includes(entry) || rootHeld.replayScheduled)
+    return;
+  rootHeld.replayScheduled = true;
+  queueMicrotask(() => {
+    if (owner.transition !== rootHeld) return;
+    rootHeld.replayScheduled = false;
+    retryRootTransition(owner);
+  });
+}
 let PROMOTED_MEMO_SWAPS = null;
 let PROMOTED_WARM_HARVEST = null;
 function takeSingleOriginTransitionUpdates(origin) {
@@ -776,18 +993,24 @@ function heldSyncCellsIntact(state) {
   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;
+    if (entry.superseded || !Object.is(entry.slot.value, entry.baseValue)) return false;
   }
   return true;
 }
+function heldTransitionHasPendingAction(entries) {
+  for (const entry of entries) {
+    if (!entry.superseded && entry.slot.pendingActionBatch?.flushed === false) return true;
+  }
+  return false;
+}
 function promoteHeldSyncTransition() {
   const held = HELD_SYNC_TRANSITION;
-  if (held === null) return false;
+  if (held === null || heldTransitionHasPendingAction(held.entries)) return false;
   HELD_SYNC_TRANSITION = null;
   const promoted = [];
   for (let i = 0; i < held.entries.length; i++) {
     const entry = held.entries[i];
-    if (!Object.is(entry.slot.value, entry.baseValue)) continue;
+    if (entry.superseded || !Object.is(entry.slot.value, entry.baseValue)) continue;
     entry.slot.value = entry.value;
     if (!entry.block.disposed) promoted.push(entry);
   }
@@ -823,7 +1046,7 @@ function discardHeldSyncTransition(state) {
 function rootTransitionCellsIntact(held) {
   for (let i = 0; i < held.entries.length; i++) {
     const entry = held.entries[i];
-    if (!Object.is(entry.slot.value, entry.baseValue)) return false;
+    if (entry.superseded || !Object.is(entry.slot.value, entry.baseValue)) return false;
   }
   return true;
 }
@@ -870,6 +1093,9 @@ function holdRootTransition(owner, transaction, attempt) {
     promoted: false,
     cue: !continuing
   };
+  for (const entry of entries) {
+    if (entry.batch !== void 0) holdTransitionHookBatch(owner, entry.batch);
+  }
   if (previous === void 0 || previous.promoted) tickTransitionCount(1);
   return true;
 }
@@ -880,6 +1106,7 @@ function retryRootTransition(owner) {
     discardRootTransition(owner);
     return false;
   }
+  if (heldTransitionHasPendingAction(held.entries)) return true;
   held.promoted = true;
   held.cue = false;
   if (held.memoSwaps !== null) {
@@ -889,6 +1116,7 @@ function retryRootTransition(owner) {
   TRANSITION_DEPTH++;
   try {
     tickTransitionCount(-1);
+    releaseTransitionHookHolder(owner);
     for (let i = 0; i < held.entries.length; i++) {
       const entry = held.entries[i];
       entry.slot.value = entry.value;
@@ -924,6 +1152,7 @@ function discardRootTransition(owner) {
   owner.wakeable = null;
   owner.generation++;
   if (!held.promoted) tickTransitionCount(-1);
+  releaseTransitionHookHolder(owner);
 }
 const JOURNAL_TEXT = 0;
 const JOURNAL_ATTR = 1;
@@ -1877,9 +2106,27 @@ let actScopeDepth = 0;
 function setIsOctaneActEnvironment(value) {
   IS_OCTANE_ACT_ENVIRONMENT = value;
 }
+function isActEnvironment() {
+  return IS_OCTANE_ACT_ENVIRONMENT || globalThis.IS_REACT_ACT_ENVIRONMENT === true;
+}
 const NESTED_UPDATE_LIMIT = 50;
 const ACT_DRAIN_LIMIT = NESTED_UPDATE_LIMIT + 50;
 let UPDATE_CHAIN_ID = 0;
+let PASSIVE_UPDATE_COUNTS = null;
+function countPassiveUpdate(block) {
+  if (process.env.NODE_ENV === "production") return;
+  const counts = PASSIVE_UPDATE_COUNTS ??= /* @__PURE__ */ new WeakMap();
+  let state = counts.get(block);
+  if (state === void 0 || state.chain !== UPDATE_CHAIN_ID) {
+    state = { chain: UPDATE_CHAIN_ID, count: 0 };
+    counts.set(block, state);
+  }
+  if (++state.count === NESTED_UPDATE_LIMIT + 1) {
+    console.error(
+      "Maximum update depth exceeded. Check the dependencies of effects that schedule state updates."
+    );
+  }
+}
 function inNestedUpdateCallback() {
   return EFFECT_BODY_DEPTH > 0 || REF_CALLBACK_DEPTH > 0 || STORE_SYNC_DEPTH > 0;
 }
@@ -1909,9 +2156,23 @@ function warnCrossComponentRenderUpdate(target, source) {
 }
 function scheduleRender(block) {
   if (block.disposed) return;
-  if (process.env.NODE_ENV !== "production" && IS_OCTANE_ACT_ENVIRONMENT && actScopeDepth === 0 && !syncFlush) {
+  if (process.env.NODE_ENV !== "production" && CURRENT_EFFECT_PHASE === INSERTION) {
+    console.error(
+      "useInsertionEffect must not schedule state updates. Move this work to a layout or passive effect."
+    );
+  }
+  if (process.env.NODE_ENV !== "production" && isActEnvironment() && actScopeDepth === 0 && !syncFlush) {
     console.error(
-      "An update to a component was not wrapped in act(...).\n\nWhen testing, code that causes state updates should be wrapped into act(...):\n\n  act(() => {\n    /* fire events that update state */\n  });\n  /* assert on the output */\n\nThis ensures you're testing the behavior the user would see in the browser."
+      `An update to ${componentName(block)} was not wrapped in act(...).
+
+When testing, code that causes state updates should be wrapped into act(...):
+
+  act(() => {
+    /* fire events that update state */
+  });
+  /* assert on the output */
+
+This ensures you're testing the behavior the user would see in the browser.`
     );
   }
   const renderPhaseSelf = CURRENT_BLOCK === block;
@@ -1929,7 +2190,9 @@ function scheduleRender(block) {
     }
     return;
   }
-  if (inNestedUpdateCallback()) {
+  if (CURRENT_EFFECT_PHASE === PASSIVE && !syncFlush) {
+    countPassiveUpdate(block);
+  } else if (inNestedUpdateCallback()) {
     if (block.nestedUpdateChain !== UPDATE_CHAIN_ID) {
       block.nestedUpdateChain = UPDATE_CHAIN_ID;
       block.nestedUpdateCount = 0;
@@ -1971,14 +2234,19 @@ function drainHydrationRenderPhaseUpdates(root) {
         QUEUE[write++] = block;
         continue;
       }
-      if (!block.pending || block.disposed) continue;
-      const seen = (renders ??= /* @__PURE__ */ new Map()).get(block) ?? 0;
-      if (seen >= RENDER_PHASE_UPDATE_LIMIT) {
-        throw new Error(formatClientError(9));
-      }
-      renders.set(block, seen + 1);
-      block.crossRenderUpdate = false;
+      if (!block.pending && !block.nestedUpdateError || block.disposed) continue;
       try {
+        if (block.nestedUpdateError) {
+          block.nestedUpdateError = false;
+          throw maximumUpdateDepthError();
+        }
+        const seen = (renders ??= /* @__PURE__ */ new Map()).get(block) ?? 0;
+        const crossRenderUpdate = block.crossRenderUpdate;
+        if (seen >= (crossRenderUpdate ? NESTED_UPDATE_LIMIT : RENDER_PHASE_UPDATE_LIMIT)) {
+          throw crossRenderUpdate ? maximumUpdateDepthError() : new Error(formatClientError(9));
+        }
+        renders.set(block, seen + 1);
+        block.crossRenderUpdate = false;
         renderBlock(block);
       } catch (error) {
         handleRenderError(block, error);
@@ -2026,12 +2294,21 @@ let SCHEDULED_VISIBILITY_DRIVER = null;
 function ensureScheduledVisibilityDriver() {
   SCHEDULED_VISIBILITY_DRIVER ??= {
     find: findScheduledVisibilityOwner,
+    holdsNativeRead,
     reveal: attemptHiddenReveal,
     visible: renderVisibleTry,
     rehide: rehideActivityAfterDescendantRender,
     retryActivity: renderHiddenActivity
   };
 }
+function holdsNativeRead(block) {
+  for (const state of HELD_TRANSITIONS) {
+    const primary = state.tryBlock;
+    if (state.transitionHeld && state.hiddenDom === null && primary !== null && (primary === block || blockIsAncestorOf(primary, block) || blockIsAncestorOf(block, primary)))
+      return true;
+  }
+  return false;
+}
 function drainQueue() {
   let pendingError = null;
   let activitiesToRehide = null;
@@ -2075,7 +2352,7 @@ function drainQueue() {
         throw maximumUpdateDepthError();
       }
       if (block.drainStamp === drainId) {
-        if (++block.drainRenders > RENDER_PHASE_UPDATE_LIMIT) {
+        if (++block.drainRenders > (crossRenderUpdate ? NESTED_UPDATE_LIMIT : RENDER_PHASE_UPDATE_LIMIT)) {
           throw crossRenderUpdate ? maximumUpdateDepthError() : new Error(formatClientError(9));
         }
       } else {
@@ -2655,6 +2932,11 @@ function drainPassivesBeforeRender() {
   if (effectQueues[PASSIVE].length > 0 || pendingPassiveUnmounts.length > 0) drainPassiveEffects();
 }
 function flushSync(fn) {
+  if (process.env.NODE_ENV !== "production" && (CURRENT_BLOCK !== null || EFFECT_BODY_DEPTH > 0 || REF_CALLBACK_DEPTH > 0)) {
+    console.error(
+      "flushSync was called while rendering or running a lifecycle callback. Move the call to an event or scheduled task."
+    );
+  }
   if (inFlush) return runNativeBatch(fn);
   VIEW_TRANSITION_DRIVER?.interrupt();
   const prevSync = syncFlush;
@@ -2867,6 +3149,7 @@ function commitEffects() {
     return;
   }
   const nativeFrame = NATIVE_READ_DRIVER?.pauseLifecycle() ?? -1;
+  EFFECT_COMMIT_DEPTH++;
   try {
     drainEffectEventUpdates();
     const caughtReports = drainEffectEventCommitActions();
@@ -2884,6 +3167,7 @@ function commitEffects() {
     }
   } finally {
     if (nativeFrame >= 0) NATIVE_READ_DRIVER.resumeLifecycle(nativeFrame);
+    finishEffectCommit();
   }
 }
 function schedulePassiveFlush() {
@@ -2988,15 +3272,25 @@ function compareEffectPostOrder(a, b) {
   if (a.scope === b.scope) return a.order - b.order || a.seq - b.seq;
   return comparePostOrder(a.scope.block, a.seq, b.scope.block, b.seq);
 }
-function reportEffectError(block, error) {
-  const handler = findTryHandler(block);
+function finishEffectCommit() {
+  if (--EFFECT_COMMIT_DEPTH !== 0 || COMMIT_PHASE_ERRORS === null) return;
+  const errors = COMMIT_PHASE_ERRORS;
+  COMMIT_PHASE_ERRORS = null;
+  for (const { block, error, handler } of errors) reportEffectError(block, error, handler);
+}
+function reportEffectError(block, error, capturedHandler) {
+  if (EFFECT_COMMIT_DEPTH > 0) {
+    (COMMIT_PHASE_ERRORS ??= []).push({ block, error, handler: capturedHandler });
+    return;
+  }
+  const handler = capturedHandler === void 0 ? findTryHandler(block) : capturedHandler;
   if (handler !== null) {
     reportCaughtError(block, error, handler(error));
     return;
   }
   let root = block;
-  while (root.parentBlock !== null) root = root.parentBlock;
-  if (root.kind === "root" && !root.disposed) {
+  while (root !== null && root.parentBlock !== null) root = root.parentBlock;
+  if (root !== null && root.kind === "root" && !root.disposed) {
     unmountBlock(root);
     drainRefDetaches();
   }
@@ -3016,7 +3310,7 @@ function fireEffectCleanup(e) {
   if (cleanup) {
     slot.cleanup = void 0;
     try {
-      runEffectCleanupCallback(cleanup);
+      runEffectCleanupCallback(cleanup, e.phase);
     } catch (err) {
       if (err instanceof MaximumUpdateDepthError) throw err;
       reportEffectError(e.scope.block, err);
@@ -3033,17 +3327,27 @@ function runEffectBody(e) {
   slot.connectedArgs = e.args;
   slot.disconnected = false;
   try {
+    const previousPhase = CURRENT_EFFECT_PHASE;
+    CURRENT_EFFECT_PHASE = e.phase;
     EFFECT_BODY_DEPTH++;
     try {
       cleanup = e.fn.apply(null, e.args ?? []);
     } finally {
       EFFECT_BODY_DEPTH--;
+      CURRENT_EFFECT_PHASE = previousPhase;
     }
   } catch (err) {
     if (err instanceof MaximumUpdateDepthError) throw err;
     reportEffectError(e.scope.block, err);
     return;
   }
+  if (process.env.NODE_ENV !== "production" && cleanup !== void 0 && typeof cleanup !== "function") {
+    const name = e.phase === PASSIVE ? "useEffect" : e.phase === LAYOUT ? "useLayoutEffect" : "useInsertionEffect";
+    const thenable = cleanup !== null && typeof cleanup.then === "function";
+    console.error(
+      name + " must return a cleanup function or nothing." + (thenable ? " Start asynchronous work inside the effect and return its cleanup separately." : "")
+    );
+  }
   if (typeof cleanup === "function") {
     slot.cleanup = cleanup;
   }
@@ -3093,20 +3397,25 @@ function runLayoutEffects(q) {
   }
 }
 function drainPassivePhase() {
-  drainDeferredPassiveUnmounts();
-  const pending = effectQueues[PASSIVE];
-  if (pending.length === 0) return;
-  const q = pending.splice(0);
-  q.sort(compareEffectPostOrder);
-  for (let i = 0; i < q.length; i++) {
-    const e = q[i];
-    if (e.scope.block.disposed || e.fn !== null && inInactiveSubtree(e.scope.block)) continue;
-    fireEffectCleanup(e);
-  }
-  for (let i = 0; i < q.length; i++) {
-    const e = q[i];
-    if (e.scope.block.disposed || inInactiveSubtree(e.scope.block)) continue;
-    runEffectBody(e);
+  EFFECT_COMMIT_DEPTH++;
+  try {
+    drainDeferredPassiveUnmounts();
+    const pending = effectQueues[PASSIVE];
+    if (pending.length === 0) return;
+    const q = pending.splice(0);
+    q.sort(compareEffectPostOrder);
+    for (let i = 0; i < q.length; i++) {
+      const e = q[i];
+      if (e.scope.block.disposed || e.fn !== null && inInactiveSubtree(e.scope.block)) continue;
+      fireEffectCleanup(e);
+    }
+    for (let i = 0; i < q.length; i++) {
+      const e = q[i];
+      if (e.scope.block.disposed || inInactiveSubtree(e.scope.block)) continue;
+      runEffectBody(e);
+    }
+  } finally {
+    finishEffectCommit();
   }
 }
 function drainEffectEventCommitActions() {
@@ -3129,14 +3438,12 @@ function drainDeferredPassiveUnmounts() {
   const q = pendingPassiveUnmounts.splice(0);
   for (let i = 0; i < q.length; i += 3) {
     try {
-      runEffectCleanupCallback(q[i]);
+      runEffectCleanupCallback(q[i], PASSIVE);
     } catch (err) {
       if (err instanceof MaximumUpdateDepthError) throw err;
       const handler = q[i + 1];
       const owner = q[i + 2];
-      if (handler !== null) {
-        reportCaughtError(owner, err, handler(err));
-      } else if (!reportUncaughtError(owner, err)) console.error(err);
+      reportEffectError(owner, err, handler);
     }
   }
 }
@@ -3400,10 +3707,17 @@ function createBlock(kind, parentBlock, parentNode, startMarker, endMarker, body
 function renderBlock(block) {
   const hydration = activeHydration();
   if (hydration !== null && !hydration.owns(block)) {
-    hydration.suspend(() => renderBlockInner(block));
+    hydration.suspend(() => renderBlock(block));
     return;
   }
-  renderBlockInner(block);
+  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));
+  }
 }
 function enqueueEffectEventUpdate(entry) {
   EFFECT_EVENT_RENDER_TARGET.push(entry);
@@ -3428,6 +3742,45 @@ function recordCapturedRender(capture, block) {
     (capture.renderedBlocks ??= /* @__PURE__ */ new Set()).add(block);
   }
 }
+function beginUrgentTransitionRender(block, render) {
+  const slots = /* @__PURE__ */ new Map();
+  for (const entries of FLUSHED_TRANSITION_UPDATES) {
+    for (const update of entries) {
+      if (update.block !== block || update.superseded) continue;
+      const previous = slots.get(update.slot);
+      if (previous !== void 0) {
+        render.cells[previous].update = update;
+      } else {
+        slots.set(update.slot, render.cells.length);
+        render.cells.push({
+          update,
+          baseValue: update.baseValue,
+          value: update.slot.value,
+          hook: void 0
+        });
+      }
+    }
+  }
+  for (const cell of render.cells) {
+    cell.hook = beginUrgentTransitionCell(cell.update);
+    if (cell.hook === null) cell.update.slot.value = cell.baseValue;
+  }
+}
+function endUrgentTransitionRender(block, render) {
+  for (let i = render.cells.length - 1; i >= 0; i--) {
+    const cell = render.cells[i];
+    if (cell.hook === void 0) continue;
+    if (cell.hook !== null) endUrgentTransitionCell(cell.hook);
+    else if (!block.disposed && !cell.update.superseded && Object.is(cell.update.slot.value, cell.baseValue))
+      cell.update.slot.value = cell.value;
+  }
+  if (block.disposed || block.pending && block.pendingMode === "urgent") return;
+  if (render.cells.length !== 0 && render.cells.every((cell) => cell.update.superseded)) return;
+  block.pending = true;
+  block.pendingMode = "transition";
+  block.pendingDeferred = render.pendingDeferred;
+  if (render.queueEpoch !== QUEUE_REINDEX_EPOCH && !QUEUE.includes(block)) QUEUE.push(block);
+}
 function renderBlockInner(block) {
   if (block.renderStatus === RENDER_INVALID) block.renderStatus = RENDER_RETRYING;
   if (WIP_CAPTURE !== null) recordCapturedRender(WIP_CAPTURE, block);
@@ -3451,6 +3804,8 @@ function renderBlockInner(block) {
   CURRENT_EFFECT_RENDER_VERSION = block.effectSlots === null ? 0 : NEXT_EFFECT_RENDER_VERSION++;
   CURRENT_EFFECT_REACHED = 0;
   const continuesParentTree = prevBlock !== null && blockIsAncestor(prevBlock, block);
+  const urgentTransitionDriver = block.pending && block.pendingMode === "transition" && continuesParentTree && prevBlock.currentRenderMode === "urgent" ? TRANSITION_SWAP_DRIVER : null;
+  const urgentTransitionRender = urgentTransitionDriver === null ? null : { pendingDeferred: block.pendingDeferred, queueEpoch: QUEUE_REINDEX_EPOCH, cells: [] };
   if (!continuesParentTree) {
     const replayEpisode = prevBlock === null && RESUME_REPLAY ? block.__warmEpisode : void 0;
     CURRENT_WARM_EPISODE = typeof replayEpisode === "number" ? replayEpisode : NEXT_WARM_EPISODE++;
@@ -3462,6 +3817,7 @@ function renderBlockInner(block) {
   EFFECT_EVENT_ACTION_TARGET = effectEventActionTarget;
   if (block.effectEventRenderVersion !== 0) block.effectEventRenderVersion++;
   block.pending = false;
+  block.crossRenderUpdate = false;
   block.__thenableIdx = 0;
   {
     const tState = block.__thenables;
@@ -3472,22 +3828,29 @@ function renderBlockInner(block) {
   }
   if (block.$$ctxReads !== null) block.$$ctxReads.clear();
   if (block.$$ctxDirect !== null) block.$$ctxDirect.clear();
-  block.currentRenderMode = block.pendingMode ?? prevBlock?.currentRenderMode ?? "urgent";
-  block.currentRenderDeferred = block.pendingMode !== null ? block.pendingDeferred : prevBlock?.currentRenderDeferred ?? false;
+  block.currentRenderMode = urgentTransitionRender !== null ? "urgent" : block.pendingMode ?? prevBlock?.currentRenderMode ?? "urgent";
+  block.currentRenderDeferred = urgentTransitionRender !== null ? false : block.pendingMode !== null ? block.pendingDeferred : prevBlock?.currentRenderDeferred ?? false;
   block.pendingMode = null;
   block.pendingDeferred = false;
   const profileFrame = typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__ && (block.kind === "root" || block.kind === "dynamic" || block.kind === "portal") ? __profileBeginRender(block, block.body, block.mounted) : null;
   let profileDidThrow = false;
   let profileThrown;
   let renderCompleted = false;
+  let renderRetry = false;
   NATIVE_READ_DRIVER?.beginRender(block);
   NATIVE_BLOCK_RETRIES?.get(block)?.clear();
   try {
+    if (urgentTransitionRender !== null)
+      urgentTransitionDriver.beginUrgent(block, urgentTransitionRender);
     const out = block.body(
       block.props,
       block,
       block.extra
     );
+    if (block.pending && !block.crossRenderUpdate) {
+      renderRetry = true;
+      return true;
+    }
     if (out !== void 0 && block.outputHandler !== null) block.outputHandler(block, out);
     finishEffectRender(block);
     if (!block.mounted) block.mounted = true;
@@ -3513,6 +3876,7 @@ function renderBlockInner(block) {
     if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__ && profileFrame !== null)
       __profileEndRender(profileFrame, profileDidThrow, profileThrown);
     if (!renderCompleted) {
+      if (renderRetry) block.renderStatus = RENDER_INVALID;
       if (block.renderStatus !== RENDER_INVALID) {
         let owner = null;
         const suspension = isSuspenseException(profileThrown);
@@ -3538,7 +3902,12 @@ function renderBlockInner(block) {
     CURRENT_EFFECT_REACHED = prevEffectReached;
     CURRENT_SCOPE = prevScope;
     CURRENT_BLOCK = prevBlock;
-    NATIVE_READ_DRIVER?.endRender(block, renderCompleted, isSuspenseException(profileThrown));
+    try {
+      NATIVE_READ_DRIVER?.endRender(block, renderCompleted, isSuspenseException(profileThrown));
+    } finally {
+      if (urgentTransitionRender !== null)
+        urgentTransitionDriver.endUrgent(block, urgentTransitionRender);
+    }
   }
 }
 function returnSlotTail(block, state) {
@@ -3745,6 +4114,7 @@ class LiteBlockImpl {
   }
 }
 function componentSlotLite(parentScope, slotKey, host, comp, props, anchor) {
+  if (CURRENT_BLOCK?.pending && !CURRENT_BLOCK.crossRenderUpdate) return;
   const hydration = activeHydration();
   let scope = parentScope.slots[slotKey];
   let adoptedOpen = null;
@@ -3908,7 +4278,7 @@ function unmountScope(scope, detachDom = true) {
         if (!passiveScheduled) schedulePassiveFlush();
       } else {
         try {
-          runEffectCleanupCallback(cleanup);
+          runEffectCleanupCallback(cleanup, slot.phase);
         } catch (err) {
           reportTeardownError(err);
         }
@@ -3983,12 +4353,66 @@ function missingSlot(name) {
   throw new Error(formatClientError(15, name));
 }
 const slotStack = [];
+let MANUAL_HOOK_DRIVER = null;
+function invokeManualHook(fn, receiver, args) {
+  const driver = MANUAL_HOOK_DRIVER ??= {
+    pending: slotStack[slotStack.length - 1],
+    active: false
+  };
+  const pending = driver.pending;
+  const active = driver.active;
+  driver.pending = void 0;
+  driver.active = true;
+  try {
+    if (pending === void 0) return Reflect.apply(fn, receiver, args);
+    switch (args.length) {
+      case 0:
+        return fn.call(receiver, pending);
+      case 1:
+        return fn.call(receiver, args[0], pending);
+      case 2:
+        return fn.call(receiver, args[0], args[1], pending);
+      case 3:
+        return fn.call(receiver, args[0], args[1], args[2], pending);
+      case 4:
+        return fn.call(receiver, args[0], args[1], args[2], args[3], pending);
+      default: {
+        const forwarded = new Array(args.length + 1);
+        for (let index = 0; index < args.length; index++) forwarded[index] = args[index];
+        forwarded[args.length] = pending;
+        return fn.apply(receiver, forwarded);
+      }
+    }
+  } finally {
+    driver.pending = pending;
+    driver.active = active;
+  }
+}
+function manualHook(fn, name) {
+  function provider() {
+    return invokeManualHook(fn, this, arguments);
+  }
+  Object.defineProperty(provider, "name", { value: name ?? fn.name, configurable: true });
+  Object.defineProperty(provider, "length", { value: fn.length, configurable: true });
+  return provider;
+}
 function withSlot(sym, fn, ...args) {
+  const driver = MANUAL_HOOK_DRIVER;
+  const pending = driver?.pending;
+  const active = driver?.active ?? false;
+  if (driver !== null) {
+    driver.pending = sym;
+    driver.active = false;
+  }
   slotStack.push(sym);
   try {
     return fn(...args);
   } finally {
     slotStack.pop();
+    if (MANUAL_HOOK_DRIVER !== null) {
+      MANUAL_HOOK_DRIVER.pending = driver === null ? slotStack[slotStack.length - 1] : pending;
+      MANUAL_HOOK_DRIVER.active = active;
+    }
   }
 }
 function appendSlotKey(key, slot) {
@@ -4019,7 +4443,7 @@ function nativeLocalHook(name, initialize, dispose, slot) {
   return cell.nativeValue;
 }
 function useState(initial, slot) {
-  if (slot === void 0 && typeof initial === "symbol") {
+  if (slot === void 0 && typeof initial === "symbol" && arguments.length === 1 && (slotStack.length === 0 || MANUAL_HOOK_DRIVER?.active === true)) {
     slot = initial;
     initial = void 0;
   }
@@ -4033,16 +4457,44 @@ function useState(initial, slot) {
     s = {
       value: initVal,
       setter: (next) => {
-        const previous = stagedTransitionValue(s);
-        const computed = typeof next === "function" ? next(previous) : next;
-        if (Object.is(computed, previous)) return;
-        if (stageTransitionValue(s, block, next, computed)) {
+        if (block.disposed) return;
+        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) {
+          (s.updates ??= []).push(next);
+          scheduleRender(block);
+          return;
+        }
+        const previous = stagedTransitionValue(s, block);
+        let computed;
+        let failed = false;
+        try {
+          computed = typeof next === "function" ? next(previous) : next;
+        } catch {
+          if (transitionActionBatchForUpdate() === null) {
+            (s.updates ??= []).push(next);
+            scheduleRender(block);
+            return;
+          }
+          computed = previous;
+          failed = true;
+        }
+        const forceRender = failed || s.updates !== void 0 || s.renderTransition !== void 0 || s.pendingActionBatch !== void 0 || block.pending && typeof next === "function";
+        if (Object.is(computed, previous) && !forceRender) {
+          if (typeof next !== "function" && TRANSITION_SWAP_DRIVER?.cancelEqual(s, block)) {
+            scheduleRender(block);
+          }
+          return;
+        }
+        const update = stageTransitionValue(s, block, next, computed, forceRender);
+        if (update !== null) {
+          if (update.state === void 0) {
+            update.state = s;
+            captureTransitionHookQueue(update, s);
+          }
           if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__) {
-            const update = s.pendingActionBatch?.updates.get(s);
-            if (update !== void 0) {
-              update.profileType = "state";
-              update.profileSlot = slot;
-            }
+            update.profileType = "state";
+            update.profileSlot = slot;
           }
           return;
         }
@@ -4054,10 +4506,95 @@ function useState(initial, slot) {
     };
     ensureHooks(scope).set(slot, s);
   }
+  if (s.renderTransition !== void 0 || s.updates !== void 0) {
+    const value = readQueuedState(s);
+    if (!s.urgentTransition && s.updates !== void 0 && Object.is(value, s.value))
+      TRANSITION_SWAP_DRIVER?.rebaseHeld(s, block, s.updates);
+    s.value = value;
+    if (!s.urgentTransition) {
+      if (s.renderTransition !== void 0) {
+        finishQueuedTransition(s.renderTransition, s.value);
+        s.renderTransition = void 0;
+      }
+      s.updates = void 0;
+    }
+  }
   return [s.value, s.setter];
 }
+function readQueuedState(state) {
+  const transition = state.renderTransition;
+  let value = transition === void 0 ? state.value : readQueuedTransition(transition, state.urgentTransition === true);
+  if (state.updates !== void 0) {
+    for (const update of state.updates)
+      value = typeof update === "function" ? update(value) : update;
+  }
+  return value;
+}
+function readQueuedTransition(last, urgent, reducer) {
+  let first = last;
+  while (first.previous !== void 0) first = first.previous;
+  let value = first.replayBaseValue;
+  for (let entry = first; ; entry = entry.next) {
+    if (entry.stateUpdates !== void 0) {
+      for (const update of entry.stateUpdates)
+        value = typeof update === "function" ? update(value) : update;
+    }
+    if (entry.reducerActions !== void 0) {
+      for (const action of entry.reducerActions) value = reducer(value, action);
+    }
+    if ((urgent || entry.superseded) && entry.urgentOperations !== void 0) {
+      for (const index of entry.urgentOperations) value = entry.operations[index](value);
+    } else if (!urgent && !entry.superseded) {
+      for (const operation of entry.operations) value = operation(value);
+    }
+    if (entry === last) return value;
+  }
+}
+function captureTransitionHookQueue(update, cell) {
+  update.replayBaseValue = cell.value;
+  const previous = cell.renderTransition ?? TRANSITION_SWAP_DRIVER?.heldUpdate(cell, update.block);
+  if (previous !== void 0) {
+    update.previous = previous;
+    previous.next = update;
+  }
+  if (update.state !== void 0) update.stateUpdates = update.state.updates?.slice();
+  else update.reducerActions = update.reducer.renderPhaseActions?.slice();
+}
+function recordUrgentActionUpdate(cell, operation) {
+  const update = cell.pendingActionBatch.updates.get(cell);
+  if (update === void 0) return;
+  (update.urgentOperations ??= []).push(update.operations.length);
+  update.operations.push(
+    typeof operation === "function" ? operation : () => operation
+  );
+  update.forceRender = true;
+}
+function finishQueuedTransition(last, value) {
+  for (let entry = last; entry; entry = entry.previous) {
+    entry.value = value;
+    if (entry !== last && Object.is(value, entry.baseValue)) entry.superseded = true;
+  }
+}
+function beginUrgentTransitionCell(update) {
+  const cell = update.state ?? update.reducer;
+  if (update.block.disposed || update.superseded || cell === void 0 || cell.renderTransition === void 0)
+    return null;
+  cell.urgentTransition = true;
+  cell.value = update.baseValue;
+  return { update, cell };
+}
+function endUrgentTransitionCell(snapshot) {
+  const { update, cell } = snapshot;
+  cell.urgentTransition = false;
+  if (update.block.disposed || update.superseded) {
+    cell.renderTransition = void 0;
+    return;
+  }
+  for (let entry = update; entry; entry = entry.previous)
+    entry.baseValue = cell.value;
+}
 function __useStateWithGetter(initial, slot) {
-  if (slot === void 0 && typeof initial === "symbol") {
+  if (slot === void 0 && typeof initial === "symbol" && arguments.length === 1 && (slotStack.length === 0 || MANUAL_HOOK_DRIVER?.active === true)) {
     slot = initial;
     initial = void 0;
   }
@@ -4067,9 +4604,9 @@ function __useStateWithGetter(initial, slot) {
   const s = CURRENT_SCOPE.hooks.get(resolved);
   const getter = s.getter ?? (s.getter = () => {
     const batch = s.pendingActionBatch;
-    if (batch === void 0) return s.value;
+    if (batch === void 0) return readQueuedState(s);
     const update = batch.updates.get(s);
-    return update === void 0 ? s.value : rebaseTransitionActionUpdate(update);
+    return update === void 0 ? readQueuedState(s) : readQueuedTransition(update, false);
   });
   return [pair[0], pair[1], getter];
 }
@@ -4169,13 +4706,11 @@ function useLinkedState(source, reconcile, options, slot) {
           else scheduleRender(block);
           return;
         }
-        if (stageTransitionValue(state, block, operation, computed)) {
+        const update = stageTransitionValue(state, block, operation, computed);
+        if (update !== null) {
           if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__) {
-            const update = state.pendingActionBatch?.updates.get(state);
-            if (update !== void 0) {
-              update.profileType = "state";
-              update.profileSlot = slot;
-            }
+            update.profileType = "state";
+            update.profileSlot = slot;
           }
           return;
         }
@@ -4293,26 +4828,31 @@ function useReducer(reducer, initialArg, initOrSlot, slot) {
       // the component once (children then bail as usual). Per
       // ReactHooksWithNoopRenderer-test.js:3889.
       dispatch: (action) => {
-        if (CURRENT_BLOCK === block) {
+        if (block.disposed) return;
+        if (CURRENT_BLOCK === block || transitionActionBatchForUpdate() === null) {
+          if (s.pendingActionBatch !== void 0 && transitionActionBatchForUpdate() === null)
+            recordUrgentActionUpdate(s, (value) => s.reducer(value, action));
           const actions = s.renderPhaseActions ??= [];
-          const previous2 = actions.length === 0 ? s.value : s.renderPhaseValue;
           actions.push(action);
-          if (s.getter !== void 0) {
-            s.renderPhaseValue = s.reducer(previous2, action);
-          }
           scheduleRender(block);
           return;
         }
-        const previous = stagedTransitionValue(s);
+        const previous = stagedTransitionValue(s, block);
         const operation = (value) => s.reducer(value, action);
-        const computed = operation(previous);
-        if (stageTransitionValue(s, block, operation, computed, true)) {
+        let computed = previous;
+        try {
+          computed = operation(previous);
+        } catch {
+        }
+        const update = stageTransitionValue(s, block, operation, computed, true);
+        if (update !== null) {
+          if (update.reducer === void 0) {
+            update.reducer = s;
+            captureTransitionHookQueue(update, s);
+          }
           if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__) {
-            const update = s.pendingActionBatch?.updates.get(s);
-            if (update !== void 0) {
-              update.profileType = "reducer";
-              update.profileSlot = slot;
-            }
+            update.profileType = "reducer";
+            update.profileSlot = slot;
           }
           return;
         }
@@ -4325,17 +4865,32 @@ function useReducer(reducer, initialArg, initOrSlot, slot) {
     ensureHooks(scope).set(slot, s);
   } else {
     s.reducer = reducer;
-    const actions = s.renderPhaseActions;
-    if (actions !== void 0) {
-      let value = s.value;
-      for (let i = 0; i < actions.length; i++) value = reducer(value, actions[i]);
+    if (s.renderTransition !== void 0 || s.renderPhaseActions !== void 0) {
+      const value = readQueuedReducer(s);
+      if (!s.urgentTransition && s.renderPhaseActions !== void 0 && Object.is(value, s.value))
+        TRANSITION_SWAP_DRIVER?.rebaseHeld(s, block, s.renderPhaseActions, reducer);
       s.value = value;
-      s.renderPhaseActions = void 0;
-      s.renderPhaseValue = void 0;
+      if (!s.urgentTransition) {
+        if (s.renderTransition !== void 0) {
+          finishQueuedTransition(s.renderTransition, s.value);
+          s.renderTransition = void 0;
+        }
+        s.renderPhaseActions = void 0;
+      }
     }
   }
   return [s.value, s.dispatch];
 }
+function readQueuedReducer(state) {
+  let value = state.renderTransition === void 0 ? state.value : readQueuedTransition(
+    state.renderTransition,
+    state.urgentTransition === true,
+    state.reducer
+  );
+  if (state.renderPhaseActions !== void 0)
+    for (const action of state.renderPhaseActions) value = state.reducer(value, action);
+  return value;
+}
 function __useReducerWithGetter(reducer, initialArg, initOrSlot, slot) {
   const resolvedInput = typeof initOrSlot === "symbol" ? initOrSlot : slot;
   const pair = useReducer(reducer, initialArg, initOrSlot, slot);
@@ -4343,18 +4898,26 @@ function __useReducerWithGetter(reducer, initialArg, initOrSlot, slot) {
   if (resolved === void 0) missingSlot("useReducer");
   const s = CURRENT_SCOPE.hooks.get(resolved);
   const getter = s.getter ?? (s.getter = () => {
-    if (s.renderPhaseActions !== void 0) return s.renderPhaseValue;
     const batch = s.pendingActionBatch;
-    if (batch === void 0) return s.value;
+    if (batch === void 0) return readQueuedReducer(s);
     const update = batch.updates.get(s);
-    return update === void 0 ? s.value : rebaseTransitionActionUpdate(update);
+    return update === void 0 ? readQueuedReducer(s) : readQueuedTransition(update, false, s.reducer);
   });
   return [pair[0], pair[1], getter];
 }
-function depsChanged(prev, next) {
+function depsChanged(prev, next, hook = false) {
   if (prev === void 0 || next === void 0) return true;
-  if (prev.length !== next.length) return true;
-  for (let i = 0; i < prev.length; i++) {
+  let length = prev.length;
+  if (length !== next.length) {
+    if (!hook) return true;
+    if (process.env.NODE_ENV !== "production") {
+      console.error(
+        `The dependency array must keep the same length between renders (previous: ${length}, next: ${next.length}).`
+      );
+    }
+    length = Math.min(length, next.length);
+  }
+  for (let i = 0; i < length; i++) {
     if (!Object.is(prev[i], next[i])) return true;
   }
   return false;
@@ -4421,7 +4984,7 @@ function enqueueEffect(slot, fn, deps, phase) {
     return;
   }
   if (prev) {
-    const changed = depsChanged(prev.deps, deps);
+    const changed = depsChanged(prev.deps, deps, true);
     if (prev.active && !changed) return;
     if (ROOT_RENDER_TRANSACTION !== null) journalObjectOnce(prev);
     let reactivated = false;
@@ -4525,7 +5088,7 @@ function adoptMemoEntry(scope, slot, deps) {
 }
 function readMemoEntry(scope, slot, deps) {
   const prev = scope.hooks?.get(slot);
-  if (prev && deps !== void 0 && !depsChanged(prev.deps, deps)) {
+  if (prev && deps !== void 0 && !depsChanged(prev.deps, deps, true)) {
     return memoEntryHit(slot, prev);
   }
   return WARM_EVER && deps !== void 0 ? adoptMemoEntry(scope, slot, deps) : null;
@@ -4540,12 +5103,21 @@ function publishMemoEntry(scope, slot, deps, value, nativeWitness) {
   }
   return value;
 }
+let devMemoComputeDepth = 0;
+function computeMemoWithDiagnostics(compute, deps) {
+  devMemoComputeDepth++;
+  try {
+    return compute.apply(null, deps ?? []);
+  } finally {
+    devMemoComputeDepth--;
+  }
+}
 function useMemo(compute, deps, slot) {
   const [d, s] = resolveHookArgs("useMemo", deps, slot);
   const scope = CURRENT_SCOPE;
   const entry = readMemoEntry(scope, s, d);
   if (entry !== null) return entry.value;
-  const value = compute.apply(null, d ?? []);
+  const value = process.env.NODE_ENV !== "production" ? computeMemoWithDiagnostics(compute, d) : compute.apply(null, d ?? []);
   return publishMemoEntry(scope, s, d, value);
 }
 function useCallback(fn, deps, slot) {
@@ -4617,7 +5189,7 @@ function hookMemoPublishInvariant(cells, base, value) {
   return value;
 }
 function useRef(initial, slot) {
-  if (slot === void 0 && typeof initial === "symbol") {
+  if (slot === void 0 && typeof initial === "symbol" && arguments.length === 1 && (slotStack.length === 0 || MANUAL_HOOK_DRIVER?.active === true)) {
     slot = initial;
     initial = void 0;
   }
@@ -4731,13 +5303,33 @@ function subscribeToStore(inst, subscribe) {
   if (checkStoreChanged(inst)) inst.forceUpdate();
   return subscribe(inst.onStoreChange);
 }
+function scheduleStoreRender(block) {
+  const depth = TRANSITION_DEPTH;
+  const asyncCount = ASYNC_TRANSITION_COUNT;
+  TRANSITION_DEPTH = 0;
+  ASYNC_TRANSITION_COUNT = 0;
+  try {
+    scheduleRender(block);
+  } finally {
+    TRANSITION_DEPTH = depth;
+    ASYNC_TRANSITION_COUNT = asyncCount;
+  }
+}
+let DID_WARN_UNCACHED_SNAPSHOT = false;
 function useSyncExternalStore(subscribe, getSnapshot, ...rest) {
   let slot = rest[rest.length - 1];
   slot = resolveSlot(slot);
   if (slot === void 0) missingSlot("useSyncExternalStore");
   const getServerSnapshot = rest.length >= 2 ? rest[0] : void 0;
   const subs = usesSubslots(slot);
-  const value = activeHydration() !== null && getServerSnapshot !== void 0 ? getServerSnapshot() : getSnapshot();
+  const readSnapshot = activeHydration() !== null && getServerSnapshot !== void 0 ? getServerSnapshot : getSnapshot;
+  const value = readSnapshot();
+  if (process.env.NODE_ENV !== "production" && !DID_WARN_UNCACHED_SNAPSHOT && !Object.is(value, readSnapshot())) {
+    DID_WARN_UNCACHED_SNAPSHOT = true;
+    console.error(
+      "The " + (readSnapshot === getSnapshot ? "getSnapshot" : "getServerSnapshot") + " result must be cached to avoid an infinite update loop."
+    );
+  }
   const scope = CURRENT_SCOPE;
   let inst = scope.hooks?.get(subs.inst);
   if (inst === void 0) {
@@ -4749,11 +5341,11 @@ function useSyncExternalStore(subscribe, getSnapshot, ...rest) {
       subscribe,
       forceUpdate: typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__ ? () => {
         if (!block.disposed) __profileSchedule(block, "external-store", slot);
-        scheduleRender(block);
-      } : () => scheduleRender(block),
+        scheduleStoreRender(block);
+      } : () => scheduleStoreRender(block),
       onStoreChange: () => {
         if (block.disposed) return;
-        if (CURRENT_BLOCK === null && block.pending && block.pendingMode === "urgent" && !block.pendingDeferred && !(typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__) && (process.env.NODE_ENV === "production" || !IS_OCTANE_ACT_ENVIRONMENT || actScopeDepth !== 0 || syncFlush)) {
+        if (CURRENT_BLOCK === null && block.pending && block.pendingMode === "urgent" && !block.pendingDeferred && !(typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__) && (process.env.NODE_ENV === "production" || !isActEnvironment() || actScopeDepth !== 0 || syncFlush)) {
           return;
         }
         if (checkStoreChanged(created)) created.forceUpdate();
@@ -5917,7 +6509,8 @@ const Suspense = /* @__PURE__ */ markComponentFlags(
     );
   },
   COMPONENT_FLAG_BOUNDARY,
-  "Suspense"
+  "Suspense",
+  /* @__PURE__ */ Symbol.for("octane.suspense")
 );
 function initializeViewTransitionComponent() {
   return markComponentFlags(
@@ -5964,6 +6557,11 @@ const ErrorBoundary = /* @__PURE__ */ markComponentFlags(
 );
 const TsrxErrorBoundary = ErrorBoundary;
 function use(usable) {
+  if (process.env.NODE_ENV !== "production" && devMemoComputeDepth !== 0) {
+    console.error(
+      "Do not call use() inside a useMemo() factory. Cached factories can skip context or promise reads; call use() before useMemo() and memoize the returned value instead."
+    );
+  }
   if (usable && usable.$$kind === CONTEXT_TAG) {
     return useContextInternal(usable);
   }
@@ -6664,6 +7262,15 @@ function warmChild(comp, props) {
     WARM_DEPTH--;
   }
 }
+function markWarm(component, plan) {
+  Object.defineProperty(component, "__warm", {
+    configurable: true,
+    get() {
+      return this === component ? plan : void 0;
+    }
+  });
+  return component;
+}
 function adoptWarmEntry(slot, deps, accept) {
   let b = CURRENT_BLOCK;
   while (b !== null) {
@@ -6962,6 +7569,8 @@ function lazy(load) {
   let thenable = null;
   let profiledComponent = null;
   let memoMetadataInstalled = false;
+  let displayName;
+  let resolvedName = "Lazy";
   let lazyWrapper;
   const initializeLazy = () => {
     if (status !== "uninitialized") return;
@@ -6994,16 +7603,23 @@ function lazy(load) {
   };
   const callResolvedComponent = (props, scope, extra) => {
     const comp = resolveLazyModule(result);
+    resolvedName = comp.displayName || comp.name || "Lazy";
     if (comp.__memo === true) {
       if (!memoMetadataInstalled) {
-        lazyWrapper.__memo = true;
-        lazyWrapper.__compare = (prev, next) => {
-          const current = resolveLazyModule(result);
-          const compare = current.__compare;
-          const previous = lazyResolvedProps(current, prev);
-          const incoming = lazyResolvedProps(current, next);
-          return compare ? compare(previous, incoming) : shallowEqualProps(previous, incoming);
-        };
+        Object.defineProperty(lazyWrapper, "__memo", {
+          get() {
+            return this === lazyWrapper;
+          }
+        });
+        Object.defineProperty(lazyWrapper, "__compare", {
+          value: (prev, next) => {
+            const current = resolveLazyModule(result);
+            const compare = current.__compare;
+            const previous = lazyResolvedProps(current, prev);
+            const incoming = lazyResolvedProps(current, next);
+            return compare ? compare(previous, incoming) : shallowEqualProps(previous, incoming);
+          }
+        });
         memoMetadataInstalled = true;
       }
       scope.block.memoInChain = true;
@@ -7033,10 +7649,22 @@ function lazy(load) {
       }
       if (settledStatus === "rejected") throw result;
     }
+    runActiveWarmPlans();
     throw new SuspenseException(thenable);
   };
-  lazyWrapper.__warm = initializeLazy;
-  Object.defineProperty(lazyWrapper, LAZY_COMPONENT, { value: true });
+  markWarm(lazyWrapper, initializeLazy);
+  Object.defineProperty(lazyWrapper, LAZY_COMPONENT, {
+    get() {
+      return this === lazyWrapper;
+    }
+  });
+  Object.defineProperty(lazyWrapper, "displayName", {
+    configurable: true,
+    get: () => displayName ?? resolvedName,
+    set: (value) => {
+      displayName = value;
+    }
+  });
   return lazyWrapper;
 }
 function useId(slot) {
@@ -7248,6 +7876,7 @@ class HydrationCapability {
     warnHydrationStructuralMismatch(loc, expected, actual);
   }
   recordTextMismatch(node, loc, server) {
+    if (process.env.NODE_ENV === "production" && ROOT_ERROR_HANDLERS === null) return;
     if (!this.textWarnings.has(node)) this.textWarnings.set(node, { loc, server });
   }
   flushTextWarnings() {
@@ -7255,7 +7884,9 @@ class HydrationCapability {
       if (!this.rootBlock.parentNode.contains(node)) continue;
       const client = node.nodeValue;
       if (pending.server !== client) {
-        warnHydrationValueMismatch(pending.loc, "text", pending.server, client);
+        noteRecoverableHydrationError(() => new Error(formatClientError(61)), this.rootBlock);
+        if (process.env.NODE_ENV !== "production")
+          warnHydrationValueMismatch(pending.loc, "text", pending.server, client);
       }
     }
     this.textWarnings.clear();
@@ -7514,10 +8145,20 @@ class HydrationCapability {
     if (first !== null && first.nodeType === 3) {
       const server = first.nodeValue;
       if (server !== text && !isTextParserNormalizedMatch(server, text) && !isHydrationSuppressed(el)) {
-        if (process.env.NODE_ENV !== "production")
-          this.recordTextMismatch(first, loc || el.__oct_loc, server);
+        this.recordTextMismatch(first, loc || el.__oct_loc, server);
         first.nodeValue = text;
       }
+      if (first.nextSibling !== null) {
+        noteRecoverableHydrationError(() => new Error(formatClientError(62)), this.rootBlock);
+        if (process.env.NODE_ENV !== "production") {
+          warnHydrationStructuralMismatch(
+            loc || el.__oct_loc,
+            "the end of the text element",
+            describeHydrationNode(first.nextSibling)
+          );
+        }
+        while (first.nextSibling !== null) el.removeChild(first.nextSibling);
+      }
       return first;
     }
     if (this.isOpen(first)) {
@@ -7539,8 +8180,7 @@ class HydrationCapability {
       if (server !== text && !isTextParserNormalizedMatch(server, text)) {
         const host2 = posNode.parentNode;
         if (!isHydrationSuppressed(host2)) {
-          if (process.env.NODE_ENV !== "production")
-            this.recordTextMismatch(posNode, host2 && host2.__oct_loc, server);
+          this.recordTextMismatch(posNode, host2 && host2.__oct_loc, server);
           posNode.nodeValue = text;
         }
       }
@@ -8727,6 +9367,7 @@ function attrNamespace(name) {
   return null;
 }
 function setAttribute(el, name, value) {
+  if (name === "innerText" || name === "textContent") return;
   if (process.env.NODE_ENV !== "production" && el.__oct_loc !== void 0 && !isHtmlCustomElement(el) && typeof el.__oct_custom_is !== "string") {
     const warning = isAriaAttributeName(name) ? ariaAttributeWarning(name, el.localName) : hostPropertyWarning(name, value, el.localName, el.namespaceURI === SVG_NS);
     if (warning !== null) devWarnAttributeOnce(el, name, warning);
@@ -8764,6 +9405,10 @@ function setAttribute(el, name, value) {
       break;
     case 8:
       if ((name === "multiple" || name === "selected") && !isHtmlCustomElement(el)) {
+        if (name === "selected") {
+          const hydration2 = activeHydration();
+          if (hydration2 !== null && !hydration2.isFresh(el)) return;
+        }
         el[name] = value && typeof value !== "function" && typeof value !== "symbol";
         return;
       }
@@ -8947,7 +9592,7 @@ function setAriaAttribute(el, name, value) {
     const warning = ariaAttributeWarning(name, el.localName);
     if (warning !== null) devWarnAttributeOnce(el, name, warning);
   }
-  const next = value == null ? null : String(value);
+  const next = value == null || typeof value === "function" || typeof value === "symbol" ? null : String(value);
   const hydration = activeHydration();
   if (hydration !== null && !hydration.allowAttribute(el, name, next)) return;
   if (TRANSITION_JOURNAL !== null) journalAttr(el, name);
@@ -8956,7 +9601,7 @@ function setAriaAttribute(el, name, value) {
 }
 function coerceAttrValue(el, name, value) {
   if (name.charCodeAt(0) === 97 && name.startsWith("aria-")) {
-    return value == null ? null : String(value);
+    return value == null || typeof value === "function" || typeof value === "symbol" ? null : String(value);
   }
   const t = typeof value;
   if (t === "boolean" && isEnumeratedBooleanAttr(name)) return value ? "true" : "false";
@@ -9004,6 +9649,7 @@ function coerceAttrValue(el, name, value) {
     if (POSITIVE_NUMERIC_ATTR_PROPS.has(lower) && !(Number(value) >= 1)) {
       return null;
     }
+    if ((lower === "rowspan" || lower === "start") && Number.isNaN(Number(value))) return null;
     if (name.length > 2 && name.charCodeAt(0) === 111 && name.charCodeAt(1) === 110) {
       return null;
     }
@@ -9097,7 +9743,9 @@ function setStyleProperty(el, name, value, staticCss, previous) {
 }
 function applyStyleValue(el, style, value, prev) {
   if (value == null || value === false || value === "") {
-    if (prev != null && prev !== false && prev !== "") style.cssText = "";
+    if (prev && typeof prev === "object") {
+      for (const key in prev) style.removeProperty(styleName(key));
+    } else if (typeof prev === "string") style.cssText = "";
     return;
   }
   if (typeof value === "string") {
@@ -9154,10 +9802,13 @@ function isEventKey(k) {
 const CAPTURE_PREFIX = "$$capture:";
 function jsxEventName(rest) {
   if (rest === "DoubleClick") return "dblclick";
+  if (rest === "Focus") return "focusin";
+  if (rest === "Blur") return "focusout";
   return rest.toLowerCase();
 }
-function eventSlot(name) {
-  if (!isEventKey(name)) return null;
+function eventSlot(name, el) {
+  if (!isEventKey(name) || el !== void 0 && isHtmlCustomElement(el) && !isDelegatedEventProp(name))
+    return null;
   let rest = name.slice(2);
   let capture = false;
   if (rest.length > 7 && rest.endsWith("Capture") && name !== "onGotPointerCapture" && name !== "onLostPointerCapture") {
@@ -9194,7 +9845,7 @@ function removeHostProp(el, name, prevValue) {
       );
       return;
     }
-    const ev = eventSlot(name);
+    const ev = eventSlot(name, el);
     if (ev) setEventHandler(el, ev.key, null);
     else setAttribute(el, name, null);
   }
@@ -9211,8 +9862,8 @@ function snapshotSpread(value) {
   return snapshot;
 }
 function formActionAttributeName(el, name) {
-  if (el.localName === "form" && name === "action") return "action";
-  if ((el.localName === "button" || el.localName === "input") && (name === "formAction" || name === "formaction"))
+  if (name === "action" && el.localName === "form") return "action";
+  if ((name === "formAction" || name === "formaction") && (el.localName === "button" || el.localName === "input"))
     return "formaction";
   return null;
 }
@@ -9300,7 +9951,7 @@ function setSpread(el, value, prev, mountScope, skipDangerouslySetInnerHTML = fa
     devValidateHostProps(el, Object(value));
   }
   if (value != null && Object.prototype.propertyIsEnumerable.call(Object(value), "suppressHydrationWarning")) {
-    el.__oct_suppress = value.suppressHydrationWarning !== false;
+    el.__oct_suppress = value.suppressHydrationWarning === true;
   }
   if (process.env.NODE_ENV !== "production" && value != null && Object.prototype.propertyIsEnumerable.call(Object(value), "suppressNativeChangeWarning")) {
     el.__oct_native_change_suppressed = value.suppressNativeChangeWarning === true;
@@ -9374,7 +10025,7 @@ function setSpread(el, value, prev, mountScope, skipDangerouslySetInnerHTML = fa
       );
       continue;
     }
-    const ev = eventSlot(k);
+    const ev = eventSlot(k, el);
     if (ev) {
       if (v === pv) continue;
       if (ev.capture) {
@@ -9406,9 +10057,9 @@ function removeHeadEventListeners(state, attrs) {
     handlers.delete(name);
   }
 }
-function adoptServerHeadEl(key, tag) {
+function adoptServerHeadEl(head, key, tag) {
   const closeKey = "/" + key;
-  for (let n = document.head.firstChild; n !== null; n = n.nextSibling) {
+  for (let n = head.firstChild; n !== null; n = n.nextSibling) {
     if (n.nodeType === 8 && n.data === key) {
       let candidate = n.nextSibling;
       let match = null;
@@ -9444,10 +10095,13 @@ function headBlock(scope, slot, key, tag, attrs, text) {
   if (typeof document === "undefined") return;
   let state = scope.slots[slot];
   if (state === void 0) {
-    let el2 = adoptServerHeadEl(headOwnershipKey(key, rootIdentifierPrefix(scope.block)), tag);
+    const parent = scope.block.parentNode;
+    const ownerDocument = parent.nodeType === 9 ? parent : parent.ownerDocument;
+    const head = ownerDocument.head;
+    let el2 = adoptServerHeadEl(head, headOwnershipKey(key, rootIdentifierPrefix(scope.block)), tag);
     if (el2 === null) {
-      el2 = document.createElement(tag);
-      document.head.appendChild(el2);
+      el2 = ownerDocument.createElement(tag);
+      head.appendChild(el2);
     }
     state = { el: el2 };
     scope.slots[slot] = state;
@@ -9572,6 +10226,7 @@ function evt0(el, key, fn) {
   return d;
 }
 function evt0u(d, fn) {
+  if (_dispatchDepth !== 0) preserveDispatchedBundle(d);
   if (TRANSITION_JOURNAL !== null) journalObjectOnce(d);
   d.fn = fn;
 }
@@ -9581,6 +10236,7 @@ function evt1(el, key, fn, a0) {
   return d;
 }
 function evt1u(d, fn, a0) {
+  if (_dispatchDepth !== 0) preserveDispatchedBundle(d);
   if (TRANSITION_JOURNAL !== null) {
     journalObjectOnce(d);
     journalObjectOnce(d.args);
@@ -9594,6 +10250,7 @@ function evt2(el, key, fn, a0, a1) {
   return d;
 }
 function evt2u(d, fn, a0, a1) {
+  if (_dispatchDepth !== 0) preserveDispatchedBundle(d);
   if (TRANSITION_JOURNAL !== null) {
     journalObjectOnce(d);
     journalObjectOnce(d.args);
@@ -9609,6 +10266,7 @@ function evtN(el, key, fn, args) {
   return d;
 }
 function evtNu(d, fn, args) {
+  if (_dispatchDepth !== 0) preserveDispatchedBundle(d);
   if (TRANSITION_JOURNAL !== null) journalObjectOnce(d);
   d.fn = fn;
   d.args = args;
@@ -9949,6 +10607,28 @@ const CURRENT_TARGET_DESCRIPTOR = {
   }
 };
 const CAPTURE_PATH = [];
+const CAPTURE_SLOTS = [];
+function snapshotDelegatedSlots(base, key, event) {
+  const type = event.type;
+  const suppressDisabled = type === "click" || type === "dblclick" || type === "mousedown" || type === "mousemove" || type === "mouseup" || type === "mouseenter" && key[2] !== "c";
+  for (let index = base; index < CAPTURE_PATH.length; index++) {
+    const node = CAPTURE_PATH[index];
+    const slot = node[key];
+    CAPTURE_SLOTS[index] = slot != null && suppressDisabled && node.disabled && (node.localName === "button" || node.localName === "input" || node.localName === "select" || node.localName === "textarea") ? null : slot;
+  }
+}
+function preserveDispatchedBundle(bundle) {
+  let snapshot;
+  for (let index = 0; index < CAPTURE_SLOTS.length; index++) {
+    if (CAPTURE_SLOTS[index] === bundle) {
+      CAPTURE_SLOTS[index] = snapshot ??= {
+        [EVENT_SLOT_KIND]: HANDLER_BUNDLE_KIND,
+        fn: bundle.fn,
+        args: bundle.args.slice()
+      };
+    }
+  }
+}
 function resolvePortalEventOwner(node) {
   if (node.$$portalParent != null || node.parentNode === null) return;
   const target = node.parentNode;
@@ -10154,9 +10834,7 @@ function finishCaptureDispatch(event) {
       maybeFlushDiscrete(type);
     }
   };
-  const target = event.target;
-  const checkableChange = type === "change" && target?.localName === "input" && (target.type === "checkbox" || target.type === "radio");
-  if (checkableChange) setTimeout(fallback, 0);
+  if (event.isTrusted) setTimeout(fallback, 0);
   else queueMicrotask(fallback);
 }
 function dispatchDelegated(event) {
@@ -10168,13 +10846,7 @@ function dispatchDelegated(event) {
   _dispatchDepth++;
   const node = event.target;
   const prevSubmitRec = ACTIVE_SUBMIT_DISPATCH;
-  const submitRec = event.type === "submit" && node != null && node.nodeName === "FORM" ? {
-    form: node,
-    event,
-    transitions: 0,
-    published: false,
-    intercepted: false
-  } : null;
+  const submitRec = event.type === "submit" && node != null && node.nodeName === "FORM" ? snapshotSubmitDispatch(node, event) : null;
   if (submitRec !== null) ACTIVE_SUBMIT_DISPATCH = submitRec;
   const nativeBatch = beginNativeEventBatch(event);
   const pathBase = CAPTURE_PATH.length;
@@ -10184,14 +10856,17 @@ function dispatchDelegated(event) {
     if (delegatedCapture(event.type) && _delegatedCapture.has(event.type) && dispatchDelegatedCapture.call(this, event))
       return;
     if (!_delegated.has(event.type)) return;
+    if (node?.nodeType === 1 && isHtmlCustomElement(node) && (event.type === "invalid" || EMULATED_BUBBLING_EVENTS.includes(event.type)))
+      return;
     buildDelegatedPath(event, this);
+    snapshotDelegatedSlots(pathBase, key, event);
     stop = Object.getOwnPropertyDescriptor(event, "stopPropagation");
     propagationStarted = true;
     beginDelegatedPropagation(event, stop, null);
     for (let i = pathBase; i < CAPTURE_PATH.length; i++) {
       const current = CAPTURE_PATH[i];
       if (targetOnly && current !== event.target) break;
-      const slot = current[key];
+      const slot = CAPTURE_SLOTS[i];
       if (slot != null) {
         setCurrentTarget(event, current);
         fireEventSlot(slot, event);
@@ -10199,8 +10874,12 @@ function dispatchDelegated(event) {
       }
       if (targetOnly) break;
     }
+    if (submitRec !== null && FORM_SUBMIT_DRIVER !== null && !event.defaultPrevented && CAPTURE_PATH.includes(submitRec.form, pathBase)) {
+      FORM_SUBMIT_DRIVER(submitRec.form, event, submitRec.action, submitRec.submitter);
+    }
   } finally {
     CAPTURE_PATH.length = pathBase;
+    CAPTURE_SLOTS.length = pathBase;
     if (propagationStarted) endDelegatedPropagation(event, stop, null);
     if (submitRec !== null) {
       ACTIVE_SUBMIT_DISPATCH = prevSubmitRec;
@@ -10223,6 +10902,7 @@ function dispatchDelegatedCapture(event) {
   const key = CAPTURE_PREFIX + event.type;
   const pathBase = CAPTURE_PATH.length;
   buildDelegatedPath(event, this, path);
+  snapshotDelegatedSlots(pathBase, key, event);
   const stop = Object.getOwnPropertyDescriptor(event, "stopPropagation");
   const immediate = delegatedCapture(event.type) ? Object.getOwnPropertyDescriptor(event, "stopImmediatePropagation") : null;
   const wasCancelled = event.cancelBubble;
@@ -10232,7 +10912,7 @@ function dispatchDelegatedCapture(event) {
   try {
     beginDelegatedPropagation(event, stop, immediate);
     for (let i = CAPTURE_PATH.length - 1; i >= pathBase; i--) {
-      const slot = CAPTURE_PATH[i][key];
+      const slot = CAPTURE_SLOTS[i];
       if (slot != null) {
         setCurrentTarget(event, CAPTURE_PATH[i]);
         fireEventSlot(slot, event);
@@ -10242,6 +10922,7 @@ function dispatchDelegatedCapture(event) {
   } finally {
     stopped = event[PROPAGATION_FLAGS] !== 0 || !wasCancelled && event.cancelBubble;
     CAPTURE_PATH.length = pathBase;
+    CAPTURE_SLOTS.length = pathBase;
     endDelegatedPropagation(event, stop, immediate);
     clearCurrentTarget(event);
     try {
@@ -10269,7 +10950,7 @@ function clearCurrentTarget(event) {
   delete event.currentTarget;
   delete event[CURRENT_TARGET_NODE];
 }
-const IDLE_FORM_STATUS = { pending: false, data: null, method: "get", action: null };
+const IDLE_FORM_STATUS = { pending: false, data: null, method: null, action: null };
 const FORM_STATUS = /* @__PURE__ */ new WeakMap();
 const FORM_STATUS_LISTENERS = /* @__PURE__ */ new WeakMap();
 function setFormStatus(form, status) {
@@ -10277,7 +10958,28 @@ function setFormStatus(form, status) {
   const ls = FORM_STATUS_LISTENERS.get(form);
   if (ls) for (const l of ls) l();
 }
+function snapshotSubmitDispatch(form, event) {
+  let submitter = event.submitter;
+  let action = form.$$formAction;
+  if (submitter !== null && submitter !== void 0) {
+    const override = submitter.$$formAction ?? submitter.getAttribute("formaction");
+    if (override != null) {
+      action = override;
+      submitter = null;
+    }
+  }
+  return {
+    form,
+    event,
+    action,
+    submitter: submitter ?? null,
+    transitions: 0,
+    published: false,
+    intercepted: false
+  };
+}
 let ACTIVE_SUBMIT_DISPATCH = null;
+let FORM_SUBMIT_DRIVER = null;
 function publishManualFormPending(rec) {
   if (rec.intercepted || rec.transitions === 0 || !rec.event.defaultPrevented) return;
   const form = rec.form;
@@ -10333,30 +11035,22 @@ function flushFormResets() {
   PENDING_FORM_RESETS = null;
   for (const f of forms) resetFormNow(f);
 }
-function setFormAction(el, name, value, prev) {
+function setFormAction(el, name, value, _prev) {
   if (typeof value === "function") {
     el.$$formAction = value;
     if (process.env.NODE_ENV !== "production") queueFormActionAuthoringDiagnostic(el);
-    if (el.nodeName === "FORM") {
-      if (!el.$$formSubmitWired) {
-        el.$$formSubmitWired = true;
-        el.$$submit = (event) => handleFormSubmit(el, event);
-        delegateEvents(["submit"]);
-      }
+    if (!el.$$formSubmitWired) {
+      el.$$formSubmitWired = true;
+      FORM_SUBMIT_DRIVER = handleFormSubmit;
+      delegateEvents(["submit"]);
     }
     el.removeAttribute(name);
     return;
   }
   el.$$formAction = void 0;
-  if (typeof prev === "function" && el.nodeName === "FORM") {
-    el.$$submit = void 0;
-    el.$$formSubmitWired = false;
-  }
   setAttribute(el, name, value);
 }
-function handleFormSubmit(form, event) {
-  const submitter = event.submitter;
-  const action = submitter && submitter.$$formAction || form.$$formAction;
+function handleFormSubmit(form, event, action, submitter) {
   if (typeof action !== "function") return;
   event.preventDefault();
   if (ACTIVE_SUBMIT_DISPATCH !== null && ACTIVE_SUBMIT_DISPATCH.form === form)
@@ -10532,7 +11226,7 @@ function armControlled(el) {
   return ctrl;
 }
 function toControlledString(v) {
-  return typeof v === "string" ? v : String(v);
+  return typeof v === "string" ? v : typeof v === "function" || typeof v === "symbol" ? "" : String(v);
 }
 function valueNeedsWrite(el, raw) {
   if (el.type === "number") {
@@ -10793,35 +11487,77 @@ function projectSelectValue(sel, sv, setDefaultSelected) {
   }
   if (defaultOption !== null) defaultOption.selected = true;
 }
-function setDefaultValue(el, value) {
+function setDefaultValue(el, value, initial) {
   const ctrl = armControlled(el);
   const hydration = activeHydration();
-  if (hydration !== null && !hydration.isFresh(el) || value == null) return;
   if (el.localName === "select") {
-    if (!Object.is(ctrl.dvv, value)) {
+    const first2 = ctrl.dvv === UNCONTROLLED;
+    const multiple = el.multiple;
+    const changedMultiple = ctrl.formMultiple !== multiple;
+    if (first2 || changedMultiple) {
       if (TRANSITION_JOURNAL !== null) {
         journalObjectOnce(ctrl);
         journalBag();
       }
       ctrl.dvv = value;
-      queueControlledCommit(SELECT_DEFAULT_SYNCS, { el, value });
+      ctrl.formMultiple = multiple;
+      if (hydration !== null && !hydration.isFresh(el)) return;
+      if (value != null)
+        queueControlledCommit(SELECT_DEFAULT_SYNCS, { el, value });
+      else if (changedMultiple)
+        projectSelectValue(el, multiple ? /* @__PURE__ */ new Set() : "", false);
     }
     return;
   }
+  const first = initial ?? !ctrl.sawV;
+  const previousDefault = ctrl.dvv;
+  if (TRANSITION_JOURNAL !== null) journalObjectOnce(ctrl);
+  ctrl.sawV = true;
+  ctrl.dvv = value;
+  const hydrating = hydration !== null && !hydration.isFresh(el);
   if (ctrl.v !== UNCONTROLLED) return;
   const input = el;
+  if (value == null) {
+    if (previousDefault !== UNCONTROLLED && previousDefault != null) {
+      if (TRANSITION_JOURNAL !== null) journalDefaultValue(input);
+      if (el.localName === "input") input.removeAttribute("value");
+      else input.defaultValue = "";
+    }
+    return;
+  }
   const s = toControlledString(value);
-  if (input.defaultValue !== s) {
+  if (first && !hydrating && input.value !== s) {
+    if (TRANSITION_JOURNAL !== null) journalControlled(el, "value", "defaultValue");
+    input.value = s;
+  }
+  if (input.defaultValue !== s || s === "" && el.localName === "input" && !input.hasAttribute("value")) {
     if (TRANSITION_JOURNAL !== null) journalDefaultValue(input);
     input.defaultValue = s;
   }
 }
+const DEFAULT_VALUE_BASELINE = /* @__PURE__ */ Symbol("octane.defaultValue");
 function setDefaultValueUncontrolled(el, value) {
   const hydration = activeHydration();
-  if (hydration !== null && !hydration.isFresh(el) || value == null) return;
   const input = el;
-  const s = toControlledString(value);
-  if (input.defaultValue !== s) {
+  const previous = input[DEFAULT_VALUE_BASELINE];
+  const s = value == null ? null : toControlledString(value);
+  if (TRANSITION_JOURNAL !== null)
+    TRANSITION_JOURNAL.push(JOURNAL_PROP, input, DEFAULT_VALUE_BASELINE, previous);
+  input[DEFAULT_VALUE_BASELINE] = s;
+  const hydrating = hydration !== null && !hydration.isFresh(el);
+  if (s === null) {
+    if (previous != null) {
+      if (TRANSITION_JOURNAL !== null) journalDefaultValue(input);
+      if (el.localName === "input") input.removeAttribute("value");
+      else input.defaultValue = "";
+    }
+    return;
+  }
+  if (previous === void 0 && !hydrating && input.value !== s) {
+    if (TRANSITION_JOURNAL !== null) journalControlled(el, "value", "defaultValue");
+    input.value = s;
+  }
+  if (input.defaultValue !== s || s === "" && el.localName === "input" && !input.hasAttribute("value")) {
     if (TRANSITION_JOURNAL !== null) journalDefaultValue(input);
     input.defaultValue = s;
   }
@@ -10890,7 +11626,6 @@ function setFormControlSources(el, sources) {
   }
   const ctrl = armControlled(el);
   const first = !ctrl.formSeen;
-  const previousDefaultValue = ctrl.formDefaultValue;
   const previousDefaultChecked = ctrl.formDefaultChecked;
   const previousMultiple = ctrl.formMultiple;
   if (TRANSITION_JOURNAL !== null) {
@@ -10912,9 +11647,7 @@ function setFormControlSources(el, sources) {
     const defaultString = defaultValue == null ? null : toControlledString(defaultValue);
     setValue(input, value);
     if (value == null) {
-      if (defaultString !== null) setDefaultValue(input, defaultString);
-      else if (!first && previousDefaultValue !== UNCONTROLLED && previousDefaultValue != null)
-        input.removeAttribute("value");
+      setDefaultValue(input, defaultString, first);
     }
     setChecked(input, checked);
     if (checked == null && defaultChecked != null) setDefaultChecked(input, defaultChecked);
@@ -10927,7 +11660,7 @@ function setFormControlSources(el, sources) {
     const textarea = el;
     setValue(textarea, value);
     if (value == null) {
-      if (defaultValue != null) setDefaultValue(textarea, defaultValue);
+      if (defaultValue != null) setDefaultValue(textarea, defaultValue, first);
       else if (!first && textarea.defaultValue !== "") textarea.defaultValue = "";
     }
     return;
@@ -10950,7 +11683,7 @@ function setFormControlSources(el, sources) {
   }
   setSelectValue(select, value);
   if (defaultValue != null) setDefaultValue(select, defaultValue);
-  else ctrl.dvv = UNCONTROLLED;
+  else if (first) ctrl.dvv = void 0;
 }
 function nativeTextChangeMessage(el, hasBubbleChange, controlled) {
   const changeProp = hasBubbleChange ? "onChange" : "onChangeCapture";
@@ -11234,7 +11967,9 @@ function unregisterPortalEventRange(target, portal2) {
   }
 }
 function portal(parentScope, slotKey, target, body, props, host, env, fragmentOwners, fragmentAnchor) {
+  if (CURRENT_BLOCK?.pending && !CURRENT_BLOCK.crossRenderUpdate) return;
   const prev = parentScope.slots[slotKey];
+  const key = portalKey(props);
   if (fragmentAnchor !== void 0 && fragmentOwners === void 0 && prev !== void 0 && prev.target === target) {
     prepareFragmentPortalInterleaving(prev);
   }
@@ -11243,12 +11978,13 @@ function portal(parentScope, slotKey, target, body, props, host, env, fragmentOw
     parentScope.block,
     target,
     body,
-    props,
+    key === null ? props : void 0,
     // `host` (passed by the compiler) is the JSX element that contains the
     // createPortal call — the natural "logical parent" for event bubbling. When
     // the portal is at top level the compiler passes the block's parentNode.
     host || parentScope.block.parentNode,
-    env
+    env,
+    key
   );
   if (prev !== state) {
     journalRootProperty(parentScope.slots, String(slotKey));
@@ -11409,16 +12145,16 @@ function registerValuePortalFragmentOwners(portal2, parentBlock, anchor) {
     registerFragmentPortalOwners(portal2, nestedOwners ?? firstOwner, anchor);
   }
 }
-function renderPortalState(prev, parentBlock, target, rawBody, rawProps, host, env) {
+function renderPortalState(prev, parentBlock, target, rawBody, rawProps, host, env, key = null) {
   const hydration = activeHydration();
   if (hydration !== null) {
     return hydration.suspend(
-      () => renderPortalState(prev, parentBlock, target, rawBody, rawProps, host, env)
+      () => renderPortalState(prev, parentBlock, target, rawBody, rawProps, host, env, key)
     );
   }
   const norm = normalizePortalBody(rawBody, rawProps);
   let state = prev;
-  if (state === null || state.target !== target) {
+  if (state === null || state.target !== target || state.key !== key) {
     if (state !== null) teardownPortalState(state);
     const start = document.createComment("portal");
     const end = document.createComment("/portal");
@@ -11439,7 +12175,7 @@ function renderPortalState(prev, parentBlock, target, rawBody, rawProps, host, e
     if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__) {
       __profileTrackComponent(block, profilePortalComponent(rawBody));
     }
-    state = { __kind: "portalSlotSlot", block, target, host, start, end };
+    state = { __kind: "portalSlotSlot", block, target, key, host, start, end };
     registerPortalEventRange(target, state);
     activityPortalCreated?.(block);
     registerDelegationTarget(target);
@@ -11521,9 +12257,13 @@ function genericPortalBody(value, scope) {
   childSlot(scope, 0, scope.parentNode, value, scope.endMarker);
 }
 const PORTAL_TAG = /* @__PURE__ */ Symbol.for("octane.portal");
+function portalKey(value) {
+  return typeof value === "string" || typeof value === "number" ? String(value) : null;
+}
 // @__NO_SIDE_EFFECTS__
 function createPortal(body, target, props = void 0) {
-  return { $$kind: PORTAL_TAG, body, target, props };
+  const key = portalKey(props);
+  return { $$kind: PORTAL_TAG, body, target, key, props: key === null ? props : void 0 };
 }
 const ELEMENT_TAG = /* @__PURE__ */ Symbol.for("octane.element");
 const KEYED_ELEMENT_DESCRIPTORS = /* @__PURE__ */ new WeakSet();
@@ -11942,6 +12682,7 @@ function componentSlotVoid(parentScope, slotKey, domParent, comp, props, anchor,
   );
 }
 function componentSlotImpl(outputHandler, parentScope, slotKey, domParent, body, identity, props, renderProps, anchor, key, singleRoot, inherit, hasKey) {
+  if (CURRENT_BLOCK?.pending && !CURRENT_BLOCK.crossRenderUpdate) return;
   const parentBlock = parentScope.block;
   const hydration = activeHydration();
   if (hydration !== null && (anchor != null && hydration.isFresh(anchor) || hydration.isFresh(domParent))) {
@@ -12051,8 +12792,8 @@ function componentSlotImpl(outputHandler, parentScope, slotKey, domParent, body,
     parentScope.slots[slotKey] = state;
     registerSlot(parentScope, state);
   }
-  const nextKey = key === void 0 ? NO_KEY : key;
-  const keyChanged = key !== void 0 && state.prevKey !== NO_KEY && !Object.is(key, state.prevKey);
+  const nextKey = key === void 0 ? NO_KEY : "" + key;
+  const keyChanged = key !== void 0 && state.prevKey !== NO_KEY && nextKey !== state.prevKey;
   const replacing = identity !== state.currentComp || keyChanged;
   const journaledSlot = ROOT_RENDER_TRANSACTION !== null && state.block !== null && replacing;
   if (journaledSlot) {
@@ -12507,25 +13248,28 @@ function clearReplacedChildBlock(state, oldBlock) {
 }
 const DEOPT_KEY_WARNED_BLOCKS = /* @__PURE__ */ new WeakSet();
 let DEOPT_KEY_WARNED_WITHOUT_BLOCK = false;
+function warnMissingListKey(owner) {
+  const warned = owner === null ? DEOPT_KEY_WARNED_WITHOUT_BLOCK : DEOPT_KEY_WARNED_BLOCKS.has(owner);
+  if (!warned) {
+    if (owner === null) DEOPT_KEY_WARNED_WITHOUT_BLOCK = true;
+    else DEOPT_KEY_WARNED_BLOCKS.add(owner);
+    console.warn(
+      'Octane: each element in an array child should have a unique "key" prop (e.g. `items.map((x) => <li key={x.id}>\u2026</li>)`). Missing keys can reconcile incorrectly on reorder \u2014 for keyed lists prefer `@for (...; key ...)`.'
+    );
+  }
+}
 function deoptKey(item, index) {
   const element = item != null && item.$$kind === ELEMENT_TAG;
+  if (item?.$$kind === PORTAL_TAG && item.key != null) return item.key;
   if (element && item.key != null && !ELEMENTS_MISSING_LIST_KEY.has(item)) return item.key;
   if (element && process.env.NODE_ENV !== "production" && activeHydration() === null) {
-    const owner = CURRENT_BLOCK;
-    const warned = owner === null ? DEOPT_KEY_WARNED_WITHOUT_BLOCK : DEOPT_KEY_WARNED_BLOCKS.has(owner);
-    if (!warned) {
-      if (owner === null) DEOPT_KEY_WARNED_WITHOUT_BLOCK = true;
-      else DEOPT_KEY_WARNED_BLOCKS.add(owner);
-      console.warn(
-        'Octane: each element in an array child should have a unique "key" prop (e.g. `items.map((x) => <li key={x.id}>\u2026</li>)`). Missing keys can reconcile incorrectly on reorder \u2014 for keyed lists prefer `@for (...; key ...)`.'
-      );
-    }
+    warnMissingListKey(CURRENT_BLOCK);
   }
   return element && item.key != null ? item.key : index;
 }
 const POSITIONAL_CHILDREN = /* @__PURE__ */ new WeakSet();
 function deoptKeyPositional(item, index) {
-  return item != null && item.$$kind === ELEMENT_TAG && item.key != null ? item.key : index;
+  return item != null && (item.$$kind === ELEMENT_TAG || item.$$kind === PORTAL_TAG) && item.key != null ? item.key : index;
 }
 function positionalChildren(children) {
   POSITIONAL_CHILDREN.add(children);
@@ -12541,6 +13285,11 @@ function noteDeoptRef(block) {
   }
 }
 function applyDeoptProp(el, name, v, ownerBlock) {
+  const actionName = formActionAttributeName(el, name);
+  if (actionName !== null) {
+    setFormAction(el, actionName, v, void 0);
+    return;
+  }
   if (name === "ref") {
     if (v != null) {
       noteDeoptRef(ownerBlock);
@@ -12551,7 +13300,7 @@ function applyDeoptProp(el, name, v, ownerBlock) {
   } else if (name === "style") {
     setStyle(el, v, void 0);
   } else {
-    const ev = eventSlot(name);
+    const ev = eventSlot(name, el);
     if (ev !== null) {
       setEventHandler(
         el,
@@ -12573,6 +13322,9 @@ function hasDangerHTML(props) {
   }
   return true;
 }
+function hasHostPropContent(descriptor) {
+  return hasDangerHTML(descriptor.props) || descriptor.type === "textarea" && (descriptor.props?.value != null || descriptor.props?.defaultValue != null);
+}
 function applyDeoptProps(el, props, ownerBlock) {
   if (props == null) {
     if (process.env.NODE_ENV !== "production") queueDevFormDiagnostic(el, ownerBlock);
@@ -12581,7 +13333,7 @@ function applyDeoptProps(el, props, ownerBlock) {
   for (const name in props) {
     if (name === "key" || name === "children") continue;
     if (name === "suppressHydrationWarning") {
-      el.__oct_suppress = props[name] !== false;
+      el.__oct_suppress = props[name] === true;
       continue;
     }
     applyDeoptProp(el, name, props[name], ownerBlock);
@@ -12602,7 +13354,7 @@ function patchDeoptProps(el, prevProps, nextProps, ownerBlock) {
     for (const name in nextProps) {
       if (name === "key" || name === "children") continue;
       if (name === "suppressHydrationWarning") {
-        el.__oct_suppress = nextProps[name] !== false;
+        el.__oct_suppress = nextProps[name] === true;
         continue;
       }
       const nv = nextProps[name];
@@ -12669,8 +13421,13 @@ function applyHostProps(el, props, scope, state) {
   for (const name in props) {
     if (name === "key" || name === "children") continue;
     const v = props[name];
+    const actionName = formActionAttributeName(el, name);
+    if (actionName !== null) {
+      setFormAction(el, actionName, v, prev?.[name]);
+      continue;
+    }
     if (name === "suppressHydrationWarning") {
-      el.__oct_suppress = v !== false;
+      el.__oct_suppress = v === true;
       continue;
     }
     if (name === "ref") {
@@ -12684,7 +13441,7 @@ function applyHostProps(el, props, scope, state) {
     } else if (name === "style") {
       setStyle(el, v, prev != null ? prev.style : void 0);
     } else {
-      const ev = eventSlot(name);
+      const ev = eventSlot(name, el);
       if (ev) {
         if (ev.capture) {
           if (!_delegatedCapture.has(ev.type)) delegateCaptureEvents([ev.type]);
@@ -12791,7 +13548,7 @@ function deoptWrapperKind(value) {
   return POSITIONAL_CHILDREN.has(value) ? "fragment" : "array";
 }
 function scopedDeoptKey(path, item, index, key) {
-  const explicit = isElementDescriptor(item) && item.key != null;
+  const explicit = (isElementDescriptor(item) || item?.$$kind === PORTAL_TAG) && item.key != null;
   if (path.length === 0) return explicit ? "k" + String(key) : "i" + index;
   return JSON.stringify([path, explicit ? "key" : "index", explicit ? String(key) : index]);
 }
@@ -12904,6 +13661,10 @@ function reconcileDeoptNode(prev, value, ownerBlock, ns) {
   if (t === "string" || t === "number" || t === "bigint") {
     const s = String(value);
     if (prev !== null && prev.nodeType === 3) {
+      const hydration = activeHydration();
+      if (hydration !== null && !hydration.isFresh(prev.parentNode)) {
+        return hydration.htextSwap(prev, s);
+      }
       updateTextValue(prev, s);
       return prev;
     }
@@ -12921,7 +13682,7 @@ function reconcileDeoptNode(prev, value, ownerBlock, ns) {
       applyDeoptProps(el, value.props, ownerBlock);
     }
     setDeoptDesc(el, value);
-    if (!hasDangerHTML(value.props)) {
+    if (!hasHostPropContent(value)) {
       reconcileDeoptChildren(el, value.children, ownerBlock);
     }
     return el;
@@ -12937,7 +13698,12 @@ function reconcileDeoptChildren(el, children, ownerBlock) {
   if (type === "string" && children !== "" || type === "number" || type === "bigint") {
     const first = getFirstChild(el);
     if (first !== null && first.nodeType === 3 && getNextSibling(first) === null && first.$$deoptKey === 0 && first.$$portalEnd == null) {
-      updateTextValue(first, String(children));
+      const hydration = activeHydration();
+      if (hydration !== null && !hydration.isFresh(el)) {
+        hydration.htextSwap(first, String(children));
+      } else {
+        updateTextValue(first, String(children));
+      }
       return;
     }
   }
@@ -13015,6 +13781,10 @@ function reconcileDeoptChildren(el, children, ownerBlock) {
   for (let i = owned.length - 1; i >= 0; i--) {
     const n = owned[i];
     if (keep === null || !keep.has(n)) {
+      const hydration = activeHydration();
+      if (hydration !== null && !hydration.isFresh(el)) {
+        noteRecoverableHydrationError(() => new Error(formatClientError(62)), ownerBlock);
+      }
       if (journal) {
         journalRootChildren(el);
         deferRootRange(el, n, n, () => detachDeoptTreeRefs(n, null));
@@ -13245,6 +14015,7 @@ function mappedDeoptItemBody(item, scope) {
 function descNeedsBlocks(value) {
   if (typeof value === "function") return true;
   if (value == null || typeof value !== "object") return false;
+  if (typeof value.then === "function") return true;
   if (Array.isArray(value)) {
     for (let i = 0; i < value.length; i++) {
       if (descNeedsBlocks(value[i])) return true;
@@ -13270,7 +14041,7 @@ function hostElementBody(d, block) {
     applyDeoptProps(el, d.props, block);
     setDeoptDesc(el, d);
     const savedCursor = hydration.node.nextSibling;
-    if (!hasDangerHTML(d.props)) {
+    if (!hasHostPropContent(d)) {
       hydration.node = el.firstChild;
       childSlot(block, 0, el, d.children, null, false, el);
     }
@@ -13298,7 +14069,7 @@ function hostElementBody(d, block) {
     block.parentNode.insertBefore(el, block.endMarker);
     applyDeoptProps(el, d.props, block);
     setDeoptDesc(el, d);
-    if (!hasDangerHTML(d.props)) {
+    if (!hasHostPropContent(d)) {
       hydration.suspend(() => childSlot(block, 0, el, d.children, null, false, el));
     }
     return;
@@ -13334,7 +14105,7 @@ function hostElementBody(d, block) {
     patchDeoptProps(el, getDeoptDesc(el)?.props ?? null, d.props, block);
   }
   setDeoptDesc(el, d);
-  if (!hasDangerHTML(d.props)) childSlot(block, 0, el, d.children, null, false, el);
+  if (!hasHostPropContent(d)) childSlot(block, 0, el, d.children, null, false, el);
 }
 function hostStringTagBody(d, block) {
   const tag = d.type;
@@ -13348,7 +14119,7 @@ function hostStringTagBody(d, block) {
       applyDeoptProps(el, d.props, block);
       setDeoptDesc(el, d);
       const savedCursor = hydration.node.nextSibling;
-      if (!hasDangerHTML(d.props)) {
+      if (!hasHostPropContent(d)) {
         hydration.node = el.firstChild;
         renderHostTagChildren(d, block, el);
       }
@@ -13376,7 +14147,7 @@ function hostStringTagBody(d, block) {
       block.parentNode.insertBefore(el, block.endMarker);
       applyDeoptProps(el, d.props, block);
       setDeoptDesc(el, d);
-      if (!hasDangerHTML(d.props)) {
+      if (!hasHostPropContent(d)) {
         hydration.suspend(() => renderHostTagChildren(d, block, el));
       }
       return;
@@ -13390,7 +14161,7 @@ function hostStringTagBody(d, block) {
     patchDeoptProps(el, getDeoptDesc(el)?.props ?? null, d.props, block);
   }
   setDeoptDesc(el, d);
-  if (!hasDangerHTML(d.props)) renderHostTagChildren(d, block, el);
+  if (!hasHostPropContent(d)) renderHostTagChildren(d, block, el);
 }
 function renderHostTagChildren(d, block, el) {
   const kids = d.children;
@@ -13568,6 +14339,8 @@ function mapSlot(scopeOrItems, slotOrMethod, domParent, items, method, native, c
     callback = native;
     native = mapSlot(items, method);
   }
+  if (process.env.NODE_ENV !== "production" && ((flags ?? 0) & 64) !== 0 && items?.length > 0)
+    warnMissingListKey(scopeOrItems.block);
   if (ownEnd === 1) ownEnd = true;
   if (native === true) {
     const previous = scopeOrItems.slots[slotOrMethod]?.forSlot;
@@ -13837,6 +14610,7 @@ function renderPreparedChildList(state, parentBlock, domParent, preparedList, hy
   return;
 }
 function childSlot(parentScope, slotKey, domParent, value, anchor, ownEnd, ownsHost, compactable, includeKeyedSingle = true, compiledMapBody, compiledMapKey, compiledMapFlags, compiledMapDeps, mappedFallback) {
+  if (CURRENT_BLOCK?.pending && !CURRENT_BLOCK.crossRenderUpdate) return;
   if (value != null && includeKeyedSingle && domParent.nodeType === 1 && VOID_ELEMENTS.has(domParent.localName) && !isPortalTarget(parentScope.block, domParent)) {
     throw new Error(formatClientError(26, domParent.localName));
   }
@@ -13911,7 +14685,7 @@ function childSlot(parentScope, slotKey, domParent, value, anchor, ownEnd, ownsH
         slotKey,
         domParent,
         value,
-        anchor,
+        anchor?.parentNode === domParent ? anchor : null,
         ownEnd,
         ownsHost,
         compactable,
@@ -14032,7 +14806,9 @@ function childSlot(parentScope, slotKey, domParent, value, anchor, ownEnd, ownsH
       portalDesc.body,
       portalDesc.props,
       // The DOM element containing this hole is the portal's logical parent.
-      domParent
+      domParent,
+      void 0,
+      portalDesc.key
     );
     if (activeFragments.size !== 0 && state.end !== null) {
       registerValuePortalFragmentOwners(state.portal, parentBlock, state.end);
@@ -14668,7 +15444,17 @@ function memo(component, arePropsEqual) {
   function memoWrapper(props, scope, extra) {
     return component(props, scope, extra);
   }
-  memoWrapper.__memo = true;
+  Object.defineProperty(memoWrapper, "type", { value: component });
+  Object.defineProperty(memoWrapper, "displayName", {
+    configurable: true,
+    writable: true,
+    value: component.displayName || component.name || "Memo"
+  });
+  Object.defineProperty(memoWrapper, "__memo", {
+    get() {
+      return this === memoWrapper;
+    }
+  });
   Object.defineProperty(memoWrapper, "defaultProps", {
     configurable: true,
     get: () => component.defaultProps,
@@ -14678,7 +15464,7 @@ function memo(component, arePropsEqual) {
   });
   if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__)
     __profileComponentSource(memoWrapper, component);
-  if (arePropsEqual) memoWrapper.__compare = arePropsEqual;
+  if (arePropsEqual) Object.defineProperty(memoWrapper, "__compare", { value: arePropsEqual });
   return memoWrapper;
 }
 const HMR = /* @__PURE__ */ Symbol.for("octane.hmr");
@@ -14703,7 +15489,7 @@ function hmr(fn) {
       meta.fn = nextFn;
       if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__)
         __profileComponentSource(wrapper, meta.fn);
-      wrapper.__warm = meta.fn.__warm;
+      markWarm(wrapper, meta.fn.__warm);
       const it = meta.liveBlocks.values();
       for (let r = it.next(); !r.done; r = it.next()) {
         const b = r.value;
@@ -14725,10 +15511,14 @@ function hmr(fn) {
     if (scope !== void 0) meta.liveBlocks.add(scope.block);
     return meta.fn(props, scope, extra);
   }
-  wrapper[HMR] = meta;
+  Object.defineProperty(wrapper, HMR, {
+    get() {
+      return this === wrapper ? meta : void 0;
+    }
+  });
   if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__)
     __profileComponentSource(wrapper, fn);
-  if (fn.__warm !== void 0) wrapper.__warm = fn.__warm;
+  if (fn.__warm !== void 0) markWarm(wrapper, fn.__warm);
   return wrapper;
 }
 let TRANSITION_FALLBACK_TIMEOUT_MS = Infinity;
@@ -15521,7 +16311,7 @@ function renderVisibleTry(state, source) {
         throw renderError;
       if (isSuspenseException(renderError)) {
         if (state.propagateSuspense) throw renderError;
-        handleSuspense(state, renderError.thenable, block, journalCheckpoint);
+        handleSuspense(state, renderError.thenable, block, journalCheckpoint, source ?? block);
       } else switchToCatch(state, renderError, true);
     } else {
       if (capture !== null) spliceOffscreenCapture(capture);
@@ -15806,6 +16596,7 @@ function releaseHeldTransition(state) {
   if (state.transitionHeld) {
     state.transitionHeld = false;
     tickTransitionCount(-1);
+    releaseTransitionHookHolder(state);
   }
   abandonHeldTransition(state);
   if (state.transitionTimeoutId !== null) {
@@ -15813,14 +16604,15 @@ function releaseHeldTransition(state) {
     state.transitionTimeoutId = null;
   }
 }
-function handleSuspense(state, thenable, sourceBlock, journalCheckpoint = -1) {
+function handleSuspense(state, thenable, sourceBlock, journalCheckpoint = -1, transitionOrigin = sourceBlock) {
   ensureScheduledVisibilityDriver();
   const isTransition = sourceBlock.currentRenderMode === "transition";
-  if ((isTransition || state.transitionHeld) && state.hasResolved && state.branch === 1 && state.hiddenDom === null) {
+  if (isTransition && state.hasResolved && state.branch === 1 && state.hiddenDom === null) {
     rollbackTransitionJournal(journalCheckpoint, state.tryBlock ?? sourceBlock);
     if (ACTIVE_TRANSITION_ATTEMPT !== null) {
       (ACTIVE_TRANSITION_ATTEMPT.heldSlots ??= /* @__PURE__ */ new Set()).add(state);
     }
+    holdTransitionHooksForBlock(state, transitionOrigin);
     if (!state.transitionHeld) {
       state.transitionHeld = true;
       tickTransitionCount(1);
@@ -15841,6 +16633,7 @@ function handleSuspense(state, thenable, sourceBlock, journalCheckpoint = -1) {
     attachResume(state, thenable);
     return;
   }
+  if (!isTransition) releaseHeldTransition(state);
   hideTryContentAndMountPending(state, thenable);
 }
 function invalidatePendingSuspenseEffects(owner) {
@@ -16133,7 +16926,10 @@ function commitResumeInner(state) {
     if (!deferringStagedRevealEffects) commitEffects();
   } finally {
     if (hiddenActivity !== null) rehideActivityAfterDescendantRender(hiddenActivity);
-    if (releaseHeld) tickTransitionCount(-1);
+    if (releaseHeld) {
+      tickTransitionCount(-1);
+      releaseTransitionHookHolder(state);
+    }
   }
 }
 function findScheduledVisibilityOwner(block, includeActivity, visibleMode = null) {
@@ -16453,6 +17249,7 @@ function attemptHiddenRevealInner(state, scheduledMode, reason = "update") {
     if (state.transitionHeld) {
       state.transitionHeld = false;
       tickTransitionCount(-1);
+      releaseTransitionHookHolder(state);
     }
     if (HELD_TRANSITIONS.has(state)) {
       HELD_TRANSITIONS.delete(state);
@@ -16507,6 +17304,7 @@ function flushStagedReveals() {
         break;
       }
     }
+    if (allVisible && heldTransitionHasPendingAction(HELD_SYNC_TRANSITION.entries)) return;
     if (allVisible && promoteHeldSyncTransition()) {
       STAGED_REVEALS.clear();
       flush();
@@ -16586,6 +17384,9 @@ function attachResume(state, thenable) {
   thenable.then(retry, retry);
 }
 function startTransition(fn) {
+  runTransition(fn);
+}
+function runTransition(fn, hook) {
   ensureTransitionSwapDriver();
   TRANSITION_DEPTH++;
   const parentActionBatch = ACTIVE_TRANSITION_ACTION_BATCH;
@@ -16593,6 +17394,10 @@ function startTransition(fn) {
   const actionBatch = parentActionBatch ?? pendingActionBatch ?? createTransitionActionBatch();
   const ownsActionBatch = parentActionBatch === null && pendingActionBatch === null;
   ACTIVE_TRANSITION_ACTION_BATCH = actionBatch;
+  if (hook !== void 0) {
+    addTransitionHookToBatch(actionBatch, hook);
+    publishTransitionHookBatch(actionBatch);
+  }
   const submitRec = ACTIVE_SUBMIT_DISPATCH;
   if (submitRec !== null) submitRec.transitions++;
   let result;
@@ -16622,7 +17427,10 @@ function startTransition(fn) {
     tickTransitionCount(-1);
     if (submitRec !== null) settleSubmitTransition(submitRec);
     flushFormResets();
-    throw err;
+    actionBatch.workComplete = true;
+    finishTransitionHookBatch(actionBatch);
+    reportTransitionError(err, hook);
+    return;
   }
   if (result != null && typeof result.then === "function") {
     ASYNC_TRANSITION_COUNT++;
@@ -16636,16 +17444,31 @@ function startTransition(fn) {
       ASYNC_TRANSITION_COUNT--;
       if (submitRec !== null) settleSubmitTransition(submitRec);
       flushFormResets();
+      queueMicrotask(() => {
+        actionBatch.workComplete = true;
+        finishTransitionHookBatch(actionBatch);
+      });
     };
-    result.then(settle, settle);
+    result.then(settle, (error) => {
+      settle();
+      reportTransitionError(error, hook);
+    });
   } else {
     queueMicrotask(() => {
       tickTransitionCount(-1);
       if (submitRec !== null) settleSubmitTransition(submitRec);
       flushFormResets();
+      actionBatch.workComplete = true;
+      finishTransitionHookBatch(actionBatch);
     });
   }
 }
+function reportTransitionError(error, hook) {
+  if (hook !== void 0 && !hook.block.disposed) {
+    hook.error = { value: error };
+    scheduleRender(hook.block);
+  } else reportListenerError(error);
+}
 function useTransition(slot) {
   slot = resolveSlot(slot);
   if (slot === void 0) missingSlot("useTransition");
@@ -16653,22 +17476,33 @@ function useTransition(slot) {
   const block = CURRENT_BLOCK;
   let s = scope.hooks?.get(slot);
   if (s === void 0) {
-    const slotRef = { isPending: false, start: startTransition };
-    s = slotRef;
-    ensureHooks(scope).set(slot, slotRef);
-    const listener = () => {
-      const next = TRANSITION_PENDING_COUNT > 0;
-      if (slotRef.isPending !== next) {
-        slotRef.isPending = next;
-        if (!block.disposed) {
+    const hook = {
+      isPending: false,
+      block,
+      pendingBatches: 0,
+      start: (fn) => {
+        if (!block.disposed) runTransition(fn, hook);
+      },
+      publish: (pending) => {
+        if (hook.isPending === pending || block.disposed) return;
+        hook.isPending = pending;
+        TRANSITION_LISTENER_PUBLISH_DEPTH++;
+        try {
           if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__)
             __profileSchedule(block, "transition-pending", slot);
           scheduleRender(block);
+        } finally {
+          TRANSITION_LISTENER_PUBLISH_DEPTH--;
         }
       }
     };
-    TRANSITION_LISTENERS.add(listener);
-    registerHookCleanup(scope, () => TRANSITION_LISTENERS.delete(listener));
+    s = hook;
+    ensureHooks(scope).set(slot, hook);
+  }
+  if (s.error !== void 0) {
+    const error = s.error.value;
+    s.error = void 0;
+    throw error;
   }
   return [s.isPending, s.start];
 }
@@ -16699,6 +17533,7 @@ function useActionState(action, initialState, permalinkOrSlot, slot) {
       }
     };
     const dispatch = ((payload) => {
+      const outsideTransition = process.env.NODE_ENV !== "production" && transitionActionBatchForUpdate() === null && ACTIVE_SUBMIT_DISPATCH?.intercepted !== true;
       slotRef.pendingCount++;
       setPending(true);
       slotRef.chain = slotRef.chain.then(
@@ -16710,7 +17545,13 @@ function useActionState(action, initialState, permalinkOrSlot, slot) {
           startTransition(() => {
             let p;
             try {
-              p = Promise.resolve(slotRef.action(prevState, payload));
+              const result = slotRef.action(prevState, payload);
+              if (process.env.NODE_ENV !== "production" && outsideTransition && result != null && typeof result.then === "function") {
+                console.error(
+                  "An async useActionState action was dispatched outside a transition or action. Use an action/formAction prop or wrap the dispatch in startTransition."
+                );
+              }
+              p = Promise.resolve(result);
             } catch (err) {
               finish();
               const handler = findTryHandler(block);
@@ -16738,7 +17579,7 @@ function useActionState(action, initialState, permalinkOrSlot, slot) {
                 resolveResult(prevState);
               }
             );
-            return p;
+            return p.then(noop, noop);
           });
         })
       );
@@ -16826,6 +17667,11 @@ function useOptimistic(passthrough, updateFnOrSlot, slot) {
       updateFn,
       armed: false,
       add: (value) => {
+        if (process.env.NODE_ENV !== "production" && TRANSITION_DEPTH === 0 && ASYNC_TRANSITION_COUNT === 0) {
+          console.error(
+            "An optimistic update was dispatched outside a transition or action. Wrap it in startTransition or call it from an action."
+          );
+        }
         slotRef.queue.push(value);
         if (TRANSITION_PENDING_COUNT > 0) {
           slotRef.armed = true;
@@ -16859,11 +17705,11 @@ function spawnDeferredSwap(s) {
   queueMicrotask(() => {
     if (!s.scheduled || s.block.disposed) return;
     s.scheduled = false;
-    if (Object.is(s.current, s.next)) return;
-    s.current = s.next;
+    if (Object.is(s.value, s.next)) return;
     startTransition(() => {
       DEFERRED_SPAWN = true;
       try {
+        stageTransitionValue(s, s.block, s.next, s.next, true);
         if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__) {
           __profileSchedule(s.block, "deferred-value", s.profileSlot);
           scheduleRender(s.block);
@@ -16874,6 +17720,14 @@ function spawnDeferredSwap(s) {
     });
   });
 }
+function hasHeldDeferredSwap(slot) {
+  const entries = HELD_SYNC_TRANSITION?.entries ?? slot.block.idState.renderOwner?.transition?.entries;
+  if (entries === void 0) return false;
+  for (const entry of entries) {
+    if (entry.slot === slot && Object.is(entry.value, slot.next)) return true;
+  }
+  return false;
+}
 function useDeferredValue(value, ...rest) {
   let slot = rest[rest.length - 1];
   slot = resolveSlot(slot);
@@ -16887,7 +17741,7 @@ function useDeferredValue(value, ...rest) {
   if (s === void 0) {
     if (hasInitial && !block.currentRenderDeferred) {
       s = {
-        current: initialValue,
+        value: initialValue,
         next: value,
         scheduled: false,
         block,
@@ -16899,31 +17753,32 @@ function useDeferredValue(value, ...rest) {
       if (!Object.is(initialValue, value)) spawnDeferredSwap(s);
       return initialValue;
     }
-    s = { current: value, next: value, scheduled: false, block, wasHidden: hidden };
+    s = { value, next: value, scheduled: false, block, wasHidden: hidden };
     if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__)
       s.profileSlot = slot;
     ensureHooks(scope).set(slot, s);
     return value;
   }
+  if (ACTIVE_TRANSITION_ATTEMPT !== null) journalObjectOnce(s);
   s.next = value;
   const wasHidden = s.wasHidden;
   s.wasHidden = hidden;
-  if (Object.is(s.current, value)) return s.current;
+  if (Object.is(s.value, value)) return s.value;
   if (hidden || wasHidden) {
     if (hasInitial && !block.currentRenderDeferred && !Object.is(initialValue, value)) {
-      s.current = initialValue;
+      s.value = initialValue;
       if (!s.scheduled) spawnDeferredSwap(s);
       return initialValue;
     }
-    s.current = value;
+    s.value = value;
     return value;
   }
   if (block.currentRenderMode === "transition") {
-    s.current = value;
+    s.value = value;
     return value;
   }
-  if (!s.scheduled) spawnDeferredSwap(s);
-  return s.current;
+  if (!s.scheduled && !hasHeldDeferredSwap(s)) spawnDeferredSwap(s);
+  return s.value;
 }
 function requestReset(state) {
   if (state.parentBlock.disposed || state.branch !== 0) return;
@@ -16997,6 +17852,7 @@ function switchToCatchInner(state, err, reportInline, adoptedStart, adoptedEnd)
   if (state.transitionHeld) {
     state.transitionHeld = false;
     tickTransitionCount(-1);
+    releaseTransitionHookHolder(state);
   }
   abandonHeldTransition(state);
   if (state.catchBody === null) {
@@ -17158,6 +18014,7 @@ function sharesBlockBoundary(parent, start, end) {
   return parent !== null && start !== null && end !== null && parent.startMarker === start && parent.endMarker === end;
 }
 function renderBranchSlot(parentScope, slotKey, state, domParent, next, body, marker, env) {
+  if (CURRENT_BLOCK?.pending && !CURRENT_BLOCK.crossRenderUpdate) return;
   const parentBlock = parentScope.block;
   const hydration = activeHydration();
   if (next !== state.branch) {
@@ -17822,6 +18679,7 @@ function queueActivityDeactivation(state, block, commitVersion) {
   });
 }
 function activityBlock(parentScope, slotKey, domParent, mode, body, anchor, env) {
+  if (CURRENT_BLOCK?.pending && !CURRENT_BLOCK.crossRenderUpdate) return;
   if (mode === "hidden") ensureScheduledVisibilityDriver();
   const parentBlock = parentScope.block;
   const hydration = activeHydration();
@@ -18060,7 +18918,7 @@ function deactivateScope(scope, disconnectPassive = true) {
         const cleanup = e.cleanup;
         e.cleanup = void 0;
         try {
-          runEffectCleanupCallback(cleanup);
+          runEffectCleanupCallback(cleanup, e.phase);
         } catch (err) {
           if (err instanceof MaximumUpdateDepthError) throw err;
           const handler = findTryHandler(scope.block);
@@ -18111,6 +18969,7 @@ 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) {
+  if (CURRENT_BLOCK?.pending && !CURRENT_BLOCK.crossRenderUpdate) return;
   const parentBlock = parentScope.block;
   const hydration = activeHydration();
   let state = parentScope.slots[slotKey];
@@ -18266,6 +19125,7 @@ function forBlock(parentScope, slotKey, domParent, items, getKey, itemBody, flag
   }
 }
 function keyedForBlock(parentScope, slotKey, domParent, items, getKey, itemBody, flags, deps, emptyBody, anchor, ownEnd, selectionBody) {
+  if (CURRENT_BLOCK?.pending && !CURRENT_BLOCK.crossRenderUpdate) return;
   const state = parentScope.slots[slotKey];
   if (TRANSITION_JOURNAL !== null && ROOT_RENDER_TRANSACTION === null) {
     if (state !== void 0) {
@@ -18594,9 +19454,25 @@ function consumeAdoptQueuePrefix(adopt, count) {
   if (count < adopt.length) adopt.copyWithin(0, count);
   adopt.length -= count;
 }
+function checkedListKey(getKey) {
+  const seen = /* @__PURE__ */ new Map();
+  let warned = false;
+  return (item, index) => {
+    const key = getKey(item, index);
+    if (!warned && seen.has(key) && seen.get(key) !== index) {
+      warned = true;
+      const label = typeof key === "object" || typeof key === "function" ? "[object identity]" : String(key);
+      console.error(
+        `Encountered two children with the same key, ${label}. Keys should be unique so that components maintain their identity across updates.`
+      );
+    } else seen.set(key, index);
+    return key;
+  };
+}
 function mountItemsLinear(parentBlock, state, items, getKey, itemBody, singleRoot, ssrMarkerless) {
   const newLen = items.length;
   if (newLen === 0) return;
+  if (process.env.NODE_ENV !== "production") getKey = checkedListKey(getKey);
   if (TRANSITION_JOURNAL !== null) journalForSlot(state);
   const oldItems = state.items;
   const parentNode = state.end.parentNode;
@@ -18666,6 +19542,7 @@ function reconcileKeyed(parentBlock, state, items, getKey, itemBody, pure, singl
     mountItemsLinear(parentBlock, state, items, getKey, itemBody, singleRoot, ssrMarkerless);
     return;
   }
+  if (process.env.NODE_ENV !== "production") getKey = checkedListKey(getKey);
   if (newLen === 0) {
     if (journalShape) journalForSlot(state);
     batchClearItems(state, oldItems);
@@ -18924,81 +19801,72 @@ function reconcileKeyed(parentBlock, state, items, getKey, itemBody, pure, singl
       }
     }
     const middleEndAnchor = afterMiddle ? afterMiddle.startMarker : state.end;
-    let nextBlock = afterMiddle;
-    let lastPlaced = null;
-    if (moved) {
+    if (patched === newMidLen) {
       const seq = lis(sources, newMidLen);
       let seqIdx = seq.length - 1;
+      let nextBlock = afterMiddle;
       for (let i = newMidLen - 1; i >= 0; i--) {
-        const targetIdx = i + prefixLen;
-        const key = newKeys[i];
-        const anchor = nextBlock ? nextBlock.startMarker : middleEndAnchor;
-        let block;
-        if (sources[i] === -1) {
-          const item = items[targetIdx];
-          block = mountItem(
-            parentBlock,
-            parentNode,
-            anchor,
-            item,
-            targetIdx,
-            itemBody,
-            state,
-            singleRoot,
-            ssrMarkerless
-          );
-          oldItems.set(key, block);
-          block.key = key;
-          state.size++;
-        } else if (seqIdx < 0 || i !== seq[seqIdx]) {
-          block = oldItems.get(key);
-          moveBlockBefore(block, anchor);
-        } else {
-          block = oldItems.get(key);
-          seqIdx--;
-        }
+        const block = oldItems.get(newKeys[i]);
+        if (seqIdx < 0 || i !== seq[seqIdx]) {
+          moveBlockBefore(block, nextBlock ? nextBlock.startMarker : middleEndAnchor);
+        } else seqIdx--;
         block.nextSibling = nextBlock;
         if (nextBlock) nextBlock.prevSibling = block;
-        if (lastPlaced === null) lastPlaced = block;
+        else state.tail = block;
         nextBlock = block;
       }
-    } else {
+      nextBlock.prevSibling = beforeMiddle;
+      if (beforeMiddle) beforeMiddle.nextSibling = nextBlock;
+      else state.head = nextBlock;
+      return;
+    }
+    if (moved) {
+      const seq = lis(sources, newMidLen);
+      let seqIdx = seq.length - 1;
+      let anchor = middleEndAnchor;
       for (let i = newMidLen - 1; i >= 0; i--) {
-        const targetIdx = i + prefixLen;
-        const key = newKeys[i];
-        const anchor = nextBlock ? nextBlock.startMarker : middleEndAnchor;
-        let block;
-        if (sources[i] === -1) {
-          const item = items[targetIdx];
-          block = mountItem(
-            parentBlock,
-            parentNode,
-            anchor,
-            item,
-            targetIdx,
-            itemBody,
-            state,
-            singleRoot,
-            ssrMarkerless
-          );
-          oldItems.set(key, block);
-          block.key = key;
-          state.size++;
-        } else {
-          block = oldItems.get(key);
+        if (sources[i] === -1) continue;
+        const block = oldItems.get(newKeys[i]);
+        if (seqIdx < 0 || i !== seq[seqIdx]) moveBlockBefore(block, anchor);
+        else seqIdx--;
+        anchor = block.startMarker;
+      }
+    }
+    let previous = beforeMiddle;
+    let nextSurvivor = 0;
+    for (let i = 0; i < newMidLen; i++) {
+      const key = newKeys[i];
+      let block;
+      if (sources[i] === -1) {
+        if (nextSurvivor <= i) {
+          nextSurvivor = i + 1;
+          while (nextSurvivor < newMidLen && sources[nextSurvivor] === -1) nextSurvivor++;
         }
-        block.nextSibling = nextBlock;
-        if (nextBlock) nextBlock.prevSibling = block;
-        if (lastPlaced === null) lastPlaced = block;
-        nextBlock = block;
-      }
+        const anchor = nextSurvivor < newMidLen ? oldItems.get(newKeys[nextSurvivor]).startMarker : middleEndAnchor;
+        const targetIdx = i + prefixLen;
+        block = mountItem(
+          parentBlock,
+          parentNode,
+          anchor,
+          items[targetIdx],
+          targetIdx,
+          itemBody,
+          state,
+          singleRoot,
+          ssrMarkerless
+        );
+        oldItems.set(key, block);
+        block.key = key;
+        state.size++;
+      } else block = oldItems.get(key);
+      block.prevSibling = previous;
+      if (previous) previous.nextSibling = block;
+      else state.head = block;
+      previous = block;
     }
-    const newMiddleHead = nextBlock;
-    const newMiddleTail = lastPlaced;
-    newMiddleHead.prevSibling = beforeMiddle;
-    if (beforeMiddle) beforeMiddle.nextSibling = newMiddleHead;
-    else state.head = newMiddleHead;
-    if (!afterMiddle) state.tail = newMiddleTail;
+    previous.nextSibling = afterMiddle;
+    if (afterMiddle) afterMiddle.prevSibling = previous;
+    else state.tail = previous;
   } finally {
     if (sources.length <= MAX_KEYED_REORDER_SCRATCH && (keyedReorderSources === null || keyedReorderSources.length < sources.length)) {
       keyedReorderSources = sources;
@@ -19704,8 +20572,19 @@ let ROOT_CONTAINER_OWNERS = null;
 const ROOT_RENDERABLE_BODY = ((value) => value === void 0 ? null : value);
 const EMPTY_ROOT_BODY = (() => void 0);
 function assertValidRootContainer(container) {
-  if (container === null || typeof container !== "object" || container.nodeType !== 1) {
-    throw new Error(formatClientError(28));
+  if (container === null || typeof container !== "object" || container.nodeType !== 1 && container.nodeType !== 9 && container.nodeType !== 11) {
+    throw new Error(formatClientError(63));
+  }
+}
+function clearRootContainer(container) {
+  if (container.nodeType !== 9) {
+    container.textContent = "";
+    return;
+  }
+  for (let child2 = container.firstChild; child2 !== null; ) {
+    const next = child2.nextSibling;
+    if (child2.nodeType !== 10) container.removeChild(child2);
+    child2 = next;
   }
 }
 function claimRootContainer(container) {
@@ -19814,17 +20693,19 @@ function devHtmlNesting(childTag, ancestors, childLocation, ancestorLocation) {
 }
 function validateRootHtmlNesting(container, body) {
   if (process.env.NODE_ENV !== "production") {
-    if (componentSourceLoc(body) === void 0 || container.namespaceURI !== "http://www.w3.org/1999/xhtml" || container.localName === "div" || container.localName === "body" || container.localName === "html" || container.localName.includes("-")) {
+    if (container.nodeType !== 1) return;
+    const element = container;
+    if (componentSourceLoc(body) === void 0 || element.namespaceURI !== "http://www.w3.org/1999/xhtml" || element.localName === "div" || element.localName === "body" || element.localName === "html" || element.localName.includes("-")) {
       return;
     }
     const root = container.firstElementChild;
     if (root === null) return;
-    if (invalidHtmlNestingWithParent(root.localName, container.localName) !== null) {
-      devHtmlNesting(root.localName, [container.localName]);
+    if (invalidHtmlNestingWithParent(root.localName, element.localName) !== null) {
+      devHtmlNesting(root.localName, [element.localName]);
       return;
     }
     let child2 = root.firstElementChild;
-    const ancestors = [root.localName, container.localName];
+    const ancestors = [root.localName, element.localName];
     while (child2 !== null && child2.namespaceURI === "http://www.w3.org/1999/xhtml") {
       if (invalidHtmlNestingWithAncestor(child2.localName, ancestors) !== null) {
         devHtmlNesting(child2.localName, ancestors);
@@ -19889,7 +20770,7 @@ function makeRoot(container, rootBlock, currentBody, currentKey, idState, output
     const previousRoot = rootBlock;
     const previousBody = currentBody;
     const previousKey = currentKey;
-    const staged = previousRoot !== null && previousRoot.mounted && !previousRoot.disposed && !renderOwner.transaction.created?.has(previousRoot);
+    const staged = container.nodeType !== 9 && previousRoot !== null && previousRoot.mounted && !previousRoot.disposed && !renderOwner.transaction.created?.has(previousRoot);
     const oldFirst = staged ? container.firstChild : null;
     const oldLast = staged ? container.lastChild : null;
     journalUndo(() => {
@@ -19914,7 +20795,7 @@ function makeRoot(container, rootBlock, currentBody, currentKey, idState, output
         end = document.createComment("/root");
         container.append(start, end);
       } else {
-        while (container.firstChild) container.removeChild(container.firstChild);
+        clearRootContainer(container);
       }
       rootBlock = createBlock(
         "root",
@@ -19957,6 +20838,7 @@ function makeRoot(container, rootBlock, currentBody, currentKey, idState, output
       mountedRoot.pendingMode = mode ?? null;
       try {
         renderBlock(mountedRoot);
+        if (QUEUE.length > 0) drainHydrationRenderPhaseUpdates(mountedRoot);
         if (process.env.NODE_ENV !== "production") {
           validateRootHtmlNesting(container, body);
         }
@@ -20075,7 +20957,8 @@ function makeRoot(container, rootBlock, currentBody, currentKey, idState, output
             false
           );
           drainRefDetaches();
-          container.textContent = "";
+          clearRootContainer(container);
+          drainDeferredPassiveUnmounts();
           rootBlock = null;
           currentBody = null;
           currentKey = null;
@@ -20234,7 +21117,7 @@ function hydrateRoot(container, bodyOrElement, propsOrOptions, rootOptions) {
     journalRootProperty(idState, "next");
     idState.next = 0;
     let firstNode = container.firstChild;
-    while (firstNode !== null && isRendererHydrationStyle(firstNode))
+    while (firstNode !== null && (firstNode.nodeType === 10 || isRendererHydrationStyle(firstNode)))
       firstNode = firstNode.nextSibling;
     const hydration = new HydrationCapability(rootBlock, firstNode, seeds);
     if (nativeManifest !== void 0)
@@ -20267,7 +21150,7 @@ function hydrateRoot(container, bodyOrElement, propsOrOptions, rootOptions) {
         } catch (unhandled) {
           rollbackRootRender(owner.transaction);
           unmountBlock(rootBlock, false);
-          container.textContent = "";
+          clearRootContainer(container);
           if (!reportUncaughtError(rootBlock, unhandled)) throw unhandled;
           return;
         }
@@ -20761,15 +21644,18 @@ export {
   hydrateRoot,
   ifBlock,
   injectStyle,
+  invokeManualHook,
   isChildrenBlock,
   isValidElement,
   keyedForBlock,
   lazy,
+  manualHook,
   mapSlot,
   markChildrenBlock,
   markDangerouslySetInnerHTMLChildren,
   markNativeChangeDiagnosticStatic,
   markSingleRoot,
+  markWarm,
   memo,
   memoPublish,
   memoPublishAlways,