octane 0.1.26 → 0.1.28

package/dist/runtime.js

@@ -1184,12 +1184,18 @@ function drainQueue() {
     }
     const crossRenderUpdate = block.crossRenderUpdate;
     block.crossRenderUpdate = false;
+    const hiddenOwner = findHiddenRenderOwner(block, true);
+    let hiddenActivity = null;
+    let hiddenTry = null;
+    if (hiddenOwner !== null) {
+      if (hiddenOwner.__kind === "trySlotSlot") hiddenTry = hiddenOwner;
+      else hiddenActivity = hiddenOwner;
+    }
     try {
       if (block.nestedUpdateError) {
         block.nestedUpdateError = false;
         throw maximumUpdateDepthError();
       }
-      const hiddenTry = findSuspenseHiddenTry(block);
       if (hiddenTry !== null) {
         attemptHiddenReveal(hiddenTry, block.pendingMode ?? "urgent");
         continue;
@@ -1221,6 +1227,8 @@ function drainQueue() {
         while (root.parentBlock !== null) root = root.parentBlock;
         if (root.kind === "root" && !root.disposed) unmountBlock(root);
       }
+    } finally {
+      if (hiddenActivity !== null) rehideActivityAfterDescendantRender(hiddenActivity);
     }
   }
   QUEUE.length = 0;
@@ -10700,8 +10708,63 @@ function setTransitionFallbackTimeout(ms) {
 function getTransitionFallbackTimeout() {
   return TRANSITION_FALLBACK_TIMEOUT_MS;
 }
-const SUSPENSE_HIDDEN_DISPLAYS = /* @__PURE__ */ new WeakMap();
-const SUSPENSE_HIDDEN_TEXTS = /* @__PURE__ */ new WeakMap();
+const HIDDEN_DISPLAYS = /* @__PURE__ */ new WeakMap();
+const HIDDEN_TEXTS = /* @__PURE__ */ new WeakMap();
+function enforceHiddenDisplay(el) {
+  const hidden = HIDDEN_DISPLAYS.get(el);
+  el.style.setProperty(
+    "display",
+    "none",
+    hidden !== void 0 && hidden.importantOwners > 0 ? "important" : ""
+  );
+}
+function retainHiddenDisplay(el, important) {
+  const existing = HIDDEN_DISPLAYS.get(el);
+  if (existing === void 0) {
+    HIDDEN_DISPLAYS.set(el, {
+      owners: 1,
+      importantOwners: important ? 1 : 0,
+      value: el.style.getPropertyValue("display"),
+      priority: el.style.getPropertyPriority("display"),
+      hadStyle: el.hasAttribute("style")
+    });
+  } else {
+    existing.owners++;
+    if (important) existing.importantOwners++;
+  }
+  enforceHiddenDisplay(el);
+}
+function releaseHiddenDisplay(el, important) {
+  const display = HIDDEN_DISPLAYS.get(el);
+  if (display === void 0) return;
+  if (important) display.importantOwners--;
+  if (--display.owners === 0) {
+    HIDDEN_DISPLAYS.delete(el);
+    if (display.value === "") el.style.removeProperty("display");
+    else el.style.setProperty("display", display.value, display.priority);
+    if (!display.hadStyle && el.getAttribute("style") === "") el.removeAttribute("style");
+  } else {
+    enforceHiddenDisplay(el);
+  }
+}
+function enforceHiddenText(text) {
+  if (text.data !== "") text.data = "";
+}
+function retainHiddenText(text) {
+  const existing = HIDDEN_TEXTS.get(text);
+  if (existing === void 0) HIDDEN_TEXTS.set(text, { owners: 1, data: text.data });
+  else existing.owners++;
+}
+function releaseHiddenText(text) {
+  const saved = HIDDEN_TEXTS.get(text);
+  if (saved === void 0) return;
+  if (--saved.owners === 0) {
+    HIDDEN_TEXTS.delete(text);
+    text.data = saved.data;
+  } else {
+    enforceHiddenText(text);
+  }
+}
 function setTryBranch(slot, next) {
   slot.branch = next;
   if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__) {
@@ -11063,31 +11126,17 @@ function hideBlockHostRange(block, hidden) {
       const el = node;
       if (!hidden.displays.has(el)) {
         hidden.displays.add(el);
-        const existing = SUSPENSE_HIDDEN_DISPLAYS.get(el);
-        if (existing === void 0) {
-          SUSPENSE_HIDDEN_DISPLAYS.set(el, {
-            owners: 1,
-            value: el.style.getPropertyValue("display"),
-            priority: el.style.getPropertyPriority("display"),
-            hadStyle: el.hasAttribute("style")
-          });
-        } else {
-          existing.owners++;
-        }
+        retainHiddenDisplay(el, true);
+      } else {
+        enforceHiddenDisplay(el);
       }
-      el.style.setProperty("display", "none", "important");
     } else if (node.nodeType === 3) {
       const text = node;
       if (!hidden.texts.has(text)) {
         hidden.texts.add(text);
-        const existing = SUSPENSE_HIDDEN_TEXTS.get(text);
-        if (existing === void 0) {
-          SUSPENSE_HIDDEN_TEXTS.set(text, { owners: 1, data: text.data });
-        } else {
-          existing.owners++;
-        }
+        retainHiddenText(text);
       }
-      if (text.data !== "") text.data = "";
+      enforceHiddenText(text);
     }
     node = node.nextSibling;
   }
@@ -11115,26 +11164,10 @@ function showTryBlock(state) {
   if (hidden === null) return;
   state.hiddenDom = null;
   for (const el of hidden.displays) {
-    const display = SUSPENSE_HIDDEN_DISPLAYS.get(el);
-    if (display === void 0) continue;
-    if (--display.owners === 0) {
-      SUSPENSE_HIDDEN_DISPLAYS.delete(el);
-      if (display.value === "") el.style.removeProperty("display");
-      else el.style.setProperty("display", display.value, display.priority);
-      if (!display.hadStyle && el.getAttribute("style") === "") el.removeAttribute("style");
-    } else {
-      el.style.setProperty("display", "none", "important");
-    }
+    releaseHiddenDisplay(el, true);
   }
   for (const text of hidden.texts) {
-    const saved = SUSPENSE_HIDDEN_TEXTS.get(text);
-    if (saved === void 0) continue;
-    if (--saved.owners === 0) {
-      SUSPENSE_HIDDEN_TEXTS.delete(text);
-      text.data = saved.data;
-    } else if (text.data !== "") {
-      text.data = "";
-    }
+    releaseHiddenText(text);
   }
 }
 function releaseHeldTransition(state) {
@@ -11286,6 +11319,7 @@ function commitResume(state) {
 }
 function commitResumeInner(state) {
   if (state.parentBlock.disposed) return;
+  const hiddenActivity = findHiddenActivity(state.parentBlock);
   const wasHeld = state.transitionHeld;
   if (wasHeld) state.transitionHeld = false;
   HELD_TRANSITIONS.delete(state);
@@ -11377,14 +11411,33 @@ function commitResumeInner(state) {
     }
     if (!deferringStagedRevealEffects) commitEffects();
   } finally {
+    if (hiddenActivity !== null) rehideActivityAfterDescendantRender(hiddenActivity);
     if (wasHeld) tickTransitionCount(-1);
   }
 }
-function findSuspenseHiddenTry(block) {
+function findHiddenRenderOwner(block, includeActivity) {
+  let activity = null;
   for (let p = block; p !== null; p = p.parentBlock) {
+    if (includeActivity && activity === null && p.inactive) {
+      const candidate = p.__activitySlot;
+      if (candidate !== void 0 && candidate.block === p && candidate.hidden) {
+        activity = candidate;
+      }
+    }
     const slot = p.__trySlot;
     if (slot !== void 0 && slot.tryBlock === p && slot.hiddenDom !== null) return slot;
   }
+  return activity;
+}
+function findSuspenseHiddenTry(block) {
+  return findHiddenRenderOwner(block, false);
+}
+function findHiddenActivity(block) {
+  for (let p = block; p !== null; p = p.parentBlock) {
+    if (!p.inactive) continue;
+    const candidate = p.__activitySlot;
+    if (candidate !== void 0 && candidate.block === p && candidate.hidden) return candidate;
+  }
   return null;
 }
 function snapshotSubtreeEffectDeps(scope) {
@@ -11500,11 +11553,19 @@ function queueCurrentHiddenRefs(state) {
   }
 }
 function attemptHiddenReveal(state, scheduledMode) {
+  const hiddenActivity = findHiddenActivity(state.tryBlock);
+  try {
+    attemptHiddenRevealInner(state, scheduledMode);
+  } finally {
+    if (hiddenActivity !== null) rehideActivityAfterDescendantRender(hiddenActivity);
+  }
+}
+function attemptHiddenRevealInner(state, scheduledMode) {
   const tryBlock2 = state.tryBlock;
   if (tryBlock2 === null || tryBlock2.disposed || state.hiddenDom === null) return;
   const hiddenAncestor = findSuspenseHiddenTry(tryBlock2.parentBlock);
   if (hiddenAncestor !== null) {
-    attemptHiddenReveal(hiddenAncestor, scheduledMode);
+    attemptHiddenRevealInner(hiddenAncestor, scheduledMode);
     return;
   }
   STAGED_REVEALS.delete(state);
@@ -12492,25 +12553,49 @@ function ifBlock(parentScope, slotKey, domParent, cond, thenBody, elseBody, anch
 function hideActivityRange(state) {
   const b = state.block;
   if (!b) return;
+  for (const el of state.hiddenDisplays) {
+    if (el.parentNode !== b.parentNode) {
+      state.hiddenDisplays.delete(el);
+      releaseHiddenDisplay(el, false);
+    }
+  }
+  for (const text of state.hiddenTexts) {
+    if (text.parentNode !== b.parentNode) {
+      state.hiddenTexts.delete(text);
+      releaseHiddenText(text);
+    }
+  }
   let node = b.startMarker.nextSibling;
   while (node && node !== b.endMarker) {
     if (node.nodeType === 1) {
       const el = node;
-      if (!state.savedDisplay.has(el)) state.savedDisplay.set(el, el.style.display);
-      el.style.display = "none";
+      if (!state.hiddenDisplays.has(el)) {
+        state.hiddenDisplays.add(el);
+        retainHiddenDisplay(el, false);
+      } else {
+        enforceHiddenDisplay(el);
+      }
     } else if (node.nodeType === 3) {
       const t = node;
-      if (!state.savedText.has(t)) state.savedText.set(t, t.nodeValue ?? "");
-      if (t.nodeValue !== "") t.nodeValue = "";
+      if (!state.hiddenTexts.has(t)) {
+        state.hiddenTexts.add(t);
+        retainHiddenText(t);
+      }
+      enforceHiddenText(t);
     }
     node = node.nextSibling;
   }
 }
+function rehideActivityAfterDescendantRender(state) {
+  const b = state.block;
+  if (b === null || !state.hidden || state.deactivationPending || blockSubtreeDisposed(b)) return;
+  hideActivityRange(state);
+}
 function showActivityRange(state) {
-  for (const [el, display] of state.savedDisplay) el.style.display = display;
-  state.savedDisplay.clear();
-  for (const [t, data] of state.savedText) t.nodeValue = data;
-  state.savedText.clear();
+  for (const el of state.hiddenDisplays) releaseHiddenDisplay(el, false);
+  state.hiddenDisplays.clear();
+  for (const text of state.hiddenTexts) releaseHiddenText(text);
+  state.hiddenTexts.clear();
 }
 function queueActivityDeactivation(state, block, commitVersion) {
   enqueueEffectEventCommitAction(() => {
@@ -12560,9 +12645,10 @@ function activityBlock(parentScope, slotKey, domParent, mode, body, anchor, env)
       hidden: false,
       commitVersion: 0,
       deactivationPending: false,
-      savedDisplay: /* @__PURE__ */ new Map(),
-      savedText: /* @__PURE__ */ new Map()
+      hiddenDisplays: /* @__PURE__ */ new Set(),
+      hiddenTexts: /* @__PURE__ */ new Set()
     };
+    b2.__activitySlot = state;
     parentScope.slots[slotKey] = state;
     registerSlot(parentScope, state);
     const adopted = open !== null;

package/dist/universal-core.js

@@ -617,6 +617,7 @@ function createOwnerRecord(root, component, parent, identityPath, key) {
     renderer: root.renderer,
     component,
     componentProps: null,
+    componentRevision: 0,
     parent,
     identityPath,
     key,
@@ -625,6 +626,7 @@ function createOwnerRecord(root, component, parent, identityPath, key) {
     hooks: /* @__PURE__ */ new Map(),
     effectOrder: [],
     children: [],
+    dirtyEpoch: 0,
     range: null,
     contextValues: null,
     updates: /* @__PURE__ */ new Map(),
@@ -642,13 +644,16 @@ function draftOwner(record, parent, replayPath) {
   return {
     record,
     componentProps: record.componentProps,
+    componentRevision: record.componentRevision,
     parent,
     replayPath,
     hooks: new Map(record.hooks),
     clonedHooks: /* @__PURE__ */ new Set(),
     seenEffects: [],
     children: [],
+    retainedChildren: null,
     claimedChildren: /* @__PURE__ */ new Set(),
+    sequentialClaimCursor: 0,
     childOwnerBuckets: null,
     childClaimCursors: null,
     childReplayOrdinals: null,
@@ -661,7 +666,8 @@ function draftOwner(record, parent, replayPath) {
     boundaryThenable: record.boundaryThenable,
     isBoundary: record.isBoundary,
     canHandleSuspense: record.canHandleSuspense,
-    visibility: parent?.visibility ?? record.visibility
+    visibility: parent?.visibility ?? record.visibility,
+    contextStable: null
   };
 }
 function childReplayPath(parent, component, identityPath, key) {
@@ -686,30 +692,79 @@ function childOwnerBucket(parent, component, identityPath, key) {
   }
   return readOwnerIdentity(buckets, component, identityPath, key);
 }
-function claimChildOwner(parent, component, identityPath, key) {
-  const attempt = currentAttempt();
-  let record;
-  const bucket = childOwnerBucket(parent, component, identityPath, key);
-  if (bucket !== void 0) {
-    const cursors = parent.childClaimCursors ??= createOwnerIdentityIndex();
-    let cursor = readOwnerIdentity(cursors, component, identityPath, key) ?? 0;
-    while (cursor < bucket.length && parent.claimedChildren.has(bucket[cursor])) cursor++;
-    record = bucket[cursor];
-    writeOwnerIdentity(
-      cursors,
-      component,
-      identityPath,
-      key,
-      cursor + (record === void 0 ? 0 : 1)
-    );
+function identityPathsEqual(left, right) {
+  if (left === right) return true;
+  if (left.length !== right.length) return false;
+  for (let index = 0; index < left.length; index++) {
+    if (!Object.is(left[index], right[index])) return false;
+  }
+  return true;
+}
+function findClaimableChildRecord(parent, component, identityPath, key) {
+  if (parent.childOwnerBuckets === null) {
+    const candidate = parent.record.children[parent.sequentialClaimCursor];
+    if (candidate !== void 0 && candidate.component === component && Object.is(candidate.key, key) && identityPathsEqual(candidate.identityPath, identityPath) && !parent.claimedChildren.has(candidate)) {
+      parent.sequentialClaimCursor++;
+      return candidate;
+    }
   }
-  record ??= createOwnerRecord(attempt.root, component, parent.record, identityPath, key);
+  const bucket = childOwnerBucket(parent, component, identityPath, key);
+  if (bucket === void 0) return void 0;
+  const cursors = parent.childClaimCursors ??= createOwnerIdentityIndex();
+  let cursor = readOwnerIdentity(cursors, component, identityPath, key) ?? 0;
+  while (cursor < bucket.length && parent.claimedChildren.has(bucket[cursor])) cursor++;
+  const record = bucket[cursor];
+  writeOwnerIdentity(
+    cursors,
+    component,
+    identityPath,
+    key,
+    cursor + (record === void 0 ? 0 : 1)
+  );
+  return record;
+}
+function adoptChildOwner(parent, record, component, identityPath, key) {
+  const attempt = currentAttempt();
   parent.claimedChildren.add(record);
   const draft = draftOwner(record, parent, childReplayPath(parent, component, identityPath, key));
   parent.children.push(draft);
   attempt.owners.push(draft);
   return draft;
 }
+function claimChildOwner(parent, component, identityPath, key) {
+  const record = findClaimableChildRecord(parent, component, identityPath, key) ?? createOwnerRecord(currentAttempt().root, component, parent.record, identityPath, key);
+  return adoptChildOwner(parent, record, component, identityPath, key);
+}
+function ancestorContextsStable(owner) {
+  if (owner.contextStable !== null) return owner.contextStable;
+  let stable = owner.parent === null ? true : ancestorContextsStable(owner.parent);
+  if (stable && owner.contextValues !== null) {
+    const committed = owner.record.mounted ? owner.record.contextValues : null;
+    if (committed === null) {
+      stable = owner.contextValues.size === 0;
+    } else if (committed.size !== owner.contextValues.size) {
+      stable = false;
+    } else {
+      for (const [context, value] of owner.contextValues) {
+        if (!committed.has(context) || !Object.is(committed.get(context), value)) {
+          stable = false;
+          break;
+        }
+      }
+    }
+  }
+  owner.contextStable = stable;
+  return stable;
+}
+function ownerSubtreeRetainable(owner) {
+  if (owner.updates.size !== 0 || owner.visibility !== "visible" || owner.isBoundary && (owner.hasBoundaryError || owner.boundaryThenable !== null) || owner.component?.__warm !== void 0 || owner.component !== null && universalComponentRevision(owner.component) !== owner.componentRevision) {
+    return false;
+  }
+  for (const child of owner.children) {
+    if (!ownerSubtreeRetainable(child)) return false;
+  }
+  return true;
+}
 function activateLazyLeafOwner() {
   const scope = CURRENT_LAZY_LEAF_OWNER;
   const attempt = CURRENT_ATTEMPT;
@@ -759,9 +814,12 @@ function executeOwner(owner, build, initialRenderCount = 0) {
     if (renderCount > 0) resetDraftChildren(owner);
     owner.seenEffects = [];
     owner.children = [];
+    owner.retainedChildren = null;
     owner.claimedChildren = /* @__PURE__ */ new Set();
+    owner.sequentialClaimCursor = 0;
     owner.childClaimCursors = null;
     owner.childReplayOrdinals = null;
+    owner.contextStable = null;
     owner.needsRender = false;
     owner.implicitSlot = 0;
     const previousOwner = CURRENT_OWNER;
@@ -846,7 +904,35 @@ function materializeComponentValue(value, expectedRenderer, path) {
   const parent = CURRENT_OWNER;
   if (parent === null) throw new Error("A nested universal component requires an owner.");
   const normalized = normalizePropsValue(value.props);
-  const owner = claimChildOwner(parent, value.component, path, value.hasKey ? value.key : null);
+  const key = value.hasKey ? value.key : null;
+  const attempt = currentAttempt();
+  const record = findClaimableChildRecord(parent, value.component, path, key);
+  if (attempt.retainEligible && record !== void 0 && record.mounted && !record.disposed && record.dirtyEpoch !== attempt.dirtyEpoch && record.visibility === "visible" && parent.visibility === "visible" && record.componentProps !== null && universalShallowEqual(record.componentProps, normalized.props) && record.range !== null && record.range.owner === record && ancestorContextsStable(parent) && ownerSubtreeRetainable(record)) {
+    const features = logicalTreeFeatures(record.range);
+    if ((features & (UNIVERSAL_TREE_PORTAL | UNIVERSAL_TREE_REGION)) === 0) {
+      parent.claimedChildren.add(record);
+      (parent.retainedChildren ??= []).push({ record, position: parent.children.length });
+      attempt.treeFeatures |= features;
+      attempt.retainedCount++;
+      return [
+        {
+          kind: "range",
+          key: record.range.key,
+          owner: record,
+          retained: record.range,
+          children: []
+        }
+      ];
+    }
+  }
+  const owner = adoptChildOwner(
+    parent,
+    record ?? createOwnerRecord(attempt.root, value.component, parent.record, path, key),
+    value.component,
+    path,
+    key
+  );
+  owner.componentRevision = universalComponentRevision(value.component);
   const props = { ...normalized.props };
   owner.componentProps = props;
   const nodes = executeOwner(owner, () => {
@@ -886,7 +972,9 @@ function disposeUncommittedDraft(owner) {
 function resetDraftChildren(owner) {
   for (const child of owner.children) disposeUncommittedDraft(child);
   owner.children = [];
+  owner.retainedChildren = null;
   owner.claimedChildren = /* @__PURE__ */ new Set();
+  owner.sequentialClaimCursor = 0;
   owner.childClaimCursors = null;
   owner.childReplayOrdinals = null;
 }
@@ -895,7 +983,9 @@ function retainCommittedOwnerTree(owner) {
   owner.seenEffects = [...owner.record.effectOrder];
   owner.contextValues = owner.record.contextValues === null ? null : new Map(owner.record.contextValues);
   owner.children = [];
+  owner.retainedChildren = null;
   owner.claimedChildren = new Set(owner.record.children);
+  owner.sequentialClaimCursor = 0;
   owner.childClaimCursors = null;
   owner.childReplayOrdinals = null;
   for (const childRecord of owner.record.children) {
@@ -1773,11 +1863,12 @@ function physicalRecords(records) {
   }
   return output;
 }
-function physicalDrafts(records) {
+function physicalDrafts(drafts) {
   const output = [];
-  for (const record of records) {
-    if (record.record.kind === "host") output.push(record);
-    else if (record.record.kind === "range") output.push(...physicalDrafts(record.children));
+  for (const draft of drafts) {
+    if (draft.record.kind === "host") output.push(draft.record);
+    else if (draft.retained === true) output.push(...physicalRecords(draft.record.children));
+    else if (draft.record.kind === "range") output.push(...physicalDrafts(draft.children));
   }
   return output;
 }
@@ -1842,6 +1933,10 @@ function stableLogicalChildren(records, blueprints) {
   for (let index = 0; index < records.length; index++) {
     const record = records[index];
     const blueprint = blueprints[index];
+    if (blueprint.kind === "range" && blueprint.retained !== void 0) {
+      if (blueprint.retained === record) continue;
+      return false;
+    }
     if (blueprint.kind === "range" && blueprint.compactLeafList !== void 0 || !sameRecordShape(record, blueprint) || !stableLogicalChildren(record.children, blueprint.children)) {
       return false;
     }
@@ -3469,6 +3564,12 @@ class UniversalRootImpl {
   scheduledFullRoot = false;
   scheduledOwners = /* @__PURE__ */ new Set();
   scheduledPreparationDepth = 0;
+  // The current dirty epoch: scheduleOwned() stamps it on the scheduled owner
+  // and its ancestors, and prepare() bumps it as it consumes the batch, so an
+  // attempt recognizes exactly the owners scheduled into it.
+  dirtyEpoch = 1;
+  attemptDirtyEpoch = 0;
+  attemptFullRootScheduled = false;
   scheduledTransitionBatches = /* @__PURE__ */ new Set();
   unattemptedTransitionBatches = /* @__PURE__ */ new Set();
   eventScopeDepth = 0;
@@ -4125,6 +4226,9 @@ class UniversalRootImpl {
   scheduleOwned(owner) {
     if (owner.root !== this || owner.disposed) return;
     this.scheduledOwners.add(owner);
+    for (let current = owner; current !== null && current.dirtyEpoch !== this.dirtyEpoch; current = current.parent) {
+      current.dirtyEpoch = this.dirtyEpoch;
+    }
     this.markUrgentScheduled();
   }
   schedule() {
@@ -4292,7 +4396,8 @@ class UniversalRootImpl {
               replay.props,
               replay.entries,
               replay.transitionBatches,
-              replay.transitionRender
+              replay.transitionRender,
+              false
             );
           } catch (error) {
             const batches = new Set(replay.transitionBatches);
@@ -4326,7 +4431,8 @@ class UniversalRootImpl {
         replay.props,
         replay.entries,
         replay.transitionBatches,
-        replay.transitionRender
+        replay.transitionRender,
+        false
       );
     } catch (error) {
       const batches = new Set(replay.transitionBatches);
@@ -4538,7 +4644,7 @@ class UniversalRootImpl {
       }
     }
     const unsupported = UNIVERSAL_TREE_PORTAL | UNIVERSAL_TREE_REGION;
-    const scopeFeatures = logicalTreeFeatures(range);
+    const scopeFeatures = range === this.rootRecord ? this.treeFeatures : logicalTreeFeatures(range);
     if ((scopeFeatures & unsupported) !== 0) return null;
     this.flushPassivesBeforeRender();
     this.pending?.abort();
@@ -4550,6 +4656,7 @@ class UniversalRootImpl {
         ordinal: 0
       }
     ]);
+    owner.componentRevision = universalComponentRevision(target.component);
     const previousAttempt = CURRENT_ATTEMPT;
     const previousOwner = CURRENT_OWNER;
     const previousWarm = CURRENT_UNIVERSAL_WARM;
@@ -4567,7 +4674,12 @@ class UniversalRootImpl {
       implicitSlot: 0,
       transitionBatches: EMPTY_UNIVERSAL_TRANSITION_BATCHES,
       transitionRender: false,
-      bridgeContextReads: null
+      bridgeContextReads: null,
+      // The owned-update guards already require a plain urgent local-driver
+      // attempt, which is exactly the retain-eligible shape.
+      retainEligible: true,
+      retainedCount: 0,
+      dirtyEpoch: this.attemptDirtyEpoch
     };
     ACTIVE_UNIVERSAL_WARM_PLANS.length = 0;
     CURRENT_UNIVERSAL_WARM = null;
@@ -4608,13 +4720,16 @@ class UniversalRootImpl {
     }
     const blueprint = {
       kind: "range",
-      key: target.rangeKey,
+      // The committed range key: rangeKey for an ownerRange() scope, null for
+      // the root range, so the reapplied key never drifts from what the full
+      // render path would commit.
+      key: range.key,
       owner: target,
       children: nodes
     };
     this.expandCompactLeafLists(blueprint);
     let scopePlacement = null;
-    if (!stableLogicalChildren(range.children, blueprint.children)) {
+    if (range !== this.rootRecord && !stableLogicalChildren(range.children, blueprint.children)) {
       scopePlacement = this.scopePhysicalPlacement(range);
       if (scopePlacement === null) {
         this.discardDraftOwners(attempt.owners);
@@ -4698,6 +4813,9 @@ class UniversalRootImpl {
   prepare(component, props) {
     const ownedTarget = this.scheduledPreparationDepth > 0 && this.scheduledUrgent && !this.scheduledFullRoot && this.scheduledOwners.size !== 0 ? this.resolveScopedTarget() : void 0;
     const scheduledUrgent = this.scheduledUrgent || this.scheduledPreparationDepth === 0;
+    this.attemptFullRootScheduled = this.scheduledFullRoot;
+    this.attemptDirtyEpoch = this.dirtyEpoch;
+    this.dirtyEpoch++;
     this.scheduledUrgent = false;
     this.scheduledFullRoot = false;
     this.scheduledOwners.clear();
@@ -4750,7 +4868,7 @@ class UniversalRootImpl {
       throw error;
     }
   }
-  prepareWithReplay(component, props, replayEntries, transitionBatches, transitionRender) {
+  prepareWithReplay(component, props, replayEntries, transitionBatches, transitionRender, allowRetain = true) {
     if (this.unmounted || this.unmounting) {
       throw new Error("Cannot render an unmounted universal root.");
     }
@@ -4769,6 +4887,7 @@ class UniversalRootImpl {
     ];
     const owner = draftOwner(ownerRecord, null, rootPath);
     owner.componentProps = props;
+    owner.componentRevision = universalComponentRevision(component);
     const previousAttempt = CURRENT_ATTEMPT;
     const previousOwner = CURRENT_OWNER;
     const previousWarm = CURRENT_UNIVERSAL_WARM;
@@ -4786,7 +4905,14 @@ class UniversalRootImpl {
       implicitSlot: 0,
       transitionBatches,
       transitionRender,
-      bridgeContextReads: null
+      bridgeContextReads: null,
+      // Replay, transition, bridge, and transport attempts re-execute every
+      // owner for their own bookkeeping (warm replays, lane rebasing, bridge
+      // context read tracking, remote commit protocols); only a plain urgent
+      // local attempt may adopt committed subtrees without re-rendering them.
+      retainEligible: allowRetain && this.transport === null && this.bridge === null && !this.attemptFullRootScheduled && replayEntries.length === 0 && transitionBatches.size === 0 && !transitionRender,
+      retainedCount: 0,
+      dirtyEpoch: this.attemptDirtyEpoch
     };
     ACTIVE_UNIVERSAL_WARM_PLANS.length = 0;
     CURRENT_UNIVERSAL_WARM = null;
@@ -4797,10 +4923,13 @@ class UniversalRootImpl {
     try {
       nodes = executeOwner(owner, () => {
         const value = component(props, componentContext(this.renderer));
-        return materializeValue(value, this.renderer, null, ["root-output"]);
+        return materializeValue(value, this.renderer, null, [
+          ...ownerRecord.identityPath,
+          "output"
+        ]);
       });
     } catch (error) {
-      const suspendedMemos = collectSuspendedMemos(attempt);
+      const suspendedMemos = attempt.retainedCount !== 0 ? [] : collectSuspendedMemos(attempt);
       this.discardDraftOwners(attempt.owners);
       if (error instanceof UniversalSuspense) {
         return this.suspend(
@@ -4823,7 +4952,12 @@ class UniversalRootImpl {
       CURRENT_OWNER = previousOwner;
     }
     try {
-      const rootBlueprint = { kind: "range", key: null, children: nodes };
+      const rootBlueprint = {
+        kind: "range",
+        key: null,
+        owner: owner.record,
+        children: nodes
+      };
       const transaction = this.createTransaction(rootBlueprint, attempt, component, props);
       this.pending = transaction;
       return transaction;
@@ -5024,6 +5158,7 @@ class UniversalRootImpl {
         for (const draft of attempt.owners) {
           const record = draft.record;
           record.componentProps = draft.componentProps;
+          record.componentRevision = draft.componentRevision;
           record.parent = draft.parent?.record ?? null;
           record.hooks = draft.hooks;
           record.effectOrder = [...draft.seenEffects];
@@ -5133,6 +5268,7 @@ class UniversalRootImpl {
         for (const draft of attempt.owners) {
           const record = draft.record;
           record.componentProps = draft.componentProps;
+          record.componentRevision = draft.componentRevision;
           record.parent = draft.parent?.record ?? null;
           record.hooks = draft.hooks;
           record.effectOrder = [...draft.seenEffects];
@@ -5229,11 +5365,29 @@ class UniversalRootImpl {
     const used = /* @__PURE__ */ new Set([scopeRecord]);
     const changedRangeOwners = [];
     let topologyChanged = false;
+    const retainedScopes = /* @__PURE__ */ new Set();
+    const retainedDraft = (record, blueprint2) => {
+      retainedScopes.add(record);
+      return { record, blueprint: blueprint2, children: [], isNew: false, hostUpdate: null, retained: true };
+    };
+    const expandRetained = (marker) => {
+      const previousAttempt = CURRENT_ATTEMPT;
+      CURRENT_ATTEMPT = attempt;
+      try {
+        return blueprintFromLogical(marker.retained);
+      } finally {
+        CURRENT_ATTEMPT = previousAttempt;
+      }
+    };
     const reconcileChildren = (oldChildren, blueprints) => {
       if ((treeFeatures & UNIVERSAL_TREE_PORTAL) === 0 && oldChildren.length === blueprints.length && oldChildren.every((record, index) => sameRecordShape(record, blueprints[index]))) {
         return oldChildren.map((record, index) => {
           used.add(record);
-          const blueprint2 = blueprints[index];
+          let blueprint2 = blueprints[index];
+          if (blueprint2.kind === "range" && blueprint2.retained !== void 0) {
+            if (blueprint2.retained === record) return retainedDraft(record, blueprint2);
+            blueprint2 = expandRetained(blueprint2);
+          }
           const draft = {
             record,
             blueprint: blueprint2,
@@ -5253,7 +5407,7 @@ class UniversalRootImpl {
       const nextKeys = /* @__PURE__ */ new Set();
       const output = [];
       for (let childIndex = 0; childIndex < blueprints.length; childIndex++) {
-        const child = blueprints[childIndex];
+        let child = blueprints[childIndex];
         let record;
         if (child.key !== null) {
           if (nextKeys.has(child.key)) {
@@ -5270,6 +5424,15 @@ class UniversalRootImpl {
             record = candidate;
           }
         }
+        if (child.kind === "range" && child.retained !== void 0) {
+          if (record === child.retained && record !== void 0) {
+            claimed.add(record);
+            used.add(record);
+            output.push(retainedDraft(record, child));
+            continue;
+          }
+          child = expandRetained(child);
+        }
         if (record?.kind === "portal" && child.kind === "portal") {
           const previousRegistration = record.portalRegistration;
           const nextRegistration = child.registration;
@@ -5309,11 +5472,14 @@ class UniversalRootImpl {
       isNew: false,
       hostUpdate: null
     };
+    if (scopeRecord.kind === "range" && scopeRecord.owner !== (blueprint.owner ?? null)) {
+      changedRangeOwners.push(draftRoot);
+    }
     const removedRoots = [];
     const findRemoved = (parent) => {
       for (const child of parent.children) {
         if (!used.has(child)) removedRoots.push(child);
-        else findRemoved(child);
+        else if (!retainedScopes.has(child)) findRemoved(child);
       }
     };
     if (topologyChanged) findRemoved(scopeRecord);
@@ -5456,7 +5622,7 @@ class UniversalRootImpl {
     const planPlacements = (parentId, oldRecords, newDrafts, sourceParentId = parentId, forceMove = false, endAnchor = null) => {
       const oldPhysical = physicalRecords(oldRecords);
       const newPhysical = physicalDrafts(newDrafts);
-      const desiredIds = new Set(newPhysical.map((entry) => entry.record.id));
+      const desiredIds = new Set(newPhysical.map((entry) => entry.id));
       for (const old of oldPhysical) {
         if (!desiredIds.has(old.id)) {
           removes.push({ op: "remove", parent: sourceParentId, id: old.id });
@@ -5465,8 +5631,7 @@ class UniversalRootImpl {
       const previousIds = new Set(oldPhysical.map((entry) => entry.id));
       const current = forceMove ? [] : oldPhysical.filter((entry) => desiredIds.has(entry.id)).map((entry) => entry.id);
       for (let index = 0; index < newPhysical.length; index++) {
-        const draft = newPhysical[index];
-        const id = draft.record.id;
+        const id = newPhysical[index].id;
         if (current[index] === id) continue;
         const currentIndex = current.indexOf(id);
         const before = current[index] ?? endAnchor;
@@ -5662,18 +5827,24 @@ class UniversalRootImpl {
     const retryMemos = retryThenables.length === 0 ? [] : collectSuspendedMemos(attempt);
     const refDetaches = [];
     const refAttaches = [];
-    const hostDraftsById = /* @__PURE__ */ new Map();
-    const lifecycleDrafts = /* @__PURE__ */ new Set();
+    const lifecycleHosts = /* @__PURE__ */ new Set();
     if ((treeFeatures & UNIVERSAL_TREE_LIFECYCLE) !== 0) {
+      const hostsById = /* @__PURE__ */ new Map();
       walkDraft(draftRoot, (draft) => {
+        if (draft.retained === true) {
+          for (const host of physicalRecords(draft.record.children)) {
+            hostsById.set(host.id, host);
+          }
+          return;
+        }
         if (draft.record.kind !== "host") return;
-        hostDraftsById.set(draft.record.id, draft);
-        if (draft.isNew || draft.hostUpdate !== null) lifecycleDrafts.add(draft);
+        hostsById.set(draft.record.id, draft.record);
+        if (draft.isNew || draft.hostUpdate !== null) lifecycleHosts.add(draft.record);
       });
       for (const placement of placements) {
         if (placement.op !== "move") continue;
-        const draft = hostDraftsById.get(placement.id);
-        if (draft !== void 0) lifecycleDrafts.add(draft);
+        const host = hostsById.get(placement.id);
+        if (host !== void 0) lifecycleHosts.add(host);
       }
     }
     if ((treeFeatures & UNIVERSAL_TREE_REF) !== 0) {
@@ -5721,11 +5892,18 @@ class UniversalRootImpl {
       }
     }
     const draftedRecords = new Set(draftOwnersParentFirst.map((owner) => owner.record));
+    const retainedOwnerRoots = /* @__PURE__ */ new Set();
+    for (const draft of draftOwnersParentFirst) {
+      if (draft.retainedChildren === null) continue;
+      for (const entry of draft.retainedChildren) retainedOwnerRoots.add(entry.record);
+    }
     const committedOwnersParentFirst = [];
     const walkCommittedOwners = (owner) => {
       if (owner === null) return;
       committedOwnersParentFirst.push(owner);
-      for (const child of owner.children) walkCommittedOwners(child);
+      for (const child of owner.children) {
+        if (!retainedOwnerRoots.has(child)) walkCommittedOwners(child);
+      }
     };
     walkCommittedOwners(scoped ? attempt.owner.record : this.owner);
     const removedOwners = committedOwnersParentFirst.filter((owner) => !draftedRecords.has(owner));
@@ -5803,6 +5981,10 @@ class UniversalRootImpl {
       };
       const apply = (draft, parent) => {
         const record = draft.record;
+        if (draft.retained === true) {
+          record.parent = parent;
+          return;
+        }
         record.parent = parent;
         record.key = draft.blueprint.key;
         if (record.kind === "host") {
@@ -5831,24 +6013,32 @@ class UniversalRootImpl {
       }
     };
     const lifecycleOrder = [];
-    if (lifecycleDrafts.size !== 0) {
+    if (lifecycleHosts.size !== 0) {
       walkDraftPostOrder(draftRoot, (draft) => {
-        if (lifecycleDrafts.has(draft)) lifecycleOrder.push(draft);
+        if (draft.retained === true) {
+          for (const host of physicalRecords(draft.record.children)) {
+            if (lifecycleHosts.has(host)) lifecycleOrder.push(host);
+          }
+          return;
+        }
+        if (lifecycleHosts.has(draft.record)) lifecycleOrder.push(draft.record);
       });
     }
     const hasPassiveWork = removedEffectEventCells.length !== 0 || orderedEffectCleanups.some((cleanup) => cleanup.phase === "passive") || effectChanges.some(({ next, changed }) => changed && next.phase === "passive");
-    const previousScopedEventListeners = /* @__PURE__ */ new Set();
-    const previousScopedLocalCallbacks = /* @__PURE__ */ new Set();
-    if (scoped) {
-      walkLogical(scopeRecord, (record) => {
+    const previousReplacedEventListeners = /* @__PURE__ */ new Set();
+    const previousReplacedLocalCallbacks = /* @__PURE__ */ new Set();
+    if ((treeFeatures & (UNIVERSAL_TREE_EVENT | UNIVERSAL_TREE_LOCAL_CALLBACK)) !== 0) {
+      const collectReplaced = (record) => {
         if (record.kind !== "host") return;
         for (const event of record.events.values()) {
-          previousScopedEventListeners.add(event.listener);
+          previousReplacedEventListeners.add(event.listener);
         }
         for (const callback of record.localCallbacks.values()) {
-          previousScopedLocalCallbacks.add(callback.listener);
+          previousReplacedLocalCallbacks.add(callback.listener);
         }
-      });
+      };
+      walkDraft(draftRoot, (draft) => collectReplaced(draft.record));
+      for (const removed of removedHosts) collectReplaced(removed);
     }
     const prepareHost = (value) => this.driver.prepareBatch(this.container, value, {
       invokeLocalCallback: (listener, args) => this.invokeLocalCallback(listener, args)
@@ -5884,9 +6074,8 @@ class UniversalRootImpl {
           }
         }
         if ((treeFeatures & UNIVERSAL_TREE_EVENT) !== 0) {
-          const handlers = scoped ? this.handlers : /* @__PURE__ */ new Map();
-          const replacedListeners = scoped ? previousScopedEventListeners : this.publishedListeners;
-          for (const listener of replacedListeners) {
+          const handlers = this.handlers;
+          for (const listener of previousReplacedEventListeners) {
             EVENT_DISPATCHERS.delete(listener);
             this.publishedListeners.delete(listener);
             handlers.delete(listener);
@@ -5902,11 +6091,10 @@ class UniversalRootImpl {
               );
             }
           }
-          this.handlers = handlers;
         }
         if ((treeFeatures & UNIVERSAL_TREE_LOCAL_CALLBACK) !== 0) {
-          const localCallbacks = scoped ? this.localCallbacks : /* @__PURE__ */ new Map();
-          for (const listener of previousScopedLocalCallbacks) {
+          const localCallbacks = this.localCallbacks;
+          for (const listener of previousReplacedLocalCallbacks) {
             localCallbacks.delete(listener);
           }
           for (const callbacks of localCallbackStage.staged.values()) {
@@ -5914,7 +6102,6 @@ class UniversalRootImpl {
               localCallbacks.set(callback.listener, callback);
             }
           }
-          this.localCallbacks = localCallbacks;
         }
         for (const owner of removedOwners) {
           owner.disposed = true;
@@ -5926,12 +6113,25 @@ class UniversalRootImpl {
         for (const draft of draftOwnersParentFirst) {
           const record = draft.record;
           record.componentProps = draft.componentProps;
+          record.componentRevision = draft.componentRevision;
           if (!scoped || draft !== attempt.owner) {
             record.parent = draft.parent?.record ?? null;
           }
           record.hooks = draft.hooks;
           record.effectOrder = [...draft.seenEffects];
-          record.children = draft.children.map((child) => child.record);
+          if (draft.retainedChildren === null) {
+            record.children = draft.children.map((child) => child.record);
+          } else {
+            const merged = [];
+            let retainedIndex = 0;
+            for (let index = 0; index <= draft.children.length; index++) {
+              while (retainedIndex < draft.retainedChildren.length && draft.retainedChildren[retainedIndex].position === index) {
+                merged.push(draft.retainedChildren[retainedIndex++].record);
+              }
+              if (index < draft.children.length) merged.push(draft.children[index].record);
+            }
+            record.children = merged;
+          }
           record.contextValues = draft.contextValues;
           record.isBoundary = draft.isBoundary;
           record.canHandleSuspense = draft.canHandleSuspense;
@@ -6036,8 +6236,7 @@ class UniversalRootImpl {
       },
       () => {
         const tasks = [];
-        for (const draft of lifecycleOrder) {
-          const record = draft.record;
+        for (const record of lifecycleOrder) {
           for (const callback of record.lifecycles.values()) {
             tasks.push(
               () => runOwnedCommit(
@@ -6381,6 +6580,7 @@ class UniversalRootImpl {
           }
         }
         this.rootRecord.children = [];
+        this.rootRecord.owner = null;
         let portalReleaseError = NO_PENDING_PASSIVE_ERROR;
         for (const registration of portalRegistrations) {
           try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "octane",
-  "version": "0.1.26",
+  "version": "0.1.28",
   "license": "MIT",
   "type": "module",
   "sideEffects": false,