octane 0.2.3 → 0.2.5

package/dist/cjs/runtime.cjs

@@ -61,6 +61,7 @@ __export(runtime_exports, {
   beginNativeReadScope: () => beginNativeReadScope,
   beginNativeReadWitness: () => beginNativeReadWitness,
   bindRendererRegionOwner: () => bindRendererRegionOwner,
+  callWithReceiver: () => callWithReceiver,
   child: () => child,
   childSlot: () => childSlot,
   childTextHole: () => childTextHole,
@@ -130,6 +131,7 @@ __export(runtime_exports, {
   injectStyle: () => injectStyle,
   invokeManualHook: () => invokeManualHook,
   isChildrenBlock: () => isChildrenBlock,
+  isInActScope: () => isInActScope,
   isValidElement: () => isValidElement,
   keyedForBlock: () => keyedForBlock,
   lazy: () => lazy,
@@ -1423,6 +1425,8 @@ function journalRootRange(parent, before, after) {
   for (let node = before === null ? parent.firstChild : before.nextSibling; node !== null && node !== after; node = node.nextSibling)
     nodes.push(node);
   journalUndo(() => {
+    if (before !== null && before.parentNode !== parent || after !== null && after.parentNode !== parent)
+      return;
     let node = before !== null && before.parentNode === parent ? before.nextSibling : parent.firstChild;
     const anchor = after !== null && after.parentNode === parent ? after : null;
     const retained = new Set(nodes);
@@ -1724,12 +1728,17 @@ function journalDefaultValue(input) {
     journalAttr(input, "value");
   }
 }
+function radioCousins(input) {
+  if (input.form !== null) return input.form.elements;
+  const root = input.getRootNode();
+  return root.nodeType === 9 ? root.getElementsByName(input.name) : root.querySelectorAll('input[type="radio"]');
+}
 function journalRadioCousins(input) {
   const name = input.name;
-  const group = input.form !== null ? input.form.elements : typeof document !== "undefined" ? document.getElementsByName(name) : [];
+  const group = radioCousins(input);
   for (let i = 0; i < group.length; i++) {
     const other = group[i];
-    if (other === input || !other.checked || other.localName !== "input" || other.type !== "radio" || other.name !== name) {
+    if (other === input || !other.checked || other.localName !== "input" || other.type !== "radio" || other.name !== name || other.form !== input.form) {
       continue;
     }
     TRANSITION_JOURNAL.push(JOURNAL_PROP, other, "checked", true);
@@ -1796,23 +1805,45 @@ function journalForSlot(state) {
     TRANSITION_JOURNAL_BAGS.delete(state);
   });
 }
+function journalForOwnedListClear(state) {
+  const seen = TRANSITION_JOURNAL_BAGS;
+  const oldItems = state.items;
+  seen.set(state, TRANSITION_JOURNAL.length);
+  const snapshot = {
+    head: state.head,
+    tail: state.tail,
+    size: state.size,
+    empty: state.emptyBlock,
+    entries: oldItems
+  };
+  journalUndo(() => {
+    restoreForSlot(state, snapshot, null);
+    seen.delete(state);
+  });
+  state.items = /* @__PURE__ */ new Map();
+}
 function restoreForSlot(state, snapshot, chain) {
-  const kept = /* @__PURE__ */ new Set();
-  for (let i = 0; i < chain.length; i++) kept.add(chain[i][0]);
+  const preservedMap = chain === null ? snapshot.entries : null;
+  const kept = chain === null ? null : /* @__PURE__ */ new Set();
+  if (chain !== null) for (let i = 0; i < chain.length; i++) kept.add(chain[i][0]);
   for (let b = state.head; b !== null; b = b.nextSibling) {
-    if (!kept.has(b)) unmountBlock(b, false);
+    if (preservedMap !== null || !kept.has(b)) unmountBlock(b, false);
   }
   if (state.end.parentNode === null) return;
   state.head = snapshot.head;
   state.tail = snapshot.tail;
   state.size = snapshot.size;
-  state.items.clear();
-  for (let i = 0; i < snapshot.entries.length; i++) {
-    state.items.set(snapshot.entries[i][0], snapshot.entries[i][1]);
-  }
-  for (let i = 0; i < chain.length; i++) {
-    chain[i][0].nextSibling = chain[i][1];
-    chain[i][0].prevSibling = chain[i][2];
+  if (preservedMap !== null) state.items = preservedMap;
+  else {
+    const originalChain = chain;
+    state.items.clear();
+    for (let i = 0; i < snapshot.entries.length; i++) {
+      state.items.set(snapshot.entries[i][0], snapshot.entries[i][1]);
+    }
+    for (let i = 0; i < originalChain.length; i++) {
+      originalChain[i][0].nextSibling = originalChain[i][1];
+      originalChain[i][0].prevSibling = originalChain[i][2];
+    }
   }
   const nodes = [];
   for (let b = state.head; b !== null; b = b.nextSibling) {
@@ -2273,6 +2304,12 @@ function reapplyFragmentBindings() {
 }
 let IS_OCTANE_ACT_ENVIRONMENT = false;
 let actScopeDepth = 0;
+let actCallbackDepth = 0;
+let asyncActCallbackDepth = 0;
+let actErrors = null;
+function isInActScope() {
+  return actCallbackDepth !== 0 || asyncActCallbackDepth !== 0;
+}
 function setIsOctaneActEnvironment(value) {
   IS_OCTANE_ACT_ENVIRONMENT = value;
 }
@@ -2599,8 +2636,13 @@ function flush() {
       (0, import_devtools_hook.__devtoolsNotifyFlush)();
     return;
   }
-  if (VIEW_TRANSITION_DRIVER?.routeFlush() === true) return;
-  flushWork();
+  try {
+    if (VIEW_TRANSITION_DRIVER?.routeFlush() === true) return;
+    flushWork();
+  } catch (error) {
+    if (actScopeDepth === 0) throw error;
+    (actErrors ??= []).push(error);
+  }
 }
 function activeElementForDocument(doc) {
   try {
@@ -2887,6 +2929,17 @@ function captureFocusedMovement(parent, snapshots) {
   }
   (renderingFocusMoves ??= []).push({ snapshot, ancestors });
 }
+function drainLayoutUpdates(pendingError) {
+  for (let guard = 0; (QUEUE.length > 0 || ROOT_RENDER_TRANSACTIONS.length > 0) && guard < LAYOUT_CASCADE_LIMIT; guard++) {
+    drainPassivesBeforeRender();
+    const focused = QUEUE.length === 0 ? null : captureQueuedFocusSelection();
+    const error = drainQueueWithFocus(focused);
+    if (focused !== null) restoreQueuedFocusSelection(focused);
+    if (error !== null && pendingError === null) pendingError = error;
+    commitEffects();
+  }
+  return pendingError;
+}
 function flushWork() {
   inFlush = true;
   const clearRetainedTransitionUpdates = FLUSHED_TRANSITION_UPDATES.length > 0;
@@ -2895,9 +2948,11 @@ function flushWork() {
   try {
     if (QUEUE.length > 0) drainPassivesBeforeRender();
     const focused = QUEUE.length === 0 ? null : captureQueuedFocusSelection();
-    const pendingError = drainQueueWithFocus(focused);
+    let pendingError = drainQueueWithFocus(focused);
     if (focused !== null) restoreQueuedFocusSelection(focused);
     commitEffects();
+    if (QUEUE.length > 0 || ROOT_RENDER_TRANSACTIONS.length > 0)
+      pendingError = drainLayoutUpdates(pendingError);
     if (pendingError !== null) throw pendingError.err;
   } finally {
     inFlush = false;
@@ -3122,24 +3177,7 @@ function flushSync(fn) {
       if (focused !== null) restoreQueuedFocusSelection(focused);
       commitEffects();
       if (QUEUE.length > 0 || ROOT_RENDER_TRANSACTIONS.length > 0) {
-        const seen = new Set(QUEUE);
-        let defer = false;
-        for (let guard = 0; (QUEUE.length > 0 || ROOT_RENDER_TRANSACTIONS.length > 0) && !defer && guard < LAYOUT_CASCADE_LIMIT; guard++) {
-          drainPassivesBeforeRender();
-          const focused2 = QUEUE.length === 0 ? null : captureQueuedFocusSelection();
-          const err = drainQueueWithFocus(focused2);
-          if (focused2 !== null) restoreQueuedFocusSelection(focused2);
-          if (err !== null && pendingError === null) pendingError = err;
-          commitEffects();
-          for (let i = 0; i < QUEUE.length; i++) {
-            const b = QUEUE[i];
-            if (seen.has(b)) {
-              defer = true;
-              break;
-            }
-            seen.add(b);
-          }
-        }
+        pendingError = drainLayoutUpdates(pendingError);
       }
     } finally {
       inFlush = false;
@@ -3279,6 +3317,35 @@ function drainRefAttaches() {
     }
   }
 }
+let refStateUpdates = null;
+let collectingRefStateUpdates = false;
+function drainCommitRefs() {
+  const previousUpdates = refStateUpdates;
+  const previousCollecting = collectingRefStateUpdates;
+  refStateUpdates = null;
+  collectingRefStateUpdates = true;
+  try {
+    drainRefDetaches();
+    drainRefAttaches();
+  } finally {
+    const updates = refStateUpdates;
+    refStateUpdates = previousUpdates;
+    collectingRefStateUpdates = previousCollecting;
+    if (updates !== null) {
+      REF_CALLBACK_DEPTH++;
+      try {
+        for (const [state, update] of updates) {
+          if (update.block.disposed || Object.is(state.value, update.previous)) continue;
+          if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__)
+            (0, import_profiling.__profileSchedule)(update.block, "state", update.profileSlot);
+          scheduleRender(update.block);
+        }
+      } finally {
+        REF_CALLBACK_DEPTH--;
+      }
+    }
+  }
+}
 function blockSubtreeDisposed(block) {
   let b = block;
   while (b !== null) {
@@ -3325,8 +3392,7 @@ function commitEffects() {
     const caughtReports = drainEffectEventCommitActions();
     drainControlledSyncs();
     const mutationBatch = drainMutationEffects();
-    drainRefDetaches();
-    drainRefAttaches();
+    drainCommitRefs();
     reapplyFragmentBindings();
     if (mutationBatch !== null) runLayoutEffects(mutationBatch);
     if (caughtReports !== null) publishInlineCaughtErrorReports(caughtReports);
@@ -3373,35 +3439,77 @@ function drainEffectEventUpdates() {
     entry.cell.impl = entry.nextImpl;
   }
 }
+function throwPendingActErrors() {
+  const errors = actErrors;
+  actErrors = null;
+  if (errors !== null)
+    throw errors.length === 1 ? errors[0] : new AggregateError(errors, (0, import_error_codes_client_generated.formatClientError)(64));
+}
+function mergePendingActErrors(error) {
+  const errors = actErrors;
+  actErrors = null;
+  return errors === null ? error : new AggregateError([...errors, error], (0, import_error_codes_client_generated.formatClientError)(64));
+}
+function actCheckpoint() {
+  return new Promise((resolve) => {
+    const channel = new MessageChannel();
+    channel.port1.onmessage = () => {
+      channel.port1.close();
+      channel.port2.close();
+      resolve();
+    };
+    channel.port2.postMessage(null);
+  });
+}
 function act(fn) {
+  const nested = isInActScope();
   actScopeDepth++;
+  actCallbackDepth++;
   let result;
   try {
     result = fn();
   } catch (err) {
     actScopeDepth--;
-    return Promise.reject(err);
+    return Promise.reject(mergePendingActErrors(err));
+  } finally {
+    actCallbackDepth--;
   }
   if (result !== null && typeof result === "object" && typeof result.then === "function") {
+    asyncActCallbackDepth++;
     return (async () => {
       try {
-        const value = await result;
+        let value;
+        try {
+          value = await result;
+        } finally {
+          asyncActCallbackDepth--;
+        }
+        if (nested) return value;
         for (let i = 0; i < ACT_DRAIN_LIMIT; i++) {
-          for (let j = 0; j < 5; j++) await Promise.resolve();
+          await actCheckpoint();
+          throwPendingActErrors();
+          const hadWork = hasPendingWork();
           drainPassiveEffects();
-          if (!hasPendingWork()) return value;
+          if (!hadWork && !hasPendingWork()) return value;
         }
         throw new Error((0, import_error_codes_client_generated.formatClientError)(14, ACT_DRAIN_LIMIT));
+      } catch (error) {
+        throw mergePendingActErrors(error);
       } finally {
         actScopeDepth--;
       }
     })();
   }
+  if (nested) {
+    actScopeDepth--;
+    return Promise.resolve(result);
+  }
   try {
     for (let i = 0; i < ACT_DRAIN_LIMIT; i++) {
       if (VIEW_TRANSITION_DRIVER?.wouldWrap() === true) flush();
       else flushSync(() => {
       });
+      throwPendingActErrors();
       drainPassiveEffects();
       if (!hasPendingWork()) break;
       if (i === ACT_DRAIN_LIMIT - 1) {
@@ -3410,16 +3518,20 @@ function act(fn) {
     }
   } catch (err) {
     actScopeDepth--;
-    return Promise.reject(err);
+    return Promise.reject(mergePendingActErrors(err));
   }
   return (async () => {
     try {
       for (let i = 0; i < ACT_DRAIN_LIMIT; i++) {
-        for (let j = 0; j < 5; j++) await Promise.resolve();
+        await actCheckpoint();
+        throwPendingActErrors();
+        const hadWork = hasPendingWork();
         drainPassiveEffects();
-        if (!hasPendingWork()) return result;
+        if (!hadWork && !hasPendingWork()) return result;
       }
       throw new Error((0, import_error_codes_client_generated.formatClientError)(14, ACT_DRAIN_LIMIT));
+    } catch (error) {
+      throw mergePendingActErrors(error);
     } finally {
       actScopeDepth--;
     }
@@ -3874,19 +3986,51 @@ function createBlock(kind, parentBlock, parentNode, startMarker, endMarker, body
   }
   return block;
 }
+let renderPhaseOwner = null;
+let renderPhaseUpdates = null;
+function captureRenderPhaseUpdate(cell, key) {
+  const updates = renderPhaseUpdates ??= /* @__PURE__ */ new Map();
+  if (!updates.has(cell)) updates.set(cell, { value: cell.value, queue: cell[key]?.slice(), key });
+}
 function renderBlock(block) {
   const hydration = activeHydration();
   if (hydration !== null && !hydration.owns(block)) {
     hydration.suspend(() => renderBlock(block));
     return;
   }
-  let retries = 0;
-  while (renderBlockInner(block)) {
-    if (block.nestedUpdateError) {
-      block.nestedUpdateError = false;
-      throw maximumUpdateDepthError();
+  const previousOwner = renderPhaseOwner;
+  let previousUpdates = renderPhaseUpdates;
+  renderPhaseOwner = block;
+  renderPhaseUpdates = null;
+  try {
+    let retries = 0;
+    while (renderBlockInner(block)) {
+      if (block.nestedUpdateError) {
+        block.nestedUpdateError = false;
+        throw maximumUpdateDepthError();
+      }
+      if (++retries > RENDER_PHASE_UPDATE_LIMIT) throw new Error((0, import_error_codes_client_generated.formatClientError)(9));
+    }
+    const updates = renderPhaseUpdates;
+    if (updates !== null && previousOwner !== null && blockIsAncestorOf(previousOwner, block)) {
+      previousUpdates ??= /* @__PURE__ */ new Map();
+      for (const [cell, snapshot] of updates) {
+        if (!previousUpdates.has(cell)) previousUpdates.set(cell, snapshot);
+      }
+    }
+  } catch (error) {
+    const updates = renderPhaseUpdates;
+    if (updates !== null) {
+      for (const [cell, snapshot] of updates) {
+        cell.value = snapshot.value;
+        cell[snapshot.key] = snapshot.queue;
+      }
+      if (!block.crossRenderUpdate) block.pending = false;
     }
-    if (++retries > RENDER_PHASE_UPDATE_LIMIT) throw new Error((0, import_error_codes_client_generated.formatClientError)(9));
+    throw error;
+  } finally {
+    renderPhaseOwner = previousOwner;
+    renderPhaseUpdates = previousUpdates;
   }
 }
 function enqueueEffectEventUpdate(entry) {
@@ -4566,6 +4710,9 @@ function manualHook(fn, name) {
   Object.defineProperty(provider, "length", { value: fn.length, configurable: true });
   return provider;
 }
+function callWithReceiver(fn, receiver, ...args) {
+  return NATIVE_REFLECT_APPLY(fn, receiver, args);
+}
 function withSlot(sym, fn, ...args) {
   const driver = MANUAL_HOOK_DRIVER;
   const pending = driver?.pending;
@@ -4631,6 +4778,7 @@ function useState(initial, slot) {
         if (s.pendingActionBatch !== void 0 && transitionActionBatchForUpdate() === null)
           recordUrgentActionUpdate(s, next);
         if ((s.updates !== void 0 || s.renderTransition !== void 0 || typeof next === "function" && TRANSITION_PENDING_COUNT > 0 && TRANSITION_SWAP_DRIVER?.hasHeld(s, block) || block.pending && typeof next === "function") && transitionActionBatchForUpdate() === null) {
+          if (CURRENT_BLOCK === block) captureRenderPhaseUpdate(s, "updates");
           (s.updates ??= []).push(next);
           scheduleRender(block);
           return;
@@ -4642,6 +4790,7 @@ function useState(initial, slot) {
           computed = typeof next === "function" ? next(previous) : next;
         } catch {
           if (transitionActionBatchForUpdate() === null) {
+            if (CURRENT_BLOCK === block) captureRenderPhaseUpdate(s, "updates");
             (s.updates ??= []).push(next);
             scheduleRender(block);
             return;
@@ -4668,6 +4817,19 @@ function useState(initial, slot) {
           }
           return;
         }
+        if (collectingRefStateUpdates && REF_CALLBACK_DEPTH > 0 && !forceRender) {
+          const updates = refStateUpdates ??= /* @__PURE__ */ new Map();
+          const state = s;
+          if (!updates.has(state)) {
+            const update2 = { block, previous: s.value };
+            if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__)
+              update2.profileSlot = slot;
+            updates.set(state, update2);
+          }
+          s.value = computed;
+          return;
+        }
+        if (CURRENT_BLOCK === block) captureRenderPhaseUpdate(s, "updates");
         s.value = computed;
         if (!block.disposed && typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__)
           (0, import_profiling.__profileSchedule)(block, "state", slot);
@@ -5000,6 +5162,7 @@ function useReducer(reducer, initialArg, initOrSlot, slot) {
       dispatch: (action) => {
         if (block.disposed) return;
         if (CURRENT_BLOCK === block || transitionActionBatchForUpdate() === null) {
+          if (CURRENT_BLOCK === block) captureRenderPhaseUpdate(s, "renderPhaseActions");
           if (s.pendingActionBatch !== void 0 && transitionActionBatchForUpdate() === null)
             recordUrgentActionUpdate(s, (value) => s.reducer(value, action));
           const actions = s.renderPhaseActions ??= [];
@@ -7975,6 +8138,7 @@ class HydrationCapability {
     this.rootBlock = rootBlock;
     this.node = node;
     this.seeds = seeds;
+    initialSuspenseHydrationRenderer = renderInitialSuspenseHydration;
   }
   rootBlock;
   node;
@@ -10053,8 +10217,9 @@ function normalizedHostProp(el, rawName) {
 }
 function setHostPropSources(el, sources, prev, scope, hasNestedChildren = false) {
   const props = /* @__PURE__ */ new Map();
+  let classMerges = null;
   let sourceOrder = 0;
-  const record = (rawName, value) => {
+  function record(rawName, value) {
     if (typeof rawName !== "string") return;
     const order = sourceOrder++;
     const previous = props.get(rawName);
@@ -10064,10 +10229,15 @@ function setHostPropSources(el, sources, prev, scope, hasNestedChildren = false)
       firstOrder: previous?.firstOrder ?? order,
       lastOrder: order
     });
-  };
+  }
   for (const source of sources) {
     if (!source[0]) {
-      record(source[1], source[2]);
+      const rawName = source[1];
+      if (source[3] === true && typeof rawName === "string" && (rawName === "class" || rawName === "className")) {
+        (classMerges ??= []).push({ rawName, value: source[2], order: sourceOrder++ });
+        continue;
+      }
+      record(rawName, source[2]);
       continue;
     }
     const spread = source[1];
@@ -10093,6 +10263,22 @@ function setHostPropSources(el, sources, prev, scope, hasNestedChildren = false)
       writer.lastOrder
     ]);
   }
+  if (classMerges !== null) {
+    for (const extra of classMerges) {
+      const [identity, name] = normalizedHostProp(el, extra.rawName);
+      const previous = values.get(identity);
+      if (previous !== void 0) {
+        values.set(identity, [
+          previous[0],
+          (0, import_css.mergeClass)(previous[1], extra.value),
+          previous[2],
+          extra.order
+        ]);
+        continue;
+      }
+      values.set(identity, [name, extra.value, extra.order, extra.order]);
+    }
+  }
   const resolved = /* @__PURE__ */ Object.create(null);
   const ordered = [...values.values()];
   if (needsWinningOrderSort) ordered.sort((a, b) => a[2] - b[2]);
@@ -10268,11 +10454,12 @@ function headBlock(scope, slot, key, tag, attrs, text) {
     const ownerDocument = parent.nodeType === 9 ? parent : parent.ownerDocument;
     const head = ownerDocument.head;
     let el2 = adoptServerHeadEl(head, (0, import_head_ownership.headOwnershipKey)(key, rootIdentifierPrefix(scope.block)), tag);
+    const adopted = el2 !== null;
     if (el2 === null) {
       el2 = ownerDocument.createElement(tag);
       head.appendChild(el2);
     }
-    state = { el: el2 };
+    state = { el: el2, attrNames: adopted ? el2.getAttributeNames() : void 0 };
     scope.slots[slot] = state;
     (scope.cleanups ??= []).push(() => {
       removeHeadEventListeners(state, null);
@@ -10281,8 +10468,20 @@ function headBlock(scope, slot, key, tag, attrs, text) {
     });
   }
   const el = state.el;
+  if (TRANSITION_JOURNAL !== null) {
+    journalObjectOnce(state);
+    journalBag();
+  }
   if (state.handlers !== void 0) removeHeadEventListeners(state, attrs);
+  const previousNames = state.attrNames;
+  if (previousNames !== void 0) {
+    for (let i = 0; i < previousNames.length; i++) {
+      const name = previousNames[i];
+      if (attrs === null || !(name in attrs)) setAttribute(el, name, null);
+    }
+  }
   if (attrs !== null) {
+    const names = [];
     for (const k in attrs) {
       const ev = k.length > 2 && k[0] === "o" && k[1] === "n" ? eventSlot(k) : null;
       if (ev !== null) {
@@ -10303,12 +10502,19 @@ function headBlock(scope, slot, key, tag, attrs, text) {
         }
         continue;
       }
+      names.push(k);
       setAttribute(el, k, attrs[k]);
     }
+    state.attrNames = names;
+  } else {
+    state.attrNames = void 0;
   }
-  if (text != null) {
-    const t = String(text);
-    if (el.textContent !== t) el.textContent = t;
+  if (text != null || tag === "title") {
+    const t = text == null ? "" : String(text);
+    if (el.textContent !== t) {
+      if (TRANSITION_JOURNAL !== null) journalRootRange(el, null, null);
+      el.textContent = t;
+    }
   }
 }
 function namespaceHead(props, scope) {
@@ -10341,8 +10547,21 @@ function namespaceHeadElement(headKey, tag, attrs, text, authoredKey) {
   return createElement(namespaceHead, config);
 }
 function injectStyle(id, css, nonce) {
+  if (typeof document === "undefined") {
+    _injectedStyles.add(id);
+    return;
+  }
+  const existing = document.querySelector(`style[data-octane="${id}"]`);
+  if (existing !== null) {
+    if (_injectedStyles.has(id)) {
+      if (existing.textContent !== css) existing.textContent = css;
+    } else {
+      _injectedStyles.add(id);
+    }
+    return;
+  }
   if (_injectedStyles.has(id)) return;
-  if (typeof document !== "undefined" && document.querySelector(`style[data-octane="${id}"], style[data-href="octane-${id}"]`)) {
+  if (document.querySelector(`style[data-href~="octane-${id}"]`)) {
     _injectedStyles.add(id);
     return;
   }
@@ -10922,6 +11141,10 @@ function buildDelegatedPath(event, listener, path = event.composedPath()) {
   }
 }
 function fireEventSlot(slot, event) {
+  const previousScope = CURRENT_SCOPE;
+  const previousBlock = CURRENT_BLOCK;
+  CURRENT_SCOPE = null;
+  CURRENT_BLOCK = null;
   try {
     if (typeof slot === "function") {
       slot(event);
@@ -10952,6 +11175,9 @@ function fireEventSlot(slot, event) {
     invokeInvalidEventListener(`${event.type} event`, slot, event);
   } catch (err) {
     reportListenerError(err);
+  } finally {
+    CURRENT_SCOPE = previousScope;
+    CURRENT_BLOCK = previousBlock;
   }
 }
 function invokeInvalidEventListener(label, listener, event) {
@@ -10980,7 +11206,7 @@ function reportListenerError(err) {
 }
 function maybeFlushDiscrete(type) {
   if (_dispatchDepth === 0 && DISCRETE_EVENTS.has(type) && pendingRestores.length > 0) {
-    if (hasPendingWork()) {
+    if (!inFlush && hasPendingWork()) {
       if (VIEW_TRANSITION_DRIVER?.queueAllTransition() === true) flush();
       else flushSync(noop);
     }
@@ -11370,13 +11596,12 @@ function armControlledBase(el) {
       sv: null,
       sawV: false,
       sawC: false,
+      sawDC: false,
       dvv: UNCONTROLLED,
       composing: false,
       compositionEndTask: void 0,
       queued: false,
       formSeen: false,
-      formDefaultValue: UNCONTROLLED,
-      formDefaultChecked: UNCONTROLLED,
       formMultiple: false
     };
     el.$$ctrl = ctrl;
@@ -11551,9 +11776,14 @@ function setCheckedState(input, value, ctrl) {
     if (process.env.NODE_ENV !== "production")
       queueDevFormDiagnostic(input, CURRENT_SCOPE ?? void 0);
     const hydration = activeHydration();
-    if (hydration !== null && !hydration.isFresh(input)) return;
-    if (input.checked !== b) input.checked = b;
+    if (hydration !== null && !hydration.isFresh(input)) {
+      input.checked = input.checked;
+      ctrl.sawDC = true;
+      return;
+    }
+    input.checked = b;
     input.defaultChecked = b;
+    ctrl.sawDC = true;
     return;
   }
   if (process.env.NODE_ENV !== "production" && ctrl.c === -1) devWarnControlledFlip(input, true);
@@ -11567,7 +11797,7 @@ function inActivationWindow(input) {
   const target = activationCheckable;
   if (target === null) return false;
   if (input === target) return true;
-  return input.type === "radio" && target.type === "radio" && input.name !== "" && input.name === target.name && input.form === target.form;
+  return input.type === "radio" && target.type === "radio" && input.name !== "" && input.name === target.name && input.form === target.form && (input.form !== null || input.getRootNode() === target.getRootNode());
 }
 function setChecked(el, value) {
   const ctrl = armControlled(el);
@@ -11705,6 +11935,7 @@ function setDefaultValue(el, value, initial) {
   }
 }
 const DEFAULT_VALUE_BASELINE = /* @__PURE__ */ Symbol("octane.defaultValue");
+const DEFAULT_CHECKED_INITIALIZED = /* @__PURE__ */ Symbol("octane.defaultCheckedInitialized");
 function setDefaultValueUncontrolled(el, value) {
   const hydration = activeHydration();
   const input = el;
@@ -11733,10 +11964,30 @@ function setDefaultValueUncontrolled(el, value) {
 }
 function setDefaultChecked(el, value) {
   const ctrl = armControlled(el);
+  const input = el;
   const hydration = activeHydration();
-  if (hydration !== null && !hydration.isFresh(el) || value == null) return;
+  const hydrating = hydration !== null && !hydration.isFresh(el);
+  const first = !ctrl.sawDC;
+  if (first) {
+    if (TRANSITION_JOURNAL !== null) {
+      journalObjectOnce(ctrl);
+      journalBag();
+    }
+    ctrl.sawDC = true;
+  }
+  if (hydrating) {
+    if (first) input.checked = input.checked;
+    return;
+  }
   if (ctrl.c !== -1) return;
-  const input = el;
+  if (first && !(DEFAULT_CHECKED_INITIALIZED in input)) {
+    if (TRANSITION_JOURNAL !== null) {
+      TRANSITION_JOURNAL.push(JOURNAL_PROP, input, "checked", input.checked);
+      if (input.type === "radio" && input.name !== "" && !!value) journalRadioCousins(input);
+    }
+    input.checked = value == null ? input.checked : !!value;
+  }
+  if (value == null) return;
   const b = !!value;
   if (input.defaultChecked !== b) {
     if (TRANSITION_JOURNAL !== null) {
@@ -11795,15 +12046,12 @@ function setFormControlSources(el, sources) {
   }
   const ctrl = armControlled(el);
   const first = !ctrl.formSeen;
-  const previousDefaultChecked = ctrl.formDefaultChecked;
   const previousMultiple = ctrl.formMultiple;
   if (TRANSITION_JOURNAL !== null) {
     journalObjectOnce(ctrl);
     journalBag();
   }
   ctrl.formSeen = true;
-  ctrl.formDefaultValue = defaultValue;
-  ctrl.formDefaultChecked = defaultChecked;
   if (process.env.NODE_ENV !== "production" && hasDevFormDiagnosticContext(el, CURRENT_SCOPE ?? void 0)) {
     const diagnostic = ensureDevFormDiagnosticState(el);
     diagnostic.authoringProps = { value, defaultValue, checked, defaultChecked, multiple };
@@ -11819,10 +12067,8 @@ function setFormControlSources(el, sources) {
       setDefaultValue(input, defaultString, first);
     }
     setChecked(input, checked);
-    if (checked == null && defaultChecked != null) setDefaultChecked(input, defaultChecked);
-    if (!first && defaultChecked == null && previousDefaultChecked !== UNCONTROLLED && previousDefaultChecked != null) {
-      input.defaultChecked = false;
-    }
+    if (checked == null && (defaultChecked != null || first))
+      setDefaultChecked(input, defaultChecked);
     return;
   }
   if (tag === "textarea") {
@@ -12015,10 +12261,10 @@ function restoreCheckedState(input, ctrl) {
 }
 function restoreRadioCousins(input) {
   const name = input.name;
-  const group = input.form !== null ? input.form.elements : typeof document !== "undefined" ? document.getElementsByName(name) : [];
+  const group = radioCousins(input);
   for (let i = 0; i < group.length; i++) {
     const other = group[i];
-    if (other === input || other.localName !== "input" || other.type !== "radio" || other.name !== name) {
+    if (other === input || other.localName !== "input" || other.type !== "radio" || other.name !== name || other.form !== input.form) {
       continue;
     }
     const octrl = other.$$ctrl;
@@ -13494,19 +13740,29 @@ function hasDangerHTML(props) {
 function hasHostPropContent(descriptor) {
   return hasDangerHTML(descriptor.props) || descriptor.type === "textarea" && (descriptor.props?.value != null || descriptor.props?.defaultValue != null);
 }
+function markInputCheckedness(input) {
+  input.checked = input.checked;
+  input[DEFAULT_CHECKED_INITIALIZED] = true;
+}
 function applyDeoptProps(el, props, ownerBlock) {
   if (props == null) {
+    if (el.localName === "input") markInputCheckedness(el);
     if (process.env.NODE_ENV !== "production") queueDevFormDiagnostic(el, ownerBlock);
     return;
   }
+  let needsCheckedInitialization = el.localName === "input";
   for (const name in props) {
     if (name === "key" || name === "children") continue;
     if (name === "suppressHydrationWarning") {
       el.__oct_suppress = props[name] === true;
       continue;
     }
-    applyDeoptProp(el, name, props[name], ownerBlock);
+    const value = props[name];
+    if (needsCheckedInitialization && (name === "defaultChecked" || name === "checked" && value != null))
+      needsCheckedInitialization = false;
+    applyDeoptProp(el, name, value, ownerBlock);
   }
+  if (needsCheckedInitialization) markInputCheckedness(el);
   if (process.env.NODE_ENV !== "production") queueDevFormDiagnostic(el, ownerBlock);
 }
 function patchDeoptProps(el, prevProps, nextProps, ownerBlock) {
@@ -13567,6 +13823,7 @@ function hostComponent(scope, slot, tag, props, childrenBody, anchor) {
 }
 function applyHostProps(el, props, scope, state) {
   const prev = state.props;
+  let needsCheckedInitialization = prev === void 0 && el.localName === "input";
   if (ROOT_RENDER_TRANSACTION !== null && prev !== props) journalObjectOnce(state);
   if (prev != null) {
     for (const k in prev) {
@@ -13584,12 +13841,15 @@ function applyHostProps(el, props, scope, state) {
   }
   state.props = props;
   if (props == null) {
+    if (needsCheckedInitialization) markInputCheckedness(el);
     if (process.env.NODE_ENV !== "production") queueDevFormDiagnostic(el, scope);
     return;
   }
   for (const name in props) {
     if (name === "key" || name === "children") continue;
     const v = props[name];
+    if (needsCheckedInitialization && (name === "defaultChecked" || name === "checked" && v != null))
+      needsCheckedInitialization = false;
     const actionName = formActionAttributeName(el, name);
     if (actionName !== null) {
       setFormAction(el, actionName, v, prev?.[name]);
@@ -13627,6 +13887,7 @@ function applyHostProps(el, props, scope, state) {
       }
     }
   }
+  if (needsCheckedInitialization) markInputCheckedness(el);
   if (process.env.NODE_ENV !== "production") queueDevFormDiagnostic(el, scope);
 }
 const DEOPT_DESC = /* @__PURE__ */ Symbol("octane.deoptDesc");
@@ -15952,6 +16213,7 @@ function releaseHiddenText(text, restore = true) {
   }
 }
 function teardownTrySlot(state, detachDom) {
+  initialSuspenseHydrations?.delete(state);
   cancelSuspenseRetry(state);
   HIDDEN_REVEAL_ACTIONS?.delete(state);
   if (state.block !== null) unmountBlock(state.block, detachDom);
@@ -16423,6 +16685,15 @@ function tryBlock(parentScope, slotKey, domParent, tryBody, catchBody, pendingBo
     state.env = env;
   }
   const s = state;
+  let initial = initialSuspenseHydrations?.get(s);
+  if (initial === void 0 && hydration !== null && s.branch === -1 && !s.propagateSuspense) {
+    initial = takeInitialSuspenseHydration(s, hydration) ?? void 0;
+    if (initial !== void 0) (initialSuspenseHydrations ??= /* @__PURE__ */ new WeakMap()).set(s, initial);
+  }
+  if (initial !== void 0) {
+    initialSuspenseHydrationRenderer(s, initial);
+    return s.reset;
+  }
   if (s.passthrough) {
     renderPassthroughTry(s);
     return s.reset;
@@ -16540,6 +16811,184 @@ function mountHiddenTryBody(state) {
   hideTryBlock(state);
   return block;
 }
+let initialSuspenseHydrations = null;
+let initialStreamedPayloads = null;
+let initialSuspenseHydrationRenderer = null;
+function takeInitialSuspenseHydration(state, hydration) {
+  const marker = state.start.nextSibling;
+  if (marker?.nodeType !== 8) return null;
+  const text = marker.data;
+  if (text.startsWith(import_constants.STREAM_SEED_COMMENT)) {
+    const boundaryId = text.slice(import_constants.STREAM_SEED_COMMENT.length);
+    const start = marker.nextSibling;
+    if (!hydration.isOpen(start)) return null;
+    const end2 = hydration.close(start);
+    const stash = typeof window !== "undefined" ? window.$OCTS : void 0;
+    const owner = marker;
+    let payload = initialStreamedPayloads?.get(owner);
+    if (payload === void 0) {
+      payload = {
+        seedRaw: typeof stash?.[boundaryId] === "string" ? stash[boundaryId] : null,
+        nativeRaw: typeof stash?.[boundaryId + "$signals"] === "string" ? stash[boundaryId + "$signals"] : null
+      };
+      (initialStreamedPayloads ??= /* @__PURE__ */ new WeakMap()).set(owner, payload);
+      if (stash !== void 0) {
+        delete stash[boundaryId];
+        delete stash[boundaryId + "$signals"];
+      }
+    }
+    state.idState = {
+      prefix: state.parentBlock.idState.prefix + "b" + boundaryId + "-",
+      next: 0,
+      renderOwner: state.parentBlock.idState.renderOwner
+    };
+    return {
+      metadata: [marker],
+      start,
+      end: end2,
+      idStart: 0,
+      ...payload,
+      consume: () => {
+        initialStreamedPayloads?.delete(owner);
+      }
+    };
+  }
+  if (!text.startsWith(import_constants.SUSPENSE_RESOLVED_COMMENT)) return null;
+  const rawCount = text.slice(import_constants.SUSPENSE_RESOLVED_COMMENT.length);
+  if (!/^(?:0|[1-9]\d*)$/.test(rawCount)) return null;
+  const count = Number(rawCount);
+  if (!Number.isSafeInteger(count)) return null;
+  let cursor = marker.nextSibling;
+  let seedRaw = null;
+  let nativeRaw = null;
+  const sidecars = [];
+  for (const attr of [import_constants.SUSPENSE_RESOLVED_SEED_ATTR, import_constants.SUSPENSE_RESOLVED_NATIVE_ATTR]) {
+    if (cursor?.nodeType !== 1) continue;
+    const script = cursor;
+    if (script.localName !== "script" || script.getAttribute("type") !== "application/json" || !script.hasAttribute(attr))
+      continue;
+    if (attr === import_constants.SUSPENSE_RESOLVED_SEED_ATTR) seedRaw = script.textContent;
+    else nativeRaw = script.textContent;
+    sidecars.push(script);
+    cursor = script.nextSibling;
+  }
+  if (!hydration.isOpen(cursor)) return null;
+  const end = hydration.close(cursor);
+  const rootIds = state.idState;
+  const idStart = rootIds.next;
+  reserveHydrationIds(rootIds, count);
+  state.idState = {
+    prefix: rootIds.prefix,
+    next: idStart,
+    limit: idStart + count,
+    overflow: rootIds,
+    renderOwner: rootIds.renderOwner
+  };
+  return {
+    metadata: [marker, ...sidecars],
+    start: cursor,
+    end,
+    idStart,
+    seedRaw,
+    nativeRaw
+  };
+}
+function finishInitialSuspenseHydration(initial, hydration) {
+  for (const node of initial.metadata) node.remove();
+  initial.consume?.();
+  if (hydration.hasAdjacentRangePair) hydration.coalesce();
+}
+function renderInitialSuspenseHydration(state, initial) {
+  state.pendingThenable = null;
+  state.idState.next = initial.idStart;
+  const block = createTryBody(state, initial.start, initial.end);
+  state.block = block;
+  setTryBranch(state, 1);
+  const hydration = new HydrationCapability(block, initial.start.nextSibling, null);
+  if (initial.seedRaw !== null) hydration.seeds = hydration.parseSeeds(initial.seedRaw);
+  hydration.claimRootRemainder(initial.end);
+  hydration.protectRootAnchor(initial.end);
+  const previousHydration = currentHydration;
+  const previousCapture = WIP_CAPTURE;
+  const capture = createOffscreenCapture();
+  currentHydration = hydration;
+  WIP_CAPTURE = capture;
+  const previousNative = (0, import_read_protocol.setNativeAdoptionResolver)(null);
+  let suspended = null;
+  let failed = false;
+  let failure;
+  try {
+    if (initial.nativeRaw !== null) {
+      hydration.nativeAdoption = ownNativeAdoption(
+        block,
+        (0, import_native_read_seeds.parseNativeSignalManifest)(initial.nativeRaw)
+      );
+      (0, import_read_protocol.setNativeAdoptionResolver)(hydration.nativeAdoption.resolve);
+    }
+    renderBlock(block);
+    drainHydrationRenderPhaseUpdates(block);
+    hydration.flushClassWrites();
+    hydration.flushTextWarnings();
+    state.hasResolved = true;
+  } catch (error) {
+    failed = true;
+    failure = error;
+    if (isSuspenseException(error)) suspended = error.thenable;
+    const refs = [];
+    collectVisibleSubtreeRefs(block, refs);
+    withRefDetachSuppression(refs, () => unmountBlock(block, false));
+    state.block = null;
+    state.tryBlock = null;
+    discardOffscreenCapture(capture);
+  } finally {
+    (0, import_read_protocol.setNativeAdoptionResolver)(previousNative);
+    WIP_CAPTURE = previousCapture;
+    currentHydration = previousHydration;
+    if (previousHydration !== null) previousHydration.node = state.end;
+  }
+  if (!failed) {
+    initialSuspenseHydrations?.delete(state);
+    (capture.renderCleanups ??= []).push((discarded) => {
+      if (discarded) return;
+      finishInitialSuspenseHydration(initial, hydration);
+    });
+    spliceOffscreenCapture(capture);
+    return;
+  }
+  if (suspended !== null) {
+    state.pendingThenable = suspended;
+    const resume = () => {
+      if (state.parentBlock.disposed || state.pendingThenable !== suspended || initialSuspenseHydrations?.get(state) !== initial)
+        return;
+      scheduleRender(state.parentBlock);
+    };
+    suspended.then(resume, resume);
+    return;
+  }
+  initialSuspenseHydrations?.delete(state);
+  if (failure instanceof import_read_protocol.NativeAdoptionMiss || isHostContextRequest(failure)) throw failure;
+  const adoptServerCatch = hydration.isRejection(failure);
+  if (!adoptServerCatch) removeRange(initial.start.nextSibling, initial.end);
+  const outerHydration = currentHydration;
+  if (adoptServerCatch) currentHydration = hydration;
+  try {
+    switchToCatch(
+      state,
+      failure,
+      true,
+      adoptServerCatch ? initial.start : void 0,
+      adoptServerCatch ? initial.end : void 0
+    );
+    if (WIP_CAPTURE === null) finishInitialSuspenseHydration(initial, hydration);
+    else
+      (WIP_CAPTURE.renderCleanups ??= []).push((discarded) => {
+        if (!discarded) finishInitialSuspenseHydration(initial, hydration);
+      });
+  } finally {
+    currentHydration = outerHydration;
+    if (outerHydration !== null) outerHydration.node = state.end;
+  }
+}
 function mountTry(state) {
   cancelSuspenseRetry(state);
   HIDDEN_REVEAL_ACTIONS?.delete(state);
@@ -18067,6 +18516,9 @@ function switchToCatchInner(state, err, reportInline, adoptedStart, adoptedEnd)
   );
   b.idState = state.idState;
   state.block = b;
+  if (adopting && hydration !== null && hydration.rootBlock.disposed && hydration.rootBlock.startMarker === bStart && hydration.rootBlock.endMarker === bEnd) {
+    hydration.rootBlock = b;
+  }
   try {
     if (!adopting && hydration !== null) hydration.suspend(() => renderBlock(b));
     else renderBlock(b);
@@ -19137,8 +19589,9 @@ function switchBlock(parentScope, slotKey, domParent, discriminant, cases, defau
   }
   renderBranchSlot(parentScope, slotKey, state, domParent, nextIdx, body, "switch", env);
 }
-function forBlock(parentScope, slotKey, domParent, items, getKey, itemBody, flags, deps, emptyBody, anchor, ownEnd) {
+function forBlock(parentScope, slotKey, domParent, inputItems, getKey, itemBody, flags, deps, emptyBody, anchor, ownEnd) {
   if (CURRENT_BLOCK?.pending && !CURRENT_BLOCK.crossRenderUpdate) return;
+  const items = Array.isArray(inputItems) ? inputItems : Array.from(inputItems);
   const parentBlock = parentScope.block;
   const hydration = activeHydration();
   let state = parentScope.slots[slotKey];
@@ -19713,8 +20166,11 @@ function reconcileKeyed(parentBlock, state, items, getKey, itemBody, pure, singl
   }
   if (process.env.NODE_ENV !== "production") getKey = checkedListKey(getKey);
   if (newLen === 0) {
-    if (journalShape) journalForSlot(state);
-    batchClearItems(state, oldItems);
+    const ownedRootClear = journalShape && canDeferRootOwnedListClear(state);
+    if (ownedRootClear && (TRANSITION_JOURNAL_BAGS.get(state) ?? -1) < TRANSITION_JOURNAL_CHECKPOINT)
+      journalForOwnedListClear(state);
+    else if (journalShape) journalForSlot(state);
+    batchClearItems(state, ownedRootClear ? state.items : oldItems, ownedRootClear);
     state.head = null;
     state.tail = null;
     state.size = 0;
@@ -20043,8 +20499,76 @@ function reconcileKeyed(parentBlock, state, items, getKey, itemBody, pure, singl
   }
 }
 const RANGE_CLEAR_MIN_ITEMS = 512;
-function batchClearItems(state, oldItems) {
+function canDeferRootOwnedListClear(state) {
+  const transaction = ROOT_RENDER_TRANSACTION;
+  const parent = state.start.parentNode;
+  if (transaction === null || transaction.aborted || ROOT_RENDER_ROLLBACK || transaction.hydrating === true || state.adopt !== null || state.size < 16 || parent === null || parent.nodeType !== 1 && parent.nodeType !== 11 || state.end.parentNode !== parent || state.start.previousSibling !== null || state.end.nextSibling !== null)
+    return false;
+  const oldHead = state.head;
+  for (let block = oldHead; block !== null; block = block.nextSibling) {
+    if (!block.mounted || block.idState.renderOwner !== transaction.owner || block.startMarker === null || block.startMarker !== block.endMarker || block.hooks !== null || block.effectSlots !== null || block.cleanups !== null || block.children !== null || block._slots !== null || block.refFields !== null || block.deoptNode !== null || block.vt !== null)
+      return false;
+  }
+  return true;
+}
+function deferRootOwnedListClear(state, certified = false) {
+  if (!certified && !canDeferRootOwnedListClear(state)) return false;
+  const transaction = ROOT_RENDER_TRANSACTION;
+  const parent = state.start.parentNode;
+  const oldHead = state.head;
+  const retired = transaction.retired ??= /* @__PURE__ */ new Set();
+  const newlyRetired = [];
+  for (let block = oldHead; block !== null; block = block.nextSibling) {
+    if (!retired.has(block)) {
+      retired.add(block);
+      newlyRetired.push(block);
+    }
+    if (block.pending) {
+      journalRootProperty(block, "pending");
+      block.pending = false;
+    }
+  }
+  let cancelled = false;
+  journalUndo(() => {
+    cancelled = true;
+    for (let i = 0; i < newlyRetired.length; i++) retired.delete(newlyRetired[i]);
+  });
+  const start = state.start;
+  const end = state.end;
+  (transaction.commit ??= []).push(() => {
+    if (cancelled) return;
+    let wholeParent = state.size === 0 && start.parentNode === parent && end.parentNode === parent && start.previousSibling === null && end.nextSibling === null;
+    if (wholeParent) {
+      let node = start.nextSibling;
+      for (let block = oldHead; block !== null; block = block.nextSibling) {
+        if (node !== block.startMarker) {
+          wholeParent = false;
+          break;
+        }
+        node = node.nextSibling;
+      }
+      if (node !== end) wholeParent = false;
+    }
+    for (let block = oldHead; block !== null; block = block.nextSibling) block.disposed = true;
+    if (wholeParent) {
+      parent.textContent = "";
+      parent.appendChild(start);
+      parent.appendChild(end);
+    } else {
+      for (let block = oldHead; block !== null; block = block.nextSibling) {
+        const node = block.startMarker;
+        if (node.parentNode !== null) node.parentNode.removeChild(node);
+      }
+    }
+  });
+  return true;
+}
+function batchClearItems(state, oldItems, ownedRootClear = false) {
   if (forSlotParkable(state)) {
+    if (deferRootOwnedListClear(state, ownedRootClear)) {
+      oldItems.clear();
+      return;
+    }
     let next;
     for (let b = state.head; b !== null; b = next) {
       next = b.nextSibling;
@@ -21747,6 +22271,7 @@ function scriptResource(attrs) {
   beginNativeReadScope,
   beginNativeReadWitness,
   bindRendererRegionOwner,
+  callWithReceiver,
   child,
   childSlot,
   childTextHole,
@@ -21816,6 +22341,7 @@ function scriptResource(attrs) {
   injectStyle,
   invokeManualHook,
   isChildrenBlock,
+  isInActScope,
   isValidElement,
   keyedForBlock,
   lazy,