octane 0.2.7 → 0.2.8

package/dist/cjs/runtime.cjs

@@ -188,6 +188,7 @@ __export(runtime_exports, {
   queueRefAttach: () => queueRefAttach,
   queueRefDetach: () => queueRefDetach,
   readContextFromScope: () => readContextFromScope,
+  registerWarmPlan: () => registerWarmPlan,
   renderBlock: () => renderBlock,
   renderClientContextProvider: () => renderClientContextProvider,
   replaceRef: () => replaceRef,
@@ -3799,7 +3800,7 @@ function runEffectBody(e) {
     CURRENT_EFFECT_PHASE = e.phase;
     EFFECT_BODY_DEPTH++;
     try {
-      cleanup = e.fn.apply(null, e.args ?? []);
+      cleanup = e.fn.apply(null, e.args);
     } finally {
       EFFECT_BODY_DEPTH--;
       CURRENT_EFFECT_PHASE = previousPhase;
@@ -4021,6 +4022,7 @@ class BlockImpl {
     this.$$ctxReads = null;
     this.$$ctxDirect = null;
     this.$$ctxCache = null;
+    this.$$ctxCacheOwner = null;
     this.$$implicitBail = false;
     this.__thenableIdx = 0;
     this.drainStamp = 0;
@@ -4067,6 +4069,7 @@ class ScopeImpl {
     this.$$ctxValues = null;
     this.$$ctxReads = null;
     this.$$ctxCache = null;
+    this.$$ctxCacheOwner = null;
     this.mounted = false;
     this.slots = [];
   }
@@ -7068,7 +7071,8 @@ function bindRendererRegionOwner(props) {
   const binding = { bridge, release };
   RENDERER_REGION_DOM_BINDINGS.set(root, binding);
   RENDERER_REGION_DOM_OWNERS.set(root, bridge);
-  root.$$ctxCache?.clear();
+  root.$$ctxCache = null;
+  root.$$ctxCacheOwner = null;
   if (previous === void 0) {
     (root.cleanups ??= []).push(() => {
       const current = RENDERER_REGION_DOM_BINDINGS.get(root);
@@ -7183,11 +7187,31 @@ function createNativeScopedResolver(read) {
     }
   };
 }
+function cacheContextOwner(reader, context, owner) {
+  if (reader === null) return;
+  const cache = reader.$$ctxCache;
+  if (cache === null) {
+    reader.$$ctxCache = context;
+    reader.$$ctxCacheOwner = owner;
+    return;
+  }
+  const inlineOwner = reader.$$ctxCacheOwner;
+  if (inlineOwner !== null) {
+    const spill = /* @__PURE__ */ new Map();
+    spill.set(cache, inlineOwner);
+    spill.set(context, owner);
+    reader.$$ctxCache = spill;
+    reader.$$ctxCacheOwner = null;
+  } else {
+    cache.set(context, owner);
+  }
+}
 function readContextFrom(reader, block, context) {
   if (SCOPED_READ_TRACKING) (SCOPED_READS ??= /* @__PURE__ */ new Map()).set(context, context.$$version);
-  if (reader !== null && reader.$$ctxCache !== null) {
-    const hit = reader.$$ctxCache.get(context);
-    if (hit !== void 0) {
+  if (reader !== null) {
+    const cache = reader.$$ctxCache;
+    const hit = cache === context ? reader.$$ctxCacheOwner : cache !== null && reader.$$ctxCacheOwner === null ? cache.get(context) : void 0;
+    if (hit !== null && hit !== void 0) {
       if (hit === DEFAULT_CTX) {
         const bridge2 = rendererRegionOwnerForBlock(block);
         return bridge2 === null ? context.defaultValue : bridge2.readContext(context);
@@ -7199,7 +7223,7 @@ function readContextFrom(reader, block, context) {
   while (scope !== null) {
     const values = scope.$$ctxValues;
     if (values !== null && values.has(context)) {
-      if (reader !== null) (reader.$$ctxCache ??= /* @__PURE__ */ new Map()).set(context, scope);
+      cacheContextOwner(reader, context, scope);
       return values.get(context);
     }
     scope = scope.parent;
@@ -7208,14 +7232,14 @@ function readContextFrom(reader, block, context) {
   while (current !== null) {
     const values = current.$$ctxValues;
     if (values !== null && values.has(context)) {
-      if (reader !== null) (reader.$$ctxCache ??= /* @__PURE__ */ new Map()).set(context, current);
+      cacheContextOwner(reader, context, current);
       return values.get(context);
     }
     current = current.parentBlock;
   }
   const bridge = rendererRegionOwnerForBlock(block);
   if (bridge !== null) return bridge.readContext(context);
-  if (reader !== null) (reader.$$ctxCache ??= /* @__PURE__ */ new Map()).set(context, DEFAULT_CTX);
+  cacheContextOwner(reader, context, DEFAULT_CTX);
   return context.defaultValue;
 }
 function readContextFromScope(scope, context) {
@@ -7431,7 +7455,7 @@ function warnUseWaterfall(block, idx) {
 }
 function useBatch(items, warm) {
   if (items.length === 0) {
-    if (warm !== void 0) ACTIVE_WARM_PLANS.push({ block: CURRENT_BLOCK, fn: warm });
+    if (warm !== void 0) ACTIVE_WARM_PLANS.push(CURRENT_BLOCK, warm, void 0);
     return;
   }
   const hydration = activeHydration();
@@ -7458,9 +7482,13 @@ function useBatch(items, warm) {
   });
   throw new SuspenseException(combined);
 }
+function registerWarmPlan(fn, props) {
+  ACTIVE_WARM_PLANS.push(CURRENT_BLOCK, fn, props);
+}
 let CURRENT_WARM = null;
 let CURRENT_WARM_CLAIMS = null;
 let WARM_EVER = false;
+let LATEST_WARM_CACHE_EPISODE = 0;
 let WARM_DEPTH = 0;
 const WARM_DEPTH_CAP = 64;
 const WARM_MISS = /* @__PURE__ */ Symbol("octane.warm.miss");
@@ -7485,16 +7513,18 @@ function warmCacheForOwner(owner) {
   }
   owner.__warmCache = cache;
   owner.__warmCacheEpisode = CURRENT_WARM_EPISODE;
+  if (CURRENT_WARM_EPISODE > LATEST_WARM_CACHE_EPISODE)
+    LATEST_WARM_CACHE_EPISODE = CURRENT_WARM_EPISODE;
   return cache;
 }
 function recordRealWarmMemo(slot, deps, source) {
   const block = CURRENT_BLOCK;
   if (block === null) return false;
   let owner = null;
-  for (let i = 0; i < ACTIVE_WARM_PLANS.length; i++) {
-    const plan = ACTIVE_WARM_PLANS[i];
-    if (!blockIsAncestor(plan.block, block)) continue;
-    owner = plan.block;
+  for (let i = 0; i < ACTIVE_WARM_PLANS.length; i += 3) {
+    const planBlock = ACTIVE_WARM_PLANS[i];
+    if (!blockIsAncestor(planBlock, block)) continue;
+    owner = planBlock;
     break;
   }
   if (owner === null) return false;
@@ -7557,11 +7587,11 @@ function runActiveWarmPlans(local) {
   const block = CURRENT_BLOCK;
   let plans = null;
   let owner = block;
-  for (let i = 0; i < ACTIVE_WARM_PLANS.length; i++) {
-    const plan = ACTIVE_WARM_PLANS[i];
-    if (!blockIsAncestor(plan.block, block)) continue;
-    (plans ??= []).push(plan);
-    if (plans.length === 1) owner = plan.block;
+  for (let i = 0; i < ACTIVE_WARM_PLANS.length; i += 3) {
+    const planBlock = ACTIVE_WARM_PLANS[i];
+    if (!blockIsAncestor(planBlock, block)) continue;
+    (plans ??= []).push(i);
+    if (plans.length === 1) owner = planBlock;
   }
   if (plans === null && local === void 0) return;
   runWarm(() => {
@@ -7569,7 +7599,8 @@ function runActiveWarmPlans(local) {
       for (let i = 0; i < plans.length; i++) {
         CURRENT_WARM_CLAIMS = /* @__PURE__ */ new Set();
         try {
-          plans[i].fn();
+          const index = plans[i];
+          ACTIVE_WARM_PLANS[index + 1](ACTIVE_WARM_PLANS[index + 2]);
         } catch {
         }
       }
@@ -7702,7 +7733,7 @@ function markWarm(component, plan) {
   return component;
 }
 function adoptWarmEntry(slot, deps, accept) {
-  let b = CURRENT_BLOCK;
+  let b = CURRENT_WARM_EPISODE <= LATEST_WARM_CACHE_EPISODE ? CURRENT_BLOCK : null;
   while (b !== null) {
     const cache = b.__warmCache;
     if (b.__warmCacheEpisode === CURRENT_WARM_EPISODE && cache !== void 0) {
@@ -8121,8 +8152,10 @@ function getFirstChild(node) {
 function getNextSibling(node) {
   return nextSiblingGetter === void 0 ? node.nextSibling : nextSiblingGetter.call(node);
 }
-function seedExpando(proto, key) {
-  if (!(key in proto)) proto[key] = void 0;
+function seedExpando(proto, key, enumerable = true) {
+  if (key in proto) return;
+  if (enumerable) proto[key] = void 0;
+  else Object.defineProperty(proto, key, { value: void 0, writable: true, configurable: true });
 }
 let domOperationsReady = false;
 function initDomOperations() {
@@ -8140,6 +8173,11 @@ function initDomOperations() {
     seedExpando(elementProto, "__oct_suppress");
     seedExpando(elementProto, "__oct_frag");
     seedExpando(elementProto, "__oct_vfrag");
+    seedExpando(elementProto, DANGER_HTML_ACTIVE, false);
+    seedExpando(elementProto, DANGER_HTML_STATIC_CHILD, false);
+    seedExpando(elementProto, DANGER_HTML_SPREAD_CHILD, false);
+    seedExpando(elementProto, DEOPT_DESC, false);
+    seedExpando(elementProto, DEFAULT_VALUE_BASELINE, false);
     if (process.env.NODE_ENV !== "production") {
       seedExpando(elementProto, "__oct_loc");
     }
@@ -8147,6 +8185,7 @@ function initDomOperations() {
   if (typeof CharacterData !== "undefined" && Object.isExtensible(CharacterData.prototype)) {
     seedExpando(CharacterData.prototype, "$$portalEnd");
     seedExpando(CharacterData.prototype, "$$deoptKey");
+    seedExpando(CharacterData.prototype, DEOPT_DESC, false);
   }
 }
 const LAZY_TEMPLATE = /* @__PURE__ */ Symbol("octane.lazy-template");
@@ -10816,6 +10855,10 @@ function isEventRoot(node, epoch) {
   return membership !== void 0 && membership.count > 0;
 }
 function prepareDelegatedEvent(event, listener) {
+  if (_delegationTargets.size === 1 && portalEventTargetCount === 0) {
+    event[EVENT_ROOT_EPOCH] = eventRootEpoch;
+    return;
+  }
   const path = event.composedPath();
   if (_delegationTargets.size === 1) {
     event[EVENT_ROOT_EPOCH] = eventRootEpoch;
@@ -11363,6 +11406,11 @@ function finishCaptureDispatch(event) {
     return;
   }
   if (!DISCRETE_EVENTS.has(type)) return;
+  if (pendingRestores.length === 0) {
+    if (!RESTORE_EVENTS.has(type)) return;
+    const tag = event.target?.localName;
+    if (tag !== "input" && tag !== "textarea" && tag !== "select") return;
+  }
   const bubbleVersion = event[DELEGATED_BUBBLE_VERSION];
   const fallback = () => {
     if (event[DELEGATED_BUBBLE_VERSION] === bubbleVersion) {
@@ -11374,7 +11422,8 @@ function finishCaptureDispatch(event) {
   else queueMicrotask(fallback);
 }
 function dispatchDelegated(event) {
-  if (delegatedCapture(event.type)) prepareDelegatedEvent(event, this);
+  const nativeCapture = delegatedCapture(event.type);
+  let path = nativeCapture ? prepareDelegatedEvent(event, this) : void 0;
   event[DELEGATED_BUBBLE_VERSION] = (event[DELEGATED_BUBBLE_VERSION] || 0) + 1;
   maybeEnqueueRestore(event);
   const key = "$$" + event.type;
@@ -11389,12 +11438,14 @@ function dispatchDelegated(event) {
   let stop;
   let propagationStarted = false;
   try {
-    if (delegatedCapture(event.type) && _delegatedCapture.has(event.type) && dispatchDelegatedCapture.call(this, event))
-      return;
+    if (nativeCapture && _delegatedCapture.has(event.type)) {
+      path ??= event.composedPath();
+      if (dispatchDelegatedCapture.call(this, event, path)) return;
+    }
     if (!_delegated.has(event.type)) return;
     if (node?.nodeType === 1 && isHtmlCustomElement(node) && (event.type === "invalid" || EMULATED_BUBBLING_EVENTS.includes(event.type)))
       return;
-    buildDelegatedPath(event, this);
+    buildDelegatedPath(event, this, path);
     snapshotDelegatedSlots(pathBase, key, event);
     stop = Object.getOwnPropertyDescriptor(event, "stopPropagation");
     propagationStarted = true;
@@ -11431,9 +11482,10 @@ function dispatchDelegated(event) {
     maybeFlushDiscrete(event.type);
   }
 }
-function dispatchDelegatedCapture(event) {
-  const path = prepareDelegatedEvent(event, this);
+function dispatchDelegatedCapture(event, path) {
+  path ??= prepareDelegatedEvent(event, this);
   if (!_delegatedCapture.has(event.type)) return false;
+  path ??= event.composedPath();
   if (!event.bubbles || !_delegated.has(event.type)) maybeEnqueueRestore(event);
   const key = CAPTURE_PREFIX + event.type;
   const pathBase = CAPTURE_PATH.length;
@@ -12830,6 +12882,14 @@ function elementKeyWasProvided(descriptor) {
 }
 const ELEMENTS_MISSING_LIST_KEY = /* @__PURE__ */ new WeakSet();
 const SCOPED_ELEMENT_PROPS = /* @__PURE__ */ new WeakSet();
+const SCOPED_CHILDREN_RESOLVER = /* @__PURE__ */ Symbol("octane.scopedChildren");
+const SCOPED_CHILDREN_PROPERTY = {
+  configurable: true,
+  enumerable: true,
+  get: function() {
+    return this[SCOPED_CHILDREN_RESOLVER]();
+  }
+};
 function hasElementConfigKey(config) {
   if (config == null || typeof config !== "object" && typeof config !== "function") return false;
   if (process.env.NODE_ENV !== "production" && import_has_own.hasOwnProp.call(config, "key")) {
@@ -12846,6 +12906,83 @@ function copyElementConfig(config) {
   }
   return props;
 }
+function restoreWritableScopedChildren(props, name, value) {
+  const inherited = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(props), name);
+  if (inherited?.get === void 0 && inherited?.set === void 0) return false;
+  Object.defineProperty(props, "children", {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    value
+  });
+  return true;
+}
+function copyScopedElementConfig(type, config, resolve) {
+  if (config != null && import_has_own.hasOwnProp.call(config, "__proto__") || import_has_own.hasOwnProp.call(Object.prototype, "children")) {
+    const props2 = copyElementConfig(config);
+    (0, import_shared_value_helpers.applyElementDefaultProps)(type, props2);
+    Object.defineProperty(props2, SCOPED_CHILDREN_RESOLVER, { value: resolve });
+    Object.defineProperty(props2, "children", SCOPED_CHILDREN_PROPERTY);
+    SCOPED_ELEMENT_PROPS.add(props2);
+    return props2;
+  }
+  const props = {};
+  Object.defineProperty(props, SCOPED_CHILDREN_RESOLVER, { value: resolve });
+  let copiedChildren;
+  let hasCopiedChildren = false;
+  let childrenAreWritable = false;
+  if (config != null) {
+    for (const name in config) {
+      if (name === "key" || !import_has_own.hasOwnProp.call(config, name)) continue;
+      if (name === "children") {
+        copiedChildren = config[name];
+        Object.defineProperty(props, "children", SCOPED_CHILDREN_PROPERTY);
+        hasCopiedChildren = true;
+      } else {
+        const value = config[name];
+        if (hasCopiedChildren && !childrenAreWritable && !import_has_own.hasOwnProp.call(props, name) && restoreWritableScopedChildren(props, name, copiedChildren)) {
+          childrenAreWritable = true;
+        }
+        props[name] = value;
+      }
+    }
+  }
+  const defaults = type?.defaultProps;
+  if (defaults != null) {
+    for (const name in defaults) {
+      if (name === "children") {
+        if ((childrenAreWritable ? props.children : hasCopiedChildren ? copiedChildren : props.children) === void 0) {
+          copiedChildren = defaults[name];
+          if (childrenAreWritable) {
+            props.children = copiedChildren;
+          } else if (!hasCopiedChildren) {
+            if ("children" in props) {
+              props.children = copiedChildren;
+            } else {
+              Object.defineProperty(props, "children", SCOPED_CHILDREN_PROPERTY);
+              hasCopiedChildren = true;
+            }
+          }
+        }
+      } else {
+        if (hasCopiedChildren && !childrenAreWritable && !import_has_own.hasOwnProp.call(props, name) && restoreWritableScopedChildren(props, name, copiedChildren)) {
+          childrenAreWritable = true;
+        }
+        if (props[name] === void 0) props[name] = defaults[name];
+      }
+    }
+  }
+  if (childrenAreWritable || !hasCopiedChildren)
+    Object.defineProperty(props, "children", SCOPED_CHILDREN_PROPERTY);
+  SCOPED_ELEMENT_PROPS.add(props);
+  return props;
+}
+function scopedElementRecord(type, props, key, ref, resolve) {
+  const descriptor = { $$kind: ELEMENT_TAG, type, props, key, ref };
+  Object.defineProperty(descriptor, SCOPED_CHILDREN_RESOLVER, { value: resolve });
+  Object.defineProperty(descriptor, "children", SCOPED_CHILDREN_PROPERTY);
+  return descriptor;
+}
 function finalizeElementDescriptor(descriptor) {
   if (process.env.NODE_ENV !== "production") {
     Object.freeze(descriptor.props);
@@ -12854,6 +12991,33 @@ function finalizeElementDescriptor(descriptor) {
   return descriptor;
 }
 const SCOPED_VALUE_RECORD = /* @__PURE__ */ Symbol("octane.scopedValue");
+function scopedValueType() {
+  return this[SCOPED_VALUE_RECORD]().type;
+}
+function scopedValueProps() {
+  return this[SCOPED_VALUE_RECORD]().props;
+}
+function scopedValueKey() {
+  const next = this[SCOPED_VALUE_RECORD]();
+  const key = next.key;
+  if (key === null && KEYED_ELEMENT_DESCRIPTORS.has(next)) {
+    KEYED_ELEMENT_DESCRIPTORS.add(this);
+  }
+  return key;
+}
+function scopedValueRef() {
+  return this[SCOPED_VALUE_RECORD]().ref;
+}
+function scopedValueChildren() {
+  return this[SCOPED_VALUE_RECORD]().children;
+}
+const SCOPED_VALUE_PROPERTIES = {
+  type: { configurable: true, enumerable: true, get: scopedValueType },
+  props: { configurable: true, enumerable: true, get: scopedValueProps },
+  key: { configurable: true, enumerable: true, get: scopedValueKey },
+  ref: { configurable: true, enumerable: true, get: scopedValueRef },
+  children: { configurable: true, enumerable: true, get: scopedValueChildren }
+};
 function createScopedValue(readElement) {
   return scopedValueDescriptor(createScopedResolver(readElement));
 }
@@ -12861,30 +13025,13 @@ function nativeCreateScopedValue(readElement) {
   return scopedValueDescriptor(createNativeScopedResolver(readElement));
 }
 function scopedValueDescriptor(resolve) {
-  const descriptor = {
-    $$kind: ELEMENT_TAG,
-    get type() {
-      return resolve().type;
-    },
-    get props() {
-      return resolve().props;
-    },
-    get key() {
-      const next = resolve();
-      const key = next.key;
-      if (key === null && KEYED_ELEMENT_DESCRIPTORS.has(next)) {
-        KEYED_ELEMENT_DESCRIPTORS.add(descriptor);
-      }
-      return key;
-    },
-    get ref() {
-      return resolve().ref;
-    },
-    get children() {
-      return resolve().children;
-    }
-  };
+  const descriptor = { $$kind: ELEMENT_TAG };
   Object.defineProperty(descriptor, SCOPED_VALUE_RECORD, { value: resolve });
+  Object.defineProperty(descriptor, "type", SCOPED_VALUE_PROPERTIES.type);
+  Object.defineProperty(descriptor, "props", SCOPED_VALUE_PROPERTIES.props);
+  Object.defineProperty(descriptor, "key", SCOPED_VALUE_PROPERTIES.key);
+  Object.defineProperty(descriptor, "ref", SCOPED_VALUE_PROPERTIES.ref);
+  Object.defineProperty(descriptor, "children", SCOPED_VALUE_PROPERTIES.children);
   if (process.env.NODE_ENV !== "production") Object.freeze(descriptor);
   return descriptor;
 }
@@ -12898,20 +13045,14 @@ function scopedElementDescriptor(type, props, children) {
   const src = props ?? null;
   const hasKey = hasElementConfigKey(src);
   const key = hasKey ? "" + src.key : null;
-  const copiedProps = copyElementConfig(src);
-  (0, import_shared_value_helpers.applyElementDefaultProps)(type, copiedProps);
-  const childProperty = { configurable: true, enumerable: true, get: children };
-  Object.defineProperty(copiedProps, "children", childProperty);
-  SCOPED_ELEMENT_PROPS.add(copiedProps);
-  const descriptor = {
-    $$kind: ELEMENT_TAG,
+  const copiedProps = copyScopedElementConfig(type, src, children);
+  const descriptor = scopedElementRecord(
     type,
-    props: copiedProps,
+    copiedProps,
     key,
-    ref: copiedProps.ref !== void 0 ? copiedProps.ref : null,
-    children: null
-  };
-  Object.defineProperty(descriptor, "children", childProperty);
+    copiedProps.ref !== void 0 ? copiedProps.ref : null,
+    children
+  );
   if (key === null && src != null && (typeof src === "object" || typeof src === "function") && "key" in src) {
     KEYED_ELEMENT_DESCRIPTORS.add(descriptor);
   }
@@ -12961,9 +13102,15 @@ function cloneElement(element, config, ...children) {
     throw new Error((0, import_error_codes_client_generated.formatClientError)(4));
   }
   let scopedChildren;
+  let copiedGetter;
   let props;
   if (SCOPED_ELEMENT_PROPS.has(element.props)) {
-    scopedChildren = Object.getOwnPropertyDescriptor(element, "children").get;
+    const get = Object.getOwnPropertyDescriptor(element, "children").get;
+    if (get === SCOPED_CHILDREN_PROPERTY.get) {
+      scopedChildren = element[SCOPED_CHILDREN_RESOLVER];
+    } else {
+      copiedGetter = get === SCOPED_VALUE_PROPERTIES.children.get ? () => get.call(element) : get;
+    }
     props = {};
     for (const name in element.props) {
       if (name !== "key" && name !== "children" && import_has_own.hasOwnProp.call(element.props, name)) {
@@ -12990,30 +13137,49 @@ function cloneElement(element, config, ...children) {
   }
   const n = children.length;
   let kids;
-  let childProperty;
+  let keepsScopedChildren = false;
   if (n === 1) {
     kids = children[0];
   } else if (n > 1) {
     POSITIONAL_CHILDREN.add(children);
     kids = children;
-  } else if (scopedChildren !== void 0 && !replacedChildren) {
-    childProperty = { configurable: true, enumerable: true, get: scopedChildren };
-    Object.defineProperty(props, "children", childProperty);
+  } else if ((scopedChildren !== void 0 || copiedGetter !== void 0) && !replacedChildren) {
+    if (copiedGetter === void 0) {
+      Object.defineProperty(props, SCOPED_CHILDREN_RESOLVER, { value: scopedChildren });
+    }
+    Object.defineProperty(
+      props,
+      "children",
+      copiedGetter === void 0 ? SCOPED_CHILDREN_PROPERTY : { configurable: true, enumerable: true, get: copiedGetter }
+    );
     SCOPED_ELEMENT_PROPS.add(props);
+    keepsScopedChildren = true;
     kids = null;
   } else {
     kids = "children" in props ? props.children : element.children;
   }
   if (n > 0) props.children = kids;
-  const descriptor = {
-    $$kind: ELEMENT_TAG,
-    type: element.type,
-    props,
-    key,
-    ref: props.ref !== void 0 ? props.ref : null,
-    children: kids ?? null
-  };
-  if (childProperty !== void 0) Object.defineProperty(descriptor, "children", childProperty);
+  const ref = props.ref !== void 0 ? props.ref : null;
+  let descriptor;
+  if (keepsScopedChildren && copiedGetter === void 0) {
+    descriptor = scopedElementRecord(element.type, props, key, ref, scopedChildren);
+  } else {
+    descriptor = {
+      $$kind: ELEMENT_TAG,
+      type: element.type,
+      props,
+      key,
+      ref,
+      children: kids ?? null
+    };
+    if (keepsScopedChildren) {
+      Object.defineProperty(descriptor, "children", {
+        configurable: true,
+        enumerable: true,
+        get: copiedGetter
+      });
+    }
+  }
   if (key === null && (elementKeyWasProvided(element) || config != null && import_has_own.hasOwnProp.call(config, "key"))) {
     KEYED_ELEMENT_DESCRIPTORS.add(descriptor);
   }
@@ -13024,20 +13190,42 @@ function cloneElement(element, config, ...children) {
 }
 function cloneAndReplaceElementKey(element, key) {
   const scoped = SCOPED_ELEMENT_PROPS.has(element.props);
-  const descriptor = {
-    $$kind: ELEMENT_TAG,
-    type: element.type,
-    props: element.props,
-    key,
-    ref: element.ref,
-    children: scoped ? null : element.children
-  };
+  let descriptor;
   if (scoped) {
-    Object.defineProperty(descriptor, "children", {
-      configurable: true,
-      enumerable: true,
-      get: Object.getOwnPropertyDescriptor(element, "children").get
-    });
+    const get = Object.getOwnPropertyDescriptor(element, "children").get;
+    if (get === SCOPED_CHILDREN_PROPERTY.get) {
+      descriptor = scopedElementRecord(
+        element.type,
+        element.props,
+        key,
+        element.ref,
+        element[SCOPED_CHILDREN_RESOLVER]
+      );
+    } else {
+      const copiedGetter = get === SCOPED_VALUE_PROPERTIES.children.get ? () => get.call(element) : get;
+      descriptor = {
+        $$kind: ELEMENT_TAG,
+        type: element.type,
+        props: element.props,
+        key,
+        ref: element.ref,
+        children: null
+      };
+      Object.defineProperty(descriptor, "children", {
+        configurable: true,
+        enumerable: true,
+        get: copiedGetter
+      });
+    }
+  } else {
+    descriptor = {
+      $$kind: ELEMENT_TAG,
+      type: element.type,
+      props: element.props,
+      key,
+      ref: element.ref,
+      children: element.children
+    };
   }
   if (ELEMENTS_MISSING_LIST_KEY.has(element)) ELEMENTS_MISSING_LIST_KEY.add(descriptor);
   return finalizeElementDescriptor(descriptor);
@@ -13958,7 +14146,7 @@ function hostComponent(scope, slot, tag, props, childrenBody, anchor) {
   if (typeof childrenBody === "function") {
     state.latest = childrenBody;
     if (state.body === void 0) {
-      state.body = ((...args) => state.latest(...args));
+      state.body = (props2, scope2, extra) => state.latest(props2, scope2, extra);
     }
     childSlot(state.childScope, 0, el, state.body, null, false, el);
   } else if (childrenBody != null || state.childScope.slots[0] !== void 0) {
@@ -14122,20 +14310,48 @@ function renderFragmentRefDescriptor(descriptor, scope) {
 function deoptWrapperKind(value) {
   return POSITIONAL_CHILDREN.has(value) ? "fragment" : "array";
 }
-function scopedDeoptKey(path, item, index, key) {
+const DEOPT_KEY_STRINGIFY = JSON.stringify;
+function nestedImplicitKeyPrefix(path) {
+  if (JSON.stringify !== DEOPT_KEY_STRINGIFY || "toJSON" in path) return null;
+  for (let i = 0; i < path.length; i++) {
+    const type = typeof path[i];
+    if (type !== "string" && type !== "number") return null;
+  }
+  return "[" + JSON.stringify(path) + ',"index",';
+}
+function appendScopedDeoptKey(outKeys, path, item, index, key, implicitPrefix) {
   const explicit = (isElementDescriptor(item) || item?.$$kind === PORTAL_TAG) && item.key != null;
-  if (path.length === 0) return explicit ? "k" + String(key) : "i" + index;
-  return JSON.stringify([path, explicit ? "key" : "index", explicit ? String(key) : index]);
+  if (path.length === 0) {
+    outKeys.push(explicit ? "k" + String(key) : index);
+    return implicitPrefix;
+  }
+  if (!explicit) {
+    if (implicitPrefix === void 0) implicitPrefix = nestedImplicitKeyPrefix(path);
+    if (implicitPrefix !== null && JSON.stringify === DEOPT_KEY_STRINGIFY && !("toJSON" in path)) {
+      outKeys.push(implicitPrefix + index + "]");
+      return implicitPrefix;
+    }
+  }
+  outKeys.push(JSON.stringify([path, explicit ? "key" : "index", explicit ? String(key) : index]));
+  return implicitPrefix;
 }
 function flattenReactChildContainer(outItems, outKeys, children, kind, path) {
   const keyFn = kind === "fragment" ? deoptKeyPositional : deoptKey;
   const count = children.length;
+  let implicitPrefix = count > 1 ? void 0 : null;
   for (let i = 0; i < count; i++) {
     const item = children[i];
     if (isFragmentDescriptor(item)) {
       if (item.ref != null || import_has_own.hasOwnProp.call(item.props, "ref")) {
         outItems.push(fragmentRefDescriptor(item));
-        outKeys.push(scopedDeoptKey(path, item, i, keyFn(item, i)));
+        implicitPrefix = appendScopedDeoptKey(
+          outKeys,
+          path,
+          item,
+          i,
+          keyFn(item, i),
+          implicitPrefix
+        );
         continue;
       }
       const nested = fragmentDescriptorChildren(item);
@@ -14158,15 +14374,18 @@ function flattenReactChildContainer(outItems, outKeys, children, kind, path) {
       continue;
     }
     outItems.push(item);
-    outKeys.push(scopedDeoptKey(path, item, i, keyFn(item, i)));
+    implicitPrefix = appendScopedDeoptKey(outKeys, path, item, i, keyFn(item, i), implicitPrefix);
   }
 }
+function singleDeoptKey(item, key) {
+  return (isElementDescriptor(item) || item?.$$kind === PORTAL_TAG) && item.key != null ? "k" + String(key) : 0;
+}
 function prepareDeoptList(value, forceSingle = false, includeKeyedSingle = true) {
   if (isFragmentDescriptor(value)) {
     if (value.ref != null || import_has_own.hasOwnProp.call(value.props, "ref")) {
       return {
         items: [fragmentRefDescriptor(value)],
-        keys: [scopedDeoptKey([], value, 0, value.key ?? 0)]
+        keys: [singleDeoptKey(value, value.key ?? 0)]
       };
     }
     const items = [];
@@ -14182,10 +14401,10 @@ function prepareDeoptList(value, forceSingle = false, includeKeyedSingle = true)
     return { items, keys };
   }
   if (includeKeyedSingle && isElementDescriptor(value) && value.key != null) {
-    return { items: [value], keys: [scopedDeoptKey([], value, 0, value.key)] };
+    return { items: [value], keys: [singleDeoptKey(value, value.key)] };
   }
   if (forceSingle) {
-    return { items: [value], keys: [scopedDeoptKey([], value, 0, deoptKeyPositional(value, 0))] };
+    return { items: [value], keys: [singleDeoptKey(value, deoptKeyPositional(value, 0))] };
   }
   return null;
 }
@@ -16014,29 +16233,36 @@ function shallowEqualPropsExact(a, b) {
   }
   return true;
 }
+const MEMO_OWNER = /* @__PURE__ */ Symbol("memoOwner");
+const MEMO_MARKER_DESCRIPTOR = {
+  get() {
+    return this === this[MEMO_OWNER];
+  }
+};
+const MEMO_DEFAULT_PROPS_DESCRIPTOR = {
+  configurable: true,
+  // Static hoisters must copy `type` along with this accessor.
+  get() {
+    return this.type.defaultProps;
+  },
+  set(value) {
+    this.type.defaultProps = value;
+  }
+};
 // @__NO_SIDE_EFFECTS__
 function memo(component, arePropsEqual) {
   function memoWrapper(props, scope, extra) {
     return component(props, scope, extra);
   }
+  Object.defineProperty(memoWrapper, MEMO_OWNER, { value: memoWrapper });
   Object.defineProperty(memoWrapper, "type", { value: component });
   Object.defineProperty(memoWrapper, "displayName", {
     configurable: true,
     writable: true,
     value: component.displayName || component.name || "Memo"
   });
-  Object.defineProperty(memoWrapper, "__memo", {
-    get() {
-      return this === memoWrapper;
-    }
-  });
-  Object.defineProperty(memoWrapper, "defaultProps", {
-    configurable: true,
-    get: () => component.defaultProps,
-    set: (value) => {
-      component.defaultProps = value;
-    }
-  });
+  Object.defineProperty(memoWrapper, "__memo", MEMO_MARKER_DESCRIPTOR);
+  Object.defineProperty(memoWrapper, "defaultProps", MEMO_DEFAULT_PROPS_DESCRIPTOR);
   if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__)
     (0, import_profiling.__profileComponentSource)(memoWrapper, component);
   if (arePropsEqual) Object.defineProperty(memoWrapper, "__compare", { value: arePropsEqual });
@@ -22557,6 +22783,7 @@ function scriptResource(attrs) {
   queueRefAttach,
   queueRefDetach,
   readContextFromScope,
+  registerWarmPlan,
   renderBlock,
   renderClientContextProvider,
   replaceRef,