octane 0.14.0 → 0.14.1

package/dist/cjs/dom-bindings.cjs

@@ -19,14 +19,18 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var dom_bindings_exports = {};
 __export(dom_bindings_exports, {
   __adoptBindings: () => __adoptBindings,
+  __adoptFixedScalarViewBindings: () => __adoptFixedScalarViewBindings,
+  __adoptFixedViewBindings: () => __adoptFixedViewBindings,
   __adoptScalarBindings: () => __adoptScalarBindings,
   __bindingURL: () => __bindingURL,
   __claimBinding: () => __claimBinding,
   __createBindingStyleRestoration: () => __createBindingStyleRestoration,
+  __isBindingTextLeaf: () => __isBindingTextLeaf,
   __mountBindings: () => __mountBindings,
   __normalizeBinding: () => normalize,
   __releaseBinding: () => __releaseBinding,
   __writeBinding: () => write,
+  __writeBindingWithTextWitness: () => __writeBindingWithTextWitness,
   adoptBindings: () => adoptBindings,
   mountBindings: () => mountBindings,
   unbound: () => unbound
@@ -105,7 +109,7 @@ function assertBindingRoot(root, descriptor) {
   }
   return root;
 }
-function isTextLeaf(node) {
+function __isBindingTextLeaf(node) {
   const first = node.firstChild;
   return first === null || !first.nextSibling && first.nodeType === 3;
 }
@@ -117,7 +121,7 @@ function resolveFixedNodes(root, descriptor) {
   for (let i = 0; i < descriptor.nodes.length; i++) {
     const [parent, tag, namespace, children, openChildren, text] = descriptor.nodes[i];
     const node = i === 0 ? parent === -1 ? root : void 0 : cursors[parent];
-    if (node == null || openChildren === true || node.localName !== tag || node.namespaceURI !== namespaces[namespace] || text && !isTextLeaf(node)) {
+    if (node == null || openChildren === true || node.localName !== tag || node.namespaceURI !== namespaces[namespace] || text && !__isBindingTextLeaf(node)) {
       throw new Error(__octaneDev ? "DOM bindings cannot adopt a mismatched static element topology." : (0, import_error_message_no_arguments.formatNoArgumentErrorMessage)(318));
     }
     if (i !== 0) {
@@ -136,6 +140,18 @@ function resolveFixedNodes(root, descriptor) {
   }
   return nodes;
 }
+function matchesFixedNodes(root, descriptor, nodes, text) {
+  try {
+    if (!resolveFixedNodes(root, descriptor).every((node, index) => node === nodes[index]))
+      return false;
+    if (text !== void 0) {
+      for (const [node, original] of text) if (node.firstChild !== original) return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
 function resolveAddressedNodes(root, descriptor) {
   const nodes = [];
   const prefix = `${descriptor.id}:`;
@@ -168,7 +184,7 @@ function resolveAddressedNodes(root, descriptor) {
     const [parent, tag, namespace, children, openChildren, text] = descriptor.nodes[i];
     const node = nodes[i];
     if (node === void 0 || node.localName !== tag || node.namespaceURI !== namespaces[namespace] || (i === 0 ? parent !== -1 || node !== root : parent < 0 || parent >= i || node.parentElement !== nodes[parent] || // A parent without a cursor claims no children.
-    descriptor.nodes[parent][4] !== true && cursors[parent] !== node) || openChildren && children === null || text && !isTextLeaf(node)) {
+    descriptor.nodes[parent][4] !== true && cursors[parent] !== node) || openChildren && children === null || text && !__isBindingTextLeaf(node)) {
       throw new Error(__octaneDev ? "DOM bindings cannot adopt a mismatched addressed element topology." : (0, import_error_message_no_arguments.formatNoArgumentErrorMessage)(321));
     }
     if (parent !== -1) {
@@ -271,6 +287,19 @@ function write(node, binding, value) {
     }
   } else return writeFixedScalar(node, binding, value);
 }
+function writeBindingWithTextWitness(node, binding, value, fixedText, writer) {
+  if (binding[1] === "text" && fixedText.get(node) === null) {
+    if (node.firstChild !== null) throw new Error(__octaneDev ? "DOM bindings cannot adopt a mismatched static element topology." : (0, import_error_message_no_arguments.formatNoArgumentErrorMessage)(318));
+    const text = node.ownerDocument.createTextNode(value);
+    node.appendChild(text);
+    fixedText.set(node, text);
+    return value;
+  }
+  return writer(node, binding, value);
+}
+function __writeBindingWithTextWitness(node, binding, value, fixedText) {
+  return writeBindingWithTextWitness(node, binding, value, fixedText, write);
+}
 const __bindingURL = [
   (binding) => binding[1] === "url" || isFixedScalarChannel(binding),
   normalize,
@@ -323,11 +352,91 @@ function __createBindingStyleRestoration(node, binding) {
     }
   };
 }
-function __adoptBindings(root, descriptor, source, options) {
+function skipBindingSidecars(next, previous) {
+  while (next?.nodeType === 1 && next.localName === "script" && (next.hasAttribute(import_native_read_seeds.NATIVE_SIGNAL_SEED_ATTR) || next.hasAttribute(import_stream_protocol.SUSPENSE_SCRIPT_ATTR) || next.hasAttribute(import_stream_protocol.STREAM_SCRIPT_ATTR)))
+    next = previous ? next.previousSibling : next.nextSibling;
+  return next;
+}
+function bindingSibling(node, previous) {
+  return skipBindingSidecars(previous ? node.previousSibling : node.nextSibling, previous);
+}
+function captureBindingSite(root) {
+  const ancestry = [];
+  for (let node = root; node !== null; node = node.parentNode)
+    ancestry.push([node, node.parentNode]);
+  return {
+    document: root.ownerDocument,
+    ancestry,
+    parent: root.parentNode,
+    previous: bindingSibling(root, true),
+    next: bindingSibling(root, false)
+  };
+}
+function validBindingSite(root, id, site) {
+  return root.parentNode !== null && root.ownerDocument === site.document && site.ancestry.every(([node, parent]) => node.parentNode === parent) && bindingSibling(root, true) === site.previous && bindingSibling(root, false) === site.next && root.getAttribute("data-octane-bindings") === id;
+}
+function displacedBindingSite(root, site, parent, node) {
+  return parent === site.parent && node !== root && (node === null || node.parentNode === parent) && (node === null ? skipBindingSidecars(parent.lastChild, true) : bindingSibling(node, true)) === site.previous;
+}
+function flushBindingPublication(retries, active) {
+  if (!retries?.size) return;
+  const pending = [...retries];
+  retries.clear();
+  for (const retry of pending)
+    queueMicrotask(() => {
+      if (active()) retry();
+    });
+}
+function prepareFixedBindingView(root, descriptor, nodes, writer) {
+  let fixedText;
+  for (let index = 0; index < nodes.length; index++)
+    if (descriptor.nodes[index][5])
+      (fixedText ??= /* @__PURE__ */ new Map()).set(nodes[index], nodes[index].firstChild);
+  return {
+    valid: () => matchesFixedNodes(root, descriptor, nodes, fixedText),
+    write: fixedText === void 0 ? writer : (node, binding, value) => writeBindingWithTextWitness(node, binding, value, fixedText, writer)
+  };
+}
+function prepareFixedScalarBindingView(root, descriptor, nodes, writer, lifetime) {
+  const fixed = prepareFixedBindingView(root, descriptor, nodes, writer);
+  const site = captureBindingSite(root);
+  let retries;
+  let handoff;
+  const view = {
+    revision: 0,
+    write: fixed.write,
+    published: () => flushBindingPublication(retries, lifetime.active),
+    dispose: () => retries?.clear()
+  };
+  lifetime.handle[import_control_handoff.BINDING_HANDOFF] = () => handoff ??= {
+    id: descriptor.id,
+    root,
+    anchor: root,
+    end: root,
+    revision: () => lifetime.busy() ? -1 : view.revision,
+    afterPublication: (callback) => {
+      (retries ??= /* @__PURE__ */ new Set()).add(callback);
+      return () => retries.delete(callback);
+    },
+    valid: () => validBindingSite(root, descriptor.id, site) && fixed.valid(),
+    active: lifetime.active,
+    retire: lifetime.retire
+  };
+  return view;
+}
+function __adoptFixedViewBindings(root, descriptor, source, options) {
+  return __adoptBindings(root, descriptor, source, options, prepareFixedBindingView);
+}
+function __adoptFixedScalarViewBindings(root, descriptor, source, options) {
+  return __adoptScalarBindings(root, descriptor, source, options, prepareFixedScalarBindingView);
+}
+function __adoptBindings(root, descriptor, source, options, prepareView) {
   if ("root" in descriptor) return descriptor.adopt(root, descriptor, source, options);
   if (!source || typeof source.getSnapshot !== "function" || typeof source.subscribe !== "function")
     throw new TypeError(__octaneDev ? "DOM bindings require synchronous getSnapshot() and subscribe() methods." : (0, import_error_message_no_arguments.formatNoArgumentErrorMessage)(325));
   const nodes = descriptor.addressed ? resolveAddressedNodes(assertBindingRoot(root, descriptor), descriptor) : resolveFixedNodes(root, descriptor);
+  const view = prepareView?.(root, descriptor, nodes, write);
+  const writeChannel = view?.write ?? write;
   const bindings = descriptor.bindings;
   const owned = [];
   const previous = [];
@@ -462,7 +571,7 @@ function __adoptBindings(root, descriptor, source, options) {
         if (!style)
           styles.set(i, style = __createBindingStyleRestoration(nodes[binding[0]], binding));
         style.write(prepared);
-      } else written = write(nodes[binding[0]], binding, prepared);
+      } else written = writeChannel(nodes[binding[0]], binding, prepared);
       if (!disposed) {
         previous[i] = prepared;
         if (binding[1] === "attr" || binding[1] === "boolean" || binding[1] === "aria" || binding[1] === "class" || binding[1] === "url" || binding[1] === "styleProperty" || binding[1] === "styleObject" || binding[1] === "text") {
@@ -670,53 +779,35 @@ function __adoptBindings(root, descriptor, source, options) {
     drain();
   };
   const handle = { refresh, dispose };
-  if (descriptor.handoff === "host") {
-    published = () => {
-      if (!publicationRetries?.size) return;
-      const pending = [...publicationRetries];
-      publicationRetries.clear();
-      for (const retry of pending)
-        queueMicrotask(() => {
-          if (!disposed) retry();
-        });
-    };
+  if (descriptor.handoff) {
+    const active = () => !disposed;
+    published = () => flushBindingPublication(publicationRetries, active);
     const host = root;
-    const document = host.ownerDocument;
-    const ancestry = [];
-    for (let node = host; node !== null; node = node.parentNode)
-      ancestry.push([node, node.parentNode]);
-    const skip = (next, previous2) => {
-      while (next?.nodeType === 1 && next.localName === "script" && (next.hasAttribute(import_native_read_seeds.NATIVE_SIGNAL_SEED_ATTR) || next.hasAttribute(import_stream_protocol.SUSPENSE_SCRIPT_ATTR) || next.hasAttribute(import_stream_protocol.STREAM_SCRIPT_ATTR)))
-        next = previous2 ? next.previousSibling : next.nextSibling;
-      return next;
-    };
-    const sibling = (node, previous2) => skip(previous2 ? node.previousSibling : node.nextSibling, previous2);
-    const site = host.parentNode;
-    const previousSibling = sibling(host, true);
-    const nextSibling = sibling(host, false);
+    const site = captureBindingSite(host);
     let handoff;
     handle[import_control_handoff.BINDING_HANDOFF] = () => {
       if (handoff !== void 0) return handoff;
-      const adjacent = (recorded, previous2) => sibling(host, previous2) === recorded;
       return handoff = {
         id: descriptor.id,
         root: host,
         anchor: host,
-        host: new Set(
-          bindings.map(
-            (binding) => binding[1] === "styleProperty" ? "style:" + binding[2] : binding[1].startsWith("style") ? "style" : binding[2]
-          )
-        ),
+        ...view ? { end: host } : {
+          host: new Set(
+            bindings.map(
+              (binding) => binding[1] === "styleProperty" ? "style:" + binding[2] : binding[1].startsWith("style") ? "style" : binding[2]
+            )
+          ),
+          // The authored node before the host still marks its site after the
+          // host leaves, including when an external clone now stands there.
+          displaced: (parent, node) => displacedBindingSite(host, site, parent, node)
+        },
         revision: () => busy ? -1 : revision,
         afterPublication: (callback) => {
           (publicationRetries ??= /* @__PURE__ */ new Set()).add(callback);
           return () => publicationRetries.delete(callback);
         },
-        valid: () => host.parentNode !== null && host.ownerDocument === document && ancestry.every(([node, parent]) => node.parentNode === parent) && adjacent(previousSibling, true) && adjacent(nextSibling, false) && host.getAttribute("data-octane-bindings") === descriptor.id,
-        // The authored node before the host still marks its site after the
-        // host leaves, including when an external clone now stands there.
-        displaced: (parent, node) => parent === site && node !== host && (node === null || node.parentNode === parent) && (node === null ? skip(parent.lastChild, true) : sibling(node, true)) === previousSibling,
-        active: () => !disposed,
+        valid: () => validBindingSite(host, descriptor.id, site) && (view?.valid() ?? true),
+        active,
         retire: (publish) => dispose(void 0, publish, true)
       };
     };
@@ -765,13 +856,13 @@ function __adoptBindings(root, descriptor, source, options) {
     throw error;
   }
 }
-function __adoptScalarBindings(root, descriptor, source, options) {
+function __adoptScalarBindings(root, descriptor, source, options, prepareView) {
   const [
     accepts = isFixedScalarChannel,
     normalizeChannel = normalizeFixedScalar,
-    writeChannel = writeFixedScalar
+    selectedWriter = writeFixedScalar
   ] = descriptor.url ?? [];
-  if (descriptor.addressed || descriptor.handoff || descriptor.connectProjection || !descriptor.bindings.every(accepts))
+  if (descriptor.addressed || descriptor.handoff !== (prepareView ? "view" : void 0) || descriptor.connectProjection || !descriptor.bindings.every(accepts))
     throw new TypeError(__octaneDev ? "This DOM binding view requires the general adopter." : (0, import_error_message_no_arguments.formatNoArgumentErrorMessage)(330));
   if (!source || typeof source.getSnapshot !== "function" || typeof source.subscribe !== "function")
     throw new TypeError(__octaneDev ? "DOM bindings require synchronous getSnapshot() and subscribe() methods." : (0, import_error_message_no_arguments.formatNoArgumentErrorMessage)(325));
@@ -786,16 +877,25 @@ function __adoptScalarBindings(root, descriptor, source, options) {
   let busy = true;
   let dirty = false;
   let unsubscribe;
-  const signal = options?.signal;
-  const dispose = () => {
-    if (disposed) return;
+  const dispose = (_disposal, publish, preservePresentation = false) => {
+    if (disposed) {
+      publish?.();
+      return;
+    }
     disposed = true;
+    view?.dispose();
     signal?.removeEventListener("abort", dispose);
     let failed = false;
     let failure;
+    try {
+      publish?.();
+    } catch (error) {
+      failed = true;
+      failure = error;
+    }
     for (const connection of signalConnections?.values() ?? []) {
       try {
-        connection.dispose();
+        connection.dispose(preservePresentation);
       } catch (error) {
         if (!failed) {
           failed = true;
@@ -864,6 +964,7 @@ function __adoptScalarBindings(root, descriptor, source, options) {
               if (!connection && signalFactory.isSignal(values[index])) {
                 connection = signalFactory.connect(() => {
                   if (!disposed) {
+                    if (view) view.revision++;
                     signalUpdates.add(index);
                     drain();
                   }
@@ -903,6 +1004,7 @@ function __adoptScalarBindings(root, descriptor, source, options) {
       throw error;
     } finally {
       busy = false;
+      view?.published();
     }
   };
   const resume = () => {
@@ -911,10 +1013,19 @@ function __adoptScalarBindings(root, descriptor, source, options) {
   };
   const refresh = () => {
     if (disposed) return;
+    if (view) view.revision++;
     dirty = true;
     drain();
   };
   const handle = { refresh, dispose };
+  const view = prepareView?.(root, descriptor, nodes, selectedWriter, {
+    handle,
+    active: () => !disposed,
+    busy: () => busy,
+    retire: (publish) => dispose(void 0, publish, true)
+  });
+  const writeChannel = view?.write ?? selectedWriter;
+  const signal = options?.signal;
   if (signal?.aborted) {
     dispose();
     return handle;
@@ -945,14 +1056,18 @@ function __adoptScalarBindings(root, descriptor, source, options) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   __adoptBindings,
+  __adoptFixedScalarViewBindings,
+  __adoptFixedViewBindings,
   __adoptScalarBindings,
   __bindingURL,
   __claimBinding,
   __createBindingStyleRestoration,
+  __isBindingTextLeaf,
   __mountBindings,
   __normalizeBinding,
   __releaseBinding,
   __writeBinding,
+  __writeBindingWithTextWitness,
   adoptBindings,
   mountBindings,
   unbound

package/dist/cjs/dom-focused-move.cjs

@@ -39,7 +39,7 @@ function moveNativeNodeBefore(parent, node, anchor, focused, contentEditable) {
     return;
   }
   const moveBefore = parent.moveBefore;
-  if (!contentEditable && typeof moveBefore === "function") {
+  if (!contentEditable && typeof moveBefore === "function" && parent.isConnected && node.isConnected && parent.ownerDocument === node.ownerDocument) {
     moveBefore.call(parent, node, anchor);
     return;
   }

package/dist/cjs/hydration-flag.cjs

@@ -18,14 +18,20 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var hydration_flag_exports = {};
 __export(hydration_flag_exports, {
+  changePendingInitialHydrations: () => changePendingInitialHydrations,
   hydrating: () => hydrating,
   hydrationStarted: () => hydrationStarted,
+  pendingInitialHydrations: () => pendingInitialHydrations,
   setHydrating: () => setHydrating,
   startHydration: () => startHydration
 });
 module.exports = __toCommonJS(hydration_flag_exports);
 let hydrating = false;
 let hydrationStarted = false;
+let pendingInitialHydrations = 0;
+function changePendingInitialHydrations(delta) {
+  pendingInitialHydrations += delta;
+}
 function setHydrating(value) {
   hydrating = value;
   if (value) hydrationStarted = true;
@@ -35,8 +41,10 @@ function startHydration() {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  changePendingInitialHydrations,
   hydrating,
   hydrationStarted,
+  pendingInitialHydrations,
   setHydrating,
   startHydration
 });

package/dist/cjs/hydration-input-control.cjs

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var hydration_input_control_exports = {};
+__export(hydration_input_control_exports, {
+  INITIAL_ADOPTION_INPUT_CHANGED: () => INITIAL_ADOPTION_INPUT_CHANGED
+});
+module.exports = __toCommonJS(hydration_input_control_exports);
+var import_read_protocol = require("./signals/read-protocol.cjs");
+const INITIAL_ADOPTION_INPUT_CHANGED = /* @__PURE__ */ Object.freeze(
+  /* @__PURE__ */ Object.create(null, { [import_read_protocol.ADOPTION_CONTROL]: { value: true } })
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  INITIAL_ADOPTION_INPUT_CHANGED
+});

package/dist/cjs/hydration-inputs.cjs

@@ -0,0 +1,184 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var hydration_inputs_exports = {};
+__export(hydration_inputs_exports, {
+  __captureHydrationInput: () => __captureHydrationInput,
+  __hydrationComponentSlot: () => __hydrationComponentSlot,
+  __observeHydrationOptionalInput: () => __observeHydrationOptionalInput,
+  __ownedHydrationInputs: () => __ownedHydrationInputs,
+  __registerHydrationInputComponent: () => __registerHydrationInputComponent,
+  __sameHydrationInput: () => __sameHydrationInput,
+  __sameHydrationOptionalInput: () => __sameHydrationOptionalInput,
+  __sameHydrationSource: () => __sameHydrationSource
+});
+module.exports = __toCommonJS(hydration_inputs_exports);
+var import_has_own = require("./has-own.cjs");
+var import_hydration_flag = require("./hydration-flag.cjs");
+var import_method_dep = require("./method-dep.cjs");
+var import_hydration_input_control = require("./hydration-input-control.cjs");
+let hydrationInputTuples;
+let hydrationInputComponents;
+let currentHydrationProps = null;
+let currentHydrationPlan = null;
+const UNSAFE_OPTIONAL_INPUT = /* @__PURE__ */ Symbol();
+const ABSENT_OPTIONAL_INPUT = /* @__PURE__ */ Symbol();
+let optionalInputObservations;
+function __registerHydrationInputComponent(component, required) {
+  (hydrationInputComponents ??= /* @__PURE__ */ new WeakMap()).set(component, required);
+  return component;
+}
+function __hydrationComponentSlot(writer, scope, slot, parent, component, props, site, anchor, localPlan) {
+  let plan = localPlan;
+  if (import_hydration_flag.hydrating || import_hydration_flag.pendingInitialHydrations > 0) {
+    if (plan === void 0) {
+      plan = hydrationInputComponents?.get(component);
+      if (plan !== void 0) {
+        for (let index = 1; index < plan.length; index++) {
+          const descriptor = Object.getOwnPropertyDescriptor(props, plan[index]);
+          if (!descriptor || !import_has_own.hasOwnProp.call(descriptor, "value")) {
+            plan = void 0;
+            break;
+          }
+        }
+      }
+    }
+    if (plan !== void 0) {
+      const previousProps = currentHydrationProps;
+      const previousPlan = currentHydrationPlan;
+      currentHydrationProps = props;
+      currentHydrationPlan = plan;
+      try {
+        return writer(scope, slot, parent, component, props, site, anchor);
+      } finally {
+        currentHydrationProps = previousProps;
+        currentHydrationPlan = previousPlan;
+      }
+    }
+  }
+  writer(scope, slot, parent, component, props, site, anchor);
+}
+function __captureHydrationInput(env, propsIndex, plan, closed = false, source) {
+  const props = env[propsIndex];
+  if (!closed) {
+    if (currentHydrationProps !== props || currentHydrationPlan !== plan) return env;
+    currentHydrationProps = null;
+    currentHydrationPlan = null;
+  }
+  if (!import_hydration_flag.hydrating && import_hydration_flag.pendingInitialHydrations === 0) return env;
+  for (let index = 1; index <= plan[0]; index++) {
+    const descriptor = Object.getOwnPropertyDescriptor(props, plan[index]);
+    if (!descriptor || !import_has_own.hasOwnProp.call(descriptor, "value") || !isHydrationArrow(descriptor.value))
+      return env;
+  }
+  let witness = null;
+  if (source !== void 0) {
+    try {
+      witness = source() ?? null;
+    } catch {
+      return env;
+    }
+    if (witness === null) return env;
+  }
+  (hydrationInputTuples ??= /* @__PURE__ */ new WeakMap()).set(env, witness);
+  return env;
+}
+function __ownedHydrationInputs(previous, next, source = false) {
+  const tuples = hydrationInputTuples;
+  if (tuples === void 0) return false;
+  if (!source) return tuples.has(previous) && tuples.has(next);
+  const left = tuples.get(previous);
+  const right = tuples.get(next);
+  return left != null && right != null && left[0] === right[0] && left[1] === right[1];
+}
+function __sameHydrationSource(previous, source) {
+  const left = hydrationInputTuples?.get(previous);
+  if (left == null) return false;
+  try {
+    const right = source();
+    return right !== void 0 && left[0] === right[0] && left[1] === right[1];
+  } catch {
+    return false;
+  }
+}
+function __sameHydrationInput(previous, next, name, method = false) {
+  const left = Object.getOwnPropertyDescriptor(previous, name);
+  const right = Object.getOwnPropertyDescriptor(next, name);
+  if (!left || !right || !import_has_own.hasOwnProp.call(left, "value") || !import_has_own.hasOwnProp.call(right, "value") || !Object.is(left.value, right.value))
+    return false;
+  return !method || isHydrationArrow(left.value);
+}
+function optionalInputValue(props, name) {
+  const descriptor = Object.getOwnPropertyDescriptor(props, name);
+  if (descriptor !== void 0) {
+    if (!import_has_own.hasOwnProp.call(descriptor, "value")) return UNSAFE_OPTIONAL_INPUT;
+    const value = descriptor.value;
+    return value == null || isHydrationArrow(value) ? value : UNSAFE_OPTIONAL_INPUT;
+  }
+  const prototype = Object.getPrototypeOf(props);
+  return prototype === null || prototype === Object.prototype && Object.getOwnPropertyDescriptor(prototype, name) === void 0 ? ABSENT_OPTIONAL_INPUT : UNSAFE_OPTIONAL_INPUT;
+}
+function __observeHydrationOptionalInput(env, props, name) {
+  if (!import_hydration_flag.hydrating) return;
+  const observation = optionalInputObservations?.get(env);
+  if (observation?.armed) {
+    observation.armed = false;
+    if (observation.props !== props || observation.name !== name || !Object.is(observation.value, optionalInputValue(props, name))) {
+      optionalInputObservations.delete(env);
+      throw import_hydration_input_control.INITIAL_ADOPTION_INPUT_CHANGED;
+    }
+    return;
+  }
+  if (!hydrationInputTuples?.has(env) && (observation?.props !== props || observation.name !== name)) {
+    if (observation !== void 0) optionalInputObservations.delete(env);
+    return;
+  }
+  const value = optionalInputValue(props, name);
+  if (value !== UNSAFE_OPTIONAL_INPUT)
+    (optionalInputObservations ??= /* @__PURE__ */ new WeakMap()).set(env, { props, name, value, armed: false });
+  else if (observation !== void 0) optionalInputObservations.delete(env);
+}
+function __sameHydrationOptionalInput(previous, next, props, name) {
+  const observation = optionalInputObservations?.get(previous);
+  if (!observation || observation.armed || observation.name !== name || observation.props !== props && !hydrationInputTuples?.has(next))
+    return false;
+  const value = optionalInputValue(props, name);
+  if (value === UNSAFE_OPTIONAL_INPUT || !Object.is(observation.value, value)) return false;
+  optionalInputObservations.set(next, { props, name, value, armed: true });
+  return true;
+}
+function isHydrationArrow(value) {
+  if (typeof value !== "function") return false;
+  try {
+    const source = Function.prototype.toString.call(value);
+    return import_method_dep.ARROW_HEAD.test(source) && (source[0] === "(" || !/^async\b/.test(source));
+  } catch {
+    return false;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  __captureHydrationInput,
+  __hydrationComponentSlot,
+  __observeHydrationOptionalInput,
+  __ownedHydrationInputs,
+  __registerHydrationInputComponent,
+  __sameHydrationInput,
+  __sameHydrationOptionalInput,
+  __sameHydrationSource
+});

package/dist/cjs/internal/client.cjs

@@ -19,18 +19,35 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var client_exports = {};
 __export(client_exports, {
+  __captureHydrationInput: () => import_hydration_inputs.__captureHydrationInput,
+  __hydrationComponentSlot: () => import_hydration_inputs.__hydrationComponentSlot,
+  __observeHydrationOptionalInput: () => import_hydration_inputs.__observeHydrationOptionalInput,
+  __ownedHydrationInputs: () => import_hydration_inputs.__ownedHydrationInputs,
+  __registerHydrationInputComponent: () => import_hydration_inputs.__registerHydrationInputComponent,
   __s: () => import_runtime.markSingleRoot,
+  __sameHydrationInput: () => import_hydration_inputs.__sameHydrationInput,
+  __sameHydrationOptionalInput: () => import_hydration_inputs.__sameHydrationOptionalInput,
+  __sameHydrationSource: () => import_hydration_inputs.__sameHydrationSource,
   isContext: () => import_context_identity.isContext,
   signalOwnerUse: () => import_owner_context.signalOwnerUse
 });
 module.exports = __toCommonJS(client_exports);
 __reExport(client_exports, require("../runtime.cjs"), module.exports);
 var import_context_identity = require("../context-identity.cjs");
+var import_hydration_inputs = require("../hydration-inputs.cjs");
 var import_runtime = require("../runtime.cjs");
 var import_owner_context = require("../signals/owner-context.cjs");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  __captureHydrationInput,
+  __hydrationComponentSlot,
+  __observeHydrationOptionalInput,
+  __ownedHydrationInputs,
+  __registerHydrationInputComponent,
   __s,
+  __sameHydrationInput,
+  __sameHydrationOptionalInput,
+  __sameHydrationSource,
   isContext,
   signalOwnerUse,
   ...require("../runtime.cjs")

package/dist/cjs/method-dep.cjs

@@ -18,6 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var method_dep_exports = {};
 __export(method_dep_exports, {
+  ARROW_HEAD: () => ARROW_HEAD,
   __methodDep: () => __methodDep
 });
 module.exports = __toCommonJS(method_dep_exports);
@@ -60,5 +61,6 @@ function ownMethodDep(receiver, method) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ARROW_HEAD,
   __methodDep
 });

package/dist/cjs/runtime/block.cjs

@@ -589,7 +589,7 @@ function unmountBlockInner(block, detachDom) {
 function registerSlot(scope, slot) {
   const slots = scope._slots;
   const transaction = import_render.ROOT_RENDER_TRANSACTION;
-  if (transaction !== null && scope.mounted && !(0, import_engine.isCreatedInRootRender)(transaction, scope.block)) {
+  if (transaction !== null && !(0, import_engine.isCreatedInRootRender)(transaction, (0, import_branches.owningBlock)(scope.block))) {
     (0, import_engine.journalUndo)(() => {
       unmountSlot(slot, true);
       const index = scope.slots.indexOf(slot);