octane 0.1.51 → 0.2.1

package/README.md

@@ -1,6 +1,6 @@
 # What is octane?
 
-[![status: alpha](https://img.shields.io/badge/status-alpha-orange)](https://www.npmjs.com/package/octane)
+[![status: beta](https://img.shields.io/badge/status-beta-yellow)](https://www.npmjs.com/package/octane)
 [![npm version](https://img.shields.io/npm/v/octane?logo=npm)](https://www.npmjs.com/package/octane)
 [![npm downloads](https://img.shields.io/npm/dm/octane?logo=npm&label=downloads)](https://www.npmjs.com/package/octane)
 
@@ -96,7 +96,8 @@ APIs. Features such as native `inert` may require a polyfill on older supported
 browsers. Validate text entry with the keyboards, languages, and browser or
 WebView versions your application supports.
 
-Octane is alpha software. It is ready to try, but not yet ready for production.
+Octane is beta software. It is ready to build with, but its APIs may still
+change before 1.0.
 
 ## License
 

package/dist/cjs/runtime.cjs

@@ -686,13 +686,12 @@ function ensureTransitionSwapDriver() {
 }
 let ACTIVE_TRANSITION_ACTION_BATCH = null;
 let IN_FLIGHT_TRANSITION_ACTION_BATCH = null;
-let ACTIVE_DISCRETE_EVENT_DEPTH = 0;
 function createTransitionActionBatch() {
   return { updates: /* @__PURE__ */ new Map(), pendingActions: 0, closed: false, flushed: false };
 }
 function transitionActionBatchForUpdate() {
   if (ACTIVE_TRANSITION_ACTION_BATCH !== null) return ACTIVE_TRANSITION_ACTION_BATCH;
-  if (syncFlush || ACTIVE_DISCRETE_EVENT_DEPTH > 0) return null;
+  if (syncFlush || _dispatchDepth > 0) return null;
   return IN_FLIGHT_TRANSITION_ACTION_BATCH;
 }
 function rebaseTransitionActionUpdate(update) {
@@ -2088,7 +2087,7 @@ function scheduleRender(block) {
     block.crossRenderUpdate = true;
     warnCrossComponentRenderUpdate(block, CURRENT_BLOCK);
   }
-  const mode = TRANSITION_DEPTH > 0 || renderPhaseSelf && block.currentRenderMode === "transition" || !syncFlush && ACTIVE_DISCRETE_EVENT_DEPTH === 0 && ASYNC_TRANSITION_COUNT > 0 ? "transition" : "urgent";
+  const mode = TRANSITION_DEPTH > 0 || renderPhaseSelf && block.currentRenderMode === "transition" || !syncFlush && _dispatchDepth === 0 && ASYNC_TRANSITION_COUNT > 0 ? "transition" : "urgent";
   const deferred = DEFERRED_SPAWN || renderPhaseSelf && block.currentRenderDeferred;
   if (block.pending) {
     if (mode === "urgent") {
@@ -2900,6 +2899,11 @@ function queueRefDetach(ref, el) {
   target.push(ref, el, TEARDOWN_HANDLER, TEARDOWN_BLOCK);
 }
 function replaceRef(scope, previous, next, target) {
+  if (TRANSITION_JOURNAL !== null) {
+    journalBag();
+    if (Object.prototype.hasOwnProperty.call(target, "_currentRef"))
+      journalRootProperty(target, "_currentRef");
+  }
   if (previous != null) queueRefDetach(previous, target);
   if (next != null) queueRefAttach(scope, next, target);
   return next;
@@ -4137,6 +4141,7 @@ function unmountSlot(val, detachDom) {
     const childDetach = k === "portalSlotSlot" ? true : detachDom;
     if (val.block) unmountBlock(val.block, childDetach);
     if (k === "portalSlotSlot" && val.target) {
+      unregisterPortalEventRange(val.target, val);
       unregisterDelegationTarget(val.target);
     }
   }
@@ -9776,6 +9781,58 @@ function evtNu(d, fn, args) {
 }
 const _delegated = /* @__PURE__ */ new Set();
 const _delegationTargets = /* @__PURE__ */ new Map();
+const _portalEventRanges = /* @__PURE__ */ new WeakMap();
+let portalEventTargetCount = 0;
+const PORTAL_EVENT_PATH_LENGTH = /* @__PURE__ */ Symbol("octane.portalPathLength");
+const _eventRoots = /* @__PURE__ */ new WeakMap();
+let eventRootEpoch = 0;
+const EVENT_ROOT_EPOCH = /* @__PURE__ */ Symbol("octane.rootEpoch");
+function changeEventRootMembership(target, delta) {
+  const previous = _eventRoots.get(target);
+  _eventRoots.set(target, {
+    count: (previous?.count || 0) + delta,
+    since: ++eventRootEpoch,
+    previous
+  });
+  if (previous !== void 0) {
+    setTimeout(() => {
+      const current = _eventRoots.get(target);
+      if (current !== void 0) current.previous = void 0;
+    }, 0);
+  }
+}
+function isEventRoot(node, epoch) {
+  let membership = _eventRoots.get(node);
+  while (membership !== void 0 && membership.since > epoch) membership = membership.previous;
+  return membership !== void 0 && membership.count > 0;
+}
+function prepareDelegatedEvent(event, listener) {
+  const path = event.composedPath();
+  if (_delegationTargets.size === 1) {
+    event[EVENT_ROOT_EPOCH] = eventRootEpoch;
+    if (portalEventTargetCount !== 0) {
+      preparePortalEventOwners(path, eventRootEpoch);
+      event[PORTAL_EVENT_PATH_LENGTH] = path.length;
+    }
+    return path;
+  }
+  for (let i = path.length - 1; i >= 0; i--) {
+    if (_delegationTargets.has(path[i])) {
+      if (path[i] === listener) {
+        event[EVENT_ROOT_EPOCH] = eventRootEpoch;
+        if (portalEventTargetCount !== 0) {
+          preparePortalEventOwners(path, eventRootEpoch);
+          event[PORTAL_EVENT_PATH_LENGTH] = path.length;
+        }
+      } else if (portalEventTargetCount !== 0 && path.length > (event[PORTAL_EVENT_PATH_LENGTH] || 0)) {
+        preparePortalEventOwners(path, event[EVENT_ROOT_EPOCH] ?? eventRootEpoch);
+        event[PORTAL_EVENT_PATH_LENGTH] = path.length;
+      }
+      break;
+    }
+  }
+  return path;
+}
 const _delegatedCapture = /* @__PURE__ */ new Set();
 const EMULATED_BUBBLING_EVENTS = [
   "abort",
@@ -9850,11 +9907,19 @@ function delegateEvents(eventNames) {
     _delegated.add(name);
     if (canSeed) seedExpando(Element.prototype, "$$" + name);
     for (const target of _delegationTargets.keys()) {
+      if (delegatedCapture(name) && _delegatedCapture.has(name)) continue;
       target.addEventListener(
         name,
         dispatchDelegated,
         delegatedListenerOptions(name, delegatedCapture(name))
       );
+      if (!delegatedCapture(name)) {
+        target.addEventListener(
+          name,
+          dispatchDelegatedCapture,
+          delegatedListenerOptions(name, true)
+        );
+      }
     }
   }
 }
@@ -9866,12 +9931,18 @@ function delegateCaptureEvents(eventNames) {
     _delegatedCapture.add(name);
     if (canSeed) seedExpando(Element.prototype, CAPTURE_PREFIX + name);
     for (const target of _delegationTargets.keys()) {
-      target.addEventListener(name, dispatchDelegatedCapture, delegatedListenerOptions(name, true));
+      if (_delegated.has(name)) continue;
+      target.addEventListener(
+        name,
+        delegatedCapture(name) ? dispatchDelegated : dispatchDelegatedCapture,
+        delegatedListenerOptions(name, true)
+      );
     }
   }
 }
-function registerDelegationTarget(target) {
+function registerDelegationTarget(target, root = false) {
   initDomOperations();
+  if (root) changeEventRootMembership(target, 1);
   const prev = _delegationTargets.get(target) || 0;
   _delegationTargets.set(target, prev + 1);
   if (prev === 0) {
@@ -9884,22 +9955,40 @@ function registerDelegationTarget(target) {
         dispatchDelegated,
         delegatedListenerOptions(name, delegatedCapture(name))
       );
+      if (!delegatedCapture(name)) {
+        target.addEventListener(
+          name,
+          dispatchDelegatedCapture,
+          delegatedListenerOptions(name, true)
+        );
+      }
     }
     for (const name of _delegatedCapture) {
-      target.addEventListener(name, dispatchDelegatedCapture, delegatedListenerOptions(name, true));
+      if (_delegated.has(name)) continue;
+      target.addEventListener(
+        name,
+        delegatedCapture(name) ? dispatchDelegated : dispatchDelegatedCapture,
+        delegatedListenerOptions(name, true)
+      );
     }
   }
 }
-function unregisterDelegationTarget(target) {
+function unregisterDelegationTarget(target, root = false) {
+  if (root) changeEventRootMembership(target, -1);
   const prev = _delegationTargets.get(target);
   if (!prev) return;
   if (prev === 1) {
     _delegationTargets.delete(target);
     for (const name of _delegated) {
       target.removeEventListener(name, dispatchDelegated, delegatedCapture(name));
+      if (!delegatedCapture(name)) target.removeEventListener(name, dispatchDelegatedCapture, true);
     }
     for (const name of _delegatedCapture) {
-      target.removeEventListener(name, dispatchDelegatedCapture, true);
+      target.removeEventListener(
+        name,
+        delegatedCapture(name) ? dispatchDelegated : dispatchDelegatedCapture,
+        true
+      );
     }
   } else {
     _delegationTargets.set(target, prev - 1);
@@ -9960,9 +10049,64 @@ const DISCRETE_EVENTS = /* @__PURE__ */ new Set([
   "volumechange"
 ]);
 let _dispatchDepth = 0;
-const CAPTURE_FLUSH_FALLBACK = /* @__PURE__ */ Symbol("octane.capture.flushFallback");
-const DELEGATED_DISPATCHED = /* @__PURE__ */ Symbol("octane.dispatched");
-const CAPTURE_DISPATCHED = /* @__PURE__ */ Symbol("octane.dispatched.capture");
+const DELEGATED_BUBBLE_VERSION = /* @__PURE__ */ Symbol("octane.bubbleVersion");
+const PROPAGATION_FLAGS = /* @__PURE__ */ Symbol("octane.propagationFlags");
+const NATIVE_STOP_PROPAGATION = /* @__PURE__ */ Symbol("octane.stopPropagation");
+const NATIVE_STOP_IMMEDIATE = /* @__PURE__ */ Symbol("octane.stopImmediatePropagation");
+function stopDelegatedPropagation() {
+  if (this[PROPAGATION_FLAGS] !== void 0) this[PROPAGATION_FLAGS] |= 1;
+  const stop = this[NATIVE_STOP_PROPAGATION] || this.stopPropagation;
+  (stop === stopDelegatedPropagation ? Event.prototype.stopPropagation : stop).call(this);
+}
+function stopImmediateNativePropagation() {
+  if (this[PROPAGATION_FLAGS] !== void 0) this[PROPAGATION_FLAGS] |= 2;
+  const stop = this[NATIVE_STOP_IMMEDIATE] || this.stopImmediatePropagation;
+  (stop === stopImmediateNativePropagation ? Event.prototype.stopImmediatePropagation : stop).call(
+    this
+  );
+}
+const STOP_PROPAGATION_DESCRIPTOR = {
+  configurable: true,
+  writable: true,
+  value: stopDelegatedPropagation
+};
+const STOP_IMMEDIATE_DESCRIPTOR = {
+  configurable: true,
+  writable: true,
+  value: stopImmediateNativePropagation
+};
+function installPropagationMethod(event, name, previous, descriptor) {
+  if (previous?.configurable === false) {
+    if (previous.writable) Object.defineProperty(event, name, { value: descriptor.value });
+  } else {
+    Object.defineProperty(event, name, descriptor);
+  }
+}
+function beginDelegatedPropagation(event, stop, immediate) {
+  event[PROPAGATION_FLAGS] = 0;
+  event[NATIVE_STOP_PROPAGATION] = event.stopPropagation;
+  installPropagationMethod(event, "stopPropagation", stop, STOP_PROPAGATION_DESCRIPTOR);
+  if (immediate !== null) {
+    event[NATIVE_STOP_IMMEDIATE] = event.stopImmediatePropagation;
+    installPropagationMethod(
+      event,
+      "stopImmediatePropagation",
+      immediate,
+      STOP_IMMEDIATE_DESCRIPTOR
+    );
+  }
+}
+function endDelegatedPropagation(event, stop, immediate) {
+  if (stop === void 0) delete event.stopPropagation;
+  else Object.defineProperty(event, "stopPropagation", stop);
+  if (immediate !== null) {
+    if (immediate === void 0) delete event.stopImmediatePropagation;
+    else Object.defineProperty(event, "stopImmediatePropagation", immediate);
+    delete event[NATIVE_STOP_IMMEDIATE];
+  }
+  delete event[PROPAGATION_FLAGS];
+  delete event[NATIVE_STOP_PROPAGATION];
+}
 const CURRENT_TARGET_NODE = /* @__PURE__ */ Symbol("octane.currentTarget");
 const CURRENT_TARGET_DESCRIPTOR = {
   configurable: true,
@@ -9971,6 +10115,129 @@ const CURRENT_TARGET_DESCRIPTOR = {
   }
 };
 const CAPTURE_PATH = [];
+function resolvePortalEventOwner(node) {
+  if (node.$$portalParent != null || node.parentNode === null) return;
+  const target = node.parentNode;
+  const ranges = _portalEventRanges.get(target);
+  if (ranges === void 0) return;
+  let owner;
+  let previous = node.previousSibling;
+  let remainingSkips = ranges.size;
+  while (previous !== null) {
+    const closedStart = previous.$$portalEventStart;
+    const closedRange = closedStart?.$$portalEventRange;
+    if (remainingSkips !== 0 && closedStart !== void 0 && closedRange !== void 0 && ranges.has(closedRange) && closedRange.start === closedStart && closedRange.end === previous && closedStart.parentNode === target) {
+      remainingSkips--;
+      previous = closedStart.previousSibling;
+      continue;
+    }
+    const range = previous.$$portalEventRange;
+    const end = range?.end;
+    if (range !== void 0 && ranges.has(range) && range.start === previous && end != null && end.parentNode === target && (previous.compareDocumentPosition(node) & Node.DOCUMENT_POSITION_FOLLOWING) !== 0 && (node.compareDocumentPosition(end) & Node.DOCUMENT_POSITION_FOLLOWING) !== 0) {
+      owner = range;
+      break;
+    }
+    previous = previous.previousSibling;
+  }
+  if (owner === void 0) return;
+  if (ROOT_RENDER_TRANSACTION !== null) {
+    journalRootProperty(node, "$$portalParent");
+    journalRootProperty(node, "$$portalContainer");
+  }
+  node.$$portalParent = owner.host;
+  node.$$portalContainer = target;
+}
+function preparePortalEventOwners(path, epoch) {
+  for (let i = 0; i < path.length; i++) {
+    const node = eventPathNode(path[i]);
+    if (node === null) continue;
+    resolvePortalEventOwner(node);
+    let logical = node.$$portalParent;
+    while (logical != null && !isEventRoot(logical, epoch) && path.indexOf(logical) < 0) {
+      resolvePortalEventOwner(logical);
+      logical = logical.$$portalParent || logical.parentNode;
+    }
+  }
+}
+function eventPathNode(target) {
+  return target != null && typeof target.nodeType === "number" ? target : null;
+}
+function buildDelegatedPath(event, listener, path = event.composedPath()) {
+  const output = CAPTURE_PATH;
+  const base = output.length;
+  const epoch = event[EVENT_ROOT_EPOCH] ?? eventRootEpoch;
+  const listenerIndex = path.indexOf(listener);
+  if (listenerIndex < 0) return 0;
+  if (_delegationTargets.size === 1 && epoch === eventRootEpoch && isEventRoot(listener, epoch)) {
+    let i = 0;
+    for (; i < listenerIndex; i++) {
+      const node = eventPathNode(path[i]);
+      if (node === null || node.$$portalParent != null) break;
+      output.push(node);
+    }
+    if (i === listenerIndex) return output.length - base;
+    output.length = base;
+  }
+  let start = eventPathNode(path[0]);
+  if (start === null) return 0;
+  let startIndex = 0;
+  let rebaseRootAtStart = false;
+  for (; ; ) {
+    output.length = base;
+    let node = start;
+    let index = startIndex;
+    let firstBoundary = null;
+    let ownsBranch = false;
+    let supersededByNearerPortal = false;
+    while (node !== null) {
+      if (isEventRoot(node, epoch) && !(node === start && rebaseRootAtStart)) {
+        firstBoundary ??= node;
+        if (node === listener) {
+          if (firstBoundary === node) ownsBranch = true;
+          else supersededByNearerPortal = true;
+        }
+        break;
+      }
+      output.push(node);
+      const logicalParent = node.$$portalParent;
+      if (logicalParent != null) {
+        const container = node.$$portalContainer;
+        if (container == null) {
+          output.length = base;
+          return 0;
+        }
+        firstBoundary ??= container;
+        if (container === listener) {
+          if (firstBoundary === container) ownsBranch = true;
+          else supersededByNearerPortal = true;
+        }
+        node = logicalParent;
+        index = path.indexOf(logicalParent);
+      } else if (index >= 0) {
+        node = eventPathNode(path[++index]);
+      } else {
+        node = node.parentNode;
+      }
+    }
+    if (supersededByNearerPortal) {
+      output.length = base;
+      return 0;
+    }
+    if (ownsBranch) return output.length - base;
+    if (firstBoundary === null) {
+      output.length = base;
+      return 0;
+    }
+    const boundaryIndex = path.indexOf(firstBoundary);
+    if (boundaryIndex < startIndex || boundaryIndex >= listenerIndex || boundaryIndex === startIndex && rebaseRootAtStart) {
+      output.length = base;
+      return 0;
+    }
+    start = firstBoundary;
+    startIndex = boundaryIndex;
+    rebaseRootAtStart = true;
+  }
+}
 function fireEventSlot(slot, event) {
   try {
     if (typeof slot === "function") {
@@ -10029,27 +10296,26 @@ function reportListenerError(err) {
   console.error(err);
 }
 function maybeFlushDiscrete(type) {
-  if (_dispatchDepth === 0 && DISCRETE_EVENTS.has(type)) {
+  if (_dispatchDepth === 0 && DISCRETE_EVENTS.has(type) && pendingRestores.length > 0) {
     if (hasPendingWork()) {
       if (VIEW_TRANSITION_DRIVER?.queueAllTransition() === true) flush();
       else flushSync(noop);
     }
-    if (pendingRestores.length > 0) restoreControlledStates();
+    restoreControlledStates();
   }
   if (type === "click") activationCheckable = null;
 }
 function finishCaptureDispatch(event) {
   const type = event.type;
   if (!event.bubbles || event.cancelBubble || !_delegated.has(type)) {
-    if (event.bubbles && _delegated.has(type) && event[DELEGATED_DISPATCHED] !== true)
-      maybeEnqueueRestore(event);
+    if (event.bubbles && _delegated.has(type)) maybeEnqueueRestore(event);
     maybeFlushDiscrete(type);
     return;
   }
-  if (!DISCRETE_EVENTS.has(type) || event[CAPTURE_FLUSH_FALLBACK] === true) return;
-  event[CAPTURE_FLUSH_FALLBACK] = true;
+  if (!DISCRETE_EVENTS.has(type)) return;
+  const bubbleVersion = event[DELEGATED_BUBBLE_VERSION];
   const fallback = () => {
-    if (event[DELEGATED_DISPATCHED] !== true) {
+    if (event[DELEGATED_BUBBLE_VERSION] === bubbleVersion) {
       maybeEnqueueRestore(event);
       maybeFlushDiscrete(type);
     }
@@ -10060,13 +10326,13 @@ function finishCaptureDispatch(event) {
   else queueMicrotask(fallback);
 }
 function dispatchDelegated(event) {
-  if (event[DELEGATED_DISPATCHED] === true) return;
-  event[DELEGATED_DISPATCHED] = true;
+  if (delegatedCapture(event.type)) prepareDelegatedEvent(event, this);
+  event[DELEGATED_BUBBLE_VERSION] = (event[DELEGATED_BUBBLE_VERSION] || 0) + 1;
   maybeEnqueueRestore(event);
   const key = "$$" + event.type;
   const targetOnly = TARGET_ONLY_DELEGATED.has(event.type);
   _dispatchDepth++;
-  let node = event.target;
+  const node = event.target;
   const prevSubmitRec = ACTIVE_SUBMIT_DISPATCH;
   const submitRec = event.type === "submit" && node != null && node.nodeName === "FORM" ? {
     form: node,
@@ -10076,29 +10342,32 @@ function dispatchDelegated(event) {
     intercepted: false
   } : null;
   if (submitRec !== null) ACTIVE_SUBMIT_DISPATCH = submitRec;
-  const discrete = DISCRETE_EVENTS.has(event.type);
-  if (discrete) ACTIVE_DISCRETE_EVENT_DEPTH++;
   const nativeBatch = (0, import_native_read_events.beginNativeEventBatch)(event);
+  const pathBase = CAPTURE_PATH.length;
+  let stop;
+  let propagationStarted = false;
   try {
-    if (delegatedCapture(event.type) && event[CAPTURE_DISPATCHED] !== true && _delegatedCapture.has(event.type)) {
-      dispatchDelegatedCapture(event);
-      if (event.cancelBubble) return;
-    }
-    while (node !== null && node !== void 0) {
-      const slot = node[key];
+    if (delegatedCapture(event.type) && _delegatedCapture.has(event.type) && dispatchDelegatedCapture.call(this, event))
+      return;
+    if (!_delegated.has(event.type)) return;
+    buildDelegatedPath(event, this);
+    stop = Object.getOwnPropertyDescriptor(event, "stopPropagation");
+    propagationStarted = true;
+    beginDelegatedPropagation(event, stop, null);
+    for (let i = pathBase; i < CAPTURE_PATH.length; i++) {
+      const current = CAPTURE_PATH[i];
+      if (targetOnly && current !== event.target) break;
+      const slot = current[key];
       if (slot != null) {
-        setCurrentTarget(event, node);
+        setCurrentTarget(event, current);
         fireEventSlot(slot, event);
-        if (event.cancelBubble) return;
-      }
-      if (targetOnly) return;
-      if (node.$$portalParent) {
-        node = node.$$portalParent;
-      } else {
-        node = node.parentNode;
+        if ((event[PROPAGATION_FLAGS] & 1) !== 0) break;
       }
+      if (targetOnly) break;
     }
   } finally {
+    CAPTURE_PATH.length = pathBase;
+    if (propagationStarted) endDelegatedPropagation(event, stop, null);
     if (submitRec !== null) {
       ACTIVE_SUBMIT_DISPATCH = prevSubmitRec;
       publishManualFormPending(submitRec);
@@ -10109,51 +10378,52 @@ function dispatchDelegated(event) {
     } catch (error) {
       reportListenerError(error);
     }
-    if (discrete) ACTIVE_DISCRETE_EVENT_DEPTH--;
     _dispatchDepth--;
     maybeFlushDiscrete(event.type);
   }
 }
 function dispatchDelegatedCapture(event) {
-  if (event[CAPTURE_DISPATCHED] === true) return;
-  event[CAPTURE_DISPATCHED] = true;
+  const path = prepareDelegatedEvent(event, this);
+  if (!_delegatedCapture.has(event.type)) return false;
   if (!event.bubbles || !_delegated.has(event.type)) maybeEnqueueRestore(event);
   const key = CAPTURE_PREFIX + event.type;
   const pathBase = CAPTURE_PATH.length;
-  for (let node = event.target; node !== null && node !== void 0; ) {
-    CAPTURE_PATH.push(node);
-    node = node.$$portalParent ? node.$$portalParent : node.parentNode;
-  }
+  buildDelegatedPath(event, this, path);
+  const stop = Object.getOwnPropertyDescriptor(event, "stopPropagation");
+  const immediate = delegatedCapture(event.type) ? Object.getOwnPropertyDescriptor(event, "stopImmediatePropagation") : null;
+  const wasCancelled = event.cancelBubble;
+  let stopped = false;
   _dispatchDepth++;
-  const discrete = DISCRETE_EVENTS.has(event.type);
-  if (discrete) ACTIVE_DISCRETE_EVENT_DEPTH++;
   const nativeBatch = (0, import_native_read_events.beginNativeEventBatch)(event);
   try {
+    beginDelegatedPropagation(event, stop, immediate);
     for (let i = CAPTURE_PATH.length - 1; i >= pathBase; i--) {
       const slot = CAPTURE_PATH[i][key];
       if (slot != null) {
         setCurrentTarget(event, CAPTURE_PATH[i]);
         fireEventSlot(slot, event);
-        if (event.cancelBubble) return;
+        if ((event[PROPAGATION_FLAGS] & 1) !== 0) break;
       }
     }
   } finally {
+    stopped = event[PROPAGATION_FLAGS] !== 0 || !wasCancelled && event.cancelBubble;
     CAPTURE_PATH.length = pathBase;
+    endDelegatedPropagation(event, stop, immediate);
     clearCurrentTarget(event);
     try {
       (0, import_native_read_events.endNativeEventBatch)(
         event,
         nativeBatch,
-        event.bubbles && !event.cancelBubble && _delegated.has(event.type) && event[DELEGATED_DISPATCHED] !== true,
+        event.bubbles && !event.cancelBubble && _delegated.has(event.type),
         reportListenerError
       );
     } catch (error) {
       reportListenerError(error);
     }
-    if (discrete) ACTIVE_DISCRETE_EVENT_DEPTH--;
     _dispatchDepth--;
     finishCaptureDispatch(event);
   }
+  return stopped;
 }
 function noop() {
 }
@@ -10563,9 +10833,8 @@ function setValue(el, value) {
   const prev = ctrl.v;
   ctrl.v = value;
   if (process.env.NODE_ENV !== "production") queueDevFormDiagnostic(el, CURRENT_SCOPE ?? void 0);
+  if (!(ctrl.composing && Object.is(prev, value)) && valueNeedsWrite(input, value)) input.value = s;
   if (input.defaultValue !== s) input.defaultValue = s;
-  if (ctrl.composing && Object.is(prev, value)) return;
-  if (valueNeedsWrite(input, value)) input.value = s;
 }
 function setCheckedState(input, value, ctrl) {
   const first = !ctrl.sawC;
@@ -11106,6 +11375,30 @@ function reassertControlledIn(form) {
     }
   }
 }
+function registerPortalEventRange(target, portal2) {
+  let ranges = _portalEventRanges.get(target);
+  if (ranges === void 0) {
+    ranges = /* @__PURE__ */ new Set();
+    _portalEventRanges.set(target, ranges);
+    portalEventTargetCount++;
+  }
+  ranges.add(portal2);
+  portal2.start.$$portalEventRange = portal2;
+  portal2.end.$$portalEventStart = portal2.start;
+}
+function unregisterPortalEventRange(target, portal2) {
+  const start = portal2.start;
+  const end = portal2.end;
+  if (start?.$$portalEventRange === portal2) delete start.$$portalEventRange;
+  if (end?.$$portalEventStart === start) delete end.$$portalEventStart;
+  const ranges = _portalEventRanges.get(target);
+  if (ranges === void 0) return;
+  ranges.delete(portal2);
+  if (ranges.size === 0) {
+    _portalEventRanges.delete(target);
+    portalEventTargetCount--;
+  }
+}
 function portal(parentScope, slotKey, target, body, props, host, env, fragmentOwners, fragmentAnchor) {
   const prev = parentScope.slots[slotKey];
   if (fragmentAnchor !== void 0 && fragmentOwners === void 0 && prev !== void 0 && prev.target === target) {
@@ -11312,12 +11605,21 @@ function renderPortalState(prev, parentBlock, target, rawBody, rawProps, host, e
     if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__) {
       (0, import_profiling.__profileTrackComponent)(block, profilePortalComponent(rawBody));
     }
-    state = { __kind: "portalSlotSlot", block, target, start, end };
+    state = { __kind: "portalSlotSlot", block, target, host, start, end };
+    registerPortalEventRange(target, state);
     activityPortalCreated?.(block);
     registerDelegationTarget(target);
-    if (ROOT_RENDER_TRANSACTION !== null) journalUndo(() => unregisterDelegationTarget(target));
+    if (ROOT_RENDER_TRANSACTION !== null) {
+      const created = state;
+      journalUndo(() => {
+        unregisterPortalEventRange(target, created);
+        unregisterDelegationTarget(target);
+      });
+    }
     renderBlock(block);
   } else {
+    if (state.host !== host) journalRootProperty(state, "host");
+    state.host = host;
     if (state.block.body !== norm.body) journalRootProperty(state.block, "body");
     if (state.block.props !== norm.props) journalRootProperty(state.block, "props");
     if (state.block.extra !== env) journalRootProperty(state.block, "extra");
@@ -11333,6 +11635,7 @@ function renderPortalState(prev, parentBlock, target, rawBody, rawProps, host, e
   if (state.interleavedFragment === void 0) {
     while (n !== null && n !== state.end) {
       n.$$portalParent = host;
+      n.$$portalContainer = target;
       n = n.nextSibling;
     }
   } else {
@@ -11343,6 +11646,7 @@ function renderPortalState(prev, parentBlock, target, rawBody, rawProps, host, e
         continue;
       }
       n.$$portalParent = host;
+      n.$$portalContainer = target;
       n = n.nextSibling;
     }
   }
@@ -11359,6 +11663,7 @@ function teardownPortalState(state) {
     state.block = null;
   }
   if (state.target) {
+    unregisterPortalEventRange(state.target, state);
     unregisterDelegationTarget(state.target);
     state.target = null;
   }
@@ -19948,7 +20253,7 @@ function makeRoot(container, rootBlock, currentBody, currentKey, idState, output
         renderOwner.adopt = void 0;
         renderOwner.retryKey = null;
         renderOwner.transaction = null;
-        unregisterDelegationTarget(container);
+        unregisterDelegationTarget(container, true);
         releaseRootContainer(container, ownerToken);
       }
     }
@@ -19968,7 +20273,7 @@ function createRootWithOutputHandler(container, options, outputHandler) {
   assertValidRootContainer(container);
   options = warnCreateRootElementOption(options);
   const ownerToken = claimRootContainer(container);
-  registerDelegationTarget(container);
+  registerDelegationTarget(container, true);
   return makeRoot(
     container,
     null,
@@ -20023,7 +20328,7 @@ function hydrateRoot(container, bodyOrElement, propsOrOptions, rootOptions) {
   const nativeManifest = nativeSidecar === null ? void 0 : (0, import_native_read_seeds.parseNativeSignalManifest)(nativeSidecar.textContent || "");
   nativeSidecar?.remove();
   const ownerToken = claimRootContainer(container);
-  registerDelegationTarget(container);
+  registerDelegationTarget(container, true);
   let rootBlock = createBlock(
     "root",
     null,

package/dist/cjs/version.cjs

@@ -21,7 +21,7 @@ __export(version_exports, {
   version: () => version
 });
 module.exports = __toCommonJS(version_exports);
-const version = "0.1.51";
+const version = "0.2.1";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   version