octane 0.1.25 → 0.1.26

package/dist/runtime.js

@@ -100,6 +100,14 @@ function profilePortalComponent(rawBody) {
 function ensureHooks(scope) {
   return scope.hooks ?? (scope.hooks = /* @__PURE__ */ new Map());
 }
+function registerHookCleanup(scope, cleanup) {
+  if (process.env.NODE_ENV !== "production") {
+    if (scope.block.body[HMR] !== void 0) {
+      cleanup[HMR] = true;
+    }
+  }
+  (scope.cleanups ??= []).push(cleanup);
+}
 let nextHookSlot = 0;
 function hookSlots(count) {
   const base = nextHookSlot;
@@ -2446,7 +2454,7 @@ function unmountScope(scope, detachDom = true) {
     unmountScopeChildrenAndSlots(scope, detachDom);
   });
 }
-function unmountScopeChildrenAndSlots(scope, detachDom) {
+function runScopeCleanups(scope) {
   const c = scope.cleanups;
   if (c !== null)
     for (let i = c.length - 1; i >= 0; i--) {
@@ -2456,6 +2464,12 @@ function unmountScopeChildrenAndSlots(scope, detachDom) {
         reportTeardownError(err);
       }
     }
+}
+function unmountScopeChildrenAndSlots(scope, detachDom) {
+  runScopeCleanups(scope);
+  unmountScopeChildrenAndSlotsOnly(scope, detachDom);
+}
+function unmountScopeChildrenAndSlotsOnly(scope, detachDom) {
   const children = scope.children;
   if (children !== null)
     for (let i = 0, n = children.length; i < n; i++) unmountScope(children[i].scope, detachDom);
@@ -3123,7 +3137,7 @@ function useEffectEvent(fn, slot) {
     s = { impl: fn, active: true };
     ensureHooks(scope).set(slot, s);
     const cell2 = s;
-    (scope.cleanups ??= []).push(() => {
+    registerHookCleanup(scope, () => {
       cell2.active = false;
     });
   } else {
@@ -3205,6 +3219,87 @@ function scopedChildrenAsBody(props) {
   return (_props, scope, extra) => childrenAsBody(props.children)(void 0, scope, extra);
 }
 const CHILDREN_DIALECT_SLOT = /* @__PURE__ */ Symbol("octane.childrenDialect");
+function hasResettableHmrRange(block) {
+  const start = block.startMarker;
+  const end = block.endMarker;
+  if (start === void 0 || end === void 0) return false;
+  if (start === null || end === null) {
+    return start === null && end === null && (block.kind === "root" || block.exclusiveMarkers === true);
+  }
+  if (start !== end) {
+    return start.parentNode === block.parentNode && end.parentNode === block.parentNode;
+  }
+  for (let parent = block.parentBlock; parent !== null; parent = parent.parentBlock) {
+    if (parent.startMarker === start && parent.endMarker === end) return false;
+  }
+  return start.parentNode === block.parentNode;
+}
+function promoteHmrBlockRange(block) {
+  const root = block.startMarker;
+  if (root === null || root !== block.endMarker) return;
+  const parent = block.parentNode;
+  const rangeStart = document.createComment("hmr");
+  const rangeEnd = document.createComment("/hmr");
+  parent.insertBefore(rangeStart, root);
+  parent.insertBefore(rangeEnd, root.nextSibling);
+  block.startMarker = rangeStart;
+  block.endMarker = rangeEnd;
+  block.exclusiveMarkers = false;
+}
+function resetHmrBlock(block) {
+  if (TEARDOWN_DEPTH === 0) {
+    TEARDOWN_HANDLER = findTryHandler(block.parentBlock) ?? rendererRegionTryHandler(block);
+  }
+  TEARDOWN_DEPTH++;
+  let abortedRefs = null;
+  if (!block.mounted) {
+    abortedRefs = [];
+    collectVisibleSubtreeRefs(block, abortedRefs);
+  }
+  try {
+    withRefDetachSuppression(abortedRefs, () => {
+      if (block.deoptNode !== null) detachDeoptTreeRefs(block.deoptNode, null);
+      const cleanups = block.cleanups;
+      let preserved = null;
+      if (cleanups !== null) {
+        for (let i = cleanups.length - 1; i >= 0; i--) {
+          const cleanup = cleanups[i];
+          if (cleanup[HMR] === true) continue;
+          try {
+            runEffectLifecycleCallback(cleanup);
+          } catch (err) {
+            reportTeardownError(err);
+          }
+        }
+        for (let i = 0; i < cleanups.length; i++) {
+          const cleanup = cleanups[i];
+          if (cleanup[HMR] === true) (preserved ??= []).push(cleanup);
+        }
+      }
+      unmountScopeChildrenAndSlotsOnly(block, true);
+      removeRange(
+        block.startMarker !== null ? block.startMarker.nextSibling : block.parentNode.firstChild,
+        block.endMarker
+      );
+      block.children = null;
+      block.cleanups = preserved;
+      block._slots = null;
+      block.refFields = null;
+      block.slots = [];
+      block.deoptNode = null;
+    });
+    const hooks = block.hooks;
+    if (hooks !== null) {
+      for (const value of hooks.values()) {
+        if (value !== null && typeof value === "object" && Object.prototype.hasOwnProperty.call(value, "deps")) {
+          value.deps = void 0;
+        }
+      }
+    }
+  } finally {
+    if (--TEARDOWN_DEPTH === 0) dispatchTeardownErrors();
+  }
+}
 function resetScopeChildren(scope) {
   const block = scope.block;
   if (TEARDOWN_DEPTH === 0) {
@@ -10559,6 +10654,13 @@ function hmr(fn) {
       const nextFn = incomingMeta ? incomingMeta.fn : incoming;
       if (meta.fn.__octaneReturnedOutput !== nextFn.__octaneReturnedOutput)
         return false;
+      for (const b of meta.liveBlocks) {
+        if (b.disposed) {
+          meta.liveBlocks.delete(b);
+          continue;
+        }
+        if (!hasResettableHmrRange(b)) return false;
+      }
       meta.fn = nextFn;
       if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__)
         __profileComponentSource(wrapper, meta.fn);
@@ -10573,6 +10675,8 @@ function hmr(fn) {
         b.body = wrapper;
         if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__)
           __profileSchedule(b, "hmr");
+        promoteHmrBlockRange(b);
+        resetHmrBlock(b);
         scheduleRender(b);
       }
       return true;
@@ -11684,7 +11788,7 @@ function useTransition(slot) {
       }
     };
     TRANSITION_LISTENERS.add(listener);
-    (scope.cleanups ??= []).push(() => TRANSITION_LISTENERS.delete(listener));
+    registerHookCleanup(scope, () => TRANSITION_LISTENERS.delete(listener));
   }
   return [s.isPending, s.start];
 }
@@ -11786,7 +11890,7 @@ function useFormStatus(slot) {
     s = { form: null, listener: null };
     const slotRef = s;
     ensureHooks(scope).set(slot, slotRef);
-    (scope.cleanups ??= []).push(() => {
+    registerHookCleanup(scope, () => {
       if (slotRef.form && slotRef.listener)
         FORM_STATUS_LISTENERS.get(slotRef.form)?.delete(slotRef.listener);
     });
@@ -11861,7 +11965,7 @@ function useOptimistic(passthrough, updateFnOrSlot, slot) {
       if (TRANSITION_PENDING_COUNT === 0 && slotRef.armed) clear();
     };
     TRANSITION_LISTENERS.add(listener);
-    (scope.cleanups ??= []).push(() => TRANSITION_LISTENERS.delete(listener));
+    registerHookCleanup(scope, () => TRANSITION_LISTENERS.delete(listener));
   }
   s.updateFn = updateFn;
   let optimistic = passthrough;

package/dist/universal-core.d.ts

@@ -611,6 +611,7 @@ export interface ObjectHostInstance {
 }
 interface ObjectDriverState {
     instances: Map<number, ObjectHostInstance>;
+    parents: Map<number, number | null>;
     events: Map<number, Map<string, UniversalEventListenerDescriptor>>;
     lifecycles: Map<number, Map<string, UniversalListenerDescriptor>>;
     localCallbacks: Map<number, Map<string, UniversalListenerDescriptor>>;

package/dist/universal-core.js

@@ -616,6 +616,7 @@ function createOwnerRecord(root, component, parent, identityPath, key) {
     root,
     renderer: root.renderer,
     component,
+    componentProps: null,
     parent,
     identityPath,
     key,
@@ -624,6 +625,7 @@ function createOwnerRecord(root, component, parent, identityPath, key) {
     hooks: /* @__PURE__ */ new Map(),
     effectOrder: [],
     children: [],
+    range: null,
     contextValues: null,
     updates: /* @__PURE__ */ new Map(),
     isBoundary: false,
@@ -639,6 +641,7 @@ function createOwnerRecord(root, component, parent, identityPath, key) {
 function draftOwner(record, parent, replayPath) {
   return {
     record,
+    componentProps: record.componentProps,
     parent,
     replayPath,
     hooks: new Map(record.hooks),
@@ -658,7 +661,7 @@ function draftOwner(record, parent, replayPath) {
     boundaryThenable: record.boundaryThenable,
     isBoundary: record.isBoundary,
     canHandleSuspense: record.canHandleSuspense,
-    visibility: parent?.visibility ?? "visible"
+    visibility: parent?.visibility ?? record.visibility
   };
 }
 function childReplayPath(parent, component, identityPath, key) {
@@ -733,6 +736,15 @@ function readOwnerContext(owner, context, trackMemoRead = true) {
       return value;
     }
   }
+  if (currentAttempt().scope !== null) {
+    for (let current = owner?.record.parent ?? null; current !== null; current = current.parent) {
+      if (current.contextValues?.has(context)) {
+        value = current.contextValues.get(context);
+        if (trackMemoRead) CURRENT_MEMO_CONTEXT_READS?.set(context, value);
+        return value;
+      }
+    }
+  }
   value = currentAttempt().root.readBridgeContext(context);
   if (trackMemoRead) CURRENT_MEMO_CONTEXT_READS?.set(context, value);
   return value;
@@ -808,7 +820,7 @@ function renderLazyLeafItem(scope, render, item, index, key) {
   }
 }
 function ownerRange(owner, children) {
-  return [{ kind: "range", key: owner.record.rangeKey, children }];
+  return [{ kind: "range", key: owner.record.rangeKey, owner: owner.record, children }];
 }
 function componentContext(renderer) {
   return {
@@ -836,6 +848,7 @@ function materializeComponentValue(value, expectedRenderer, path) {
   const normalized = normalizePropsValue(value.props);
   const owner = claimChildOwner(parent, value.component, path, value.hasKey ? value.key : null);
   const props = { ...normalized.props };
+  owner.componentProps = props;
   const nodes = executeOwner(owner, () => {
     const rendered = value.component(props, componentContext(expectedRenderer));
     return materializeValue(rendered, expectedRenderer, null, [...path, "output"]);
@@ -862,6 +875,8 @@ function disposeUncommittedDraft(owner) {
   for (const child of owner.children) disposeUncommittedDraft(child);
   if (!owner.record.mounted) {
     owner.record.disposed = true;
+    owner.record.componentProps = null;
+    owner.record.range = null;
     owner.record.updates.clear();
     for (const hook of owner.hooks.values()) {
       if (hook.kind === "effect-event") hook.cell.active = false;
@@ -907,6 +922,7 @@ function blueprintFromLogical(record) {
     return {
       kind: "range",
       key: record.key,
+      ...record.owner === null ? null : { owner: record.owner },
       children: record.children.map(blueprintFromLogical)
     };
   }
@@ -1777,6 +1793,61 @@ function walkDraftPostOrder(record, visit) {
   for (const child of record.children) walkDraftPostOrder(child, visit);
   visit(record);
 }
+function logicalTreeFeatures(record) {
+  let features = 0;
+  walkLogical(record, (current) => {
+    if (current.kind === "portal") {
+      features |= UNIVERSAL_TREE_PORTAL;
+      return;
+    }
+    if (current.kind !== "host") return;
+    if (current.events.size !== 0) features |= UNIVERSAL_TREE_EVENT;
+    if (current.lifecycles.size !== 0) features |= UNIVERSAL_TREE_LIFECYCLE;
+    if (current.localCallbacks.size !== 0) features |= UNIVERSAL_TREE_LOCAL_CALLBACK;
+    if (current.ref != null) features |= UNIVERSAL_TREE_REF;
+    if (current.visibility !== "visible") features |= UNIVERSAL_TREE_HIDDEN;
+    for (const value of Object.values(current.props)) {
+      if (isRendererRegion(value)) {
+        features |= UNIVERSAL_TREE_REGION;
+        break;
+      }
+    }
+  });
+  return features;
+}
+function ownerTreeHasWarmPlan(owner) {
+  if (owner.component?.__warm !== void 0) return true;
+  for (const child of owner.children) {
+    if (ownerTreeHasWarmPlan(child)) return true;
+  }
+  return false;
+}
+function commonOwnerAncestor(left, right) {
+  let leftDepth = 0;
+  for (let current = left.parent; current !== null; current = current.parent) leftDepth++;
+  let rightDepth = 0;
+  for (let current = right.parent; current !== null; current = current.parent) rightDepth++;
+  let a = left;
+  let b = right;
+  for (; leftDepth > rightDepth; leftDepth--) a = a.parent;
+  for (; rightDepth > leftDepth; rightDepth--) b = b.parent;
+  while (a !== null && a !== b) {
+    a = a.parent;
+    b = b.parent;
+  }
+  return a;
+}
+function stableLogicalChildren(records, blueprints) {
+  if (records.length !== blueprints.length) return false;
+  for (let index = 0; index < records.length; index++) {
+    const record = records[index];
+    const blueprint = blueprints[index];
+    if (blueprint.kind === "range" && blueprint.compactLeafList !== void 0 || !sameRecordShape(record, blueprint) || !stableLogicalChildren(record.children, blueprint.children)) {
+      return false;
+    }
+  }
+  return true;
+}
 function collectRemovedPostOrder(record, output) {
   for (const child of record.children) collectRemovedPostOrder(child, output);
   if (record.kind === "host") output.push(record);
@@ -2090,7 +2161,7 @@ function scheduleOwner(owner, slot) {
     "state",
     typeof slot === "symbol" || typeof slot === "number" ? slot : void 0
   );
-  owner.root.schedule();
+  owner.root.scheduleOwned(owner);
 }
 function currentDraftOwner() {
   currentAttempt();
@@ -3395,6 +3466,8 @@ class UniversalRootImpl {
   retryRenderInput = null;
   scheduled = false;
   scheduledUrgent = false;
+  scheduledFullRoot = false;
+  scheduledOwners = /* @__PURE__ */ new Set();
   scheduledPreparationDepth = 0;
   scheduledTransitionBatches = /* @__PURE__ */ new Set();
   unattemptedTransitionBatches = /* @__PURE__ */ new Set();
@@ -4041,7 +4114,7 @@ class UniversalRootImpl {
     }
     this.__scheduleMicrotask(() => this.flushScheduledWork());
   }
-  schedule() {
+  markUrgentScheduled() {
     if (this.unmounted || this.owner?.disposed || this.lastComponent === null) return;
     this.scheduledUrgent = true;
     if (this.scheduled) return;
@@ -4049,6 +4122,15 @@ class UniversalRootImpl {
     SCHEDULED_UNIVERSAL_ROOTS.add(this);
     if (this.eventScopeDepth === 0 && UNIVERSAL_SYNC_DEPTH === 0) this.queueScheduledWork();
   }
+  scheduleOwned(owner) {
+    if (owner.root !== this || owner.disposed) return;
+    this.scheduledOwners.add(owner);
+    this.markUrgentScheduled();
+  }
+  schedule() {
+    this.scheduledFullRoot = true;
+    this.markUrgentScheduled();
+  }
   /** @internal Associates promoted transition work with its accepting transaction. */
   scheduleTransition(batch) {
     if (batch.settled || this.unmounted || this.owner?.disposed || this.lastComponent === null) {
@@ -4391,6 +4473,8 @@ class UniversalRootImpl {
     for (const draft of owners) {
       if (committed.has(draft.record)) continue;
       draft.record.disposed = true;
+      draft.record.componentProps = null;
+      draft.record.range = null;
       draft.record.updates.clear();
       for (const hook of draft.hooks.values()) {
         if (hook.kind === "effect-event") hook.cell.active = false;
@@ -4439,9 +4523,184 @@ class UniversalRootImpl {
       projectedThenable: null
     };
   }
+  // A local state update may replay only the component range that owns its hook.
+  // The retained topology check keeps reconciliation atomic: features that need
+  // root-wide coordination, or any structural change, fall back to the ordinary
+  // full-root attempt before a host batch is prepared.
+  prepareOwnedUpdate(target, component, props) {
+    const range = target.range;
+    if (this.transport !== null || this.bridge !== null || target.component === null || target.componentProps === null || ownerTreeHasWarmPlan(target) || range === null || range.kind !== "range" || range.owner !== target || target.visibility === "suspense-hidden") {
+      return null;
+    }
+    for (let ancestor = target.parent; ancestor !== null; ancestor = ancestor.parent) {
+      if (ancestor.isBoundary && (ancestor.hasBoundaryError || ancestor.boundaryThenable !== null)) {
+        return null;
+      }
+    }
+    const unsupported = UNIVERSAL_TREE_PORTAL | UNIVERSAL_TREE_REGION;
+    const scopeFeatures = logicalTreeFeatures(range);
+    if ((scopeFeatures & unsupported) !== 0) return null;
+    this.flushPassivesBeforeRender();
+    this.pending?.abort();
+    const owner = draftOwner(target, null, [
+      {
+        component: target.component,
+        identityPath: target.identityPath,
+        key: target.key,
+        ordinal: 0
+      }
+    ]);
+    const previousAttempt = CURRENT_ATTEMPT;
+    const previousOwner = CURRENT_OWNER;
+    const previousWarm = CURRENT_UNIVERSAL_WARM;
+    const previousWarmClaims = CURRENT_UNIVERSAL_WARM_CLAIMS;
+    const previousWarmPlans = ACTIVE_UNIVERSAL_WARM_PLANS.slice();
+    const attempt = {
+      root: this,
+      owner,
+      scope: target,
+      owners: [owner],
+      treeFeatures: 0,
+      replayEntries: [],
+      retryThenables: /* @__PURE__ */ new Set(),
+      nextUniversalId: this.nextUniversalId,
+      implicitSlot: 0,
+      transitionBatches: EMPTY_UNIVERSAL_TRANSITION_BATCHES,
+      transitionRender: false,
+      bridgeContextReads: null
+    };
+    ACTIVE_UNIVERSAL_WARM_PLANS.length = 0;
+    CURRENT_UNIVERSAL_WARM = null;
+    CURRENT_UNIVERSAL_WARM_CLAIMS = null;
+    CURRENT_ATTEMPT = attempt;
+    CURRENT_OWNER = owner;
+    let nodes;
+    try {
+      nodes = executeOwner(owner, () => {
+        const value = target.component(target.componentProps, componentContext(this.renderer));
+        return materializeValue(value, this.renderer, null, [...target.identityPath, "output"]);
+      });
+    } catch (error) {
+      this.discardDraftOwners(attempt.owners);
+      if (error instanceof UniversalSuspense) {
+        UNIVERSAL_WARM_CACHES.delete(this);
+        return null;
+      }
+      for (let ancestor = target.parent; ancestor !== null; ancestor = ancestor.parent) {
+        if (ancestor.isBoundary) {
+          UNIVERSAL_WARM_CACHES.delete(this);
+          return null;
+        }
+      }
+      throw error;
+    } finally {
+      ACTIVE_UNIVERSAL_WARM_PLANS.length = 0;
+      ACTIVE_UNIVERSAL_WARM_PLANS.push(...previousWarmPlans);
+      CURRENT_UNIVERSAL_WARM = previousWarm;
+      CURRENT_UNIVERSAL_WARM_CLAIMS = previousWarmClaims;
+      CURRENT_ATTEMPT = previousAttempt;
+      CURRENT_OWNER = previousOwner;
+    }
+    if (attempt.retryThenables.size !== 0 || (attempt.treeFeatures & unsupported) !== 0) {
+      this.discardDraftOwners(attempt.owners);
+      UNIVERSAL_WARM_CACHES.delete(this);
+      return null;
+    }
+    const blueprint = {
+      kind: "range",
+      key: target.rangeKey,
+      owner: target,
+      children: nodes
+    };
+    this.expandCompactLeafLists(blueprint);
+    let scopePlacement = null;
+    if (!stableLogicalChildren(range.children, blueprint.children)) {
+      scopePlacement = this.scopePhysicalPlacement(range);
+      if (scopePlacement === null) {
+        this.discardDraftOwners(attempt.owners);
+        UNIVERSAL_WARM_CACHES.delete(this);
+        return null;
+      }
+    }
+    try {
+      const transaction = this.createPreparedTransaction(
+        blueprint,
+        attempt,
+        component,
+        props,
+        /* @__PURE__ */ new Set(),
+        range,
+        scopeFeatures,
+        scopePlacement
+      );
+      this.pending = transaction;
+      return transaction;
+    } catch (error) {
+      this.discardDraftOwners(attempt.owners);
+      throw error;
+    }
+  }
+  // The physical frame a scoped range commits into: its nearest host (or
+  // container) ancestor plus the first physical host that follows the scope
+  // inside that parent. Untouched siblings cannot move during a scoped commit,
+  // so both stay valid anchors for inserted or reordered scope content. A
+  // portal or detached ancestor owns a separate physical tree: no frame.
+  scopePhysicalPlacement(scope) {
+    let endAnchor = null;
+    let current = scope;
+    for (let parent = current.parent; parent !== null; current = parent, parent = current.parent) {
+      if (parent.kind !== "host" && parent.kind !== "range") return null;
+      if (endAnchor === null) {
+        const siblings = parent.children;
+        for (let index = siblings.indexOf(current) + 1; index < siblings.length; index++) {
+          const found = physicalRecords([siblings[index]]);
+          if (found.length !== 0) {
+            endAnchor = found[0].id;
+            break;
+          }
+        }
+      }
+      if (parent.kind === "host") return { parent: parent.id, endAnchor };
+      if (parent === this.rootRecord) return { parent: null, endAnchor };
+    }
+    return null;
+  }
+  // A scheduled owner that cannot replay alone (an anonymous @for-item owner,
+  // or several owners raised by one event scope) still has one smallest
+  // ancestor whose retained props and range can replay every queued update:
+  // the nearest enclosing component owner of their common ancestor.
+  resolveScopedTarget() {
+    let scope = null;
+    for (const owner of this.scheduledOwners) {
+      if (owner.disposed) continue;
+      if (owner.visibility === "suspense-hidden") return void 0;
+      scope = scope === null ? owner : commonOwnerAncestor(scope, owner);
+      if (scope === null) return void 0;
+    }
+    let target = null;
+    for (let current = scope; current !== null; current = current.parent) {
+      if (current.component !== null && current.componentProps !== null && current.range !== null) {
+        target = current;
+        break;
+      }
+    }
+    if (target === null) return void 0;
+    for (const owner of this.scheduledOwners) {
+      if (owner.disposed) continue;
+      for (let current = owner; current !== target; current = current.parent) {
+        if (current === null || current.isBoundary && (current.hasBoundaryError || current.boundaryThenable !== null)) {
+          return void 0;
+        }
+      }
+    }
+    return target;
+  }
   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.scheduledUrgent = false;
+    this.scheduledFullRoot = false;
+    this.scheduledOwners.clear();
     if (scheduledUrgent) this.urgentBoundarySuspension = null;
     const bridgeReplay = this.bridge === null ? null : this.queuedReplay;
     if (!scheduledUrgent && bridgeReplay !== null && bridgeReplay.component === component && bridgeReplay.active) {
@@ -4468,6 +4727,10 @@ class UniversalRootImpl {
     const scheduledTransitions = scheduledUrgent ? EMPTY_UNIVERSAL_TRANSITION_BATCHES : this.takeScheduledTransitionBatches();
     UNIVERSAL_WARM_CACHES.delete(this);
     try {
+      if (ownedTarget !== void 0 && component === this.lastComponent && universalShallowEqual(props, this.lastProps)) {
+        const ownedAttempt = this.prepareOwnedUpdate(ownedTarget, component, props);
+        if (ownedAttempt !== null) return ownedAttempt;
+      }
       const attempt = this.prepareWithReplay(
         component,
         props,
@@ -4505,6 +4768,7 @@ class UniversalRootImpl {
       { component, identityPath: ownerRecord.identityPath, key: ownerRecord.key, ordinal: 0 }
     ];
     const owner = draftOwner(ownerRecord, null, rootPath);
+    owner.componentProps = props;
     const previousAttempt = CURRENT_ATTEMPT;
     const previousOwner = CURRENT_OWNER;
     const previousWarm = CURRENT_UNIVERSAL_WARM;
@@ -4513,6 +4777,7 @@ class UniversalRootImpl {
     const attempt = {
       root: this,
       owner,
+      scope: null,
       owners: [owner],
       treeFeatures: 0,
       replayEntries,
@@ -4758,6 +5023,7 @@ class UniversalRootImpl {
         }
         for (const draft of attempt.owners) {
           const record = draft.record;
+          record.componentProps = draft.componentProps;
           record.parent = draft.parent?.record ?? null;
           record.hooks = draft.hooks;
           record.effectOrder = [...draft.seenEffects];
@@ -4866,6 +5132,7 @@ class UniversalRootImpl {
         }
         for (const draft of attempt.owners) {
           const record = draft.record;
+          record.componentProps = draft.componentProps;
           record.parent = draft.parent?.record ?? null;
           record.hooks = draft.hooks;
           record.effectOrder = [...draft.seenEffects];
@@ -4955,23 +5222,29 @@ class UniversalRootImpl {
       throw error;
     }
   }
-  createPreparedTransaction(blueprint, attempt, component, props, stagedPortalRegistrations) {
+  createPreparedTransaction(blueprint, attempt, component, props, stagedPortalRegistrations, scopeRecord = this.rootRecord, scopeFeatures = 0, scopePlacement = null) {
     let nextId = this.nextId;
-    const treeFeatures = this.treeFeatures | attempt.treeFeatures;
-    const used = /* @__PURE__ */ new Set([this.rootRecord]);
+    const scoped = scopeRecord !== this.rootRecord;
+    const treeFeatures = (scoped ? scopeFeatures : this.treeFeatures) | attempt.treeFeatures;
+    const used = /* @__PURE__ */ new Set([scopeRecord]);
+    const changedRangeOwners = [];
     let topologyChanged = false;
     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];
-          return {
+          const draft = {
             record,
             blueprint: blueprint2,
             children: reconcileChildren(record.children, blueprint2.children),
             isNew: false,
             hostUpdate: null
           };
+          if (record.kind === "range" && record.owner !== (blueprint2.owner ?? null)) {
+            changedRangeOwners.push(draft);
+          }
+          return draft;
         });
       }
       const keyed = /* @__PURE__ */ new Map();
@@ -5012,13 +5285,17 @@ class UniversalRootImpl {
         record ??= createLogicalRecord(nextId++, child);
         claimed.add(record);
         used.add(record);
-        output.push({
+        const draft = {
           record,
           blueprint: child,
           children: reconcileChildren(record.children, child.children),
           isNew,
           hostUpdate: null
-        });
+        };
+        if (record.kind === "range" && record.owner !== (child.owner ?? null)) {
+          changedRangeOwners.push(draft);
+        }
+        output.push(draft);
       }
       if (oldChildren.length !== output.length || output.some((draft, index) => draft.record !== oldChildren[index])) {
         topologyChanged = true;
@@ -5026,9 +5303,9 @@ class UniversalRootImpl {
       return output;
     };
     const draftRoot = {
-      record: this.rootRecord,
+      record: scopeRecord,
       blueprint,
-      children: reconcileChildren(this.rootRecord.children, blueprint.children),
+      children: reconcileChildren(scopeRecord.children, blueprint.children),
       isNew: false,
       hostUpdate: null
     };
@@ -5039,13 +5316,13 @@ class UniversalRootImpl {
         else findRemoved(child);
       }
     };
-    if (topologyChanged) findRemoved(this.rootRecord);
+    if (topologyChanged) findRemoved(scopeRecord);
     const previousPortalRegistrations = /* @__PURE__ */ new Set();
     const nextPortalRegistrations = /* @__PURE__ */ new Set();
     let reorderedPortalRecords = null;
     if ((treeFeatures & UNIVERSAL_TREE_PORTAL) !== 0) {
       const previousPortalsByTarget = topologyChanged ? /* @__PURE__ */ new Map() : null;
-      for (const child of this.rootRecord.children) {
+      for (const child of scopeRecord.children) {
         walkLogical(child, (record) => {
           if (record.kind === "portal" && record.portalRegistration !== null) {
             previousPortalRegistrations.add(record.portalRegistration);
@@ -5092,7 +5369,7 @@ class UniversalRootImpl {
     const stagedRegionBridges = [];
     const nextRegionBridges = /* @__PURE__ */ new Set();
     if ((treeFeatures & UNIVERSAL_TREE_REGION) !== 0) {
-      for (const child of this.rootRecord.children) {
+      for (const child of scopeRecord.children) {
         walkLogical(child, (record) => {
           if (record.kind !== "host") return;
           for (const value of Object.values(record.props)) {
@@ -5176,7 +5453,7 @@ class UniversalRootImpl {
     });
     const removes = [];
     const placements = [];
-    const planPlacements = (parentId, oldRecords, newDrafts, sourceParentId = parentId, forceMove = false) => {
+    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));
@@ -5192,7 +5469,7 @@ class UniversalRootImpl {
         const id = draft.record.id;
         if (current[index] === id) continue;
         const currentIndex = current.indexOf(id);
-        const before = current[index] ?? null;
+        const before = current[index] ?? endAnchor;
         if (currentIndex === -1) {
           placements.push({
             op: forceMove && previousIds.has(id) ? "move" : "insert",
@@ -5211,6 +5488,15 @@ class UniversalRootImpl {
       walkDraftPostOrder(draftRoot, (draft) => {
         if (draft.record === this.rootRecord) {
           planPlacements(null, this.rootRecord.children, draft.children);
+        } else if (scoped && draft === draftRoot && scopePlacement !== null) {
+          planPlacements(
+            scopePlacement.parent,
+            draft.record.children,
+            draft.children,
+            scopePlacement.parent,
+            false,
+            scopePlacement.endAnchor
+          );
         } else if (draft.record.kind === "host") {
           planPlacements(draft.record.id, draft.record.children, draft.children);
         } else if (draft.record.kind === "portal") {
@@ -5441,7 +5727,7 @@ class UniversalRootImpl {
       committedOwnersParentFirst.push(owner);
       for (const child of owner.children) walkCommittedOwners(child);
     };
-    walkCommittedOwners(this.owner);
+    walkCommittedOwners(scoped ? attempt.owner.record : this.owner);
     const removedOwners = committedOwnersParentFirst.filter((owner) => !draftedRecords.has(owner));
     const removedEffectEventCells = collectEffectEventCells(removedOwners);
     const orderedEffectCleanups = [];
@@ -5506,20 +5792,34 @@ class UniversalRootImpl {
         record.localCallbacks = localCallbackStage.staged.get(record) ?? record.localCallbacks;
         record.visibility = host.visibility;
       };
+      const applyRangeOwner = (draft) => {
+        const record = draft.record;
+        const nextOwner = draft.blueprint.owner ?? null;
+        if (record.owner !== nextOwner && record.owner?.range === record) {
+          record.owner.range = null;
+        }
+        record.owner = nextOwner;
+        if (nextOwner !== null) nextOwner.range = record;
+      };
       const apply = (draft, parent) => {
         const record = draft.record;
         record.parent = parent;
         record.key = draft.blueprint.key;
         if (record.kind === "host") {
           applyHost(draft);
+        } else if (record.kind === "range") {
+          applyRangeOwner(draft);
         } else if (record.kind === "portal") {
           record.portalRegistration = draft.blueprint.registration;
         }
         record.children = draft.children.map((child) => child.record);
         for (const child of draft.children) apply(child, record);
       };
-      if (topologyChanged) apply(draftRoot, null);
-      else for (const draft of hostDrafts) applyHost(draft);
+      if (topologyChanged) apply(draftRoot, scoped ? scopeRecord.parent : null);
+      else {
+        for (const draft of hostDrafts) applyHost(draft);
+        for (const draft of changedRangeOwners) applyRangeOwner(draft);
+      }
       stagedPortalRegistrations.clear();
       for (const registration of previousPortalRegistrations) {
         if (nextPortalRegistrations.has(registration)) continue;
@@ -5537,6 +5837,19 @@ class UniversalRootImpl {
       });
     }
     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) => {
+        if (record.kind !== "host") return;
+        for (const event of record.events.values()) {
+          previousScopedEventListeners.add(event.listener);
+        }
+        for (const callback of record.localCallbacks.values()) {
+          previousScopedLocalCallbacks.add(callback.listener);
+        }
+      });
+    }
     const prepareHost = (value) => this.driver.prepareBatch(this.container, value, {
       invokeLocalCallback: (listener, args) => this.invokeLocalCallback(listener, args)
     });
@@ -5571,9 +5884,13 @@ class UniversalRootImpl {
           }
         }
         if ((treeFeatures & UNIVERSAL_TREE_EVENT) !== 0) {
-          for (const listener of this.publishedListeners) EVENT_DISPATCHERS.delete(listener);
-          this.publishedListeners.clear();
-          const handlers = /* @__PURE__ */ new Map();
+          const handlers = scoped ? this.handlers : /* @__PURE__ */ new Map();
+          const replacedListeners = scoped ? previousScopedEventListeners : this.publishedListeners;
+          for (const listener of replacedListeners) {
+            EVENT_DISPATCHERS.delete(listener);
+            this.publishedListeners.delete(listener);
+            handlers.delete(listener);
+          }
           for (const [record, events] of stagedEvents) {
             if (!stagedVisibleEventRecords.has(record)) continue;
             for (const event of events.values()) {
@@ -5588,7 +5905,10 @@ class UniversalRootImpl {
           this.handlers = handlers;
         }
         if ((treeFeatures & UNIVERSAL_TREE_LOCAL_CALLBACK) !== 0) {
-          const localCallbacks = /* @__PURE__ */ new Map();
+          const localCallbacks = scoped ? this.localCallbacks : /* @__PURE__ */ new Map();
+          for (const listener of previousScopedLocalCallbacks) {
+            localCallbacks.delete(listener);
+          }
           for (const callbacks of localCallbackStage.staged.values()) {
             for (const callback of callbacks.values()) {
               localCallbacks.set(callback.listener, callback);
@@ -5599,11 +5919,16 @@ class UniversalRootImpl {
         for (const owner of removedOwners) {
           owner.disposed = true;
           owner.mounted = false;
+          owner.componentProps = null;
+          owner.range = null;
           owner.updates.clear();
         }
         for (const draft of draftOwnersParentFirst) {
           const record = draft.record;
-          record.parent = draft.parent?.record ?? null;
+          record.componentProps = draft.componentProps;
+          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);
@@ -5659,19 +5984,19 @@ class UniversalRootImpl {
             }
           }
         }
-        this.owner = attempt.owner.record;
+        if (!scoped) this.owner = attempt.owner.record;
         this.lastComponent = component;
         this.lastProps = props;
         this.retryRenderInput = null;
         this.urgentBoundarySuspension = null;
-        this.bridgeContextReads = attempt.bridgeContextReads;
+        if (!scoped) this.bridgeContextReads = attempt.bridgeContextReads;
         if (retryThenables.length > 0) {
           this.publishLocalReplay(retryThenables, retryMemos, component, props);
         }
         this.nextId = nextId;
         this.nextUniversalId = attempt.nextUniversalId;
         this.nextListener = nextListener;
-        this.treeFeatures = attempt.treeFeatures;
+        this.treeFeatures = scoped ? this.treeFeatures | attempt.treeFeatures : attempt.treeFeatures;
         for (const context of changedContexts) context.$$version++;
         const retainedRegionCells = /* @__PURE__ */ new Set();
         for (const { next, previous } of stagedRegionBridges) {
@@ -6034,6 +6359,8 @@ class UniversalRootImpl {
       finalize: (acceptedHostError) => {
         this.scheduled = false;
         this.scheduledUrgent = false;
+        this.scheduledFullRoot = false;
+        this.scheduledOwners.clear();
         SCHEDULED_UNIVERSAL_ROOTS.delete(this);
         const transitionBatches = new Set(this.takeScheduledTransitionBatches());
         for (const transition of stagedTransitionBatches) transitionBatches.add(transition);
@@ -6042,6 +6369,8 @@ class UniversalRootImpl {
         this.cancelSuspendedReplays();
         this.scheduled = false;
         this.scheduledUrgent = false;
+        this.scheduledFullRoot = false;
+        this.scheduledOwners.clear();
         SCHEDULED_UNIVERSAL_ROOTS.delete(this);
         let attachmentUnsubscribeError = NO_PENDING_PASSIVE_ERROR;
         if (this.hostAttachments !== null) {
@@ -6068,6 +6397,8 @@ class UniversalRootImpl {
         for (const owner of owners) {
           owner.disposed = true;
           owner.mounted = false;
+          owner.componentProps = null;
+          owner.range = null;
           owner.updates.clear();
         }
         const deactivatedRegionCells = /* @__PURE__ */ new Set();
@@ -6450,6 +6781,7 @@ function createObjectContainer(renderer = "object") {
   assertRendererId(renderer, "Object container renderer");
   const state = {
     instances: /* @__PURE__ */ new Map(),
+    parents: /* @__PURE__ */ new Map(),
     events: /* @__PURE__ */ new Map(),
     lifecycles: /* @__PURE__ */ new Map(),
     localCallbacks: /* @__PURE__ */ new Map(),
@@ -6517,8 +6849,14 @@ function createObjectDriver(renderer = "object") {
       }
       const state = container[OBJECT_DRIVER_STATE];
       const simulated = /* @__PURE__ */ new Map();
-      for (const [id, instance] of state.instances) {
-        simulated.set(id, {
+      const destroyed = /* @__PURE__ */ new Set();
+      const readSimulated = (id) => {
+        if (destroyed.has(id)) return void 0;
+        let value = simulated.get(id);
+        if (value !== void 0) return value;
+        const instance = state.instances.get(id);
+        if (instance === void 0) return void 0;
+        value = {
           type: instance.type,
           props: instance.props,
           visible: instance.visible,
@@ -6526,8 +6864,11 @@ function createObjectDriver(renderer = "object") {
           events: new Map(state.events.get(id)),
           lifecycles: new Map(state.lifecycles.get(id)),
           localCallbacks: new Map(state.localCallbacks.get(id))
-        });
-      }
+        };
+        simulated.set(id, value);
+        return value;
+      };
+      const hasSimulated = (id) => !destroyed.has(id) && (simulated.has(id) || state.instances.has(id));
       const stagedInstances = /* @__PURE__ */ new Map();
       const cleanupKeys = /* @__PURE__ */ new Set();
       const invokeKeys = /* @__PURE__ */ new Set();
@@ -6536,17 +6877,35 @@ function createObjectDriver(renderer = "object") {
         const separator = key.indexOf(":");
         return [Number(key.slice(0, separator)), key.slice(separator + 1)];
       };
-      const rootChildren = container.children.map((child) => child.id);
+      const DETACHED = /* @__PURE__ */ Symbol("octane.object-driver.detached");
+      const parentChanges = /* @__PURE__ */ new Map();
+      let rootChildren = null;
+      const readParent = (id) => {
+        if (parentChanges.has(id)) return parentChanges.get(id);
+        return state.parents.has(id) ? state.parents.get(id) : DETACHED;
+      };
       const simulatedChildren = (parent) => {
-        if (parent === null) return rootChildren;
-        const value = simulated.get(parent);
+        if (parent === null) {
+          return rootChildren ??= container.children.map((child) => child.id);
+        }
+        const value = readSimulated(parent);
         if (value === void 0) throw new Error(`Object driver: unknown parent ${parent}.`);
         return value.children;
       };
+      const detachSimulated = (id) => {
+        const parent = readParent(id);
+        if (parent === DETACHED) return;
+        const children = simulatedChildren(parent);
+        const index = children.indexOf(id);
+        if (index === -1) throw new Error(`Object driver: child ${id} is not attached.`);
+        children.splice(index, 1);
+        parentChanges.set(id, DETACHED);
+      };
       for (const command of batch.commands) {
         if (command.op === "create") {
-          if (simulated.has(command.id))
+          if (hasSimulated(command.id))
             throw new Error(`Object driver: duplicate id ${command.id}.`);
+          destroyed.delete(command.id);
           simulated.set(command.id, {
             type: command.type,
             props: command.props,
@@ -6564,11 +6923,11 @@ function createObjectDriver(renderer = "object") {
             children: []
           });
         } else if (command.op === "update") {
-          const value = simulated.get(command.id);
+          const value = readSimulated(command.id);
           if (value === void 0) throw new Error(`Object driver: unknown update ${command.id}.`);
           value.props = command.props;
         } else if (command.op === "recreate") {
-          const value = simulated.get(command.id);
+          const value = readSimulated(command.id);
           const current = state.instances.get(command.id);
           if (value === void 0 || current === void 0) {
             throw new Error(`Object driver: unknown recreate ${command.id}.`);
@@ -6589,25 +6948,25 @@ function createObjectDriver(renderer = "object") {
             invokeKeys.add(keyFor(command.id, type));
           }
         } else if (command.op === "visibility") {
-          const value = simulated.get(command.id);
+          const value = readSimulated(command.id);
           if (value === void 0) {
             throw new Error(`Object driver: unknown visibility target ${command.id}.`);
           }
           value.visible = command.state === "visible";
         } else if (command.op === "event") {
-          const value = simulated.get(command.id);
+          const value = readSimulated(command.id);
           if (value === void 0)
             throw new Error(`Object driver: unknown event target ${command.id}.`);
           if (command.listener === null) value.events.delete(command.type);
           else value.events.set(command.type, command.listener);
         } else if (command.op === "lifecycle") {
-          const value = simulated.get(command.id);
+          const value = readSimulated(command.id);
           if (value === void 0)
             throw new Error(`Object driver: unknown lifecycle target ${command.id}.`);
           if (command.listener === null) value.lifecycles.delete(command.type);
           else value.lifecycles.set(command.type, command.listener);
         } else if (command.op === "local-callback") {
-          const value = simulated.get(command.id);
+          const value = readSimulated(command.id);
           if (value === void 0)
             throw new Error(`Object driver: unknown local callback target ${command.id}.`);
           const key = keyFor(command.id, command.type);
@@ -6621,21 +6980,16 @@ function createObjectDriver(renderer = "object") {
           if (command.parent !== null && typeof command.parent !== "number") {
             throw new Error("Object driver does not support portal target parents.");
           }
-          if (!simulated.has(command.id))
+          if (!hasSimulated(command.id))
             throw new Error(`Object driver: unknown child ${command.id}.`);
-          for (const value of [
-            rootChildren,
-            ...[...simulated.values()].map((entry) => entry.children)
-          ]) {
-            const old = value.indexOf(command.id);
-            if (old !== -1) value.splice(old, 1);
-          }
+          detachSimulated(command.id);
           const children = simulatedChildren(command.parent);
           const before = command.before === null ? children.length : children.indexOf(command.before);
           if (before === -1) throw new Error(`Object driver: unknown before id ${command.before}.`);
           children.splice(before, 0, command.id);
+          parentChanges.set(command.id, command.parent);
           if (command.op === "move") {
-            for (const type of simulated.get(command.id).localCallbacks.keys()) {
+            for (const type of readSimulated(command.id).localCallbacks.keys()) {
               const key = keyFor(command.id, type);
               cleanupKeys.add(key);
               invokeKeys.add(key);
@@ -6649,26 +7003,22 @@ function createObjectDriver(renderer = "object") {
           const index = children.indexOf(command.id);
           if (index === -1) throw new Error(`Object driver: child ${command.id} is not attached.`);
           children.splice(index, 1);
-          for (const type of simulated.get(command.id).localCallbacks.keys()) {
+          parentChanges.set(command.id, DETACHED);
+          for (const type of readSimulated(command.id).localCallbacks.keys()) {
             cleanupKeys.add(keyFor(command.id, type));
           }
         } else if (command.op === "destroy") {
-          const instance = simulated.get(command.id);
+          const instance = readSimulated(command.id);
           if (instance === void 0)
             throw new Error(`Object driver: unknown destroy ${command.id}.`);
-          for (const value of [
-            rootChildren,
-            ...[...simulated.values()].map((entry) => entry.children)
-          ]) {
-            const attached = value.indexOf(command.id);
-            if (attached !== -1) value.splice(attached, 1);
-          }
+          detachSimulated(command.id);
+          for (const child of instance.children) parentChanges.set(child, DETACHED);
           instance.children.length = 0;
-          simulated.delete(command.id);
+          destroyed.add(command.id);
         }
       }
       for (const [id, instance] of stagedInstances) {
-        const staged = simulated.get(id);
+        const staged = readSimulated(id);
         if (staged === void 0) continue;
         instance.visible = staged.visible;
         instance.children.splice(
@@ -6681,6 +7031,16 @@ function createObjectDriver(renderer = "object") {
       }
       let status = "prepared";
       let acceptedCallbacksRan = false;
+      const liveChildren = (parent) => objectChildren(container, parent, state.instances);
+      const detachLive = (id) => {
+        if (!state.parents.has(id)) return;
+        const parent = state.parents.get(id);
+        const instance = state.instances.get(id);
+        const children = liveChildren(parent);
+        const index = children.indexOf(instance);
+        if (index !== -1) children.splice(index, 1);
+        state.parents.delete(id);
+      };
       return {
         apply() {
           if (status !== "prepared") return;
@@ -6697,7 +7057,11 @@ function createObjectDriver(renderer = "object") {
           tasks.push(() => {
             for (const command of batch.commands) {
               if (command.op === "create") {
-                state.instances.set(command.id, stagedInstances.get(command.id));
+                const instance = stagedInstances.get(command.id);
+                state.instances.set(command.id, instance);
+                for (const child of instance.children) {
+                  state.parents.set(child.id, command.id);
+                }
                 state.events.set(command.id, /* @__PURE__ */ new Map());
                 state.lifecycles.set(command.id, /* @__PURE__ */ new Map());
                 state.localCallbacks.set(command.id, /* @__PURE__ */ new Map());
@@ -6707,10 +7071,8 @@ function createObjectDriver(renderer = "object") {
               } else if (command.op === "recreate") {
                 const previous = state.instances.get(command.id);
                 const replacement = stagedInstances.get(command.id);
-                for (const parent of [
-                  container.children,
-                  ...[...state.instances.values()].map((entry) => entry.children)
-                ]) {
+                if (state.parents.has(command.id)) {
+                  const parent = liveChildren(state.parents.get(command.id));
                   const index = parent.indexOf(previous);
                   if (index !== -1) parent[index] = replacement;
                 }
@@ -6735,33 +7097,25 @@ function createObjectDriver(renderer = "object") {
                   throw new Error("Object driver does not support portal target parents.");
                 }
                 const instance = state.instances.get(command.id);
-                for (const parent of [
-                  container.children,
-                  ...[...state.instances.values()].map((entry) => entry.children)
-                ]) {
-                  const old = parent.indexOf(instance);
-                  if (old !== -1) parent.splice(old, 1);
-                }
-                const children = objectChildren(container, command.parent, state.instances);
+                detachLive(command.id);
+                const children = liveChildren(command.parent);
                 const before = command.before === null ? children.length : children.indexOf(state.instances.get(command.before));
                 children.splice(before, 0, instance);
+                state.parents.set(command.id, command.parent);
               } else if (command.op === "remove") {
                 if (command.parent !== null && typeof command.parent !== "number") {
                   throw new Error("Object driver does not support portal target parents.");
                 }
-                const children = objectChildren(container, command.parent, state.instances);
+                const children = liveChildren(command.parent);
                 children.splice(children.indexOf(state.instances.get(command.id)), 1);
+                state.parents.delete(command.id);
               } else if (command.op === "destroy") {
                 const instance = state.instances.get(command.id);
-                for (const parent of [
-                  container.children,
-                  ...[...state.instances.values()].map((entry) => entry.children)
-                ]) {
-                  const attached = parent.indexOf(instance);
-                  if (attached !== -1) parent.splice(attached, 1);
-                }
+                detachLive(command.id);
+                for (const child of instance.children) state.parents.delete(child.id);
                 instance.children.length = 0;
                 state.instances.delete(command.id);
+                state.parents.delete(command.id);
                 state.events.delete(command.id);
                 state.lifecycles.delete(command.id);
                 state.localCallbacks.delete(command.id);
@@ -6782,13 +7136,8 @@ function createObjectDriver(renderer = "object") {
             const listener = state.localCallbacks.get(id)?.get(type);
             if (instance === void 0 || listener === void 0) continue;
             tasks.push(() => {
-              let parent = null;
-              for (const candidate of state.instances.values()) {
-                if (candidate.children.includes(instance)) {
-                  parent = candidate;
-                  break;
-                }
-              }
+              const parentId = state.parents.get(id);
+              const parent = parentId == null ? null : state.instances.get(parentId) ?? null;
               const cleanup = context.invokeLocalCallback(listener.id, [parent, instance]);
               if (cleanup == null) return;
               if (typeof cleanup !== "function") {

package/package.json

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