octane 0.2.12 → 0.2.13

package/dist/runtime.js

@@ -1,5 +1,13 @@
 import { resolveHookPath } from "./hook-slot-cache.js";
 import { DOMStage } from "./dom-stage.js";
+import { __normalizeBindingStyle } from "./dom-binding-styles.js";
+import {
+  BINDING_HANDOFF,
+  claimBindingHandoff,
+  consumeBindingEvent,
+  beginBindingEvent,
+  releaseBindingHandoff
+} from "./dom-binding-handoff.js";
 import { bumpContextEpoch, contextEpochNow } from "./context-epoch.js";
 import {
   SUSPENSE_SCRIPT_ATTR,
@@ -12,6 +20,8 @@ import {
   HYDRATE_WHEN_ATTR,
   HYDRATE_ID_COUNT_ATTR,
   HYDRATE_SEED_ATTR,
+  HYDRATE_INPUT_ATTR,
+  HYDRATE_INDEPENDENT_ATTR,
   STREAM_BOUNDARY_ATTR,
   STREAM_SCRIPT_ATTR,
   STREAM_SEED_COMMENT,
@@ -87,9 +97,12 @@ import {
   HYDRATE_SUPPORTED_INTERACTION_EVENTS,
   hydrationEventPathWithin,
   initializeHydrationEventCapture,
+  isHydrationSelectionIntentCurrent,
   markDelegatedDynamicHydrationIntent,
   registerHydrationIntentBoundary,
   shouldPreventHydrationInteractionDefault,
+  snapshotHydrationControl,
+  consumeHydrationControl,
   takeDelegatedDynamicHydrationIntent,
   takePendingHydrationIntents,
   unregisterHydrationIntentBoundary,
@@ -108,6 +121,8 @@ import {
 } from "./component-flags.js";
 import { formatClientError } from "./error-codes.client.generated.js";
 import { formAuthoringDiagnostics } from "./form-diagnostics.js";
+import { isBindingOpenComment } from "./dom-binding-protocol.js";
+import { moveNativeNodeBefore } from "./dom-focused-move.js";
 import {
   HYDRATE_STREAM_TOKEN_ATTR,
   isRendererStreamBoundaryTemplate,
@@ -120,10 +135,19 @@ import {
   validateNativeReadWitness
 } from "./signals/native-read-collector.js";
 import { createNativeReadRetry } from "./signals/native-read-retry.js";
+import {
+  activeCandidate,
+  swapActiveSignalCandidate,
+  withoutSignalCandidate
+} from "./signals/transition-state.js";
+import { SignalCandidateFrame } from "./signals/transition-candidate.js";
 import {
   NativeAdoptionMiss,
+  NATIVE_TRANSITION_CONSUMER,
   readNativeDomStyle,
+  registerNativeActionResolver,
   runNativeBatch,
+  setNativeCandidateResolver,
   setNativeAdoptionResolver
 } from "./signals/read-protocol.js";
 import { beginNativeEventBatch, endNativeEventBatch } from "./signals/native-read-events.js";
@@ -133,6 +157,34 @@ import {
   NATIVE_SIGNAL_FRESH_COMMENT,
   parseNativeSignalManifest
 } from "./signals/native-read-seeds.js";
+import {
+  currentExplicitSignalOwner,
+  activeSignalOwnerEnvironment,
+  activeSynchronousSignalOwner,
+  currentSignalOwner,
+  retireSignalOwnerIdentity,
+  runWithSignalOwner
+} from "./signals/owner-context.js";
+import {
+  documentSignalOwner,
+  enableSignalDocument,
+  signalDocumentEnabled,
+  streamedSignalOwnerActivator as STREAMED_SIGNAL_OWNER_ACTIVATOR
+} from "./signals/document-owner.js";
+import {
+  documentSignalOwner as documentSignalOwner2,
+  installStreamedSignalOwnerActivator
+} from "./signals/document-owner.js";
+import {
+  hasHydrationControlSignalWriter,
+  registerHydrationControlSignalWriter,
+  registerSignalOwnerDocument
+} from "./signals/early-values.js";
+import {
+  SIGNAL_BINDING_READ,
+  SIGNAL_BINDING_SUBSCRIBE,
+  SIGNAL_HANDLE
+} from "./signals/types.js";
 let PROFILE_COMPONENT_OVERRIDE = null;
 function withProfileComponentOverride(target, component, run) {
   const previous = PROFILE_COMPONENT_OVERRIDE;
@@ -169,24 +221,395 @@ function registerHookCleanup(scope, cleanup) {
 let NATIVE_READ_DRIVER = null;
 let NATIVE_BLOCK_RETRIES = null;
 let NATIVE_ADOPTION_RELEASES = null;
+let SIGNAL_BINDINGS_ENABLED = false;
+const SCOPE_SIGNAL_OWNERS = /* @__PURE__ */ new WeakMap();
+const SCOPE_SIGNAL_INSTANCE_KEYS = /* @__PURE__ */ new WeakMap();
+let RETAINED_SIGNAL_OWNERS;
+const SIGNAL_RETRY_LOCATIONS = /* @__PURE__ */ new WeakMap();
+function signalRetryBoundary(block) {
+  let current = block;
+  while (current !== null) {
+    const state = current.__trySlot;
+    if (state !== void 0 && !state.propagateSuspense) return state;
+    current = current.parentBlock;
+  }
+}
+function retireRendererSignalOwner(owner) {
+  EFFECT_EVENT_LIFECYCLE_DEPTH++;
+  const frame = NATIVE_READ_DRIVER?.pauseLifecycle() ?? -1;
+  try {
+    retireSignalOwnerIdentity(owner);
+  } finally {
+    if (frame >= 0) NATIVE_READ_DRIVER.resumeLifecycle(frame);
+    EFFECT_EVENT_LIFECYCLE_DEPTH--;
+  }
+}
+function signalRetrySlot(scope, target) {
+  const children = scope.children;
+  if (children !== null) {
+    for (const child2 of children) {
+      if (child2.scope === target) return ["scope", child2.key];
+      const nested = signalRetrySlot(child2.scope, target);
+      if (nested !== null) return ["scope", child2.key, ...nested];
+    }
+  }
+  const block = target.block;
+  for (let index = 0; index < scope.slots.length; index++) {
+    const slot = scope.slots[index];
+    if (slot === null || typeof slot !== "object") continue;
+    if (block.forSlot !== null && (slot === block.forSlot || slot.forSlot === block.forSlot))
+      return ["slot", index, "item", block.key];
+    if (slot.block === block || slot.tryBlock === block || slot.emptyBlock === block) {
+      return [
+        "slot",
+        index,
+        slot.__kind,
+        slot.tryBlock === block ? "primary" : slot.branch,
+        slot.emptyBlock === block ? "empty" : slot.currentIsBodyFn ? void 0 : slot.currentComp,
+        slot.prevKey
+      ];
+    }
+  }
+  return null;
+}
+function signalRetryPath(scope, root) {
+  if (scope === root) return [];
+  const location = SIGNAL_RETRY_LOCATIONS.get(scope);
+  let parent = location?.parent ?? scope.parent ?? scope.block.parentBlock;
+  while (parent instanceof LiteBlockImpl) parent = parent.parentBlock;
+  if (parent === null) return null;
+  const segment = location === void 0 ? signalRetrySlot(parent, scope) : ["slot", location.slot, location.kind, location.branch, location.component, location.key];
+  if (segment === null) return null;
+  const path = signalRetryPath(parent, root);
+  return path === null ? null : path.concat(segment);
+}
+function signalRetryNode(cache, path, create) {
+  let node = cache.paths;
+  for (const key of path) {
+    let next = node.children?.get(key);
+    if (next === void 0) {
+      if (!create) return;
+      next = {};
+      (node.children ??= /* @__PURE__ */ new Map()).set(key, next);
+    }
+    node = next;
+  }
+  return node;
+}
+function retainSignalRetryScope(scope, root, holder, subtree = false) {
+  const owner = SCOPE_SIGNAL_OWNERS.get(scope);
+  if (owner) {
+    const path = signalRetryPath(scope, root);
+    if (path !== null) {
+      const cache = holder.retrySignalOwners ??= { paths: {}, owners: /* @__PURE__ */ new Set() };
+      const node = signalRetryNode(cache, path, true);
+      const previous = node.owner;
+      node.owner = owner;
+      cache.owners.add(owner);
+      if (previous !== void 0 && previous !== owner) {
+        cache.owners.delete(previous);
+        retireRendererSignalOwner(previous);
+      }
+    }
+  }
+  if (subtree)
+    forEachSubtreeChild(scope, (child2) => retainSignalRetryScope(child2, root, holder, true));
+  else if (scope.children !== null)
+    for (const child2 of scope.children) retainSignalRetryScope(child2.scope, root, holder);
+}
+function clearSignalRetryOwners(holder) {
+  const cache = holder.retrySignalOwners;
+  if (cache === void 0) return;
+  holder.retrySignalOwners = void 0;
+  for (const owner of cache.owners) retireRendererSignalOwner(owner);
+}
+function discardSignalRetryItem(block, error) {
+  const previous = RETAINED_SIGNAL_OWNERS;
+  if (isSuspenseException(error)) {
+    const owner = block.idState.renderOwner;
+    const boundary = signalRetryBoundary(block);
+    const root = boundary?.tryBlock ?? owner?.current;
+    const holder = boundary ?? owner;
+    if (holder !== void 0 && root != null) {
+      retainSignalRetryScope(block, root, holder, true);
+      RETAINED_SIGNAL_OWNERS = holder.retrySignalOwners;
+    }
+  }
+  try {
+    unmountBlock(
+      block,
+      activeHydration() === null && !ROOT_RENDER_TRANSACTION?.hydrating && !ROOT_RENDER_TRANSACTION?.retainedCreated?.has(block)
+    );
+  } finally {
+    RETAINED_SIGNAL_OWNERS = previous;
+  }
+}
+function signalRetryListPath(scope, state, root) {
+  while (scope instanceof LiteBlockImpl) scope = scope.parentBlock;
+  for (let index = 0; index < scope.slots.length; index++) {
+    const slot = scope.slots[index];
+    if (slot === state || slot?.forSlot === state) {
+      const path = signalRetryPath(scope, root);
+      return path === null ? null : path.concat("slot", index, "item");
+    }
+  }
+  if (scope.children !== null) {
+    for (const child2 of scope.children) {
+      const path = signalRetryListPath(child2.scope, state, root);
+      if (path !== null) return path;
+    }
+  }
+  return null;
+}
+function collectRetiredSignalRetryOwners(node, cache, retired) {
+  if (node.owner !== void 0) {
+    cache.owners.delete(node.owner);
+    retired.push(node.owner);
+    node.owner = void 0;
+  }
+  if (node.children !== void 0)
+    for (const child2 of node.children.values())
+      collectRetiredSignalRetryOwners(child2, cache, retired);
+}
+function trackSignalRetryListKeys(parent, state, length, source) {
+  const boundary = signalRetryBoundary(parent);
+  const owner = parent.idState.renderOwner;
+  const cache = boundary?.retrySignalOwners ?? owner?.retrySignalOwners;
+  const root = boundary?.retrySignalOwners !== void 0 ? boundary.tryBlock : owner?.current;
+  if (cache === void 0 || root == null) return;
+  const path = signalRetryListPath(parent, state, root);
+  const node = path === null ? void 0 : signalRetryNode(cache, path, false);
+  if (node?.children === void 0) return;
+  const prune = (keys) => {
+    const present = new Set(keys);
+    const retired = [];
+    for (const [key, child2] of node.children) {
+      if (present.has(key)) continue;
+      node.children.delete(key);
+      collectRetiredSignalRetryOwners(child2, cache, retired);
+    }
+    for (const owner2 of retired) retireRendererSignalOwner(owner2);
+  };
+  if (typeof source !== "function") {
+    prune(source);
+    return;
+  }
+  if (length === 0) {
+    prune([]);
+    return;
+  }
+  const observed = /* @__PURE__ */ new Map();
+  let complete = false;
+  return (index, key) => {
+    if (!complete) {
+      observed.set(index, key);
+      if (observed.size === length) {
+        complete = true;
+        prune(observed.values());
+      }
+    }
+  };
+}
+function enableSignalBindings(abi = 1, potentialOnly = false) {
+  if (abi !== 1) throw new TypeError(formatClientError(74));
+  SIGNAL_BINDINGS_ENABLED = true;
+  if (!potentialOnly) enableSignalDocument(abi);
+}
+function signalIdentityKey(value) {
+  if (value === null) return "null";
+  const kind = typeof value;
+  return kind === "string" || kind === "number" || kind === "bigint" || kind === "boolean" ? kind.charCodeAt(0).toString(36) + ":" + String(value) : kind === "undefined" ? "u:" : "o:" + String(value);
+}
+function rootSignalInstanceKey(ids) {
+  return JSON.stringify([ids.signalState?.prefix ?? ids.prefix, "root"]);
+}
+function resolveSignalInstanceKey(scope) {
+  const identity = SCOPE_SIGNAL_INSTANCE_KEYS.get(scope);
+  if (identity === void 0 || typeof identity === "string") return identity;
+  const key = structuralSignalInstanceKey(
+    identity.parentScope,
+    identity.invocationSite,
+    identity.key,
+    identity.hasKey
+  );
+  SCOPE_SIGNAL_INSTANCE_KEYS.set(scope, key);
+  return key;
+}
+function structuralSignalInstanceKey(parentScope, invocationSite, key, hasKey) {
+  let base = resolveSignalInstanceKey(parentScope);
+  const itemKeys = [];
+  const visited = /* @__PURE__ */ new Set();
+  let scope = parentScope;
+  while (base === void 0 && scope !== null) {
+    const block2 = scope.block;
+    if (!visited.has(block2)) {
+      visited.add(block2);
+      if (block2.forSlot !== null) itemKeys.push(signalIdentityKey(block2.key));
+      base = resolveSignalInstanceKey(block2);
+    }
+    scope = scope.parent;
+    if (base === void 0 && scope !== null) base = resolveSignalInstanceKey(scope);
+  }
+  let block = parentScope.block;
+  while (base === void 0 && block !== null) {
+    if (!visited.has(block)) {
+      visited.add(block);
+      if (block.forSlot !== null) itemKeys.push(signalIdentityKey(block.key));
+    }
+    base = resolveSignalInstanceKey(block);
+    block = block.parentBlock;
+  }
+  base ??= rootSignalInstanceKey(parentScope.block.idState);
+  itemKeys.reverse();
+  return base + JSON.stringify([invocationSite ?? "legacy", itemKeys, hasKey ? signalIdentityKey(key) : ""]);
+}
+function stampSignalInstance(scope, parentScope, invocationSite, key, hasKey) {
+  if (SIGNAL_BINDINGS_ENABLED || signalDocumentEnabled) {
+    SCOPE_SIGNAL_INSTANCE_KEYS.set(scope, { parentScope, invocationSite, key, hasKey });
+  }
+}
+function scopeSignalOwner(scope) {
+  if (scope === null) return;
+  const root = scope.block.idState.renderOwner;
+  let documentOwner = root?.signalOwner;
+  if (documentOwner === void 0 && signalDocumentEnabled) {
+    documentOwner = documentSignalOwner(scope.block.parentNode);
+    if (root !== void 0) root.signalOwner = documentOwner;
+  }
+  if (documentOwner === void 0) return;
+  let owner = SCOPE_SIGNAL_OWNERS.get(scope);
+  const retired = owner === null;
+  if (!owner || owner.documentOwner !== documentOwner) {
+    const ids = scope.block.idState;
+    owner = void 0;
+    const boundary = signalRetryBoundary(scope.block);
+    const cache = boundary?.retrySignalOwners ?? root?.retrySignalOwners;
+    const retryRoot = boundary?.retrySignalOwners !== void 0 ? boundary.tryBlock : root?.current;
+    if (cache !== void 0 && !retired && !scope.block.disposed && retryRoot != null) {
+      const path = signalRetryPath(scope, retryRoot);
+      const node = path === null ? void 0 : signalRetryNode(cache, path, false);
+      if (node?.owner !== void 0) {
+        owner = node.owner;
+        node.owner = void 0;
+        cache.owners.delete(owner);
+      }
+    }
+    if (owner === void 0 || owner.documentOwner !== documentOwner) {
+      const identity = {
+        scopeKey: documentOwner.scopeKey,
+        documentOwner,
+        instanceOwner: scope,
+        instanceKey: resolveSignalInstanceKey(scope) ?? rootSignalInstanceKey(ids)
+      };
+      identity.instanceOwner = identity;
+      owner = Object.freeze(identity);
+    }
+    SCOPE_SIGNAL_OWNERS.set(scope, owner);
+    if (retired) retireRendererSignalOwner(owner);
+  }
+  registerSignalOwnerDocument(owner, scope.block.parentNode.ownerDocument);
+  return owner;
+}
+function runWithBlockSignalOwner(scope, callback) {
+  const owner = scopeSignalOwner(scope);
+  if (owner !== void 0) STREAMED_SIGNAL_OWNER_ACTIVATOR?.(owner);
+  return owner === void 0 || currentSignalOwner() === owner ? callback() : runWithSignalOwner(owner, callback);
+}
 import { readNativeDomStyle as readNativeDomStyle2, readNativeDomProps } from "./signals/read-protocol.js";
 function disposeNativeStyleBinding(binding) {
   if (binding.block !== null) unmountBlock(binding.block, false);
   binding.block = null;
 }
 function nativeStyleBody(props, scope) {
-  const value = readNativeDomStyle(props.value);
+  const value = SIGNAL_BINDINGS_ENABLED ? runWithBlockSignalOwner(scope.parent, () => readNativeDomStyle(props.value)) : readNativeDomStyle(props.value);
   setStyle(props.el, value, scope.slots[0]);
   journalRootProperty(scope.slots, 0, scope.slots[0]);
   scope.slots[0] = value;
 }
 function nativeStyleBinding(owner, slotIndex, el, value) {
+  nativePresentationBinding(owner, slotIndex, el, nativeStyleBody, { el, value });
+}
+function prepareNativeProjection(props, scope) {
+  const prepare = () => {
+    const projected = props.compute();
+    return props.fields.map((field) => {
+      const value = projected?.[field];
+      if (field === "style") return __normalizeBindingStyle(readNativeDomStyle(value));
+      if (field === "class" || field === "className")
+        return value == null || value === false ? null : normalizeClass(value);
+      return coerceAttrValue(props.el, field, value);
+    });
+  };
+  return SIGNAL_BINDINGS_ENABLED ? runWithBlockSignalOwner(scope.parent, prepare) : prepare();
+}
+function publishNativeProjection(props, values, previous) {
+  for (let i = 0; i < props.fields.length; i++) {
+    const field = props.fields[i];
+    const value = values[i];
+    if (previous !== void 0 && Object.is(previous[i], value)) continue;
+    if (field === "style") setStyle(props.el, value, previous?.[i]);
+    else if (field === "class" || field === "className") setClassAttr(props.el, value);
+    else setAttribute(props.el, field, value);
+  }
+}
+function nativeProjectionBody(props, scope) {
+  const values = prepareNativeProjection(props, scope);
+  publishNativeProjection(props, values, scope.slots[0]);
+  journalRootProperty(scope.slots, 0, scope.slots[0]);
+  scope.slots[0] = values;
+}
+function preparedNativeStyleBody(props, scope) {
+  const native = setNativeAdoptionResolver(null);
+  const witness = beginNativeReadWitness();
+  let value;
+  let completed = false;
+  try {
+    value = runWithBlockSignalOwner(
+      scope.parent,
+      () => __normalizeBindingStyle(readNativeDomStyle(props.value))
+    );
+    completed = true;
+  } finally {
+    props.frame.witnesses.set(scope, finishNativeReadWitness(witness, completed));
+    setNativeAdoptionResolver(native);
+  }
+  preparePresentationOperation(props.frame, scope, "native", () => {
+    setStyle(props.el, value, "");
+    scope.block.body = nativeStyleBody;
+  });
+  journalRootProperty(scope.slots, 0, scope.slots[0]);
+  scope.slots[0] = value;
+}
+function preparedNativeProjectionBody(props, scope) {
+  const native = setNativeAdoptionResolver(null);
+  const witness = beginNativeReadWitness();
+  let values;
+  let completed = false;
+  try {
+    values = prepareNativeProjection(props, scope);
+    completed = true;
+  } finally {
+    props.frame.witnesses.set(scope, finishNativeReadWitness(witness, completed));
+    setNativeAdoptionResolver(native);
+  }
+  preparePresentationOperation(props.frame, scope, "native", () => {
+    publishNativeProjection(
+      props,
+      values,
+      props.fields.map((field) => field === "style" ? "" : void 0)
+    );
+    scope.block.body = nativeProjectionBody;
+  });
+  journalRootProperty(scope.slots, 0, scope.slots[0]);
+  scope.slots[0] = values;
+}
+function nativeProjectionBinding(owner, slotIndex, el, compute, fields) {
+  nativePresentationBinding(owner, slotIndex, el, nativeProjectionBody, { el, compute, fields });
+}
+function nativePresentationBinding(owner, slotIndex, el, body, props) {
   let binding = owner.slots[slotIndex];
   if (binding === void 0) {
-    const block = createBlock("control-flow", owner.block, el, null, null, nativeStyleBody, {
-      el,
-      value
-    });
+    const block = createBlock("control-flow", owner.block, el, null, null, body, props);
     block.parent = owner;
     binding = {
       __kind: "nativeStyleBinding",
@@ -206,7 +629,7 @@ function nativeStyleBinding(owner, slotIndex, el, value) {
       block.slots[0] = void 0;
     }
     journalRootProperty(block, "props", block.props);
-    block.props = { el, value };
+    block.props = props;
   }
   renderBlock(binding.block);
 }
@@ -226,6 +649,15 @@ function beginActiveNativeReadScope(scope) {
   return block === null ? -1 : NATIVE_READ_DRIVER.beginScope(scope, block);
 }
 function scheduleNativeRead(target) {
+  const activation = preservedHydrateActivationCount === 0 ? null : pendingHydrateOwner(target);
+  if (activation !== null) {
+    invalidateRender(target, activation.block);
+    if (activation.activationRequested) {
+      activation.serverActivationStarted = false;
+      scheduleRender(activation.parentBlock);
+    }
+    return;
+  }
   invalidateRender(target, target);
   const retainPriority = SCHEDULED_VISIBILITY_DRIVER?.holdsNativeRead(target) === true;
   if (retainPriority) TRANSITION_DEPTH++;
@@ -241,6 +673,8 @@ function ensureNativeReadDriver() {
     capture: () => WIP_CAPTURE,
     cleanup: registerHookCleanup,
     schedule: scheduleNativeRead,
+    prepare: prepareNativeTransitionBlock,
+    retire: retireNativeTransitionBlock,
     suspended: retainNativeRetryReads,
     replayRefs: (capture, owner) => replayNativeUnpublishedRefs(capture, owner),
     refDisposed: (entry) => blockSubtreeDisposed(entry.block)
@@ -272,13 +706,13 @@ function inspectDevtoolsName(scope) {
 }
 function acceptNativeCapture(capture, owner, replayRootRefs = false) {
   const driver = NATIVE_READ_DRIVER;
-  if (driver === null) return;
+  if (driver === null) return false;
   if (DEFERRED_LAYOUT_DRIVER?.stageAction(
     () => acceptNativeCapture(capture, owner, replayRootRefs)
   ) === true)
-    return;
+    return true;
   const native = driver.acceptCapture(capture);
-  if (owner === void 0) return;
+  if (owner === void 0) return false;
   const replays = replayRootRefs && driver.replayDeferredRefs(capture, owner);
   if (native || replays || driver.hasPublication(owner)) {
     driver.stampPublication(owner, [
@@ -289,6 +723,7 @@ function acceptNativeCapture(capture, owner, replayRootRefs = false) {
       capture.refs
     ]);
   }
+  return false;
 }
 function replayNativeUnpublishedRefs(capture, owner) {
   const driver = NATIVE_READ_DRIVER;
@@ -326,6 +761,7 @@ function replayNativeReadWitness(witness) {
   NATIVE_READ_DRIVER?.replay(witness);
 }
 function retainNativeRetryReads(block, reads) {
+  if (NATIVE_TRANSITION_ATTEMPT !== null) return;
   for (let current = block; current !== null; current = current.parentBlock) {
     if (current.__suspenseHandler) {
       const retries = NATIVE_BLOCK_RETRIES ??= /* @__PURE__ */ new WeakMap();
@@ -482,6 +918,7 @@ function hydrationNodeMatches(server, template2, partialStyles, path = "") {
   const tAttrs = (STAGED_DOM?.view(t) ?? t).attributes;
   for (let i = 0; i < tAttrs.length; i++) {
     const a = tAttrs[i];
+    if ((STAGED_DOM?.view(a) ?? a).name === HYDRATE_INPUT_ATTR) continue;
     if ((STAGED_DOM?.view(s) ?? s).getAttribute((STAGED_DOM?.view(a) ?? a).name) !== (STAGED_DOM?.view(a) ?? a).value && !((STAGED_DOM?.view(a) ?? a).name === "style" && partialStyles !== void 0 && partialStyles.includes("|" + path + "|"))) {
       return false;
     }
@@ -538,22 +975,24 @@ let COMMIT_PHASE_ERRORS = null;
 let REF_CALLBACK_DEPTH = 0;
 let STORE_SYNC_DEPTH = 0;
 let EFFECT_EVENT_LIFECYCLE_DEPTH = 0;
-function runEffectLifecycleCallback(callback) {
+function runEffectLifecycleCallback(callback, scope = null) {
   EFFECT_EVENT_LIFECYCLE_DEPTH++;
   const nativeFrame = NATIVE_READ_DRIVER?.pauseLifecycle() ?? -1;
   try {
-    callback();
+    if (signalDocumentEnabled || scope?.block.idState.renderOwner?.signalOwner !== void 0)
+      runWithBlockSignalOwner(scope, callback);
+    else callback();
   } finally {
     if (nativeFrame >= 0) NATIVE_READ_DRIVER.resumeLifecycle(nativeFrame);
     EFFECT_EVENT_LIFECYCLE_DEPTH--;
   }
 }
-function runEffectCleanupCallback(callback, phase = -1) {
+function runEffectCleanupCallback(callback, phase = -1, scope = null) {
   const previousPhase = CURRENT_EFFECT_PHASE;
   CURRENT_EFFECT_PHASE = phase;
   EFFECT_BODY_DEPTH++;
   try {
-    runEffectLifecycleCallback(callback);
+    runEffectLifecycleCallback(callback, scope);
   } finally {
     EFFECT_BODY_DEPTH--;
     CURRENT_EFFECT_PHASE = previousPhase;
@@ -588,8 +1027,275 @@ function ensureTransitionSwapDriver() {
     rebaseHeld: rebaseHeldTransitionUpdate
   };
 }
+let NATIVE_TRANSITION_QUEUE = null;
+let NATIVE_TRANSITION_ATTEMPT = null;
+function queueNativeTransition(batch) {
+  (NATIVE_TRANSITION_QUEUE ??= /* @__PURE__ */ new Set()).add(batch);
+  if (!scheduled && !syncFlush) {
+    scheduled = true;
+    queueMicrotask(flush);
+  }
+}
+function prepareNativeTransitionBlock(block) {
+  const admission = NATIVE_TRANSITION_ATTEMPT;
+  if (block.disposed || admission.blocks.has(block)) return;
+  const hidden = SCHEDULED_VISIBILITY_DRIVER?.find(block, false);
+  if (hidden?.nativeTransition !== void 0 && hidden.tryBlock !== null) block = hidden.tryBlock;
+  if (admission.blocks.has(block)) return;
+  const owner = block.idState.renderOwner;
+  if (owner === void 0 || owner.disposed) return;
+  const retired = owner.transaction?.retired;
+  if (retired !== void 0 && retired !== null) {
+    for (let current = block; current !== null; current = current.parentBlock)
+      if (retired.has(current)) return;
+  }
+  admission.blocks.add(block);
+  const root = beginRootRender(owner);
+  admission.transactions.add(owner.transaction);
+  const mode = block.pendingMode;
+  block.pendingMode = "transition";
+  const attempt = beginTransitionAttempt(block);
+  if (attempt !== null) admission.attempts.push(attempt);
+  try {
+    invalidateRender(block, block);
+    if (hidden?.nativeTransition !== void 0) {
+      journalObjectOnce(hidden);
+      journalRootProperty(block, "inactive", block.inactive);
+      SCHEDULED_VISIBILITY_DRIVER.reveal(hidden, "transition");
+    } else renderBlock(block);
+  } catch (error) {
+    if (isSuspenseException(error)) {
+      for (let owner2 = block; owner2 !== null; owner2 = owner2.parentBlock) {
+        const handler = owner2.__suspenseHandler;
+        if (handler) {
+          try {
+            handler(error.thenable, block);
+          } catch (suspension) {
+            if (!isSuspenseException(suspension)) throw suspension;
+          }
+          break;
+        }
+      }
+      throw error.thenable;
+    }
+    admission.errorBlock ??= block;
+    throw error;
+  } finally {
+    endTransitionAttempt(attempt);
+    block.pendingMode = mode;
+    endRootRender(root);
+  }
+}
+function finishNativeTransition(batch) {
+  batch.nativeWake?.();
+  batch.nativeWake = void 0;
+  batch.native = void 0;
+  for (const block of batch.nativeBlocks ?? [])
+    block.idState.renderOwner?.nativeTransitions?.delete(batch);
+  batch.nativeBlocks = void 0;
+  for (const state of batch.nativeBoundaries?.keys() ?? []) {
+    if (state.nativeTransition !== batch) continue;
+    state.nativeTransition = void 0;
+    if (state.transitionTimeoutId !== null) {
+      clearTimeout(state.transitionTimeoutId);
+      state.transitionTimeoutId = null;
+    }
+  }
+  batch.nativeBoundaries = void 0;
+  NATIVE_TRANSITION_QUEUE?.delete(batch);
+  if (NATIVE_TRANSITION_QUEUE?.size === 0) NATIVE_TRANSITION_QUEUE = null;
+  releaseTransitionHookHolder(batch);
+}
+function retireNativeTransitionBlock(block) {
+  if (ROOT_RENDER_ROLLBACK) return;
+  for (const batch of block.idState.renderOwner?.nativeTransitions ?? []) {
+    if (!batch.nativeBlocks?.has(block)) continue;
+    queueNativeTransition(batch);
+  }
+}
+function prepareNativeTransitionUpdates(batch) {
+  for (const update of batch.updates.values()) {
+    const { block, slot, state, reducer } = update;
+    const owner = block.idState.renderOwner;
+    if (block.disposed || owner === void 0 || owner.disposed) continue;
+    const frame = beginRootRender(owner);
+    NATIVE_TRANSITION_ATTEMPT.transactions.add(owner.transaction);
+    try {
+      journalObjectOnce(slot);
+      if (state !== void 0) {
+        state.renderTransition = update;
+        state.updates = void 0;
+      } else if (reducer !== void 0) {
+        reducer.renderTransition = update;
+        reducer.renderPhaseActions = void 0;
+      } else slot.value = rebaseTransitionActionUpdate(update);
+      if (slot.pendingActionBatch === batch) {
+        slot.pendingActionBatch = void 0;
+        slot.pendingActionValue = void 0;
+      }
+    } finally {
+      endRootRender(frame);
+    }
+  }
+}
+function prepareNativeTransitionHook(batch, hook) {
+  const owner = hook.block.idState.renderOwner;
+  if (hook.block.disposed || owner === void 0 || owner.disposed) return;
+  const frame = beginRootRender(owner);
+  NATIVE_TRANSITION_ATTEMPT.transactions.add(owner.transaction);
+  try {
+    if (batch.hooksPending && hook.pendingBatches === 1) {
+      journalObjectOnce(hook);
+      hook.isPending = false;
+    }
+  } finally {
+    endRootRender(frame);
+  }
+  prepareNativeTransitionBlock(hook.block);
+}
+function flushNativeTransitions() {
+  const queue = NATIVE_TRANSITION_QUEUE;
+  if (queue === null) return;
+  NATIVE_TRANSITION_QUEUE = null;
+  for (const batch of queue) {
+    const candidate = batch.native;
+    if (candidate === void 0) continue;
+    batch.nativeWake?.();
+    batch.nativeWake = void 0;
+    try {
+      if (!candidate.validate()) candidate.rebase();
+    } catch {
+      candidate.discard();
+      finishNativeTransition(batch);
+      flushTransitionActionBatch(batch);
+      continue;
+    }
+    if (!candidate.hasWrites()) {
+      candidate.discard();
+      finishNativeTransition(batch);
+      flushTransitionActionBatch(batch);
+      continue;
+    }
+    const admission = {
+      blocks: /* @__PURE__ */ new Set(),
+      transactions: /* @__PURE__ */ new Set(),
+      attempts: [],
+      presentations: [],
+      suspensions: /* @__PURE__ */ new Map()
+    };
+    NATIVE_TRANSITION_ATTEMPT = admission;
+    let outcome;
+    try {
+      outcome = candidate.prepare([
+        () => prepareNativeTransitionUpdates(batch),
+        ...batch.hook === null ? [] : [() => prepareNativeTransitionHook(batch, batch.hook)],
+        ...(batch.hooks ?? []).map((hook) => () => prepareNativeTransitionHook(batch, hook)),
+        ...[...batch.updates.values()].map(
+          (update) => () => prepareNativeTransitionBlock(update.block)
+        ),
+        ...candidate.consumers().filter((consumer) => consumer.active()).map((consumer) => () => {
+          const presentation = consumer.prepare();
+          if (presentation !== void 0) admission.presentations.push(presentation);
+        })
+      ]);
+    } finally {
+      NATIVE_TRANSITION_ATTEMPT = null;
+    }
+    for (const block of batch.nativeBlocks ?? [])
+      block.idState.renderOwner?.nativeTransitions?.delete(batch);
+    batch.nativeBlocks = admission.blocks;
+    for (const transaction of admission.transactions)
+      (transaction.owner.nativeTransitions ??= /* @__PURE__ */ new Set()).add(batch);
+    const valid = outcome.status === "ready" && admission.presentations.every((presentation) => presentation.validate()) && [...admission.transactions].every(
+      (transaction) => !transaction.aborted && !transaction.owner.disposed && currentPresentations(transaction.capture) && (NATIVE_READ_DRIVER === null || NATIVE_READ_DRIVER.validateCapture(transaction.capture))
+    );
+    if (valid && outcome.status === "ready" && outcome.receipt.publish(() => {
+      for (const transaction of admission.transactions) {
+        transaction.nativeAdmitted = true;
+        acceptNativeCapture(transaction.capture, transaction.owner, true);
+      }
+      batch.flushed = true;
+      batch.updates.clear();
+      finishNativeTransition(batch);
+      for (const presentation of admission.presentations) presentation.commit();
+      commitRootRenders();
+    })) {
+      continue;
+    }
+    for (const transaction of admission.transactions) rollbackRootRender(transaction);
+    for (const presentation of admission.presentations) presentation.discard();
+    for (let i = admission.attempts.length - 1; i >= 0; i--) {
+      const swaps = admission.attempts[i].memoSwaps;
+      if (swaps !== null)
+        for (let j = swaps.length - 1; j >= 0; j--) applyTransitionMemoSwap(swaps[j], false);
+    }
+    commitRootRenders();
+    if (outcome.status === "pending") {
+      for (const state of batch.nativeBoundaries?.keys() ?? []) {
+        if (admission.suspensions.has(state)) continue;
+        if (state.nativeTransition === batch) state.nativeTransition = void 0;
+        if (state.transitionTimeoutId !== null) {
+          clearTimeout(state.transitionTimeoutId);
+          state.transitionTimeoutId = null;
+        }
+      }
+      for (const [state, thenable] of admission.suspensions) {
+        state.nativeTransition = batch;
+        if (state.hasResolved && state.branch === 1 && state.pendingBody !== null && TRANSITION_FALLBACK_TIMEOUT_MS !== Infinity && TRANSITION_FALLBACK_TIMEOUT_MS >= 0 && (state.transitionTimeoutId === null || batch.nativeBoundaries?.get(state) !== thenable)) {
+          if (state.transitionTimeoutId !== null) clearTimeout(state.transitionTimeoutId);
+          state.transitionTimeoutId = setTimeout(() => {
+            state.transitionTimeoutId = null;
+            if (state.nativeTransition === batch && !state.parentBlock.disposed && state.branch === 1)
+              SCHEDULED_VISIBILITY_DRIVER.hidePending(state);
+          }, TRANSITION_FALLBACK_TIMEOUT_MS);
+        }
+      }
+      batch.nativeBoundaries = admission.suspensions;
+      batch.nativeWake = candidate.watchPreparation(outcome, () => queueNativeTransition(batch));
+    } else if (outcome.status === "ready" || outcome.status === "invalid" && outcome.reason === "stale") {
+      queueNativeTransition(batch);
+    } else {
+      candidate.discard();
+      finishNativeTransition(batch);
+      for (const update of batch.updates.values()) {
+        if (update.slot.pendingActionBatch === batch) {
+          update.slot.pendingActionBatch = void 0;
+          update.slot.pendingActionValue = void 0;
+        }
+      }
+      batch.updates.clear();
+      batch.flushed = true;
+      if (outcome.status === "error") {
+        if (admission.errorBlock !== void 0 && !admission.errorBlock.disposed)
+          handleResumeError(admission.errorBlock, outcome.error);
+        else reportTransitionError(outcome.error, batch.hook ?? void 0);
+      } else if (outcome.status === "invalid")
+        reportTransitionError(new TypeError(formatClientError(79)), batch.hook ?? void 0);
+    }
+  }
+}
 let ACTIVE_TRANSITION_ACTION_BATCH = null;
 let IN_FLIGHT_TRANSITION_ACTION_BATCH = null;
+let nativeActionResolverInstalled = false;
+function nativeCandidateForAction(batch) {
+  let candidate = batch.native;
+  if (candidate !== void 0 && !candidate.validate()) {
+    if (candidate.hasWrites()) candidate.rebase();
+    else {
+      candidate.discard();
+      candidate = void 0;
+    }
+  }
+  return candidate ?? (batch.native = new SignalCandidateFrame());
+}
+function ensureNativeActionResolver() {
+  if (nativeActionResolverInstalled) return;
+  nativeActionResolverInstalled = true;
+  registerNativeActionResolver(() => {
+    const batch = transitionActionBatchForUpdate();
+    return batch === null ? void 0 : nativeCandidateForAction(batch);
+  });
+}
 function createTransitionActionBatch() {
   return {
     updates: /* @__PURE__ */ new Map(),
@@ -652,6 +1358,16 @@ function stageTransitionValue(slot, block, operation, value, forceRender = false
 }
 function flushTransitionActionBatch(batch) {
   if (batch.flushed) return;
+  if (batch.native !== void 0) {
+    if (batch.native.hasWrites()) {
+      holdTransitionHookBatch(batch, batch);
+      queueNativeTransition(batch);
+      if (IN_FLIGHT_TRANSITION_ACTION_BATCH === batch) IN_FLIGHT_TRANSITION_ACTION_BATCH = null;
+      return;
+    }
+    batch.native.discard();
+    batch.native = void 0;
+  }
   batch.flushed = true;
   for (const update of batch.updates.values()) {
     const { slot, block, forceRender } = update;
@@ -1317,24 +2033,45 @@ function journalRootSlot(state, parent, before, after) {
   journalUndo(() => {
     structures.delete(state);
   });
-  journalRootRange(parent, before, after);
+  if (PRESENTATION_HYDRATION?.revision === void 0) journalRootRange(parent, before, after);
 }
 function journalRootRange(parent, before, after) {
+  const leases = ROOT_RENDER_TRANSACTION?.owner.bindingLeases;
   const nodes = [];
   for (let node = before === null ? getFirstChild(parent) : getNextSibling(before); node !== null && node !== after; node = getNextSibling(node))
     nodes.push(node);
   journalUndo(() => {
+    let restore = nodes;
+    for (const lease of leases ?? []) {
+      if (lease.end === void 0 || !lease.active()) continue;
+      let ancestor = parent;
+      while (ancestor !== null && ancestor.parentNode !== lease.root.parentNode)
+        ancestor = ancestor.parentNode;
+      for (let current2 = lease.root; current2 !== null; current2 = current2.nextSibling) {
+        if (current2 === ancestor) return;
+        if (current2 === lease.end) break;
+      }
+      const start = restore.indexOf(lease.root);
+      const end = restore.indexOf(lease.end);
+      if (start < 0 || end < start || lease.root.parentNode !== parent) continue;
+      const current = [];
+      for (let node2 = lease.root; node2 !== null; node2 = node2.nextSibling) {
+        current.push(node2);
+        if (node2 === lease.end) break;
+      }
+      restore = [...restore.slice(0, start), ...current, ...restore.slice(end + 1)];
+    }
     if (before !== null && (STAGED_DOM?.view(before) ?? before).parentNode !== parent || after !== null && (STAGED_DOM?.view(after) ?? after).parentNode !== parent)
       return;
     let node = before !== null && (STAGED_DOM?.view(before) ?? before).parentNode === parent ? getNextSibling(before) : getFirstChild(parent);
     const anchor = after !== null && (STAGED_DOM?.view(after) ?? after).parentNode === parent ? after : null;
-    const retained = new Set(nodes);
+    const retained = new Set(restore);
     while (node !== null && node !== anchor) {
       const next = getNextSibling(node);
       if (!retained.has(node)) (STAGED_DOM?.view(parent) ?? parent).removeChild(node);
       node = next;
     }
-    restoreRootNodes(parent, nodes, anchor);
+    restoreRootNodes(parent, restore, anchor);
   });
 }
 function journalRootChildren(parent) {
@@ -1479,6 +2216,7 @@ function createdInRootRender(block) {
   if (transaction === null || ROOT_RENDER_ROLLBACK || isCreatedInRootRender(transaction, block))
     return;
   block.createdStamp = transaction.createdStamp;
+  if (PRESENTATION_HYDRATION?.revision !== void 0) preserveRootCreatedDom(block);
   (transaction.created ??= []).push(block);
   TRANSITION_JOURNAL.push(JOURNAL_CREATED, block, transaction, null);
 }
@@ -1489,6 +2227,8 @@ function preserveRootCreatedDom(block) {
 function rollbackRootRender(transaction) {
   if (transaction.aborted) return;
   transaction.aborted = true;
+  if (transaction.owner.retrySignalOwners !== void 0 && transaction.owner.retrySignalOwners !== RETAINED_SIGNAL_OWNERS)
+    clearSignalRetryOwners(transaction.owner);
   const frame = beginRootRender(transaction.owner);
   const previousRollback = ROOT_RENDER_ROLLBACK;
   ROOT_RENDER_ROLLBACK = true;
@@ -1515,6 +2255,19 @@ function rollbackRootRender(transaction) {
     endRootRender(frame);
   }
 }
+function retireDetachedBindingLeases(owner) {
+  for (const lease of owner.bindingLeases) {
+    if (owner.bindingContainer.contains(lease.anchor)) continue;
+    owner.bindingLeases.delete(lease);
+    PRESENTATION_PREPARATIONS.delete(lease);
+    releaseBindingHandoff(lease);
+    try {
+      lease.retire();
+    } catch (error) {
+      if (!reportUncaughtError(owner.current, error)) console.error(error);
+    }
+  }
+}
 function commitRootRenders() {
   const transactions = ROOT_RENDER_TRANSACTIONS;
   if (transactions.length === 0) return;
@@ -1528,17 +2281,23 @@ function commitRootRenders() {
         if (owner.transition !== void 0) TRANSITION_SWAP_DRIVER.commitRoot(owner, transaction);
         continue;
       }
-      if (NATIVE_READ_DRIVER !== null && !NATIVE_READ_DRIVER.validateCapture(transaction.capture)) {
+      if (!transaction.nativeAdmitted && (!currentPresentations(transaction.capture) || NATIVE_READ_DRIVER !== null && !NATIVE_READ_DRIVER.validateCapture(transaction.capture))) {
+        const presentationChanged = !currentPresentations(transaction.capture);
         rollbackRootRender(transaction);
         if (owner.transaction === transaction) owner.transaction = null;
         if (!owner.disposed) {
           owner.wakeable = null;
           owner.generation++;
-          owner.retry();
+          if (presentationChanged) retryPresentations(transaction.capture);
+          else owner.retry();
         }
         continue;
       }
       if (owner.transaction === transaction) owner.transaction = null;
+      if (transaction.capture.presentations !== void 0 && STAGED_COMMIT_CAPTURE !== null) {
+        stagedOwnerGuard(STAGED_COMMIT_CAPTURE, owner);
+        STAGED_COMMIT_CAPTURE.owners.get(owner).presentation = transaction;
+      }
       if (transaction.rootRequest && (owner.transition === void 0 || !TRANSITION_SWAP_DRIVER.keepsRoot(owner))) {
         owner.wakeable = null;
         owner.generation++;
@@ -1546,8 +2305,9 @@ function commitRootRenders() {
       if (owner.wakeable === null) {
         owner.retryKey = null;
         owner.nativeRetry?.clear();
+        if (owner.retrySignalOwners !== void 0) clearSignalRetryOwners(owner);
       }
-      acceptNativeCapture(transaction.capture, owner, true);
+      const deferredNativeAcceptance = acceptNativeCapture(transaction.capture, owner, true);
       const acceptedGeneration = owner.generation;
       const commits = transaction.commit;
       if (commits !== null) {
@@ -1573,7 +2333,11 @@ function commitRootRenders() {
         discardOffscreenCapture(transaction.capture);
         continue;
       }
-      spliceOffscreenCapture(transaction.capture);
+      spliceOffscreenCapture(transaction.capture, deferredNativeAcceptance);
+      if (owner.bindingLeases !== void 0 && owner.bindingLeases.size > 0) {
+        if (DEFERRED_LAYOUT_DRIVER?.stageAction(() => retireDetachedBindingLeases(owner)) !== true)
+          retireDetachedBindingLeases(owner);
+      }
       if (owner.transition !== void 0) TRANSITION_SWAP_DRIVER.commitRoot(owner, transaction);
     } finally {
       finishStagedOwner?.();
@@ -1592,7 +2356,19 @@ function suspendRootRender(block, wakeable, attempt) {
           retainDiscardedWarmMemos(created);
       }
     }
-    rollbackRootRender(transaction);
+    const previousRetainedOwners = RETAINED_SIGNAL_OWNERS;
+    const rootBlock = owner.current;
+    if (rootBlock !== null && transaction.created !== null && owner.signalOwner !== void 0) {
+      for (const created of transaction.created) {
+        if (!created.disposed) retainSignalRetryScope(created, rootBlock, owner);
+      }
+      RETAINED_SIGNAL_OWNERS = owner.retrySignalOwners;
+    }
+    try {
+      rollbackRootRender(transaction);
+    } finally {
+      RETAINED_SIGNAL_OWNERS = previousRetainedOwners;
+    }
   }
   owner.wakeable = wakeable;
   const generation = ++owner.generation;
@@ -3274,6 +4050,7 @@ function ensureScheduledVisibilityDriver() {
     find: findScheduledVisibilityOwner,
     holdsNativeRead,
     reveal: attemptHiddenReveal,
+    hidePending: hideTryContentAndMountPending,
     visible: renderVisibleTry,
     rehide: rehideActivityAfterDescendantRender,
     retryActivity: renderHiddenActivity
@@ -3369,16 +4146,22 @@ function drainQueue() {
       } catch (unhandled) {
         const transaction = block.idState.renderOwner?.transaction;
         if (transaction != null) rollbackRootRender(transaction);
-        if (!reportUncaughtError(block, unhandled)) {
-          if (pendingError === null) pendingError = { err: unhandled, all: [unhandled] };
+        const reported = unhandled instanceof PresentationAdoptionMiss && Object.prototype.hasOwnProperty.call(unhandled, "failure") ? unhandled.failure : unhandled;
+        if (!reportUncaughtError(block, reported)) {
+          if (pendingError === null) pendingError = { err: reported, all: [reported] };
           else {
-            pendingError.all.push(unhandled);
+            pendingError.all.push(reported);
             pendingError.err = typeof AggregateError === "function" ? new AggregateError(pendingError.all, formatClientError(13)) : pendingError.all[0];
           }
         }
         let root = block;
         while (root.parentBlock !== null) root = root.parentBlock;
-        if (root.kind === "root" && !root.disposed) unmountBlock(root);
+        if (root.kind === "root" && !root.disposed) {
+          if (unhandled instanceof PresentationAdoptionMiss && root.idState.renderOwner !== void 0) {
+            root.idState.renderOwner.preservePresentation = true;
+            DOM_ROOT_DISPOSERS.get(root)?.();
+          } else unmountBlock(root);
+        }
       }
     } finally {
       endRootRender(rootFrame);
@@ -3391,6 +4174,7 @@ function drainQueue() {
     for (const activity of activitiesToRehide) SCHEDULED_VISIBILITY_DRIVER.rehide(activity);
   }
   commitRootRenders();
+  flushNativeTransitions();
   return pendingError;
 }
 function flush() {
@@ -4146,6 +4930,7 @@ function vtFlush(work = flushWork, queuedOwners, queuedBlocks) {
     beginStagedCommitPublication(stagedCommit);
     try {
       try {
+        rejectStagedPresentations(stagedCommit);
         stage.commit();
       } finally {
         publishStagedCommit(stagedCommit);
@@ -4647,6 +5432,23 @@ function beginStagedCommitPublication(capture) {
 function endStagedCommitPublication(capture) {
   if (PUBLISHING_STAGED_COMMIT === capture) PUBLISHING_STAGED_COMMIT = null;
 }
+function rejectStagedPresentations(capture) {
+  for (const [owner, receipt] of capture.owners) {
+    const transaction = receipt.presentation;
+    if (transaction === void 0 || owner.disposed || owner.generation !== receipt.generation || currentPresentations(transaction.capture) && (NATIVE_READ_DRIVER === null || NATIVE_READ_DRIVER.validateCapture(transaction.capture)))
+      continue;
+    const pending = owner.transaction;
+    owner.transaction = transaction;
+    try {
+      rollbackRootRender(transaction);
+    } finally {
+      owner.transaction = pending;
+    }
+    owner.generation++;
+    retryPresentations(transaction.capture);
+    if (transaction.rootRequest) owner.retry();
+  }
+}
 function stagedOwnerGuard(capture, owner) {
   if (owner === void 0) return void 0;
   let receipt = capture.owners.get(owner);
@@ -4808,9 +5610,10 @@ function publishStagedCommit(capture) {
   capture.selects.length = capture.defaults.length = capture.checks.length = capture.autofocus.length = 0;
   capture.bundles.clear();
   capture.controls.clear();
+  capture.signalHosts?.clear();
   commitEffects();
 }
-function runStagedTeardown(cleanup, phase, handler, owner, suppressed) {
+function runStagedTeardown(cleanup, phase, handler, owner, suppressed, scope) {
   const previousHandler = TEARDOWN_HANDLER;
   const previousOwner = TEARDOWN_BLOCK;
   const previousErrors = TEARDOWN_ERRORS;
@@ -4822,8 +5625,8 @@ function runStagedTeardown(cleanup, phase, handler, owner, suppressed) {
   TEARDOWN_DEPTH++;
   try {
     try {
-      if (phase < 0) runEffectLifecycleCallback(cleanup);
-      else runEffectCleanupCallback(cleanup, phase);
+      if (phase < 0) runEffectLifecycleCallback(cleanup, scope);
+      else runEffectCleanupCallback(cleanup, phase, scope);
     } catch (error) {
       reportTeardownError(error);
     }
@@ -4898,7 +5701,7 @@ function ensureDeferredLayoutDriver() {
         enqueueStagedAction(capture, action, durable);
         return true;
       },
-      stageTeardown(cleanup, phase) {
+      stageTeardown(cleanup, phase, scope) {
         const capture = STAGED_COMMIT_CAPTURE;
         if (capture === null) return false;
         const handler = TEARDOWN_HANDLER;
@@ -4906,7 +5709,7 @@ function ensureDeferredLayoutDriver() {
         const suppressed = REF_DETACH_SUPPRESSION;
         enqueueStagedAction(
           capture,
-          () => runStagedTeardown(cleanup, phase, handler, owner, suppressed),
+          () => runStagedTeardown(cleanup, phase, handler, owner, suppressed, scope),
           true
         );
         return true;
@@ -4920,7 +5723,7 @@ function ensureDeferredLayoutDriver() {
           const handler = findTryHandler(scope.block);
           enqueueStagedAction(
             capture,
-            () => runStagedTeardown(cleanup, slot.phase, handler, scope.block, null),
+            () => runStagedTeardown(cleanup, slot.phase, handler, scope.block, null, scope),
             true
           );
         }
@@ -5258,7 +6061,7 @@ function drainPassiveEffects() {
   drainPassivePhase();
 }
 function hasPendingWork() {
-  return QUEUE.length > 0 || ROOT_RENDER_TRANSACTIONS.length > 0 || effectEventQueue.length > 0 || effectEventCommitActions.length > 0 || effectQueues[INSERTION].length > 0 || effectQueues[LAYOUT].length > 0 || effectQueues[PASSIVE].length > 0 || pendingPassiveUnmounts.length > 0 || storeSyncQueue.length > 0 || NATIVE_ADOPTION_RELEASES !== null || hasControlledSyncs();
+  return QUEUE.length > 0 || ROOT_RENDER_TRANSACTIONS.length > 0 || NATIVE_TRANSITION_QUEUE !== null || effectEventQueue.length > 0 || effectEventCommitActions.length > 0 || effectQueues[INSERTION].length > 0 || effectQueues[LAYOUT].length > 0 || effectQueues[PASSIVE].length > 0 || pendingPassiveUnmounts.length > 0 || storeSyncQueue.length > 0 || NATIVE_ADOPTION_RELEASES !== null || hasControlledSyncs();
 }
 function drainEffectEventUpdates() {
   if (effectEventQueue.length === 0) return;
@@ -5442,7 +6245,7 @@ function fireEffectCleanup(e) {
   if (cleanup) {
     slot.cleanup = void 0;
     try {
-      runEffectCleanupCallback(cleanup, e.phase);
+      runEffectCleanupCallback(cleanup, e.phase, e.scope);
     } catch (err) {
       if (err instanceof MaximumUpdateDepthError) throw err;
       reportEffectError(e.scope.block, err);
@@ -5463,7 +6266,7 @@ function runEffectBody(e) {
     CURRENT_EFFECT_PHASE = e.phase;
     EFFECT_BODY_DEPTH++;
     try {
-      cleanup = e.fn.apply(null, e.args);
+      cleanup = signalDocumentEnabled || e.scope.block.idState.renderOwner?.signalOwner !== void 0 ? runWithBlockSignalOwner(e.scope, () => e.fn.apply(null, e.args)) : e.fn.apply(null, e.args);
     } finally {
       EFFECT_BODY_DEPTH--;
       CURRENT_EFFECT_PHASE = previousPhase;
@@ -5571,7 +6374,7 @@ function drainDeferredPassiveUnmounts() {
   const q = pendingPassiveUnmounts.splice(0);
   for (let i = 0; i < q.length; i += 3) {
     try {
-      runEffectCleanupCallback(q[i], PASSIVE);
+      runEffectCleanupCallback(q[i], PASSIVE, q[i + 2]);
     } catch (err) {
       if (err instanceof MaximumUpdateDepthError) throw err;
       const handler = q[i + 1];
@@ -5764,6 +6567,14 @@ function captureRenderPhaseUpdate(cell, key) {
   if (!updates.has(cell)) updates.set(cell, { value: cell.value, queue: cell[key]?.slice(), key });
 }
 function renderBlock(block) {
+  if (signalDocumentEnabled || block.idState.renderOwner?.signalOwner !== void 0) {
+    const owner = scopeSignalOwner(block);
+    if (owner !== void 0) STREAMED_SIGNAL_OWNER_ACTIVATOR?.(owner);
+    if (owner !== void 0 && currentSignalOwner() !== owner) {
+      runWithSignalOwner(owner, () => renderBlock(block));
+      return;
+    }
+  }
   const hydration = activeHydration();
   if (hydration !== null && !hydration.owns(block)) {
     hydration.suspend(() => renderBlock(block));
@@ -5782,6 +6593,8 @@ function renderBlock(block) {
       }
       if (++retries > RENDER_PHASE_UPDATE_LIMIT) throw new Error(formatClientError(9));
     }
+    if (signalDocumentEnabled && block.__trySlot?.tryBlock === block && block.__trySlot.retrySignalOwners !== void 0)
+      clearSignalRetryOwners(block.__trySlot);
     const updates = renderPhaseUpdates;
     if (updates !== null && previousOwner !== null && blockIsAncestorOf(previousOwner, block)) {
       previousUpdates ??= /* @__PURE__ */ new Map();
@@ -5798,6 +6611,8 @@ function renderBlock(block) {
       }
       if (!block.crossRenderUpdate) block.pending = false;
     }
+    if (block.idState.renderOwner?.signalOwner !== void 0 && !block.mounted && block.forSlot !== null && block.forSlot.items.get(block.key) !== block)
+      discardSignalRetryItem(block, error);
     throw error;
   } finally {
     renderPhaseOwner = previousOwner;
@@ -6075,7 +6890,8 @@ function renderReturnedValue(block, out) {
           d.key ?? void 0,
           true,
           void 0,
-          activeHydration() !== null && elementKeyWasProvided(d)
+          activeHydration() !== null && elementKeyWasProvided(d),
+          d.__octaneInvocationSite
         )
       );
     } else {
@@ -6089,7 +6905,8 @@ function renderReturnedValue(block, out) {
         d.key ?? void 0,
         true,
         void 0,
-        activeHydration() !== null && elementKeyWasProvided(d)
+        activeHydration() !== null && elementKeyWasProvided(d),
+        d.__octaneInvocationSite
       );
     }
   } else {
@@ -6196,7 +7013,7 @@ class LiteBlockImpl {
     this.idState = parentBlock.idState;
   }
 }
-function componentSlotLite(parentScope, slotKey, host, comp, props, anchor) {
+function componentSlotLite(parentScope, slotKey, host, comp, props, anchor, invocationSite) {
   if (CURRENT_BLOCK?.pending && !CURRENT_BLOCK.crossRenderUpdate) return;
   if (parentScope === SHARED_BODY_SCOPE) {
     componentSlotImpl(
@@ -6210,7 +7027,10 @@ function componentSlotLite(parentScope, slotKey, host, comp, props, anchor) {
       props,
       anchor,
       void 0,
-      2
+      2,
+      void 0,
+      void 0,
+      invocationSite
     );
     return;
   }
@@ -6238,6 +7058,7 @@ function componentSlotLite(parentScope, slotKey, host, comp, props, anchor) {
       }
     }
     scope.block = new LiteBlockImpl(host, endMarker, parentScope.block);
+    stampSignalInstance(scope, parentScope, invocationSite, void 0, false);
     if (adoptedOpen !== null && adoptedClose !== null) {
       hydration.liteRanges.set(scope, {
         start: adoptedOpen,
@@ -6258,7 +7079,9 @@ function componentSlotLite(parentScope, slotKey, host, comp, props, anchor) {
   let profileThrown;
   const nativeToken = NATIVE_READ_DRIVER === null ? -1 : beginActiveNativeReadScope(scope);
   try {
-    comp(props, scope, void 0);
+    if (signalDocumentEnabled || scope.block.idState.renderOwner?.signalOwner !== void 0)
+      runWithBlockSignalOwner(scope, () => comp(props, scope, void 0));
+    else comp(props, scope, void 0);
     if (!scope.mounted) scope.mounted = true;
   } catch (error) {
     profileDidThrow = true;
@@ -6377,10 +7200,10 @@ function unmountScope(scope, detachDom = true) {
         pendingPassiveUnmounts.push(cleanup, TEARDOWN_HANDLER, TEARDOWN_BLOCK);
         if (!passiveScheduled) schedulePassiveFlush();
       } else {
-        if (STAGED_COMMIT_CAPTURE !== null && DEFERRED_LAYOUT_DRIVER.stageTeardown(cleanup, slot.phase) === true)
+        if (STAGED_COMMIT_CAPTURE !== null && DEFERRED_LAYOUT_DRIVER.stageTeardown(cleanup, slot.phase, scope) === true)
           continue;
         try {
-          runEffectCleanupCallback(cleanup, slot.phase);
+          runEffectCleanupCallback(cleanup, slot.phase, scope);
         } catch (err) {
           reportTeardownError(err);
         }
@@ -6396,21 +7219,46 @@ function unmountScope(scope, detachDom = true) {
     unmountScopeChildrenAndSlots(scope, detachDom);
   });
 }
-function runScopeCleanups(scope) {
+function runScopeCleanups(scope, retireUnowned) {
   const c = scope.cleanups;
   if (c !== null)
     for (let i = c.length - 1; i >= 0; i--) {
-      if (STAGED_COMMIT_CAPTURE !== null && DEFERRED_LAYOUT_DRIVER.stageTeardown(c[i], -1) === true)
+      if (STAGED_COMMIT_CAPTURE !== null && DEFERRED_LAYOUT_DRIVER.stageTeardown(c[i], -1, scope) === true)
         continue;
       try {
-        runEffectLifecycleCallback(c[i]);
+        runEffectLifecycleCallback(c[i], scope);
       } catch (err) {
         reportTeardownError(err);
       }
     }
+  const signalOwner = SCOPE_SIGNAL_OWNERS.get(scope);
+  if (signalOwner) {
+    if (RETAINED_SIGNAL_OWNERS?.owners.has(signalOwner)) return;
+    if (STAGED_COMMIT_CAPTURE !== null && DEFERRED_LAYOUT_DRIVER.stageAction(() => {
+      if (retireUnowned) SCOPE_SIGNAL_OWNERS.set(scope, null);
+      else SCOPE_SIGNAL_OWNERS.delete(scope);
+      retireRendererSignalOwner(signalOwner);
+    }, true))
+      return;
+    if (retireUnowned) SCOPE_SIGNAL_OWNERS.set(scope, null);
+    else SCOPE_SIGNAL_OWNERS.delete(scope);
+    retireRendererSignalOwner(signalOwner);
+  } else if (retireUnowned && signalOwner === false) {
+    if (STAGED_COMMIT_CAPTURE !== null && DEFERRED_LAYOUT_DRIVER.stageAction(() => retireUnownedSignalScope(scope), true))
+      return;
+    retireUnownedSignalScope(scope);
+  }
+}
+function retireUnownedSignalScope(scope) {
+  const owner = SCOPE_SIGNAL_OWNERS.get(scope);
+  if (owner === false) SCOPE_SIGNAL_OWNERS.set(scope, null);
+  else if (owner) {
+    SCOPE_SIGNAL_OWNERS.set(scope, null);
+    retireRendererSignalOwner(owner);
+  }
 }
-function unmountScopeChildrenAndSlots(scope, detachDom) {
-  runScopeCleanups(scope);
+function unmountScopeChildrenAndSlots(scope, detachDom, retireUnowned = true) {
+  runScopeCleanups(scope, retireUnowned);
   unmountScopeChildrenAndSlotsOnly(scope, detachDom);
 }
 function unmountScopeChildrenAndSlotsOnly(scope, detachDom) {
@@ -7726,7 +8574,7 @@ function resetHmrBlock(block) {
           const cleanup = cleanups[i];
           if (cleanup[HMR] === true) continue;
           try {
-            runEffectLifecycleCallback(cleanup);
+            runEffectLifecycleCallback(cleanup, block);
           } catch (err) {
             reportTeardownError(err);
           }
@@ -7761,7 +8609,7 @@ function resetHmrBlock(block) {
     if (--TEARDOWN_DEPTH === 0) dispatchTeardownErrors();
   }
 }
-function resetScopeChildren(scope) {
+function resetScopeChildren(scope, detachDom = true) {
   const block = scope.block;
   if (TEARDOWN_DEPTH === 0) {
     TEARDOWN_HANDLER = findTryHandler(block.parentBlock) ?? rendererRegionTryHandler(block);
@@ -7769,12 +8617,13 @@ function resetScopeChildren(scope) {
   }
   TEARDOWN_DEPTH++;
   try {
-    unmountScopeChildrenAndSlots(scope, true);
+    unmountScopeChildrenAndSlots(scope, detachDom, false);
     const start = block.startMarker;
-    removeRange(
-      start !== null ? getNextSibling(start) : getFirstChild(block.parentNode),
-      block.endMarker
-    );
+    if (detachDom)
+      removeRange(
+        start !== null ? getNextSibling(start) : getFirstChild(block.parentNode),
+        block.endMarker
+      );
     scope.children = null;
     scope.cleanups = null;
     scope._slots = null;
@@ -7806,6 +8655,19 @@ const HYDRATE_STREAM_BOUNDARY_SELECTOR = `template[${STREAM_BOUNDARY_ATTR}]`;
 const HYDRATE_STREAM_SCAN_MASK = 1 | 128;
 let hydrateStreamWaitCleanups = null;
 let preservedHydrateActivations = null;
+let preservedHydrateActivationCount = 0;
+function releasePreservedHydrateActivation(state) {
+  if (preservedHydrateActivations?.delete(state)) preservedHydrateActivationCount--;
+}
+function pendingHydrateOwner(target) {
+  let owner = null;
+  for (let block = target; block !== null; block = block.parentBlock) {
+    const state = block.slots[0];
+    if (state?.__kind === "hydrateBlockSlot" && !state.hydrated && preservedHydrateActivations?.has(state))
+      owner = state;
+  }
+  return owner;
+}
 function findSuspendedHydrateBlock(scope, thenable) {
   const own = scope.block.__thenables;
   if (own !== void 0 && own.includes(thenable)) return scope.block;
@@ -7826,7 +8688,9 @@ function preserveSuspendedHydrateActivation(state, hydration, thenable) {
     source: suspendedBlock === state.block ? null : suspendedBlock,
     cursor: hydration.node
   };
-  (preservedHydrateActivations ??= /* @__PURE__ */ new WeakMap()).set(state, activation);
+  const activations = preservedHydrateActivations ??= /* @__PURE__ */ new WeakMap();
+  if (!activations.has(state)) preservedHydrateActivationCount++;
+  activations.set(state, activation);
   const resume = () => {
     if (state.block.disposed || !state.activationRequested || state.activationGeneration !== activation.generation || preservedHydrateActivations?.get(state) !== activation)
       return;
@@ -8070,15 +8934,18 @@ function invalidateHydrateActivation(state) {
   state.replays = [];
 }
 function teardownHydrateBoundary(state) {
+  const preserved = preservedHydrateActivations?.get(state);
+  if (preserved !== void 0) {
+    if (isRecordingTransitionJournal()) journalObjectOnce(state.block);
+    state.block.mounted = false;
+  }
   if (DEFERRED_LAYOUT_DRIVER?.stageAction(() => teardownHydrateBoundary(state), true) === true)
     return;
   cleanupHydrateInstallers(state);
   cleanupHydrateStreamWait(state);
-  const preserved = preservedHydrateActivations?.get(state);
   if (preserved !== void 0) {
-    preservedHydrateActivations.delete(state);
+    releasePreservedHydrateActivation(state);
     discardOffscreenCapture(preserved.capture);
-    state.block.mounted = false;
   }
   state.prefetchAbort?.abort();
   resolveHydrateWaiters(state, "abort");
@@ -8116,7 +8983,7 @@ function hydrateStrategyInteractionEvents(strategy) {
 }
 function queueHydrateIntent(state, intent) {
   if (state.hydrated || resolveHydrateStrategy(state)._t === "never") return;
-  state.replays.push(intent);
+  if (!intent.earlyBinding) state.replays.push(intent);
   requestHydrateBoundary(state);
 }
 function handleRegisteredHydrationIntent(state, eventType, intent) {
@@ -8297,6 +9164,7 @@ function requestHydrateBoundary(state) {
 }
 function installHydrateBoundary(state) {
   if (!state.serverPreserved || state.hydrated) return () => void 0;
+  if (state.independent) return () => teardownHydrateBoundary(state);
   const strategy = resolveHydrateStrategy(state);
   if (strategy._t === "never") {
     state.strategyCleanup = null;
@@ -8354,14 +9222,14 @@ function createHydrateSlot(props, scope, boundaryId) {
       HYDRATE_WHEN_ATTR,
       hydrateStrategyType(props.when)
     );
-  let start;
-  let end;
+  if (props.__independent !== void 0)
+    (STAGED_DOM?.view(wrapper) ?? wrapper).setAttribute(HYDRATE_INDEPENDENT_ATTR, "");
+  let start = null;
+  let end = null;
   let seedRaw = null;
   let nativeSeedRaw = null;
   let idState = parentBlock.idState;
-  if (serverPreserved && hydration.isOpen(getFirstChild(wrapper))) {
-    start = getFirstChild(wrapper);
-    end = hydration.close(start);
+  if (serverPreserved) {
     const rawCount = (STAGED_DOM?.view(wrapper) ?? wrapper).getAttribute(HYDRATE_ID_COUNT_ATTR);
     const parsedCount = rawCount === null ? 0 : Number(rawCount);
     const idCount = Number.isSafeInteger(parsedCount) && parsedCount >= 0 ? parsedCount : 0;
@@ -8371,11 +9239,17 @@ function createHydrateSlot(props, scope, boundaryId) {
     idState = {
       prefix: rootIds.prefix,
       next: childStart,
+      signalState: rootIds.signalState,
       limit: childStart + idCount,
       overflow: rootIds,
       renderOwner: rootIds.renderOwner
     };
     (STAGED_DOM?.view(wrapper) ?? wrapper).removeAttribute(HYDRATE_ID_COUNT_ATTR);
+  }
+  if (props.__independent !== void 0) {
+  } else if (serverPreserved && hydration.isOpen(getFirstChild(wrapper))) {
+    start = getFirstChild(wrapper);
+    end = hydration.close(start);
     const seed = findHydrateSeedSidecar(wrapper);
     if (seed !== null) {
       seedRaw = (STAGED_DOM?.view(seed) ?? seed).textContent || "[]";
@@ -8442,17 +9316,19 @@ function createHydrateSlot(props, scope, boundaryId) {
     didNotify: false,
     hasError: false,
     error: void 0,
-    replays: []
+    replays: [],
+    independent: props.__independent !== void 0
   };
   if (nativeSeedRaw !== null) state.nativeSeedRaw = nativeSeedRaw;
   scope.slots[0] = state;
   registerSlot(scope, state);
-  registerHydrationIntentBoundary(wrapper, intentBoundary);
+  if (!state.independent) registerHydrationIntentBoundary(wrapper, intentBoundary);
   block.body = hydrateBoundaryBody(state);
   const initialStrategy = resolveHydrateStrategy(state);
-  const pendingIntents = takePendingHydrationIntents(wrapper);
-  if (serverPreserved && pendingIntents !== void 0 && initialStrategy._t !== "never") {
-    state.replays.push(...pendingIntents);
+  const pendingIntents = state.independent ? void 0 : takePendingHydrationIntents(wrapper);
+  if (state.independent) {
+  } else if (serverPreserved && pendingIntents !== void 0 && initialStrategy._t !== "never") {
+    state.replays.push(...pendingIntents.filter((intent) => !intent.earlyBinding));
     requestHydrateBoundary(state);
   } else if (serverPreserved) {
     const shouldDefer = initialStrategy._d ? initialStrategy._d() : initialStrategy._t !== "load";
@@ -8461,9 +9337,14 @@ function createHydrateSlot(props, scope, boundaryId) {
   return state;
 }
 function activateHydrateBoundary(state) {
+  if (state.start === null || state.end === null) return;
   const block = state.block;
+  let preserved = preservedHydrateActivations?.get(state);
+  if (preserved !== void 0 && !currentPresentations(preserved.capture)) {
+    discardHydratePresentation(state, preserved.capture);
+    preserved = void 0;
+  }
   const activationSlot = block.slots[0];
-  const preserved = preservedHydrateActivations?.get(state);
   if (!state.serverPreserved || activationSlot?.__kind === "trySlotSlot" && preserved === void 0) {
     renderBlock(block);
     return;
@@ -8476,6 +9357,13 @@ function activateHydrateBoundary(state) {
   const previousHydration = currentHydration;
   const previousCapture = WIP_CAPTURE;
   const capture = preserved?.capture ?? createOffscreenCapture();
+  if (block.idState.renderOwner?.bindingLeases?.size) {
+    hydration.retryPresentation = () => {
+      if (block.disposed) return;
+      discardHydratePresentation(state, capture);
+      scheduleRender(state.parentBlock);
+    };
+  }
   currentHydration = hydration;
   WIP_CAPTURE = capture;
   const previousNative = setNativeAdoptionResolver(hydration.nativeAdoption?.resolve ?? null);
@@ -8515,10 +9403,19 @@ function activateHydrateBoundary(state) {
       completed = true;
     }
   } catch (error) {
-    preservedHydrateActivations?.delete(state);
+    releasePreservedHydrateActivation(state);
     discardOffscreenCapture(capture);
     state.block.mounted = false;
-    if (error instanceof NativeAdoptionMiss) nativeRecovery = error;
+    if (error instanceof PresentationAdoptionMiss) {
+      discardHydratePresentation(state, capture);
+      if (error.retry && error.lease?.active()) {
+        retryPresentationMiss(error, () => {
+          if (!block.disposed) scheduleRender(state.parentBlock);
+        });
+        return;
+      }
+      throw error;
+    } else if (error instanceof NativeAdoptionMiss) nativeRecovery = error;
     else throw error;
   } finally {
     setNativeAdoptionResolver(previousNative);
@@ -8558,16 +9455,36 @@ function activateHydrateBoundary(state) {
     return;
   }
   if (completed) {
-    preservedHydrateActivations?.delete(state);
+    releasePreservedHydrateActivation(state);
     spliceOffscreenCapture(capture);
   }
-  if (completed && hydration.hasAdjacentRangePair) hydration.coalesce();
+  if (completed && hydration.hasAdjacentRangePair && !hydration.presentation) hydration.coalesce();
 }
-function cloneHydrationReplayEvent(event, target) {
-  const realm = target.ownerDocument.defaultView ?? globalThis;
-  if (realm.PointerEvent !== void 0 && event instanceof realm.PointerEvent) {
-    return new realm.PointerEvent(event.type, event);
-  }
+function discardHydratePresentation(state, capture) {
+  const refs = [];
+  collectVisibleSubtreeRefs(state.block, refs);
+  discardOffscreenCapture(capture);
+  releasePreservedHydrateActivation(state);
+  for (const frame of capture.presentations ?? [])
+    if (PRESENTATION_PREPARATIONS.get(frame.lease) === frame)
+      PRESENTATION_PREPARATIONS.delete(frame.lease);
+  const previousRollback = ROOT_RENDER_ROLLBACK;
+  ROOT_RENDER_ROLLBACK = true;
+  try {
+    withRefDetachSuppression(refs, () => resetScopeChildren(state.block, false));
+  } finally {
+    ROOT_RENDER_ROLLBACK = previousRollback;
+  }
+  state.block.mounted = false;
+  state.block.deoptNode = null;
+  state.hydrated = false;
+  state.serverActivationStarted = false;
+}
+function cloneHydrationReplayEvent(event, target) {
+  const realm = target.ownerDocument.defaultView ?? globalThis;
+  if (realm.PointerEvent !== void 0 && event instanceof realm.PointerEvent) {
+    return new realm.PointerEvent(event.type, event);
+  }
   if (realm.KeyboardEvent !== void 0 && event instanceof realm.KeyboardEvent) {
     return new realm.KeyboardEvent(event.type, event);
   }
@@ -8673,8 +9590,11 @@ function initializeHydrateComponent() {
       if (state === void 0) {
         state = createHydrateSlot(props, scope, boundaryId);
       } else {
+        if (state.independent !== (props.__independent !== void 0)) {
+          throw new Error(formatClientError(66));
+        }
         state.props = props;
-        if (!state.hydrated) {
+        if (!state.independent && !state.hydrated) {
           const strategy = resolveHydrateStrategy(state);
           if (strategy._t === "never") {
             cleanupHydrateStrategy(state);
@@ -8684,6 +9604,10 @@ function initializeHydrateComponent() {
           }
         }
       }
+      if (state.independent) {
+        useEffect(() => installHydrateBoundary(state), [state], HYDRATE_SETUP_SLOT);
+        return;
+      }
       if (state.hasError) throw state.error;
       if (!state.hydrated && state.activationReady && (!state.serverPreserved || !state.serverActivationStarted)) {
         if (state.serverPreserved) state.serverActivationStarted = true;
@@ -10161,6 +11085,8 @@ class HydrationCapability {
   /** Skip component-frame adoption until the declared container owner. */
   passthroughRanges = false;
   nativeAdoption;
+  retryPresentation;
+  presentation;
   isActive() {
     return this.depth === 0 && !this.abandoned;
   }
@@ -10371,6 +11297,7 @@ class HydrationCapability {
   }
   /** Give up root adoption after an unframed return/fragment mismatch. */
   abandonRoot(expected, actual, loc) {
+    if (PRESENTATION_HYDRATION?.revision !== void 0) presentationMiss();
     noteRecoverableHydrationError(() => new Error(formatClientError(52)));
     if (loc) warnHydrationStructuralMismatch(loc, expected, actual);
     let node = this.node;
@@ -10417,11 +11344,13 @@ class HydrationCapability {
       this.claimRootRemainder(framedRemainder === void 0 ? remainder : framedRemainder);
     }
     if (cursor === null) {
+      if (PRESENTATION_HYDRATION?.revision !== void 0) presentationMiss();
       if (claimsRoot) this.claimRootRemainder(null);
       if (template2 === null) template2 = resolveLazyTemplate(lazy2);
       return this.freshClone(template2);
     }
     if (!isFragment && (template2 !== null ? !hydrationNodeMatches(cursor, template2, partialStyles) : !lazyRootMatches(cursor, lazy2))) {
+      if (PRESENTATION_HYDRATION?.revision !== void 0) presentationMiss();
       noteRecoverableHydrationError(() => new Error(formatClientError(51)));
       if (template2 === null) template2 = resolveLazyTemplate(lazy2);
       if (process.env.NODE_ENV !== "production" && loc)
@@ -10631,6 +11560,10 @@ class HydrationCapability {
     return true;
   }
   coalesce() {
+    const leases = this.rootBlock.idState.renderOwner?.bindingLeases;
+    if (leases !== void 0) {
+      for (const lease of leases) if (lease.revision !== void 0 && lease.active()) return;
+    }
     coalesceHydratedRanges(this.rootBlock, this.liteRanges);
   }
 }
@@ -10744,6 +11677,7 @@ function clone(node, loc, partialStyles) {
 }
 function drainFrag(root, parent, anchor) {
   if (activeHydration() !== null && root.__oct_vfrag === true) return;
+  if (PRESENTATION_HYDRATION?.revision !== void 0) presentationMiss(false);
   if (root.nodeType === 11) {
     (STAGED_DOM?.view(parent) ?? parent).insertBefore(root, anchor);
     return;
@@ -10854,10 +11788,423 @@ function htextSwap(posNode, value) {
   (STAGED_DOM?.view(parent) ?? parent).replaceChild(t, posNode);
   return t;
 }
+function bindingText(posNode, value, marker) {
+  const text = coerceText(value);
+  const hydration = activeHydration();
+  const frame = PRESENTATION_HYDRATION;
+  if (frame?.revision !== void 0) {
+    const range = presentationRange(frame, posNode, marker, "text");
+    const existing = getNextSibling(posNode);
+    if (existing === range.end) {
+      const node2 = document.createTextNode(text);
+      preparePresentationOperation(
+        frame,
+        posNode,
+        "text",
+        () => range.end.parentNode.insertBefore(node2, range.end)
+      );
+      return node2;
+    }
+    if (existing?.nodeType !== 3 || getNextSibling(existing) !== range.end) presentationMiss();
+    preparePresentationOperation(frame, existing, "text", () => {
+      if (existing.nodeValue !== text) existing.nodeValue = text;
+    });
+    return existing;
+  }
+  if (hydration !== null && isBlockOpen(posNode)) {
+    const close2 = hydration.close(posNode);
+    const existing = getNextSibling(posNode);
+    if (existing !== close2 && existing?.nodeType === 3 && getNextSibling(existing) === close2) {
+      if ((STAGED_DOM?.view(existing) ?? existing).nodeValue !== text)
+        (STAGED_DOM?.view(existing) ?? existing).nodeValue = text;
+      return existing;
+    }
+    if (existing !== close2) throw new TypeError(formatClientError(72));
+    const node2 = (STAGED_DOM?.view(document) ?? document).createTextNode(text);
+    domNode((STAGED_DOM?.view(close2) ?? close2).parentNode).insertBefore(node2, close2);
+    return node2;
+  }
+  const parent = domNode(posNode).parentNode;
+  const close = (STAGED_DOM?.view(document) ?? document).createComment(HYDRATION_END);
+  (STAGED_DOM?.view(posNode) ?? posNode).data = marker;
+  (STAGED_DOM?.view(parent) ?? parent).insertBefore(close, getNextSibling(posNode));
+  const node = (STAGED_DOM?.view(document) ?? document).createTextNode(text);
+  (STAGED_DOM?.view(parent) ?? parent).insertBefore(node, close);
+  return node;
+}
+const BINDING_VIEW_ROOT = /* @__PURE__ */ Symbol.for("octane.binding.view-root");
+let PRESENTATION_HYDRATION = null;
+const PRESENTATION_PREPARATIONS = /* @__PURE__ */ new WeakMap();
+class PresentationAdoptionMiss extends Error {
+  constructor(lease, retry, revision = PRESENTATION_HYDRATION?.revision) {
+    super(formatClientError(75));
+    this.lease = lease;
+    this.retry = retry;
+    this.revision = revision;
+  }
+  lease;
+  retry;
+  revision;
+}
+function retryPresentationMiss(error, retry) {
+  const revision = error.lease?.revision?.();
+  if (revision !== void 0 && revision >= 0 && revision !== error.revision) queueMicrotask(retry);
+  else error.lease?.afterPublication?.(retry);
+}
+function isAdoptionControl(error) {
+  return error instanceof NativeAdoptionMiss || error instanceof PresentationAdoptionMiss;
+}
+function presentationFailure(error) {
+  const frame = PRESENTATION_HYDRATION;
+  if (frame?.revision !== void 0 && !isSuspenseException(error) && !isAdoptionControl(error)) {
+    const failure = new PresentationAdoptionMiss(frame.lease, false);
+    failure.failure = error;
+    throw failure;
+  }
+  throw error;
+}
+function presentationMiss(retry = true) {
+  throw new PresentationAdoptionMiss(PRESENTATION_HYDRATION?.lease, retry);
+}
+function currentPresentation(frame) {
+  if (frame.revision === void 0) return true;
+  const lease = frame.lease;
+  return lease.active() && lease.valid?.() !== false && lease.revision?.() === frame.revision && lease.root.parentNode !== null && lease.end?.parentNode === lease.root.parentNode && [...frame.witnesses.values()].every(
+    (witness) => witness === null || validateNativeReadWitness(witness)
+  );
+}
+function currentPresentations(capture) {
+  return capture.presentations?.every((frame) => frame.current(frame)) !== false;
+}
+function retryPresentations(capture) {
+  const retries = /* @__PURE__ */ new Set();
+  for (const frame of capture.presentations ?? []) {
+    PRESENTATION_PREPARATIONS.delete(frame.lease);
+    if (frame.hydration?.retryPresentation) retries.add(frame.hydration.retryPresentation);
+  }
+  for (const retry of retries) retry();
+}
+function preparePresentationOperation(frame, target, key, write) {
+  let operations = frame.writes.get(target);
+  if (operations === void 0) frame.writes.set(target, operations = /* @__PURE__ */ new Map());
+  operations.set(key, write);
+}
+function matchesClosedPresentationKeys(value, keys) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") return false;
+  let index = 0;
+  for (const key of Reflect.ownKeys(value)) {
+    if (typeof key !== "string") return false;
+    if (!Object.prototype.propertyIsEnumerable.call(value, key)) continue;
+    if (keys[index++] !== key) return false;
+  }
+  return index === keys.length;
+}
+function hasClosedPresentationView(lease, scope, id) {
+  try {
+    const root = scope.block.startMarker ?? activeHydration()?.node;
+    const proof = root == null ? void 0 : lease.view?.(root);
+    return proof?.id === id && matchesClosedPresentationKeys(scope.block.props, proof.closedProps);
+  } catch {
+    return false;
+  }
+}
+function beginPresentationHydration(scope, id, supported = false, structural = false, conditionalRest = false) {
+  const owner = scope.block.idState.renderOwner;
+  if (PRESENTATION_HYDRATION !== null && PRESENTATION_HYDRATION.scope.block.idState.renderOwner === owner) {
+    if (conditionalRest) {
+      if (!supported || !structural || !hasClosedPresentationView(PRESENTATION_HYDRATION.lease, scope, id))
+        presentationMiss(false);
+    } else if (!supported) presentationMiss(false);
+    return null;
+  }
+  if (owner?.bindingLeases === void 0 || WIP_CAPTURE === null) return null;
+  const hydration = activeHydration();
+  const lease = [...owner.bindingLeases].find(
+    (candidate) => candidate.id === id && (candidate.root === scope.block.startMarker || candidate.root === hydration?.node || candidate.root.nodeType === 8 && candidate.root.nextSibling === hydration?.node)
+  );
+  if (lease === void 0) return null;
+  if (conditionalRest ? !supported || !structural || !hasClosedPresentationView(lease, scope, id) : !supported)
+    throw new PresentationAdoptionMiss(lease, false);
+  const revision = lease.revision?.();
+  if (revision !== void 0 && revision >= 0 && lease.valid?.() === false)
+    throw new PresentationAdoptionMiss(lease, false);
+  if (revision !== void 0 && (!structural || revision < 0))
+    throw new PresentationAdoptionMiss(lease, revision < 0, revision);
+  const pending = PRESENTATION_PREPARATIONS.get(lease);
+  const frame = {
+    previous: PRESENTATION_HYDRATION,
+    scope,
+    // A suspended component's cache can skip an unchanged writer on retry.
+    // Carry that same scope's prepared operations, replacing by native channel.
+    writes: pending?.scope === scope ? new Map([...pending.writes].map(([node, writes]) => [node, new Map(writes)])) : /* @__PURE__ */ new Map(),
+    native: setNativeAdoptionResolver(null),
+    readToken: beginNativeReadScope(scope),
+    witnessToken: beginNativeReadWitness(),
+    witnesses: pending?.scope === scope ? new Map(pending.witnesses) : /* @__PURE__ */ new Map(),
+    completed: false,
+    lease,
+    ...revision === void 0 ? {} : { revision, current: currentPresentation },
+    hydration
+  };
+  PRESENTATION_HYDRATION = frame;
+  if (revision !== void 0 && hydration !== null) {
+    hydration.presentation = true;
+    for (let block = scope.block; block !== null; block = block.parentBlock) {
+      preserveRootCreatedDom(block);
+      if (block === hydration.rootBlock) break;
+    }
+  }
+  PRESENTATION_PREPARATIONS.set(lease, frame);
+  if (revision !== void 0) (WIP_CAPTURE.presentations ??= []).push(frame);
+  (WIP_CAPTURE.renderCleanups ??= []).push((discarded) => {
+    if (discarded || !frame.completed || owner.disposed || scope.block.disposed || PRESENTATION_PREPARATIONS.get(lease) !== frame)
+      return;
+    if (!currentPresentation(frame)) {
+      frame.hydration?.retryPresentation?.();
+      return;
+    }
+    PRESENTATION_PREPARATIONS.delete(lease);
+    owner.bindingLeases.delete(lease);
+    releaseBindingHandoff(lease);
+    let published = false;
+    try {
+      lease.retire(() => {
+        for (const writes of frame.writes.values()) for (const write of writes.values()) write();
+        published = true;
+      });
+    } catch (error) {
+      if (!published) throw error;
+      reportRendererOwnerError(scope, error);
+    } finally {
+      frame.writes.clear();
+      if (published && !owner.disposed && owner.current !== null && [...frame.witnesses.values()].some(
+        (witness) => witness !== null && !validateNativeReadWitness(witness)
+      )) {
+        owner.generation++;
+        invalidateRender(scope.block);
+        scheduleRender(owner.current);
+      }
+      frame.witnesses.clear();
+    }
+  });
+  return frame;
+}
+function endPresentationHydration(frame, completed = true) {
+  if (frame === null) return;
+  frame.completed = completed;
+  frame.witnesses.set(frame.scope, finishNativeReadWitness(frame.witnessToken, completed));
+  endNativeReadScope(frame.readToken, completed);
+  setNativeAdoptionResolver(frame.native);
+  PRESENTATION_HYDRATION = frame.previous;
+}
+function preparedPresentationAttribute(el, name, value, kind) {
+  if (kind === "class") return value == null || value === false ? null : normalizeClass(value);
+  if (kind === "booleanAttr")
+    return !!value && typeof value !== "function" && typeof value !== "symbol";
+  const result = coerceAttrValue(el, name, value);
+  return result === "" && BOOLEAN_ATTR_PROPS.has(name.toLowerCase()) ? true : result;
+}
+function preparePresentationSignalAttribute(args, frame) {
+  const [scope, previous, element, name, value, site, attributeKind = "attr"] = args;
+  return runWithBlockSignalOwner(scope, () => {
+    const handle = isSignalHandle(value) ? value : null;
+    const current = handle === null ? value : handle.get();
+    const prepared = preparedPresentationAttribute(element, name, current, attributeKind);
+    if (handle === null) {
+      preparePresentationOperation(
+        frame,
+        element,
+        name,
+        () => writeDirectSignalScalar(element, prepared, "attribute", previous, name, attributeKind)
+      );
+      return value;
+    }
+    const prior = previous;
+    const reusable = prior?.[DIRECT_SIGNAL_BINDING] === true && !prior.disposed && prior.unsubscribe === void 0 && prior.handle === handle && prior.target === element && prior.site === site && prior.name === name && prior.attributeKind === attributeKind;
+    const binding = reusable ? prior : {
+      [DIRECT_SIGNAL_BINDING]: true,
+      scope,
+      target: element,
+      kind: "attribute",
+      site,
+      name,
+      attributeKind,
+      handle,
+      value: current,
+      disposed: false
+    };
+    if (!reusable) registerHookCleanup(scope, () => disposeDirectSignalBinding(binding));
+    preparePresentationOperation(frame, element, name, () => {
+      if (binding.disposed) return;
+      writeDirectSignalScalar(element, prepared, "attribute", previous, name, attributeKind);
+      binding.value = current;
+      runWithBlockSignalOwner(scope, () => activateDirectSignalBinding(binding, void 0));
+    });
+    return binding;
+  });
+}
+function presentationHostWrite(writer, ...args) {
+  const frame = PRESENTATION_HYDRATION;
+  if (frame === null) return writer(...args);
+  const [scope, previous, element, sources, site, hasNestedChildren, readStyle, proofs] = args;
+  if (frame.revision === void 0 || !Array.isArray(proofs) || proofs.length === 0)
+    presentationMiss(false);
+  const proven = /* @__PURE__ */ new Set();
+  for (const proof of proofs) {
+    const receipt = frame.lease.rest?.(element, proof.site);
+    const row = sources[proof.source];
+    if (receipt === void 0 || receipt.id !== proof.id || receipt.node !== proof.node || receipt.spread !== proof.spread || row?.[0] !== true || proven.has(proof.source) || !matchesClosedPresentationKeys(row[1], receipt.keys))
+      presentationMiss(false);
+    proven.add(proof.source);
+  }
+  for (let index = 0; index < sources.length; index++)
+    if (sources[index][0] && !proven.has(index)) presentationMiss(false);
+  const prepared = prepareSignalHostPropSources(
+    scope,
+    previous,
+    element,
+    sources,
+    site,
+    hasNestedChildren,
+    readStyle
+  );
+  preparePresentationOperation(frame, element, "hostProps", prepared.publish);
+  return prepared.binding;
+}
+function presentationWrite(writer, kind, ...args) {
+  const frame = PRESENTATION_HYDRATION;
+  if (frame === null) return writer(...args);
+  if (kind === "markDangerouslySetInnerHTMLChildren") {
+    const element2 = args[0];
+    if (!frame.writes.get(element2)?.has("hostProps") || element2[DANGER_HTML_ACTIVE] === true)
+      presentationMiss(false);
+    preparePresentationOperation(frame, element2, "hostChildren", () => writer(element2));
+    return void 0;
+  }
+  if (kind === "bindSignalText") {
+    const value = args[3];
+    if (value !== null && (typeof value === "object" || typeof value === "function") || typeof args[7] !== "string")
+      presentationMiss(false);
+    return bindingText(args[2], value, args[7]);
+  }
+  if (kind === "setText") {
+    const text = coerceText(args[1]);
+    preparePresentationOperation(frame, args[0], "text", () => writer(args[0], text));
+    return void 0;
+  }
+  if (kind === "bindSignalAttribute") return preparePresentationSignalAttribute(args, frame);
+  if (kind === "nativeStyleBinding" || kind === "nativeProjectionBinding") {
+    const [owner, slot, el] = args;
+    const style = kind === "nativeStyleBinding";
+    nativePresentationBinding(
+      owner,
+      slot,
+      el,
+      style ? preparedNativeStyleBody : preparedNativeProjectionBody,
+      style ? { el, value: args[3], frame } : { el, compute: args[3], fields: args[4], frame }
+    );
+    return void 0;
+  }
+  const prepared = args.slice();
+  let result;
+  if (kind === "setEventHandler") {
+    preparePresentationOperation(frame, prepared[0], "event:" + prepared[1], () => {
+      writer(...prepared);
+      if (SIGNAL_BINDINGS_ENABLED || signalDocumentEnabled)
+        (SIGNAL_EVENT_OWNERS ??= /* @__PURE__ */ new WeakMap()).set(prepared[0], frame.scope);
+    });
+    return void 0;
+  }
+  if (kind === "setStyle") {
+    prepared[1] = __normalizeBindingStyle(args[1]);
+    prepared[2] = "";
+  } else if (kind === "setStyleProperty") {
+    prepared[2] = args[2] == null || typeof args[2] === "boolean" ? null : cssStyleValue(args[1], args[2]);
+  } else if (kind === "setStyleProperties") {
+    prepared[1] = args[1].map(
+      (value, i) => i % 2 === 0 || value == null || typeof value === "boolean" ? value : cssStyleValue(args[1][i - 1], value)
+    );
+  } else if (kind === "setBindingClass" || kind === "setBindingClassIfChanged") {
+    const index = kind.endsWith("IfChanged") ? 0 : 2;
+    const value = args[index];
+    prepared[index] = [normalizeClass(value[0]), value[1].map(normalizeClass)];
+    result = value;
+  } else {
+    const changed2 = kind.endsWith("IfChanged") || kind.startsWith("updateFresh");
+    const valueIndex = changed2 ? 0 : kind === "setClassName" || kind === "setClassAttr" ? 1 : 2;
+    const element2 = args[changed2 ? 2 : 0];
+    const className = kind.includes("Class");
+    const name = className ? "class" : args[changed2 ? 3 : 1];
+    const attributeKind = className ? "class" : kind.includes("Boolean") ? "booleanAttr" : "attr";
+    prepared[valueIndex] = preparedPresentationAttribute(
+      element2,
+      name,
+      args[valueIndex],
+      attributeKind
+    );
+    result = kind.startsWith("updateFresh") ? prepared[valueIndex] : args[valueIndex];
+  }
+  const changed = kind.endsWith("IfChanged") || kind.startsWith("updateFresh");
+  const element = args[changed ? 2 : 0];
+  const key = kind.includes("Class") ? "class" : kind.startsWith("setStyle") ? kind === "setStyleProperty" ? "style:" + args[1] : "style" : args[changed ? 3 : 1];
+  preparePresentationOperation(frame, element, key, () => {
+    writer(...prepared);
+  });
+  return result;
+}
+function bindPresentationView(view, id) {
+  view[BINDING_VIEW_ROOT] = "[b;" + id + ";root";
+  return markComponentFlags(view, COMPONENT_FLAG_BOUNDARY, view.name);
+}
+const BINDING_CHILDREN_SITE = /* @__PURE__ */ Symbol.for("octane.binding.children-site");
+function markBindingChildren(body, site) {
+  body[BINDING_CHILDREN_SITE] = site;
+  return body;
+}
+function presentationRange(frame, start, marker, kind) {
+  const range = start === null ? void 0 : frame.lease.ranges?.().get(start);
+  if (frame.lease.revision?.() !== frame.revision || start?.nodeType !== 8 || start.data !== marker || range?.kind !== kind || range.end.parentNode !== start.parentNode || activeHydration()?.close(start) !== range.end)
+    presentationMiss();
+  return range;
+}
+function presentationStructure(writer, kind, marker, ...args) {
+  const frame = PRESENTATION_HYDRATION;
+  if (frame?.revision === void 0) return writer(...args);
+  const hydration = activeHydration();
+  if (hydration === null) presentationMiss(false);
+  const anchorIndex = kind === "if" ? 6 : 5;
+  const start = hydration.resolveOpen(args[anchorIndex] ?? null, args[2]);
+  if (kind === "if") {
+    const arm = args[3] ? args[4] === null ? -1 : 0 : args[5] === null ? -1 : 1;
+    const range2 = presentationRange(frame, start, marker + arm, kind);
+    if (range2.arm !== arm) presentationMiss();
+    writer(...args);
+    return;
+  }
+  const range = presentationRange(frame, start, marker, kind);
+  const expected = args[3][BINDING_VIEW_ROOT];
+  if (expected !== "[b;" + range.view + ";root") presentationMiss(false);
+  writer(...args);
+}
+function setBindingClass(element, receipt, values) {
+  const snapshot = [normalizeClass(values[0]), values[1].map(normalizeClass)];
+  const classes = [snapshot[0], ...snapshot[1]].filter(Boolean).join(" ");
+  if ((STAGED_DOM?.view(element) ?? element).getAttribute("class") !== classes)
+    setClassAttr(element, classes);
+  const serialized = JSON.stringify(snapshot);
+  if ((STAGED_DOM?.view(element) ?? element).getAttribute(receipt) !== serialized)
+    setStringData(element, receipt, serialized);
+}
+function setBindingClassIfChanged(value, previous, element, receipt) {
+  if (value !== previous) setBindingClass(element, receipt, value);
+  return value;
+}
 function hydrationMarkerMultiplicity(data, open) {
   const marker = open ? HYDRATION_START : HYDRATION_END;
   if (data === marker) return 1;
   if (open && (data === HYDRATION_FOR_EMPTY || data === HYDRATION_FOR_ITEMS)) return 1;
+  if (open && (data.startsWith("[b;") || data.startsWith("[f")) && isBindingOpenComment(data))
+    return 1;
   if (data.length < 2 || data.charCodeAt(0) !== marker.charCodeAt(0)) return 0;
   const first = data.charCodeAt(1);
   if (first < 49 || first > 57) return 0;
@@ -10916,7 +12263,9 @@ function findMatchingClose(open, matches) {
 function ssrForMarkerState(node) {
   if (node.nodeType !== 8) return -1;
   const data = (STAGED_DOM?.view(node) ?? node).data;
-  return data === HYDRATION_FOR_EMPTY ? 0 : data === HYDRATION_FOR_ITEMS ? 1 : -1;
+  if (data === HYDRATION_FOR_EMPTY) return 0;
+  if (data === HYDRATION_FOR_ITEMS) return 1;
+  return isBindingOpenComment(data) && data.startsWith("[f") ? data.charCodeAt(2) === 48 ? 0 : 1 : -1;
 }
 function child(node) {
   if (currentHydration !== null) return (STAGED_DOM?.view(node) ?? node).firstChild;
@@ -10949,6 +12298,330 @@ function setText(node, value) {
   if (hiddenTextWriter !== null && hiddenTextWriter(node, text)) return;
   (STAGED_DOM?.view(node) ?? node).nodeValue = text;
 }
+const DIRECT_SIGNAL_BINDING = /* @__PURE__ */ Symbol("octane.direct-signal-binding");
+function isSignalHandle(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && value[SIGNAL_HANDLE] === true;
+}
+function readSignalBinding(handle) {
+  return handle[SIGNAL_BINDING_READ]();
+}
+function nativeTransitionBindingNotify(binding, notify) {
+  return Object.assign(notify, {
+    [NATIVE_TRANSITION_CONSUMER]: {
+      active: () => !binding.disposed && !binding.scope.block.disposed,
+      prepare: () => prepareNativeTransitionBlock(binding.scope.block)
+    }
+  });
+}
+function isWritableSignal(value) {
+  return isSignalHandle(value) && value.kind === "signal" && typeof value.set === "function";
+}
+function disposeDirectSignalBinding(binding) {
+  if (binding.disposed) return;
+  if (DEFERRED_LAYOUT_DRIVER?.stageAction(() => disposeDirectSignalBinding(binding)) === true)
+    return;
+  binding.disposed = true;
+  binding.unsubscribe?.();
+  retireNativeTransitionBlock(binding.scope.block);
+  binding.controlWriterCleanup?.();
+  if (binding.input !== void 0) {
+    domNode(binding.target).removeEventListener("input", binding.input);
+  }
+}
+function directSignalControlValue(binding, snapshot) {
+  if (binding.kind === "checked") return snapshot.checked ?? false;
+  return snapshot.selectedValues ?? snapshot.value;
+}
+function validateDirectSignalControl(element, site) {
+  const actual = (STAGED_DOM?.view(element) ?? element).getAttribute(HYDRATE_INPUT_ATTR);
+  if (actual === null && activeHydration() === null) {
+    (STAGED_DOM?.view(element) ?? element).setAttribute(HYDRATE_INPUT_ATTR, site);
+    return;
+  }
+  if (actual !== site) {
+    throw new Error(formatClientError(67, site));
+  }
+}
+function writeDirectSignalBinding(binding, value) {
+  if (TRANSITION_JOURNAL !== null) journalObjectOnce(binding);
+  if (binding.kind === "text" || binding.kind === "textOnlyChild") {
+    if (binding.text === void 0) {
+      binding.text = binding.kind === "textOnlyChild" ? htext(binding.target, value) : htextSwap(binding.target, value);
+    } else {
+      setText(binding.text, value);
+    }
+  } else if (binding.kind === "attribute") {
+    const element = binding.target;
+    switch (binding.attributeKind) {
+      case "class":
+        if (element.namespaceURI === HTML_NS) setClassName(element, value);
+        else setClassAttr(element, value);
+        break;
+      case "booleanAttr":
+        setBooleanAttribute(element, binding.name, value);
+        break;
+      case "ariaAttr":
+        setAriaAttribute(element, binding.name, value);
+        break;
+      case "stringData":
+        setStringData(element, binding.name, value);
+        break;
+      default:
+        setAttribute(element, binding.name, value);
+    }
+  } else if (binding.kind === "value") {
+    const element = binding.target;
+    if (element.localName === "select") setSelectValue(element, value);
+    else setValue(element, value);
+  } else {
+    setChecked(binding.target, value);
+  }
+  binding.value = value;
+}
+function writeDirectSignalScalar(target, value, kind, previous, name, attributeKind) {
+  if (kind === "text" || kind === "textOnlyChild") {
+    if (previous instanceof Text) {
+      setText(previous, value);
+      return previous;
+    }
+    return kind === "textOnlyChild" ? htext(target, value) : htextSwap(target, value);
+  }
+  if (kind === "attribute") {
+    const element = target;
+    switch (attributeKind) {
+      case "class":
+        if (element.namespaceURI === HTML_NS) setClassName(element, value);
+        else setClassAttr(element, value);
+        break;
+      case "booleanAttr":
+        setBooleanAttribute(element, name, value);
+        break;
+      case "ariaAttr":
+        setAriaAttribute(element, name, value);
+        break;
+      case "stringData":
+        setStringData(element, name, value);
+        break;
+      default:
+        setAttribute(element, name, value);
+    }
+  } else if (kind === "value") {
+    const element = target;
+    if (element.localName === "select") setSelectValue(element, value);
+    else setValue(element, value);
+  } else {
+    setChecked(target, value);
+  }
+  return value;
+}
+function updateDirectSignalBinding(binding) {
+  if (binding.disposed || binding.pendingControl || binding.handle === null || binding.scope.block.disposed)
+    return;
+  try {
+    runWithBlockSignalOwner(binding.scope, () => {
+      const value = readSignalBinding(binding.handle);
+      if (!Object.is(binding.value, value)) writeDirectSignalBinding(binding, value);
+      if (process.env.NODE_ENV !== "production" && STAGED_DOM === null && binding.target.nodeType === 1)
+        drainDevFormDiagnostics(binding.target);
+    });
+  } catch {
+    scheduleRender(binding.scope.block);
+  }
+}
+function installDirectSignalControl(binding) {
+  if (!isWritableSignal(binding.handle)) return;
+  const element = binding.target;
+  validateDirectSignalControl(element, binding.site);
+  const handle = binding.handle;
+  const input = () => {
+    if (binding.disposed || binding.pendingControl) return;
+    const snapshot = snapshotHydrationControl(element);
+    if (snapshot === null) return;
+    withoutSignalCandidate(
+      () => runWithBlockSignalOwner(
+        binding.scope,
+        () => handle.set(directSignalControlValue(binding, snapshot))
+      )
+    );
+  };
+  binding.input = input;
+  (STAGED_DOM?.view(element) ?? element).addEventListener("input", input);
+  binding.controlWriterCleanup = registerHydrationControlSignalWriter(
+    element,
+    binding.kind === "checked" ? "checked" : "value",
+    (value) => withoutSignalCandidate(
+      () => runWithBlockSignalOwner(binding.scope, () => {
+        if (!binding.disposed && !binding.pendingControl && isWritableSignal(binding.handle))
+          binding.handle.set(value);
+      })
+    )
+  );
+}
+function queueDirectSignalControlAdoption(binding) {
+  enqueueEffectEventCommitAction(() => {
+    if (binding.disposed || binding.scope.block.disposed || !binding.pendingControl) return;
+    withoutSignalCandidate(
+      () => runWithBlockSignalOwner(binding.scope, () => {
+        const element = binding.target;
+        const snapshot = snapshotHydrationControl(element);
+        if (snapshot.editRevision > 0 && isWritableSignal(binding.handle)) {
+          binding.handle.set(directSignalControlValue(binding, snapshot));
+        }
+        if (binding.disposed || binding.scope.block.disposed) return;
+        if (!consumeHydrationControl(element, snapshot.revision)) {
+          queueDirectSignalControlAdoption(binding);
+          return;
+        }
+        binding.pendingControl = false;
+        writeDirectSignalBinding(binding, readSignalBinding(binding.handle));
+      })
+    );
+  });
+}
+function activateDirectSignalBinding(binding, revision) {
+  if (binding.disposed) return;
+  if (binding.handle !== null)
+    binding.unsubscribe = binding.handle[SIGNAL_BINDING_SUBSCRIBE](
+      nativeTransitionBindingNotify(binding, () => updateDirectSignalBinding(binding))
+    );
+  if (revision !== void 0) {
+    installDirectSignalControl(binding);
+    if (!binding.pendingControl) consumeHydrationControl(binding.target, revision);
+  }
+}
+function createDirectSignalBinding(scope, target, value, site, kind, name, attributeKind, text) {
+  const handle = isSignalHandle(value) ? value : null;
+  const binding = {
+    [DIRECT_SIGNAL_BINDING]: true,
+    scope,
+    kind,
+    target,
+    site,
+    name,
+    attributeKind,
+    handle,
+    value: scope,
+    disposed: false
+  };
+  if (text !== void 0) binding.text = text;
+  const controlSnapshot = kind === "value" || kind === "checked" ? snapshotHydrationControl(target) : null;
+  if (controlSnapshot !== null) validateDirectSignalControl(target, site);
+  binding.pendingControl = activeHydration() !== null && isWritableSignal(handle) && controlSnapshot !== null && controlSnapshot.editRevision > 0;
+  const initial = handle === null ? value : readSignalBinding(handle);
+  if (!binding.pendingControl) writeDirectSignalBinding(binding, initial);
+  if (STAGED_COMMIT_CAPTURE !== null) {
+    DEFERRED_LAYOUT_DRIVER.stageAction(() => {
+      runWithBlockSignalOwner(
+        scope,
+        () => activateDirectSignalBinding(binding, controlSnapshot?.revision)
+      );
+      updateDirectSignalBinding(binding);
+    });
+  } else activateDirectSignalBinding(binding, controlSnapshot?.revision);
+  if (binding.pendingControl) queueDirectSignalControlAdoption(binding);
+  registerHookCleanup(scope, () => disposeDirectSignalBinding(binding));
+  return binding;
+}
+function bindDirectSignal(scope, previous, target, value, site, kind, name, attributeKind) {
+  const prior = typeof previous === "object" && previous !== null && previous[DIRECT_SIGNAL_BINDING] === true ? previous : null;
+  const handle = isSignalHandle(value) ? value : null;
+  if (handle !== null && (!signalDocumentEnabled || currentSignalOwner() !== SCOPE_SIGNAL_OWNERS.get(scope))) {
+    if (!signalDocumentEnabled) enableSignalBindings();
+    return runWithBlockSignalOwner(
+      scope,
+      () => bindDirectSignal(scope, previous, target, value, site, kind, name, attributeKind)
+    );
+  }
+  if (handle === null && prior === null) {
+    if (kind === "attribute" && previous === value) {
+      const hydration = value === void 0 ? activeHydration() : null;
+      if (hydration === null || hydration.isFresh(target)) return previous;
+    }
+    if (TRANSITION_JOURNAL !== null) journalBag();
+    const scalarTarget = (kind === "text" || kind === "textOnlyChild") && previous instanceof Text ? previous : target;
+    return writeDirectSignalScalar(scalarTarget, value, kind, previous, name, attributeKind);
+  }
+  if (prior !== null && !prior.disposed && prior.target === target && prior.kind === kind && prior.site === site && prior.name === name && prior.attributeKind === attributeKind && prior.handle === handle) {
+    if (prior.pendingControl) {
+      queueDirectSignalControlAdoption(prior);
+      return prior;
+    }
+    const next = readSignalBinding(handle);
+    if (!Object.is(prior.value, next)) writeDirectSignalBinding(prior, next);
+    return prior;
+  }
+  if (TRANSITION_JOURNAL !== null) journalBag();
+  if (handle === null) {
+    const scalarTarget = kind === "text" || kind === "textOnlyChild" ? prior?.text ?? prior?.target ?? target : target;
+    const token = writeDirectSignalScalar(
+      scalarTarget,
+      value,
+      kind,
+      kind === "text" || kind === "textOnlyChild" ? prior?.text : prior?.value ?? previous,
+      name,
+      attributeKind
+    );
+    if (prior !== null) {
+      const finish = (discarded) => {
+        if (!discarded) disposeDirectSignalBinding(prior);
+      };
+      if (WIP_CAPTURE === null) finish(false);
+      else (WIP_CAPTURE.renderCleanups ??= []).push(finish);
+    }
+    return token;
+  }
+  const signalTarget = (kind === "text" || kind === "textOnlyChild") && previous instanceof Text ? previous : target;
+  const binding = createDirectSignalBinding(
+    scope,
+    signalTarget,
+    value,
+    site,
+    kind,
+    name,
+    attributeKind,
+    kind === "text" || kind === "textOnlyChild" ? prior?.text ?? (previous instanceof Text ? previous : void 0) : void 0
+  );
+  if (prior !== null) {
+    const finish = (discarded) => disposeDirectSignalBinding(discarded ? binding : prior);
+    if (WIP_CAPTURE === null) finish(false);
+    else (WIP_CAPTURE.renderCleanups ??= []).push(finish);
+  }
+  return binding;
+}
+function bindSignalText(scope, previous, position, value, site, onlyChild = false, seededText = void 0, bindingMarker, previousValue) {
+  if (previous instanceof Text && arguments.length > 8 && previousValue === value && !isSignalHandle(value))
+    return previous;
+  if (previous === void 0 && bindingMarker !== void 0) {
+    const existing = activeHydration() !== null ? getNextSibling(position) : null;
+    previous = bindingText(
+      position,
+      existing?.nodeType === 3 ? (STAGED_DOM?.view(existing) ?? existing).nodeValue : "",
+      bindingMarker
+    );
+  }
+  if (previous === void 0 && onlyChild && seededText === 1 && activeHydration() === null) {
+    const text = getFirstChild(position);
+    if (text instanceof Text) previous = text;
+  }
+  const prior = previous;
+  return bindDirectSignal(
+    scope,
+    previous,
+    prior?.target ?? (previous instanceof Text ? previous : position),
+    value,
+    site,
+    onlyChild ? "textOnlyChild" : "text"
+  );
+}
+function bindSignalAttribute(scope, previous, element, name, value, site, attributeKind = "attr") {
+  return bindDirectSignal(scope, previous, element, value, site, "attribute", name, attributeKind);
+}
+function bindSignalValue(scope, previous, element, value, site) {
+  return bindDirectSignal(scope, previous, element, value, site, "value");
+}
+function bindSignalChecked(scope, previous, element, value, site) {
+  return bindDirectSignal(scope, previous, element, value, site, "checked");
+}
 function setAttributeIfChanged(value, previous, el, name) {
   if (previous === value) return previous;
   setAttribute(el, name, value);
@@ -12380,8 +14053,7 @@ function normalizedHostProp(el, rawName) {
   if (actionName !== null) return actionName;
   return isHtmlCustomElement(el) ? rawName : ATTRIBUTE_ALIASES.get(rawName) ?? rawName;
 }
-function setHostPropSources(el, sources, prev, scope, hasNestedChildren = false, readStyle) {
-  const props = /* @__PURE__ */ new Map();
+function resolveHostPropSources(el, sources, props, readStyle) {
   let classMerges = null;
   let sourceOrder = 0;
   function record(rawName, value) {
@@ -12405,64 +14077,440 @@ function setHostPropSources(el, sources, prev, scope, hasNestedChildren = false,
       record(rawName, source[2]);
       continue;
     }
-    const spread = source[1];
-    if (spread == null || typeof spread !== "object" && typeof spread !== "function") continue;
-    for (const name of Object.keys(Object(spread))) {
-      record(name, spread[name]);
+    const spread = source[1];
+    if (spread == null || typeof spread !== "object" && typeof spread !== "function") continue;
+    for (const name of Object.keys(Object(spread))) {
+      record(name, spread[name]);
+    }
+  }
+  const values = /* @__PURE__ */ new Map();
+  const html = el.namespaceURI === "http://www.w3.org/1999/xhtml";
+  let needsWinningOrderSort = false;
+  for (const writer of props.values()) {
+    const rawName = writer.name;
+    if (rawName === "key") continue;
+    const identityKey = isHostPropIdentityKey(rawName);
+    const name = identityKey ? rawName : normalizedHostProp(el, rawName);
+    const identity = html && !identityKey ? name.toLowerCase() : name;
+    const previous = values.get(identity);
+    if (previous !== void 0) {
+      if (previous.lastOrder >= writer.lastOrder) continue;
+      needsWinningOrderSort = true;
+    }
+    writer.name = process.env.NODE_ENV !== "production" && (rawName === "tabIndex" || rawName === "htmlFor") ? rawName : name;
+    values.set(identity, writer);
+  }
+  if (classMerges !== null) {
+    for (const extra of classMerges) {
+      const previous = values.get("class");
+      if (previous !== void 0) {
+        previous.value = mergeClass(previous.value, extra.value);
+        previous.lastOrder = extra.order;
+      } else {
+        values.set("class", {
+          name: "class",
+          value: extra.value,
+          firstOrder: extra.order,
+          lastOrder: extra.order
+        });
+      }
+    }
+  }
+  const resolved = /* @__PURE__ */ Object.create(null);
+  const ordered = needsWinningOrderSort ? [...values.values()].sort((a, b) => a.firstOrder - b.firstOrder) : values.values();
+  for (const { name, value } of ordered) resolved[name] = value;
+  if (readStyle !== void 0 && "style" in resolved) resolved.style = readStyle(resolved.style);
+  return resolved;
+}
+function setHostPropSources(el, sources, prev, scope, hasNestedChildren = false, readStyle, deferControl = false) {
+  const props = /* @__PURE__ */ new Map();
+  const resolved = resolveHostPropSources(el, sources, props, readStyle);
+  const tag = el.localName;
+  const formHost = tag === "input" || tag === "textarea" || tag === "select";
+  setSpread(el, resolved, prev, scope, true, formHost);
+  setDangerouslySetInnerHTMLSources(el, sources, hasNestedChildren);
+  if (formHost && !deferControl)
+    applyFormControlValues(
+      el,
+      tag,
+      props.get("value")?.value,
+      props.get("defaultValue")?.value,
+      props.get("checked")?.value,
+      props.get("defaultChecked")?.value,
+      props.get("multiple")?.value
+    );
+  return resolved;
+}
+const SIGNAL_HOST_PROP_SOURCES = /* @__PURE__ */ Symbol("octane.signal-host-prop-sources");
+function resolveSignalStyle(value, handles, read) {
+  if (isSignalHandle(value)) {
+    handles.add(value);
+    return read(value);
+  }
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return value;
+  let copy;
+  for (const name of Object.keys(value)) {
+    const current = value[name];
+    if (!isSignalHandle(current)) continue;
+    handles.add(current);
+    copy ??= { ...value };
+    copy[name] = read(current);
+  }
+  return copy ?? value;
+}
+function resolveSignalHostPropSources(sources, readStyle, read = readSignalBinding) {
+  const handles = /* @__PURE__ */ new Set();
+  let rows;
+  for (let i = 0; i < sources.length; i++) {
+    const source = sources[i];
+    if (!source[0]) {
+      const value = source[1] === "children" || source[1] === "style" && readStyle !== void 0 ? source[2] : source[1] === "style" ? resolveSignalStyle(source[2], handles, read) : isSignalHandle(source[2]) ? (handles.add(source[2]), read(source[2])) : source[2];
+      if (value !== source[2]) {
+        rows ??= sources.slice();
+        rows[i] = [false, source[1], value, source[3]];
+      }
+      continue;
+    }
+    const spread = source[1];
+    if (spread === null || typeof spread !== "object") continue;
+    let copy;
+    for (const name of Object.keys(spread)) {
+      const current = spread[name];
+      const value = name === "children" || name === "style" && readStyle !== void 0 ? current : name === "style" ? resolveSignalStyle(current, handles, read) : isSignalHandle(current) ? (handles.add(current), read(current)) : current;
+      if (value !== current) {
+        copy ??= { ...spread };
+        copy[name] = value;
+      }
+    }
+    if (copy !== void 0) {
+      rows ??= sources.slice();
+      rows[i] = [true, copy];
+    }
+  }
+  return { sources: rows ?? sources, handles };
+}
+function winningSignalHostControl(sources, name) {
+  let winner;
+  for (const source of sources) {
+    if (!source[0]) {
+      if (source[1] === name) winner = source[2];
+      continue;
+    }
+    const spread = source[1];
+    if (spread !== null && typeof spread === "object" && Object.prototype.propertyIsEnumerable.call(spread, name)) {
+      winner = spread[name];
+    }
+  }
+  return isSignalHandle(winner) ? winner : null;
+}
+function updateSignalHostPropSources(binding) {
+  if (binding.disposed || binding.pendingControl || binding.scope.block.disposed) return;
+  try {
+    runWithBlockSignalOwner(binding.scope, () => {
+      const next = resolveSignalHostPropSources(binding.sources, binding.readStyle);
+      binding.resolved = setHostPropSources(
+        binding.element,
+        next.sources,
+        binding.resolved,
+        binding.scope,
+        binding.hasNestedChildren,
+        binding.readStyle
+      );
+      if (process.env.NODE_ENV !== "production" && STAGED_DOM === null)
+        drainDevFormDiagnostics(binding.element);
+    });
+  } catch {
+    scheduleRender(binding.scope.block);
+  }
+}
+function addSignalHostSubscription(binding, handle) {
+  const unsubscribe = handle[SIGNAL_BINDING_SUBSCRIBE](
+    nativeTransitionBindingNotify(binding, () => updateSignalHostPropSources(binding))
+  );
+  binding.subscriptions.set(handle, unsubscribe);
+  return unsubscribe;
+}
+function rebindSignalHostSubscriptions(binding, handles) {
+  for (const [handle, unsubscribe] of binding.subscriptions) {
+    if (handles.has(handle)) continue;
+    unsubscribe();
+    binding.subscriptions.delete(handle);
+    if (TRANSITION_JOURNAL !== null) {
+      journalUndo(() => {
+        if (binding.disposed || binding.scope.block.disposed) return;
+        runWithBlockSignalOwner(binding.scope, () => addSignalHostSubscription(binding, handle));
+      });
+    }
+  }
+  for (const handle of handles) {
+    if (binding.subscriptions.has(handle)) continue;
+    const unsubscribe = addSignalHostSubscription(binding, handle);
+    if (TRANSITION_JOURNAL !== null) {
+      journalUndo(() => {
+        unsubscribe();
+        binding.subscriptions.delete(handle);
+      });
+    }
+  }
+}
+function addSignalHostControlWriter(binding, channel) {
+  const cleanup = registerHydrationControlSignalWriter(binding.element, channel, (next) => {
+    withoutSignalCandidate(
+      () => runWithBlockSignalOwner(binding.scope, () => {
+        const handle = winningSignalHostControl(binding.sources, channel);
+        if (!binding.disposed && !binding.pendingControl && isWritableSignal(handle))
+          handle.set(next);
+      })
+    );
+  });
+  binding.controlWriters.set(channel, cleanup);
+  return cleanup;
+}
+function syncSignalHostControl(binding) {
+  const element = binding.element;
+  const value = winningSignalHostControl(binding.sources, "value");
+  const checked = winningSignalHostControl(binding.sources, "checked");
+  const writable = isWritableSignal(value) || isWritableSignal(checked);
+  for (const [channel, cleanup] of binding.controlWriters) {
+    if (channel === "value" && isWritableSignal(value) || channel === "checked" && isWritableSignal(checked)) {
+      continue;
+    }
+    cleanup();
+    binding.controlWriters.delete(channel);
+    if (TRANSITION_JOURNAL !== null) {
+      journalUndo(() => {
+        if (!binding.disposed && !binding.scope.block.disposed)
+          addSignalHostControlWriter(binding, channel);
+      });
     }
   }
-  const values = /* @__PURE__ */ new Map();
-  const html = el.namespaceURI === "http://www.w3.org/1999/xhtml";
-  let needsWinningOrderSort = false;
-  for (const writer of props.values()) {
-    const rawName = writer.name;
-    if (rawName === "key") continue;
-    const identityKey = isHostPropIdentityKey(rawName);
-    const name = identityKey ? rawName : normalizedHostProp(el, rawName);
-    const identity = html && !identityKey ? name.toLowerCase() : name;
-    const previous = values.get(identity);
-    if (previous !== void 0) {
-      if (previous.lastOrder >= writer.lastOrder) continue;
-      needsWinningOrderSort = true;
+  if (isWritableSignal(value) && !binding.controlWriters.has("value")) {
+    const cleanup = addSignalHostControlWriter(binding, "value");
+    if (TRANSITION_JOURNAL !== null) {
+      journalUndo(() => {
+        cleanup();
+        binding.controlWriters.delete("value");
+      });
     }
-    writer.name = process.env.NODE_ENV !== "production" && (rawName === "tabIndex" || rawName === "htmlFor") ? rawName : name;
-    values.set(identity, writer);
   }
-  if (classMerges !== null) {
-    for (const extra of classMerges) {
-      const previous = values.get("class");
-      if (previous !== void 0) {
-        previous.value = mergeClass(previous.value, extra.value);
-        previous.lastOrder = extra.order;
-      } else {
-        values.set("class", {
-          name: "class",
-          value: extra.value,
-          firstOrder: extra.order,
-          lastOrder: extra.order
+  if (isWritableSignal(checked) && !binding.controlWriters.has("checked")) {
+    const cleanup = addSignalHostControlWriter(binding, "checked");
+    if (TRANSITION_JOURNAL !== null) {
+      journalUndo(() => {
+        cleanup();
+        binding.controlWriters.delete("checked");
+      });
+    }
+  }
+  if (!writable) {
+    if (binding.input !== void 0) {
+      const input2 = binding.input;
+      (STAGED_DOM?.view(element) ?? element).removeEventListener("input", input2);
+      if (TRANSITION_JOURNAL !== null) {
+        journalUndo(() => {
+          if (!binding.disposed && !binding.scope.block.disposed)
+            (STAGED_DOM?.view(element) ?? element).addEventListener("input", input2);
         });
       }
+      binding.input = void 0;
     }
+    return;
   }
-  const resolved = /* @__PURE__ */ Object.create(null);
-  const ordered = needsWinningOrderSort ? [...values.values()].sort((a, b) => a.firstOrder - b.firstOrder) : values.values();
-  for (const { name, value } of ordered) resolved[name] = value;
-  if (readStyle !== void 0 && "style" in resolved) resolved.style = readStyle(resolved.style);
-  const tag = el.localName;
-  const formHost = tag === "input" || tag === "textarea" || tag === "select";
-  setSpread(el, resolved, prev, scope, true, formHost);
-  setDangerouslySetInnerHTMLSources(el, sources, hasNestedChildren);
-  if (formHost)
-    applyFormControlValues(
-      el,
-      tag,
-      props.get("value")?.value,
-      props.get("defaultValue")?.value,
-      props.get("checked")?.value,
-      props.get("defaultChecked")?.value,
-      props.get("multiple")?.value
+  validateDirectSignalControl(element, binding.site);
+  if (binding.input !== void 0) return;
+  const input = () => {
+    if (binding.disposed || binding.pendingControl) return;
+    const live = snapshotHydrationControl(element);
+    if (live === null) return;
+    withoutSignalCandidate(
+      () => runWithBlockSignalOwner(binding.scope, () => {
+        const nextValue = winningSignalHostControl(binding.sources, "value");
+        const nextChecked = winningSignalHostControl(binding.sources, "checked");
+        if (isWritableSignal(nextChecked) && live.checked !== void 0)
+          nextChecked.set(live.checked);
+        if (isWritableSignal(nextValue)) nextValue.set(live.selectedValues ?? live.value);
+      })
     );
-  return resolved;
+  };
+  binding.input = input;
+  (STAGED_DOM?.view(element) ?? element).addEventListener("input", input);
+  if (TRANSITION_JOURNAL !== null)
+    journalUndo(() => (STAGED_DOM?.view(element) ?? element).removeEventListener("input", input));
+}
+function disposeSignalHostPropSources(binding) {
+  if (binding.disposed) return;
+  if (DEFERRED_LAYOUT_DRIVER?.stageAction(() => disposeSignalHostPropSources(binding)) === true)
+    return;
+  binding.disposed = true;
+  for (const unsubscribe of binding.subscriptions.values()) unsubscribe();
+  retireNativeTransitionBlock(binding.scope.block);
+  binding.subscriptions.clear();
+  for (const cleanup of binding.controlWriters.values()) cleanup();
+  binding.controlWriters.clear();
+  if (binding.input !== void 0)
+    domNode(binding.element).removeEventListener("input", binding.input);
+  queueOwnRefDetach(binding.resolved, binding.element);
+}
+function queueSignalHostControlAdoption(binding) {
+  enqueueEffectEventCommitAction(() => {
+    if (binding.disposed || binding.scope.block.disposed || !binding.pendingControl) return;
+    withoutSignalCandidate(
+      () => runWithBlockSignalOwner(binding.scope, () => {
+        const snapshot = snapshotHydrationControl(binding.element);
+        if (snapshot.editRevision > 0) {
+          const checked = winningSignalHostControl(binding.sources, "checked");
+          const value = winningSignalHostControl(binding.sources, "value");
+          if (isWritableSignal(checked) && snapshot.checked !== void 0)
+            checked.set(snapshot.checked);
+          if (isWritableSignal(value)) value.set(snapshot.selectedValues ?? snapshot.value);
+        }
+        if (binding.disposed || binding.scope.block.disposed) return;
+        if (!consumeHydrationControl(binding.element, snapshot.revision)) {
+          queueSignalHostControlAdoption(binding);
+          return;
+        }
+        binding.pendingControl = false;
+        updateSignalHostPropSources(binding);
+      })
+    );
+  });
+}
+function createSignalHostPropSourcesBinding(scope, element, sources, site, hasNestedChildren, readStyle) {
+  const binding = {
+    [SIGNAL_HOST_PROP_SOURCES]: true,
+    scope,
+    element,
+    site,
+    hasNestedChildren,
+    readStyle,
+    sources,
+    resolved: void 0,
+    subscriptions: /* @__PURE__ */ new Map(),
+    controlWriters: /* @__PURE__ */ new Map(),
+    disposed: false
+  };
+  registerHookCleanup(scope, () => disposeSignalHostPropSources(binding));
+  return binding;
+}
+function prepareSignalHostPropSources(scope, previous, element, sources, site, hasNestedChildren = false, readStyle) {
+  if (isHtmlCustomElement(element) || element.hasAttribute("is") || element.localName === "input" || element.localName === "textarea" || element.localName === "select")
+    presentationMiss(false);
+  return runWithBlockSignalOwner(scope, () => {
+    const next = resolveSignalHostPropSources(sources, readStyle, (handle) => handle.get());
+    const writers = /* @__PURE__ */ new Map();
+    const resolved = resolveHostPropSources(element, next.sources, writers, readStyle);
+    for (const name of writers.keys()) {
+      if (name === "ref" || isEventKey(name)) continue;
+      if (isHostPropIdentityKey(name) || name === "is" || name === "muted" || name === "selected" || formActionAttributeName(element, name) !== null)
+        presentationMiss(false);
+    }
+    const prepared = /* @__PURE__ */ Object.create(null);
+    for (const name of Object.keys(resolved)) {
+      const value = resolved[name];
+      prepared[name] = name === "ref" || isEventKey(name) ? value : name === "style" ? __normalizeBindingStyle(value) : preparedPresentationAttribute(
+        element,
+        name,
+        value,
+        name === "class" ? "class" : "attr"
+      );
+    }
+    const prior = previous;
+    const reusable = prior?.[SIGNAL_HOST_PROP_SOURCES] === true && !prior.disposed && prior.resolved === void 0 && prior.scope === scope && prior.element === element && prior.site === site && prior.hasNestedChildren === hasNestedChildren && prior.readStyle === readStyle;
+    const binding = reusable ? prior : createSignalHostPropSourcesBinding(
+      scope,
+      element,
+      sources,
+      site,
+      hasNestedChildren,
+      readStyle
+    );
+    let published = false;
+    return {
+      binding,
+      publish() {
+        if (published || binding.disposed || scope.block.disposed) return;
+        published = true;
+        runWithBlockSignalOwner(scope, () => {
+          setSpread(
+            element,
+            prepared,
+            "style" in prepared ? { style: "" } : void 0,
+            scope,
+            true
+          );
+          binding.sources = sources;
+          binding.resolved = resolved;
+          rebindSignalHostSubscriptions(binding, next.handles);
+        });
+      }
+    };
+  });
+}
+function bindSignalHostPropSources(scope, previous, element, sources, site, hasNestedChildren = false, readStyle) {
+  let binding = typeof previous === "object" && previous !== null && previous[SIGNAL_HOST_PROP_SOURCES] === true ? previous : void 0;
+  if (binding === void 0) {
+    binding = createSignalHostPropSourcesBinding(
+      scope,
+      element,
+      sources,
+      site,
+      hasNestedChildren,
+      readStyle
+    );
+  } else if (STAGED_COMMIT_CAPTURE === null) {
+    if (TRANSITION_JOURNAL !== null) journalObjectOnce(binding);
+    binding.sources = sources;
+  }
+  const committed = binding;
+  if (STAGED_COMMIT_CAPTURE !== null) {
+    const projections = STAGED_COMMIT_CAPTURE.signalHosts ??= /* @__PURE__ */ new Map();
+    binding = projections.get(committed);
+    if (binding === void 0) {
+      binding = { ...committed };
+      projections.set(committed, binding);
+      if (isRecordingTransitionJournal()) journalUndo(() => projections.delete(committed));
+    } else if (TRANSITION_JOURNAL !== null) journalObjectOnce(binding);
+    binding.sources = sources;
+  }
+  const valueControl = winningSignalHostControl(sources, "value");
+  const checkedControl = winningSignalHostControl(sources, "checked");
+  const controlSnapshot = isWritableSignal(valueControl) || isWritableSignal(checkedControl) ? snapshotHydrationControl(element) : null;
+  if (controlSnapshot !== null) {
+    validateDirectSignalControl(element, site);
+    binding.pendingControl ||= activeHydration() !== null && controlSnapshot.editRevision > 0;
+  }
+  const next = resolveSignalHostPropSources(sources, readStyle);
+  binding.resolved = setHostPropSources(
+    element,
+    next.sources,
+    binding.resolved,
+    scope,
+    hasNestedChildren,
+    readStyle,
+    binding.pendingControl
+  );
+  if (STAGED_COMMIT_CAPTURE !== null) {
+    DEFERRED_LAYOUT_DRIVER.stageAction(() => {
+      if (committed.disposed) return;
+      committed.sources = binding.sources;
+      committed.resolved = binding.resolved;
+      committed.pendingControl = binding.pendingControl;
+      runWithBlockSignalOwner(scope, () => {
+        rebindSignalHostSubscriptions(committed, next.handles);
+        syncSignalHostControl(committed);
+      });
+      if (!committed.pendingControl && controlSnapshot !== null)
+        consumeHydrationControl(element, controlSnapshot.revision);
+      updateSignalHostPropSources(committed);
+    });
+  } else {
+    rebindSignalHostSubscriptions(binding, next.handles);
+    syncSignalHostControl(binding);
+    if (!binding.pendingControl && controlSnapshot !== null)
+      consumeHydrationControl(element, controlSnapshot.revision);
+  }
+  if (binding.pendingControl) queueSignalHostControlAdoption(committed);
+  return committed;
 }
 function isAggregatedFormControlProp(el, name) {
   switch (el.localName) {
@@ -12517,6 +14565,8 @@ function setSpread(el, value, prev, mountScope, skipDangerouslySetInnerHTML = fa
     if (process.env.NODE_ENV !== "production") queueDevFormDiagnostic(el, mountScope);
     return;
   }
+  const hydration = prev === void 0 ? activeHydration() : null;
+  const initialHydration = hydration !== null && !hydration.isFresh(el);
   for (const k of Object.keys(Object(value))) {
     if (k === "key" || k === "children") continue;
     if (skipDangerouslySetInnerHTML && k === "dangerouslySetInnerHTML") continue;
@@ -12532,7 +14582,7 @@ function setSpread(el, value, prev, mountScope, skipDangerouslySetInnerHTML = fa
     if (k === "suppressHydrationWarning" || k === "suppressNativeChangeWarning" || k === "__octaneNativeChangeDiagnostic")
       continue;
     if (k === "class" || k === "className") {
-      if (v === pv) continue;
+      if (v === pv && !initialHydration) continue;
       setClassAttr(el, v);
       continue;
     }
@@ -12546,7 +14596,7 @@ function setSpread(el, value, prev, mountScope, skipDangerouslySetInnerHTML = fa
     }
     const actionName = formActionAttributeName(el, k);
     if (actionName !== null) {
-      if (v === pv) continue;
+      if (v === pv && !initialHydration) continue;
       setFormAction(
         el,
         actionName,
@@ -12555,9 +14605,10 @@ function setSpread(el, value, prev, mountScope, skipDangerouslySetInnerHTML = fa
       );
       continue;
     }
-    if (v === pv && !isControlledHostProp(el, k)) continue;
+    if (v === pv && !isControlledHostProp(el, k) && !initialHydration) continue;
     const ev = eventSlot(k, el);
     if (ev) {
+      if (v === pv) continue;
       if (ev.capture) {
         if (!_delegatedCapture.has(ev.type)) delegateCaptureEvents([ev.type]);
       } else if (!_delegated.has(ev.type)) {
@@ -12832,6 +14883,7 @@ function isUsableEventSlot(slot) {
   return typeof slot === "function" || isHandlerBundle(slot);
 }
 const EMPTY_ARGS = [];
+let SIGNAL_EVENT_OWNERS = null;
 function setEventHandler(el, key, handler) {
   if (TRANSITION_JOURNAL !== null) {
     TRANSITION_JOURNAL.push(
@@ -12843,6 +14895,18 @@ function setEventHandler(el, key, handler) {
     journalBag();
   }
   (STAGED_DOM?.view(el) ?? el)[key] = handler;
+  if (SIGNAL_BINDINGS_ENABLED || signalDocumentEnabled) {
+    const owner = (activeSynchronousSignalOwner !== null || activeSignalOwnerEnvironment !== void 0 ? currentExplicitSignalOwner() : null) ?? (signalDocumentEnabled || CURRENT_SCOPE?.block.idState.renderOwner?.signalOwner !== void 0 ? CURRENT_SCOPE === null ? currentSignalOwner() : SCOPE_SIGNAL_OWNERS.get(CURRENT_SCOPE) || CURRENT_SCOPE : CURRENT_SCOPE);
+    if (owner !== null) {
+      if ((owner instanceof ScopeImpl || owner instanceof BlockImpl) && SCOPE_SIGNAL_OWNERS.get(owner) === void 0)
+        SCOPE_SIGNAL_OWNERS.set(owner, false);
+      if (STAGED_COMMIT_CAPTURE !== null)
+        DEFERRED_LAYOUT_DRIVER.stageAction(
+          () => (SIGNAL_EVENT_OWNERS ??= /* @__PURE__ */ new WeakMap()).set(el, owner)
+        );
+      else (SIGNAL_EVENT_OWNERS ??= /* @__PURE__ */ new WeakMap()).set(el, owner);
+    }
+  }
 }
 function evt0(el, key, fn) {
   const d = { fn, args: EMPTY_ARGS, [EVENT_SLOT_KIND]: HANDLER_BUNDLE_KIND };
@@ -12940,11 +15004,13 @@ function isEventRoot(node, epoch) {
 }
 function prepareDelegatedEvent(event, listener) {
   if (_delegationTargets.size === 1 && portalEventTargetCount === 0) {
+    beginBindingEvent(event);
     event[EVENT_ROOT_EPOCH] = eventRootEpoch;
     return;
   }
   const path = event.composedPath();
   if (_delegationTargets.size === 1) {
+    beginBindingEvent(event);
     event[EVENT_ROOT_EPOCH] = eventRootEpoch;
     if (portalEventTargetCount !== 0) {
       preparePortalEventOwners(path, eventRootEpoch);
@@ -12955,6 +15021,7 @@ function prepareDelegatedEvent(event, listener) {
   for (let i = path.length - 1; i >= 0; i--) {
     if (_delegationTargets.has(path[i])) {
       if (path[i] === listener) {
+        beginBindingEvent(event);
         event[EVENT_ROOT_EPOCH] = eventRootEpoch;
         if (portalEventTargetCount !== 0) {
           preparePortalEventOwners(path, eventRootEpoch);
@@ -13433,12 +15500,12 @@ function buildDelegatedPath(event, listener, path = event.composedPath()) {
     rebaseRootAtStart = true;
   }
 }
-function fireEventSlot(slot, event) {
+function fireEventSlot(slot, event, currentTarget) {
   const previousScope = CURRENT_SCOPE;
   const previousBlock = CURRENT_BLOCK;
   CURRENT_SCOPE = null;
   CURRENT_BLOCK = null;
-  try {
+  const invoke = () => {
     if (typeof slot === "function") {
       slot(event);
       return;
@@ -13476,6 +15543,12 @@ function fireEventSlot(slot, event) {
       return;
     }
     invokeInvalidEventListener(`${event.type} event`, slot, event);
+  };
+  try {
+    const recorded = SIGNAL_EVENT_OWNERS?.get(currentTarget);
+    const owner = recorded instanceof ScopeImpl || recorded instanceof BlockImpl ? scopeSignalOwner(recorded) : recorded;
+    if (owner === void 0 || currentSignalOwner() === owner) invoke();
+    else runWithSignalOwner(owner, invoke);
   } catch (err) {
     reportListenerError(err);
   } finally {
@@ -13574,9 +15647,9 @@ function dispatchDelegated(event) {
       const current = CAPTURE_PATH[i];
       if (targetOnly && current !== event.target) break;
       const slot = CAPTURE_SLOTS[i];
-      if (slot != null) {
+      if (slot != null && !consumeBindingEvent(event, current, false)) {
         setCurrentTarget(event, current, frame);
-        fireEventSlot(slot, event);
+        fireEventSlot(slot, event, current);
         if ((frame.flags & 1) !== 0) break;
       }
       if (targetOnly) break;
@@ -13621,9 +15694,9 @@ function dispatchDelegatedCapture(event, path, type = _delegated.get(event.type)
     frame = beginDelegatedPropagation(event, stop, immediate);
     for (let i = CAPTURE_PATH.length - 1; i >= pathBase; i--) {
       const slot = CAPTURE_SLOTS[i];
-      if (slot != null) {
+      if (slot != null && !consumeBindingEvent(event, CAPTURE_PATH[i], true)) {
         setCurrentTarget(event, CAPTURE_PATH[i], frame);
-        fireEventSlot(slot, event);
+        fireEventSlot(slot, event, CAPTURE_PATH[i]);
         if ((frame.flags & 1) !== 0) break;
       }
     }
@@ -14471,7 +16544,7 @@ function formDiagnosticOutcome(el) {
   const ctrl = host.$$ctrl;
   if (isTextEntry(el)) {
     const controlled = ctrl !== void 0 && ctrl.v !== UNCONTROLLED;
-    if (hasInput) return null;
+    if (hasInput || hasHydrationControlSignalWriter(el, "value")) return null;
     if (hasChange) {
       const dev = getDevFormDiagnosticState(el);
       if (host.__oct_native_change_suppressed === true || dev?.staticNativeChange === true)
@@ -14489,7 +16562,8 @@ function formDiagnosticOutcome(el) {
     };
   }
   if (el.localName === "select") {
-    if (ctrl === void 0 || ctrl.sv === null || hasInput || hasChange) return null;
+    if (ctrl === void 0 || ctrl.sv === null || hasInput || hasChange || hasHydrationControlSignalWriter(el, "value"))
+      return null;
     return {
       signature: "controlled-select-missing",
       message: "You provided a `value` prop to a select without an `onInput` or `onChange` handler. This will render a read-only field. Set a usable native handler, `readOnly`, or use `defaultValue` for an uncontrolled field."
@@ -14499,25 +16573,33 @@ function formDiagnosticOutcome(el) {
   const checkable = input.localName === "input" && ((STAGED_DOM?.view(input) ?? input).type === "checkbox" || (STAGED_DOM?.view(input) ?? input).type === "radio");
   if (!checkable || ctrl === void 0 || ctrl.c === -1) return null;
   const hasClick = isUsableEventSlot(host.$$click) || isUsableEventSlot(host["$$capture:click"]);
-  if (hasClick || hasInput || hasChange) return null;
+  if (hasClick || hasInput || hasChange || hasHydrationControlSignalWriter(el, "checked"))
+    return null;
   return {
     signature: `controlled-checkable-missing:${(STAGED_DOM?.view(input) ?? input).type}`,
     message: "You provided a `checked` prop to a checkbox or radio without an `onClick`, `onInput`, or `onChange` handler. This will render a read-only field. Set a usable native handler, `readOnly`, or use `defaultChecked` for an uncontrolled field."
   };
 }
-function drainDevFormDiagnostics() {
+function drainDevFormDiagnostics(target) {
   if (process.env.NODE_ENV === "production") return;
-  const q = DEV_FORM_CHECKS;
+  let q = DEV_FORM_CHECKS;
   if (q === null || q.length === 0) return;
-  DEV_FORM_CHECKS = [];
-  DEV_FORM_CHECK_GENERATION++;
+  if (target !== void 0) {
+    const index = q.indexOf(target);
+    if (index < 0) return;
+    q.splice(index, 1);
+    delete target[DEV_FORM_CHECK_MARK];
+    q = [target];
+  } else DEV_FORM_CHECKS = [];
+  if (target === void 0) DEV_FORM_CHECK_GENERATION++;
   for (let i = 0; i < q.length; i++) {
     const el = q[i];
     const authoring = getDevFormDiagnosticState(el);
     if (authoring !== void 0) {
       let props = authoring.authoringProps;
       if (authoring.authoringSelected !== void 0) {
-        (props ??= /* @__PURE__ */ Object.create(null)).selected = authoring.authoringSelected();
+        const selected = authoring.authoringSelected();
+        (props ??= /* @__PURE__ */ Object.create(null)).selected = typeof selected === "object" && selected !== null && selected[DIRECT_SIGNAL_BINDING] === true ? selected.value : selected;
       }
       const action = el.$$formAction;
       if (typeof action === "function") {
@@ -15144,8 +17226,9 @@ function copyScopedElementConfig(type, config, resolve) {
   SCOPED_ELEMENT_PROPS.add(props);
   return props;
 }
-function scopedElementRecord(type, props, key, ref, resolve) {
+function scopedElementRecord(type, props, key, ref, resolve, invocationSite) {
   const descriptor = { $$kind: ELEMENT_TAG, type, props, key, ref };
+  if (invocationSite !== void 0) descriptor.__octaneInvocationSite = invocationSite;
   Object.defineProperty(descriptor, SCOPED_CHILDREN_RESOLVER, { value: resolve });
   Object.defineProperty(descriptor, "children", SCOPED_CHILDREN_PROPERTY);
   return descriptor;
@@ -15178,12 +17261,20 @@ function scopedValueRef() {
 function scopedValueChildren() {
   return this[SCOPED_VALUE_RECORD]().children;
 }
+function scopedValueInvocationSite() {
+  return this[SCOPED_VALUE_RECORD]().__octaneInvocationSite;
+}
 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 }
+  children: { configurable: true, enumerable: true, get: scopedValueChildren },
+  __octaneInvocationSite: {
+    configurable: true,
+    enumerable: true,
+    get: scopedValueInvocationSite
+  }
 };
 function createScopedValue(readElement) {
   return scopedValueDescriptor(createScopedResolver(readElement));
@@ -15199,16 +17290,26 @@ function scopedValueDescriptor(resolve) {
   Object.defineProperty(descriptor, "key", SCOPED_VALUE_PROPERTIES.key);
   Object.defineProperty(descriptor, "ref", SCOPED_VALUE_PROPERTIES.ref);
   Object.defineProperty(descriptor, "children", SCOPED_VALUE_PROPERTIES.children);
+  Object.defineProperty(
+    descriptor,
+    "__octaneInvocationSite",
+    SCOPED_VALUE_PROPERTIES.__octaneInvocationSite
+  );
   if (process.env.NODE_ENV !== "production") Object.freeze(descriptor);
   return descriptor;
 }
-function createScopedElement(type, props, readChildren) {
-  return scopedElementDescriptor(type, props, createScopedResolver(readChildren));
+function createScopedElement(type, props, readChildren, invocationSite) {
+  return scopedElementDescriptor(type, props, createScopedResolver(readChildren), invocationSite);
 }
-function nativeCreateScopedElement(type, props, readChildren) {
-  return scopedElementDescriptor(type, props, createNativeScopedResolver(readChildren));
+function nativeCreateScopedElement(type, props, readChildren, invocationSite) {
+  return scopedElementDescriptor(
+    type,
+    props,
+    createNativeScopedResolver(readChildren),
+    invocationSite
+  );
 }
-function scopedElementDescriptor(type, props, children) {
+function scopedElementDescriptor(type, props, children, invocationSite) {
   const src = props ?? null;
   const hasKey = hasElementConfigKey(src);
   const key = hasKey ? "" + src.key : null;
@@ -15218,7 +17319,8 @@ function scopedElementDescriptor(type, props, children) {
     copiedProps,
     key,
     copiedProps.ref !== void 0 ? copiedProps.ref : null,
-    children
+    children,
+    invocationSite
   );
   if (key === null && src != null && (typeof src === "object" || typeof src === "function") && "key" in src) {
     KEYED_ELEMENT_DESCRIPTORS.add(descriptor);
@@ -15226,6 +17328,12 @@ function scopedElementDescriptor(type, props, children) {
   return finalizeElementDescriptor(descriptor);
 }
 function createElement(type, props, ...children) {
+  return createElementFromConfig(void 0, type, props, children);
+}
+function createElementAt(invocationSite, type, props, ...children) {
+  return createElementFromConfig(invocationSite, type, props, children);
+}
+function createElementFromConfig(invocationSite, type, props, children = EMPTY_ARGS) {
   if (typeof type === "function" && isRendererContext(type)) {
     registerClientRendererBridge(renderClientContextProvider, flushSync);
   }
@@ -15250,6 +17358,7 @@ function createElement(type, props, ...children) {
     ref: p.ref !== void 0 ? p.ref : null,
     children: kids ?? null
   };
+  if (invocationSite !== void 0) descriptor.__octaneInvocationSite = invocationSite;
   if (key === null && src != null && (typeof src === "object" || typeof src === "function") && "key" in src) {
     KEYED_ELEMENT_DESCRIPTORS.add(descriptor);
   }
@@ -15329,7 +17438,14 @@ function cloneElement(element, config, ...children) {
   const ref = props.ref !== void 0 ? props.ref : null;
   let descriptor;
   if (keepsScopedChildren && copiedGetter === void 0) {
-    descriptor = scopedElementRecord(element.type, props, key, ref, scopedChildren);
+    descriptor = scopedElementRecord(
+      element.type,
+      props,
+      key,
+      ref,
+      scopedChildren,
+      element.__octaneInvocationSite
+    );
   } else {
     descriptor = {
       $$kind: ELEMENT_TAG,
@@ -15339,6 +17455,8 @@ function cloneElement(element, config, ...children) {
       ref,
       children: kids ?? null
     };
+    if (element.__octaneInvocationSite !== void 0)
+      descriptor.__octaneInvocationSite = element.__octaneInvocationSite;
     if (keepsScopedChildren) {
       Object.defineProperty(descriptor, "children", {
         configurable: true,
@@ -15366,7 +17484,8 @@ function cloneAndReplaceElementKey(element, key) {
         element.props,
         key,
         element.ref,
-        element[SCOPED_CHILDREN_RESOLVER]
+        element[SCOPED_CHILDREN_RESOLVER],
+        element.__octaneInvocationSite
       );
     } else {
       const copiedGetter = get === SCOPED_VALUE_PROPERTIES.children.get ? () => get.call(element) : get;
@@ -15378,6 +17497,8 @@ function cloneAndReplaceElementKey(element, key) {
         ref: element.ref,
         children: null
       };
+      if (element.__octaneInvocationSite !== void 0)
+        descriptor.__octaneInvocationSite = element.__octaneInvocationSite;
       Object.defineProperty(descriptor, "children", {
         configurable: true,
         enumerable: true,
@@ -15393,6 +17514,8 @@ function cloneAndReplaceElementKey(element, key) {
       ref: element.ref,
       children: element.children
     };
+    if (element.__octaneInvocationSite !== void 0)
+      descriptor.__octaneInvocationSite = element.__octaneInvocationSite;
   }
   if (ELEMENTS_MISSING_LIST_KEY.has(element)) ELEMENTS_MISSING_LIST_KEY.add(descriptor);
   return finalizeElementDescriptor(descriptor);
@@ -15537,7 +17660,7 @@ const Children = {
   }
 };
 const NO_KEY = /* @__PURE__ */ Symbol("NO_KEY");
-function componentSlot(parentScope, slotKey, domParent, comp, props, anchor, key, singleRoot, inherit, hasKey) {
+function componentSlot(parentScope, slotKey, domParent, comp, props, anchor, key, singleRoot, inherit, hasKey, invocationSite) {
   const dispatch = activityDescriptorDispatch;
   const activity = dispatch !== null && comp === dispatch.type;
   if (!activity && typeof comp !== "function" && typeof comp !== "string") {
@@ -15573,10 +17696,11 @@ function componentSlot(parentScope, slotKey, domParent, comp, props, anchor, key
     key,
     singleRoot,
     inherit,
-    hasKey
+    hasKey,
+    invocationSite
   );
 }
-function componentSlotVoid(parentScope, slotKey, domParent, comp, props, anchor, key, singleRoot, inherit, hasKey) {
+function componentSlotVoid(parentScope, slotKey, domParent, comp, props, anchor, key, singleRoot, inherit, hasKey, invocationSite) {
   if (typeof comp !== "function") throw invalidElementTypeError(comp);
   componentSlotImpl(
     null,
@@ -15591,10 +17715,11 @@ function componentSlotVoid(parentScope, slotKey, domParent, comp, props, anchor,
     key,
     singleRoot,
     inherit,
-    hasKey
+    hasKey,
+    invocationSite
   );
 }
-function componentSlotImpl(outputHandler, parentScope, slotKey, domParent, body, identity, props, renderProps, anchor, key, singleRoot, inherit, hasKey) {
+function componentSlotImpl(outputHandler, parentScope, slotKey, domParent, body, identity, props, renderProps, anchor, key, singleRoot, inherit, hasKey, invocationSite) {
   if (CURRENT_BLOCK?.pending && !CURRENT_BLOCK.crossRenderUpdate) return;
   const parentBlock = parentScope.block;
   const hydration = activeHydration();
@@ -15613,7 +17738,8 @@ function componentSlotImpl(outputHandler, parentScope, slotKey, domParent, body,
         key,
         singleRoot,
         inherit,
-        hasKey
+        hasKey,
+        invocationSite
       )
     );
     return;
@@ -15745,6 +17871,15 @@ function componentSlotImpl(outputHandler, parentScope, slotKey, domParent, body,
     journalRootProperty(state, "prevKey", state.prevKey);
   state.prevKey = nextKey;
   if (replacing) {
+    const signalInstanceKey = SIGNAL_BINDINGS_ENABLED || signalDocumentEnabled ? { parentScope, invocationSite, key, hasKey: key != null } : void 0;
+    const retryLocation = state.block === null || !state.block.mounted || parentBlock.idState.renderOwner?.signalOwner === void 0 ? void 0 : {
+      parent: parentScope,
+      slot: slotKey,
+      kind: state.__kind,
+      branch: void 0,
+      component: identity,
+      key: nextKey
+    };
     const swapDriver = TRANSITION_SWAP_DRIVER;
     const transitionMode = parentBlock.currentRenderMode === "transition";
     const canSwapOffscreen = swapDriver !== null && state.block !== null && state.block.mounted && hydration === null;
@@ -15769,7 +17904,12 @@ function componentSlotImpl(outputHandler, parentScope, slotKey, domParent, body,
           stageAfter,
           body,
           renderProps,
-          outputHandler
+          outputHandler,
+          "dynamic",
+          void 0,
+          false,
+          signalInstanceKey,
+          retryLocation
         );
         if (r.suspended || r.failed) {
           disposeWip(r.wip);
@@ -15800,7 +17940,12 @@ function componentSlotImpl(outputHandler, parentScope, slotKey, domParent, body,
           state.end,
           body,
           renderProps,
-          outputHandler
+          outputHandler,
+          "dynamic",
+          void 0,
+          false,
+          signalInstanceKey,
+          retryLocation
         );
         if (r.suspended || r.failed) {
           transitionSwap.dispose(r.wip);
@@ -15827,7 +17972,12 @@ function componentSlotImpl(outputHandler, parentScope, slotKey, domParent, body,
           probeAfter,
           body,
           renderProps,
-          outputHandler
+          outputHandler,
+          "dynamic",
+          void 0,
+          false,
+          signalInstanceKey,
+          retryLocation
         );
         transitionSwap.dispose(r.wip);
         if (r.failed) throw r.error;
@@ -15871,6 +18021,7 @@ function componentSlotImpl(outputHandler, parentScope, slotKey, domParent, body,
         void 0,
         outputHandler
       );
+      if (signalInstanceKey !== void 0) SCOPE_SIGNAL_INSTANCE_KEYS.set(b, signalInstanceKey);
       if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__ && typeof identity === "function")
         profileTrackComponent(b, identity);
       state.block = b;
@@ -15900,6 +18051,7 @@ function componentSlotImpl(outputHandler, parentScope, slotKey, domParent, body,
         void 0,
         outputHandler
       );
+      if (signalInstanceKey !== void 0) SCOPE_SIGNAL_INSTANCE_KEYS.set(b, signalInstanceKey);
       if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__ && typeof identity === "function")
         profileTrackComponent(b, identity);
       if (state.inherited) b.exclusiveMarkers = true;
@@ -15919,7 +18071,7 @@ function componentSlotImpl(outputHandler, parentScope, slotKey, domParent, body,
 function coerceChildText(v) {
   return v == null || v === false || v === true ? "" : String(v);
 }
-function renderOffscreen(parentBlock, domParent, afterNode, body, props, outputHandler, kind = "dynamic", env, implicitBail = false) {
+function renderOffscreen(parentBlock, domParent, afterNode, body, props, outputHandler, kind = "dynamic", env, implicitBail = false, signalInstanceKey, retryLocation) {
   const start = (STAGED_DOM?.view(document) ?? document).createComment("wip");
   const end = (STAGED_DOM?.view(document) ?? document).createComment("/wip");
   const ref = getNextSibling(afterNode);
@@ -15940,6 +18092,8 @@ function renderOffscreen(parentBlock, domParent, afterNode, body, props, outputH
     env,
     outputHandler
   );
+  if (signalInstanceKey !== void 0) SCOPE_SIGNAL_INSTANCE_KEYS.set(block, signalInstanceKey);
+  if (retryLocation !== void 0) SIGNAL_RETRY_LOCATIONS.set(block, retryLocation);
   if (implicitBail) {
     block.$$implicitBail = true;
     block.memoInChain = true;
@@ -15960,15 +18114,32 @@ function renderOffscreen(parentBlock, domParent, afterNode, body, props, outputH
   } finally {
     WIP_CAPTURE = prev;
   }
+  const wip = { block, start, end, capture, domParent, refDetachCheckpoint };
+  if (suspended !== null && retryLocation !== void 0) {
+    const owner = parentBlock.idState.renderOwner;
+    const boundary = signalRetryBoundary(parentBlock);
+    const retryRoot = boundary?.tryBlock ?? owner?.current;
+    const holder = boundary ?? owner;
+    if (holder !== void 0 && retryRoot != null) {
+      retainSignalRetryScope(block, retryRoot, holder, true);
+      for (const created of ROOT_RENDER_TRANSACTION?.created ?? [])
+        if (!created.disposed && blockIsAncestorOf(block, created))
+          retainSignalRetryScope(created, retryRoot, holder);
+      wip.retrySignalOwners = holder.retrySignalOwners;
+    }
+  }
   return {
-    wip: { block, start, end, capture, domParent, refDetachCheckpoint },
+    wip,
     suspended,
     error,
     failed
   };
 }
-function spliceOffscreenCapture(capture) {
-  NATIVE_READ_DRIVER?.spliceCapture(capture, WIP_CAPTURE);
+function spliceOffscreenCapture(capture, deferredNativeAcceptance = false) {
+  if (capture.presentations !== void 0 && WIP_CAPTURE !== null)
+    (WIP_CAPTURE.presentations ??= []).push(...capture.presentations);
+  if (WIP_CAPTURE !== null || !deferredNativeAcceptance)
+    NATIVE_READ_DRIVER?.spliceCapture(capture, WIP_CAPTURE);
   const rendered = capture.renderedBlocks;
   capture.renderedBlocks = null;
   capture.renderRoot = null;
@@ -16048,10 +18219,13 @@ function commitOffscreen(wip, beforeNode) {
 }
 function disposeWip(wip) {
   const previousCapture = WIP_CAPTURE;
+  const previousRetained = RETAINED_SIGNAL_OWNERS;
+  if (wip.retrySignalOwners !== void 0) RETAINED_SIGNAL_OWNERS = wip.retrySignalOwners;
   WIP_CAPTURE = wip.capture;
   try {
     unmountBlock(wip.block, true);
   } finally {
+    RETAINED_SIGNAL_OWNERS = previousRetained;
     WIP_CAPTURE = previousCapture;
     refDetachQueue.splice(wip.refDetachCheckpoint);
     discardOffscreenCapture(wip.capture);
@@ -17011,7 +19185,9 @@ function mappedDeoptItemBody(item, scope) {
         block.endMarker,
         void 0,
         true,
-        true
+        true,
+        void 0,
+        item.__octaneInvocationSite
       );
       return;
     }
@@ -17668,8 +19844,151 @@ function renderPreparedChildList(state, parentBlock, domParent, preparedList, hy
   }
   return;
 }
-function childSlot(parentScope, slotKey, domParent, value, anchor, ownEnd, ownsHost, compactable, includeKeyedSingle = true, compiledMapBody, compiledMapKey, compiledMapFlags, compiledMapDeps, mappedFallback) {
+const DIRECT_SIGNAL_CHILD = /* @__PURE__ */ Symbol("octane.direct-signal-child");
+let IMPLICIT_SIGNAL_CHILD_DEPTH = 0;
+function disposeDirectSignalChild(binding) {
+  if (binding.disposed) return;
+  binding.disposed = true;
+  binding.unsubscribe?.();
+  retireNativeTransitionBlock(binding.scope.block);
+}
+function updateDirectSignalChild(binding) {
+  if (binding.disposed || binding.scope.block.disposed) return;
+  try {
+    runWithBlockSignalOwner(binding.scope, () => {
+      const value = readSignalBinding(binding.handle);
+      if (Object.is(binding.value, value)) return;
+      const state = binding.scope.slots[binding.slotKey];
+      const type = typeof value;
+      const primitive = value == null || type !== "object" && type !== "function";
+      const text = primitive ? coerceChildText(value) : null;
+      if (state === void 0 && binding.text != null && text !== null && text !== "") {
+        setText(binding.text, text);
+        binding.value = value;
+        return;
+      }
+      if (state === binding.state && state?.block === null && state.forSlot === null && state.hostNode === null && state.portal === null && text !== null && text !== "" && state.text !== null) {
+        setText(state.text, text);
+        binding.value = value;
+        return;
+      }
+      scheduleRender(binding.scope.block);
+    });
+  } catch {
+    scheduleRender(binding.scope.block);
+  }
+}
+function bindSignalChild(parentScope, previous, slotKey, domParent, value, _site, anchor, ownEnd, ownsHost, compactable, onlyChild, bindingMarker) {
+  const prior = typeof previous === "object" && previous !== null && previous[DIRECT_SIGNAL_CHILD] === true ? previous : null;
+  const cachedText = prior?.text ?? (previous instanceof Text ? previous : null);
+  if (!isSignalHandle(value)) {
+    const text2 = onlyChild ? childTextHole(parentScope, slotKey, domParent, value, cachedText) : (bindingMarker === void 0 ? childSlot(parentScope, slotKey, domParent, value, anchor, ownEnd, ownsHost, compactable) : bindingChildSlot(parentScope, slotKey, domParent, value, bindingMarker, anchor, ownEnd), null);
+    if (prior !== null) {
+      if (TRANSITION_JOURNAL !== null) journalBag();
+      const finish = (discarded) => {
+        if (!discarded) disposeDirectSignalChild(prior);
+      };
+      if (WIP_CAPTURE === null) finish(false);
+      else (WIP_CAPTURE.renderCleanups ??= []).push(finish);
+    }
+    return text2;
+  }
+  if (prior !== null && !prior.disposed && prior.handle === value) {
+    const next = readSignalBinding(value);
+    if (TRANSITION_JOURNAL !== null) journalObjectOnce(prior);
+    if (onlyChild) prior.text = childTextHole(parentScope, slotKey, domParent, next, cachedText);
+    else if (bindingMarker !== void 0)
+      bindingChildSlot(parentScope, slotKey, domParent, next, bindingMarker, anchor, ownEnd);
+    else childSlot(parentScope, slotKey, domParent, next, anchor, ownEnd, ownsHost, compactable);
+    prior.value = next;
+    prior.state = parentScope.slots[slotKey];
+    return prior;
+  }
+  const initial = readSignalBinding(value);
+  const text = onlyChild ? childTextHole(parentScope, slotKey, domParent, initial, cachedText) : (bindingMarker === void 0 ? childSlot(parentScope, slotKey, domParent, initial, anchor, ownEnd, ownsHost, compactable) : bindingChildSlot(parentScope, slotKey, domParent, initial, bindingMarker, anchor, ownEnd), null);
+  if (TRANSITION_JOURNAL !== null) journalBag();
+  const binding = {
+    [DIRECT_SIGNAL_CHILD]: true,
+    scope: parentScope,
+    slotKey,
+    handle: value,
+    text,
+    state: parentScope.slots[slotKey],
+    value: initial,
+    disposed: false
+  };
+  binding.unsubscribe = value[SIGNAL_BINDING_SUBSCRIBE](
+    nativeTransitionBindingNotify(binding, () => updateDirectSignalChild(binding))
+  );
+  registerHookCleanup(parentScope, () => disposeDirectSignalChild(binding));
+  if (prior !== null) {
+    const finish = (discarded) => disposeDirectSignalChild(discarded ? binding : prior);
+    if (WIP_CAPTURE === null) finish(false);
+    else (WIP_CAPTURE.renderCleanups ??= []).push(finish);
+  }
+  return binding;
+}
+function bindingChildSlot(parentScope, slotKey, domParent, value, marker, anchor, ownEnd) {
+  const frame = PRESENTATION_HYDRATION;
+  if (frame?.revision !== void 0) {
+    const start = activeHydration()?.resolveOpen(anchor ?? null, domParent) ?? null;
+    const range = presentationRange(frame, start, marker, "slot");
+    if (value == null ? range.slot !== void 0 || getNextSibling(start) !== range.end : range.slot === void 0 || typeof value !== "function" || value[BINDING_CHILDREN_SITE] !== range.slot)
+      presentationMiss(false);
+  }
+  childSlot(
+    parentScope,
+    slotKey,
+    domParent,
+    value,
+    anchor,
+    ownEnd,
+    void 0,
+    false,
+    true,
+    void 0,
+    void 0,
+    void 0,
+    void 0,
+    void 0,
+    marker
+  );
+}
+function childSlot(parentScope, slotKey, domParent, value, anchor, ownEnd, ownsHost, compactable, includeKeyedSingle = true, compiledMapBody, compiledMapKey, compiledMapFlags, compiledMapDeps, mappedFallback, bindingMarker) {
   if (CURRENT_BLOCK?.pending && !CURRENT_BLOCK.crossRenderUpdate) return;
+  if (IMPLICIT_SIGNAL_CHILD_DEPTH === 0) {
+    const existing = parentScope.slots[slotKey];
+    const previous = existing?.implicitSignal;
+    if (isSignalHandle(value) || previous !== void 0) {
+      if (isSignalHandle(value)) enableSignalBindings();
+      IMPLICIT_SIGNAL_CHILD_DEPTH++;
+      let token;
+      try {
+        token = runWithBlockSignalOwner(
+          parentScope,
+          () => bindSignalChild(
+            parentScope,
+            previous,
+            slotKey,
+            domParent,
+            value,
+            `runtime:${slotKey}`,
+            anchor,
+            ownEnd,
+            ownsHost,
+            compactable,
+            void 0,
+            bindingMarker
+          )
+        );
+      } finally {
+        IMPLICIT_SIGNAL_CHILD_DEPTH--;
+      }
+      const state2 = parentScope.slots[slotKey];
+      if (state2 !== void 0) state2.implicitSignal = token;
+      return;
+    }
+  }
   if (value != null && includeKeyedSingle && domParent.nodeType === 1 && VOID_ELEMENTS.has(domParent.localName) && !isPortalTarget(parentScope.block, domParent)) {
     throw new Error(formatClientError(26, domParent.localName));
   }
@@ -17692,7 +20011,8 @@ function childSlot(parentScope, slotKey, domParent, value, anchor, ownEnd, ownsH
         compiledMapKey,
         compiledMapFlags,
         compiledMapDeps,
-        mappedFallback
+        mappedFallback,
+        bindingMarker
       )
     );
     return;
@@ -17753,7 +20073,8 @@ function childSlot(parentScope, slotKey, domParent, value, anchor, ownEnd, ownsH
         compiledMapKey,
         compiledMapFlags,
         compiledMapDeps,
-        mappedFallback
+        mappedFallback,
+        bindingMarker
       );
       return;
     }
@@ -17786,6 +20107,13 @@ function childSlot(parentScope, slotKey, domParent, value, anchor, ownEnd, ownsH
         hydration.claimRootRemainder(getNextSibling(end));
       }
       hydration.node = getNextSibling(start);
+    } else if (bindingMarker !== void 0) {
+      start = (STAGED_DOM?.view(document) ?? document).createComment(bindingMarker);
+      end = ownEnd && anchor != null ? anchor : (STAGED_DOM?.view(document) ?? document).createComment(HYDRATION_END);
+      (STAGED_DOM?.view(end) ?? end).data = HYDRATION_END;
+      (STAGED_DOM?.view(domParent) ?? domParent).insertBefore(start, anchor ?? null);
+      if (end !== anchor)
+        (STAGED_DOM?.view(domParent) ?? domParent).insertBefore(end, anchor ?? null);
     } else if (ownEnd && anchor != null) {
       start = null;
       end = anchor;
@@ -17815,7 +20143,8 @@ function childSlot(parentScope, slotKey, domParent, value, anchor, ownEnd, ownsH
       currentIsBodyFn: false,
       forSlot: null,
       hostNode: null,
-      portal: null
+      portal: null,
+      implicitSignal: void 0
     };
     parentScope.slots[slotKey] = state;
     registerSlot(parentScope, state);
@@ -17917,6 +20246,9 @@ function childSlot(parentScope, slotKey, domParent, value, anchor, ownEnd, ownsH
   let comp = null;
   let props = {};
   let isBodyFn = false;
+  let invocationSite;
+  let componentKey;
+  let componentHasKey = false;
   if (isHostDescriptor(value)) {
     if (pureHost) {
       if (state.block !== null || state.text !== null) clearChildContent(state);
@@ -17986,6 +20318,9 @@ function childSlot(parentScope, slotKey, domParent, value, anchor, ownEnd, ownsH
     }
     comp = activity ? dispatch.body : value.type;
     props = value.props;
+    invocationSite = value.__octaneInvocationSite;
+    componentKey = value.key;
+    componentHasKey = value.key != null;
   }
   if (comp !== null) {
     if (isBodyFn && state.block !== null && state.currentIsBodyFn) {
@@ -18015,6 +20350,15 @@ function childSlot(parentScope, slotKey, domParent, value, anchor, ownEnd, ownsH
       renderBlock(state.block);
       return;
     }
+    const signalInstanceKey = SIGNAL_BINDINGS_ENABLED || signalDocumentEnabled ? { parentScope, invocationSite, key: componentKey, hasKey: componentHasKey } : void 0;
+    const retryLocation = state.block === null && state.hostNode === null && state.text === null || parentBlock.idState.renderOwner?.signalOwner === void 0 ? void 0 : {
+      parent: parentScope,
+      slot: slotKey,
+      kind: state.__kind,
+      branch: void 0,
+      component: isBodyFn ? void 0 : comp,
+      key: void 0
+    };
     const swapDriver = TRANSITION_SWAP_DRIVER;
     const transitionMode = parentBlock.currentRenderMode === "transition";
     const committedSuspense = swapDriver !== null && state.block !== null && state.block.mounted && hydration === null && preservesCommittedSuspense(parentBlock);
@@ -18032,7 +20376,12 @@ function childSlot(parentScope, slotKey, domParent, value, anchor, ownEnd, ownsH
           state.end,
           comp,
           props,
-          renderReturnedValue
+          renderReturnedValue,
+          "dynamic",
+          void 0,
+          false,
+          signalInstanceKey,
+          retryLocation
         )
       ) : transitionSwap.render(
         parentBlock,
@@ -18040,7 +20389,12 @@ function childSlot(parentScope, slotKey, domParent, value, anchor, ownEnd, ownsH
         state.end,
         comp,
         props,
-        renderReturnedValue
+        renderReturnedValue,
+        "dynamic",
+        void 0,
+        false,
+        signalInstanceKey,
+        retryLocation
       );
       if (r.suspended || r.failed) {
         transitionSwap.dispose(r.wip);
@@ -18077,6 +20431,7 @@ function childSlot(parentScope, slotKey, domParent, value, anchor, ownEnd, ownsH
         void 0,
         renderReturnedValue
       );
+      if (signalInstanceKey !== void 0) SCOPE_SIGNAL_INSTANCE_KEYS.set(b2, signalInstanceKey);
       preserveRootCreatedDom(b2);
       if (state.borrowed) b2.exclusiveMarkers = true;
       b2.$$implicitBail = true;
@@ -18108,7 +20463,9 @@ function childSlot(parentScope, slotKey, domParent, value, anchor, ownEnd, ownsH
             renderReturnedValue,
             "dynamic",
             void 0,
-            implicitBail
+            implicitBail,
+            signalInstanceKey,
+            retryLocation
           )
         ) : renderOffscreen(
           parentBlock,
@@ -18119,7 +20476,9 @@ function childSlot(parentScope, slotKey, domParent, value, anchor, ownEnd, ownsH
           renderReturnedValue,
           "dynamic",
           void 0,
-          implicitBail
+          implicitBail,
+          signalInstanceKey,
+          retryLocation
         );
         if (r.suspended || r.failed) {
           disposeWip(r.wip);
@@ -18168,6 +20527,7 @@ function childSlot(parentScope, slotKey, domParent, value, anchor, ownEnd, ownsH
       void 0,
       renderReturnedValue
     );
+    if (signalInstanceKey !== void 0) SCOPE_SIGNAL_INSTANCE_KEYS.set(b, signalInstanceKey);
     if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__ && comp !== hostElementBody)
       __profileTrackComponent(b, !isBodyFn || __profileHasComponentMetadata(comp) ? comp : null);
     if (state.borrowed) b.exclusiveMarkers = true;
@@ -18896,6 +21256,7 @@ function releaseHiddenText(text, restore = true) {
   }
 }
 function teardownTrySlot(state, detachDom) {
+  if (state.retrySignalOwners !== void 0) clearSignalRetryOwners(state);
   initialSuspenseHydrations?.delete(state);
   cancelSuspenseRetry(state);
   HIDDEN_REVEAL_ACTIONS?.delete(state);
@@ -18966,7 +21327,7 @@ function clearPassthroughTry(state) {
   state.tryBlock = null;
 }
 function mountPassthroughCatch(state, error, reportInline = false) {
-  if (error instanceof NativeAdoptionMiss) throw error;
+  if (isAdoptionControl(error)) throw error;
   clearPassthroughTry(state);
   state.pendingThenable = null;
   setTryBranch(state, 0);
@@ -19142,7 +21503,7 @@ function errorBlock(parentScope, slotKey, domParent, tryBody, catchBody, anchor,
     try {
       renderBlock(current);
     } catch (error) {
-      if (isHostContextRequest(error) || isSuspenseException(error) || error instanceof NativeAdoptionMiss)
+      if (isHostContextRequest(error) || isSuspenseException(error) || isAdoptionControl(error))
         throw error;
       switchErrorToCatch(state, error, true);
     }
@@ -19203,7 +21564,7 @@ function errorBlock(parentScope, slotKey, domParent, tryBody, catchBody, anchor,
     renderBlock(body);
     state.hasResolved = true;
   } catch (error) {
-    if (isHostContextRequest(error) || isSuspenseException(error) || error instanceof NativeAdoptionMiss)
+    if (isHostContextRequest(error) || isSuspenseException(error) || isAdoptionControl(error))
       throw error;
     const adoptServerCatch = hydration?.isRejection(error) === true;
     switchErrorToCatch(
@@ -19220,7 +21581,7 @@ function errorBlock(parentScope, slotKey, domParent, tryBody, catchBody, anchor,
   return state.reset;
 }
 function switchErrorToCatch(state, error, reportInline = false, adoptedStart, adoptedEnd) {
-  if (error instanceof NativeAdoptionMiss) throw error;
+  if (isAdoptionControl(error)) throw error;
   const frame = beginDetachedBoundaryRender(state);
   try {
     switchErrorToCatchInner(state, error, reportInline, adoptedStart, adoptedEnd);
@@ -19361,6 +21722,8 @@ function tryBlock(parentScope, slotKey, domParent, tryBody, catchBody, pendingBo
     registerSlot(parentScope, newState);
     state = newState;
   } else {
+    if (state.retrySignalOwners !== void 0 && (state.tryBody !== tryBody || state.env !== env && depsChanged(state.env, env)))
+      clearSignalRetryOwners(state);
     state.tryBody = tryBody;
     state.catchBody = catchBody;
     state.pendingBody = pendingBody;
@@ -19432,8 +21795,7 @@ function renderVisibleTry(state, source) {
         if (effectDeps !== null) restoreSubtreeEffectDeps(block, effectDeps);
         discardOffscreenCapture(capture);
       }
-      if (isHostContextRequest(renderError) || renderError instanceof NativeAdoptionMiss)
-        throw renderError;
+      if (isHostContextRequest(renderError) || isAdoptionControl(renderError)) throw renderError;
       if (isSuspenseException(renderError)) {
         if (state.propagateSuspense) throw renderError;
         handleSuspense(state, renderError.thenable, block, journalCheckpoint, source ?? block);
@@ -19475,6 +21837,7 @@ function createTryBody(state, start, end) {
   return block;
 }
 function restartUncommittedTry(state) {
+  if (state.retrySignalOwners !== void 0) clearSignalRetryOwners(state);
   HIDDEN_REVEAL_ACTIONS?.delete(state);
   const old = state.tryBlock;
   const refs = [];
@@ -19595,6 +21958,8 @@ function renderInitialSuspenseHydration(state, initial) {
   hydration.claimRootRemainder(initial.end);
   hydration.protectRootAnchor(initial.end);
   const previousHydration = currentHydration;
+  if (previousHydration?.retryPresentation !== void 0)
+    hydration.retryPresentation = previousHydration.retryPresentation;
   const previousCapture = WIP_CAPTURE;
   const capture = createOffscreenCapture();
   currentHydration = hydration;
@@ -19622,7 +21987,19 @@ function renderInitialSuspenseHydration(state, initial) {
     if (isSuspenseException(error)) suspended = error.thenable;
     const refs = [];
     collectVisibleSubtreeRefs(block, refs);
-    withRefDetachSuppression(refs, () => unmountBlock(block, false));
+    const previousRetained = RETAINED_SIGNAL_OWNERS;
+    if (suspended !== null && state.parentBlock.idState.renderOwner?.signalOwner !== void 0) {
+      retainSignalRetryScope(block, block, state, true);
+      for (const created of ROOT_RENDER_TRANSACTION?.created ?? [])
+        if (!created.disposed && blockIsAncestorOf(block, created))
+          retainSignalRetryScope(created, block, state);
+      RETAINED_SIGNAL_OWNERS = state.retrySignalOwners;
+    } else if (state.retrySignalOwners !== void 0) clearSignalRetryOwners(state);
+    try {
+      withRefDetachSuppression(refs, () => unmountBlock(block, false));
+    } finally {
+      RETAINED_SIGNAL_OWNERS = previousRetained;
+    }
     state.block = null;
     state.tryBlock = null;
     discardOffscreenCapture(capture);
@@ -19633,6 +22010,7 @@ function renderInitialSuspenseHydration(state, initial) {
     if (previousHydration !== null) previousHydration.node = state.end;
   }
   if (!failed) {
+    if (state.retrySignalOwners !== void 0) clearSignalRetryOwners(state);
     initialSuspenseHydrations?.delete(state);
     (capture.renderCleanups ??= []).push((discarded) => {
       if (discarded) return;
@@ -19652,7 +22030,7 @@ function renderInitialSuspenseHydration(state, initial) {
     return;
   }
   initialSuspenseHydrations?.delete(state);
-  if (failure instanceof NativeAdoptionMiss || isHostContextRequest(failure)) throw failure;
+  if (isAdoptionControl(failure) || isHostContextRequest(failure)) throw failure;
   const adoptServerCatch = hydration.isRejection(failure);
   if (!adoptServerCatch) removeRange(getNextSibling(initial.start), initial.end);
   const outerHydration = currentHydration;
@@ -19676,6 +22054,7 @@ function renderInitialSuspenseHydration(state, initial) {
   }
 }
 function mountTry(state) {
+  if (state.retrySignalOwners !== void 0) clearSignalRetryOwners(state);
   cancelSuspenseRetry(state);
   HIDDEN_REVEAL_ACTIONS?.delete(state);
   const wasPending = state.branch === 2;
@@ -19794,7 +22173,7 @@ function mountTry(state) {
     state.hasResolved = true;
     if (wasPending) recordSuspenseCommit(state);
   } catch (err) {
-    if (isHostContextRequest(err) || err instanceof NativeAdoptionMiss) throw err;
+    if (isHostContextRequest(err) || isAdoptionControl(err)) throw err;
     if (isSuspenseException(err)) {
       if (state.propagateSuspense) throw err;
       handleSuspense(state, err.thenable, b);
@@ -19911,6 +22290,10 @@ function releaseHeldTransition(state) {
   }
 }
 function handleSuspense(state, thenable, sourceBlock, journalCheckpoint = -1, transitionOrigin = sourceBlock) {
+  if (NATIVE_TRANSITION_ATTEMPT !== null) {
+    NATIVE_TRANSITION_ATTEMPT.suspensions.set(state, thenable);
+    throw new SuspenseException(thenable);
+  }
   ensureScheduledVisibilityDriver();
   const isTransition = sourceBlock.currentRenderMode === "transition";
   if (isTransition && state.hasResolved && state.branch === 1 && state.hiddenDom === null) {
@@ -20432,6 +22815,10 @@ function attemptHiddenReveal(state, scheduledMode, reason = "update") {
   }
 }
 function attemptHiddenRevealInner(state, scheduledMode, reason = "update") {
+  if (state.nativeTransition !== void 0 && NATIVE_TRANSITION_ATTEMPT === null) {
+    queueNativeTransition(state.nativeTransition);
+    return;
+  }
   const retryOnly = reason === "retry";
   let tryBlock2 = state.tryBlock;
   if (tryBlock2 === null || tryBlock2.disposed || state.hiddenDom === null) return;
@@ -20493,6 +22880,7 @@ function attemptHiddenRevealInner(state, scheduledMode, reason = "update") {
   if (didThrow) {
     restoreSubtreeEffectDeps(tryBlock2, effectDeps);
     discardOffscreenCapture(hiddenCapture);
+    if (NATIVE_TRANSITION_ATTEMPT !== null) throw thrown;
     if (isSuspenseException(thrown)) {
       deactivateScope(tryBlock2, false);
       hideTryBlock(state);
@@ -20704,6 +23092,7 @@ function startTransition(fn) {
 }
 function runTransition(fn, hook) {
   ensureTransitionSwapDriver();
+  ensureNativeActionResolver();
   TRANSITION_DEPTH++;
   const parentActionBatch = ACTIVE_TRANSITION_ACTION_BATCH;
   const pendingActionBatch = IN_FLIGHT_TRANSITION_ACTION_BATCH;
@@ -20720,7 +23109,18 @@ function runTransition(fn, hook) {
   try {
     tickTransitionCount(1);
     try {
-      result = fn();
+      const previousCandidate = activeCandidate;
+      const nativeResolver = setNativeCandidateResolver(() => {
+        const candidate = nativeCandidateForAction(actionBatch);
+        swapActiveSignalCandidate(candidate);
+        return candidate;
+      });
+      try {
+        result = fn();
+      } finally {
+        swapActiveSignalCandidate(previousCandidate);
+        setNativeCandidateResolver(nativeResolver);
+      }
       if (result != null && typeof result.then === "function") {
         actionBatch.pendingActions++;
         IN_FLIGHT_TRANSITION_ACTION_BATCH = actionBatch;
@@ -21114,7 +23514,7 @@ function forwardFallbackSuspension(fallbackBlock, error) {
   return true;
 }
 function switchToCatch(state, err, reportInline = false, adoptedStart, adoptedEnd) {
-  if (err instanceof NativeAdoptionMiss) throw err;
+  if (isAdoptionControl(err)) throw err;
   const frame = beginDetachedBoundaryRender(state);
   try {
     switchToCatchInner(state, err, reportInline, adoptedStart, adoptedEnd);
@@ -21126,6 +23526,7 @@ function switchToCatch(state, err, reportInline = false, adoptedStart, adoptedEn
   }
 }
 function switchToCatchInner(state, err, reportInline, adoptedStart, adoptedEnd) {
+  if (state.retrySignalOwners !== void 0) clearSignalRetryOwners(state);
   cancelSuspenseRetry(state);
   HIDDEN_REVEAL_ACTIONS?.delete(state);
   const hydration = activeHydration();
@@ -21250,7 +23651,7 @@ function findTryHandler(block) {
   return rendererRegionTryHandler(origin);
 }
 function handleRenderError(block, err, attempt = null) {
-  if (err instanceof NativeAdoptionMiss) throw err;
+  if (isAdoptionControl(err)) throw err;
   if (isHostContextRequest(err)) {
     const bridge = rendererRegionOwnerForBlock(block);
     if (bridge !== null && bridge.routeSuspense(err.thenable)) return;
@@ -21440,7 +23841,17 @@ function renderBranchSlot(parentScope, slotKey, state, domParent, next, body, ma
           void 0,
           null,
           "control-flow",
-          env
+          env,
+          false,
+          void 0,
+          parentBlock.idState.renderOwner?.signalOwner === void 0 ? void 0 : {
+            parent: parentScope,
+            slot: slotKey,
+            kind: state.__kind,
+            branch: next,
+            component: void 0,
+            key: void 0
+          }
         );
         if (r.suspended || r.failed) {
           disposeWip(r.wip);
@@ -21477,7 +23888,17 @@ function renderBranchSlot(parentScope, slotKey, state, domParent, next, body, ma
           void 0,
           null,
           "control-flow",
-          env
+          env,
+          false,
+          void 0,
+          parentBlock.idState.renderOwner?.signalOwner === void 0 ? void 0 : {
+            parent: parentScope,
+            slot: slotKey,
+            kind: state.__kind,
+            branch: next,
+            component: void 0,
+            key: void 0
+          }
         );
         if (r.suspended || r.failed) {
           transitionSwap.dispose(r.wip);
@@ -21547,6 +23968,8 @@ function renderBranchSlot(parentScope, slotKey, state, domParent, next, body, ma
           inner = getNextSibling(state.start);
           innerEnd = hydration.close(inner);
           if (innerEnd !== state.end && getNextSibling(innerEnd) !== state.end) {
+            if (PRESENTATION_HYDRATION?.revision !== void 0)
+              throw new Error(formatClientError(75));
             if (process.env.NODE_ENV !== "production") {
               const mmLoc = siteLoc(parentScope, slotKey);
               if (mmLoc)
@@ -21590,6 +24013,7 @@ function renderBranchSlot(parentScope, slotKey, state, domParent, next, body, ma
           renderBlock(b);
         }
       } else if (hydration !== null && getNextSibling(state.start) !== state.end) {
+        if (PRESENTATION_HYDRATION?.revision !== void 0) throw new Error(formatClientError(75));
         if (process.env.NODE_ENV !== "production") {
           const mmLoc = siteLoc(parentScope, slotKey);
           if (mmLoc)
@@ -22163,7 +24587,8 @@ function detachSubtreeRefs(scope, out, shouldDetach = true, includeHiddenTry = t
         } else if (kind === "s") {
           const el = bag[rm[j + 2]];
           if (el == null) continue;
-          const ref = bag[rm[j + 1]]?.ref ?? activityRefs?.get(el)?.connected;
+          const spread = bag[rm[j + 1]];
+          const ref = (spread?.[SIGNAL_HOST_PROP_SOURCES] === true ? spread.resolved : spread)?.ref ?? activityRefs?.get(el)?.connected;
           if (ref == null) continue;
           out.push({ ref, el, scope });
           if (shouldDetach && !refAttachWasDiscarded(uncommitted, el, ref)) {
@@ -22245,7 +24670,7 @@ function deactivateScope(scope, disconnectPassive = true) {
         const cleanup = e.cleanup;
         e.cleanup = void 0;
         try {
-          if (!staged) runEffectCleanupCallback(cleanup, e.phase);
+          if (!staged) runEffectCleanupCallback(cleanup, e.phase, scope);
         } catch (err) {
           if (err instanceof MaximumUpdateDepthError) throw err;
           const handler = findTryHandler(scope.block);
@@ -22544,6 +24969,7 @@ function mountFastHostItems(parentScope, state, parentNode, items, getKey, itemB
       );
       current = block;
       block.forSlot = state;
+      block.key = key;
       block.itemIndex = index;
       block.currentRenderMode = renderMode;
       block.currentRenderDeferred = deferred;
@@ -22558,7 +24984,6 @@ function mountFastHostItems(parentScope, state, parentNode, items, getKey, itemB
       block.startMarker = root;
       block.endMarker = root;
       state.items.set(key, block);
-      block.key = key;
       block.prevSibling = previous;
       if (previous !== null) previous.nextSibling = block;
       else state.head = block;
@@ -22816,6 +25241,7 @@ function checkedListKey(keySource, normalizeKey) {
 }
 function mountItemsLinear(parentBlock, state, items, keySource, itemBody, singleRoot, ssrMarkerless, normalizeKey = false) {
   const newLen = items.length;
+  const observeKey = parentBlock.idState.renderOwner?.signalOwner !== void 0 ? trackSignalRetryListKeys(parentBlock, state, newLen, keySource) : void 0;
   if (newLen === 0) return;
   if (process.env.NODE_ENV !== "production") {
     keySource = checkedListKey(keySource, normalizeKey);
@@ -22839,6 +25265,7 @@ function mountItemsLinear(parentBlock, state, items, keySource, itemBody, single
     for (let i = 0; i < newLen; i++) {
       const item = items[i];
       const key = readListKey(keySource, item, i, normalizeKey);
+      if (observeKey !== void 0) observeKey(i, key);
       let adoptNode = null;
       let anchor = state.end;
       if (adoptByKey !== null) {
@@ -22862,6 +25289,7 @@ function mountItemsLinear(parentBlock, state, items, keySource, itemBody, single
         anchor,
         item,
         i,
+        key,
         itemBody,
         state,
         singleRoot,
@@ -22869,7 +25297,6 @@ function mountItemsLinear(parentBlock, state, items, keySource, itemBody, single
         adoptNode
       );
       oldItems.set(key, block);
-      block.key = key;
       block.prevSibling = prev;
       block.nextSibling = null;
       if (prev) prev.nextSibling = block;
@@ -22884,7 +25311,9 @@ function mountItemsLinear(parentBlock, state, items, keySource, itemBody, single
       prev = block.prevSibling;
       oldItems.delete(block.key);
       if (isSuspenseException(error)) retainDiscardedWarmMemos(block);
-      unmountBlock(block, !ROOT_RENDER_TRANSACTION?.retainedCreated?.has(block));
+      if (block.idState.renderOwner?.signalOwner !== void 0)
+        discardSignalRetryItem(block, error);
+      else unmountBlock(block, !ROOT_RENDER_TRANSACTION?.retainedCreated?.has(block));
     }
     state.head = null;
     state.tail = null;
@@ -22919,6 +25348,7 @@ function reconcileKeyed(parentBlock, state, items, keySource, itemBody, pure, si
     );
     return;
   }
+  const observeKey = parentBlock.idState.renderOwner?.signalOwner !== void 0 ? trackSignalRetryListKeys(parentBlock, state, newLen, keySource) : void 0;
   if (process.env.NODE_ENV !== "production") {
     keySource = checkedListKey(keySource, normalizeKey);
     normalizeKey = false;
@@ -22940,6 +25370,7 @@ function reconcileKeyed(parentBlock, state, items, keySource, itemBody, pure, si
     const newItem = items[prefixLen];
     const newKey = readListKey(keySource, newItem, prefixLen, normalizeKey);
     if (oldFirst.key !== newKey) break;
+    if (observeKey !== void 0) observeKey(prefixLen, newKey);
     const block = oldFirst;
     if (!pure || block.props !== newItem || block.body !== itemBody || block.itemIndex !== prefixLen)
       updateSurvivor(block, newItem, prefixLen, itemBody, pure, lite, indexIndependent, state.env);
@@ -22954,6 +25385,7 @@ function reconcileKeyed(parentBlock, state, items, keySource, itemBody, pure, si
     const newItem = items[newEnd];
     const newKey = readListKey(keySource, newItem, newEnd, normalizeKey);
     if (oldLast.key !== newKey) break;
+    if (observeKey !== void 0) observeKey(newEnd, newKey);
     const block = oldLast;
     if (!pure || block.props !== newItem || block.body !== itemBody || block.itemIndex !== newEnd)
       updateSurvivor(block, newItem, newEnd, itemBody, pure, lite, indexIndependent, state.env);
@@ -22977,19 +25409,20 @@ function reconcileKeyed(parentBlock, state, items, keySource, itemBody, pure, si
     for (let i = prefixLen; i <= newEnd; i++) {
       const item = items[i];
       const key = readListKey(keySource, item, i, normalizeKey);
+      if (observeKey !== void 0) observeKey(i, key);
       const block = mountItem(
         parentBlock,
         parentNode,
         anchor,
         item,
         i,
+        key,
         itemBody,
         state,
         singleRoot,
         ssrMarkerless
       );
       oldItems.set(key, block);
-      block.key = key;
       block.prevSibling = prev;
       block.nextSibling = afterMiddle;
       if (prev) prev.nextSibling = block;
@@ -23027,6 +25460,7 @@ function reconcileKeyed(parentBlock, state, items, keySource, itemBody, pure, si
     const key = readListKey(keySource, items[prefixLen + i], prefixLen + i, normalizeKey);
     newKeys[i] = key;
     newKeysToIdx.set(key, i);
+    if (observeKey !== void 0) observeKey(prefixLen + i, key);
   }
   if (beforeMiddle === null && afterMiddle === null && !newKeysToIdx.has(oldFirst.key)) {
     let anySurvivors = false;
@@ -23054,13 +25488,13 @@ function reconcileKeyed(parentBlock, state, items, keySource, itemBody, pure, si
           state.end,
           item,
           i,
+          key,
           itemBody,
           state,
           singleRoot,
           ssrMarkerless
         );
         oldItems.set(key, block);
-        block.key = key;
         block.prevSibling = prev;
         block.nextSibling = null;
         if (prev) prev.nextSibling = block;
@@ -23221,13 +25655,13 @@ function reconcileKeyed(parentBlock, state, items, keySource, itemBody, pure, si
           anchor,
           items[targetIdx],
           targetIdx,
+          key,
           itemBody,
           state,
           singleRoot,
           ssrMarkerless
         );
         oldItems.set(key, block);
-        block.key = key;
         state.size++;
       } else block = oldItems.get(key);
       block.prevSibling = previous;
@@ -23349,7 +25783,7 @@ function batchClearItems(state, oldItems, ownedRootClear = false) {
   }
   oldItems.clear();
 }
-function mountItem(parentBlock, parentNode, anchor, item, index, body, forSlot, singleRoot, ssrMarkerless, adoptNode = null) {
+function mountItem(parentBlock, parentNode, anchor, item, index, key, body, forSlot, singleRoot, ssrMarkerless, adoptNode = null) {
   const hydration = activeHydration();
   if (hydration !== null) {
     if (ssrMarkerless && !hydration.isOpen(hydration.node) && (singleRoot !== 2 || forSlot.plainDeopt !== true || isHostDescriptor(item) && !descNeedsBlocks(item))) {
@@ -23366,6 +25800,7 @@ function mountItem(parentBlock, parentNode, anchor, item, index, body, forSlot,
           forSlot.env
         );
         block3.forSlot = forSlot;
+        block3.key = key;
         block3.itemIndex = index;
         if (singleRoot === 2 && forSlot.plainDeopt === true) block3.deoptNode = root;
         renderBlock(block3);
@@ -23384,6 +25819,7 @@ function mountItem(parentBlock, parentNode, anchor, item, index, body, forSlot,
           anchor,
           item,
           index,
+          key,
           body,
           forSlot,
           singleRoot,
@@ -23404,6 +25840,7 @@ function mountItem(parentBlock, parentNode, anchor, item, index, body, forSlot,
           anchor,
           item,
           index,
+          key,
           body,
           forSlot,
           singleRoot,
@@ -23425,6 +25862,7 @@ function mountItem(parentBlock, parentNode, anchor, item, index, body, forSlot,
       forSlot.env
     );
     block2.forSlot = forSlot;
+    block2.key = key;
     block2.itemIndex = index;
     renderBlock(block2);
     hydration.node = getNextSibling(itemEnd);
@@ -23443,6 +25881,7 @@ function mountItem(parentBlock, parentNode, anchor, item, index, body, forSlot,
         forSlot.env
       );
       block3.forSlot = forSlot;
+      block3.key = key;
       block3.itemIndex = index;
       block3.deoptNode = adoptNode;
       preserveRootCreatedDom(block3);
@@ -23460,6 +25899,7 @@ function mountItem(parentBlock, parentNode, anchor, item, index, body, forSlot,
       forSlot.env
     );
     block2.forSlot = forSlot;
+    block2.key = key;
     block2.itemIndex = index;
     renderBlock(block2);
     const root = (STAGED_DOM?.view(anchor) ?? anchor).previousSibling;
@@ -23487,6 +25927,7 @@ function mountItem(parentBlock, parentNode, anchor, item, index, body, forSlot,
     forSlot.env
   );
   block.forSlot = forSlot;
+  block.key = key;
   block.itemIndex = index;
   if (adoptNode !== null) {
     block.deoptNode = adoptNode;
@@ -23540,8 +25981,29 @@ function moveFocusedNodeBefore(parent, node, anchor, snapshots) {
   } else if (snapshots.focused.ownerDocument === node.ownerDocument) {
     snapshot = snapshots;
   }
+  if (STAGED_DOM === null) {
+    moveNativeNodeBefore(
+      parent,
+      node,
+      anchor,
+      snapshot?.focused ?? null,
+      snapshot?.contentEditable ?? false
+    );
+    return;
+  }
   const focused = snapshot?.focused ?? null;
-  if (focused === null || node !== focused && (node.nodeType !== 1 || !(STAGED_DOM?.view(node) ?? node).contains(focused))) {
+  let containsFocused = node === focused;
+  if (!containsFocused && focused !== null && node.nodeType === 1) {
+    let candidate = focused;
+    do {
+      if (STAGED_DOM.view(node).contains(candidate)) {
+        containsFocused = true;
+        break;
+      }
+      candidate = STAGED_DOM.view(candidate).getRootNode().host;
+    } while (candidate !== void 0);
+  }
+  if (!containsFocused) {
     (STAGED_DOM?.view(parent) ?? parent).insertBefore(node, anchor);
     return;
   }
@@ -23631,6 +26093,7 @@ function coalesceHydratedRanges(rootBlock, liteRanges) {
   }
   function makeGroup(startNode, endNode, block, liteScope, owner) {
     if (!isBlockOpen(startNode) || !isBlockClose(endNode) || startNode === endNode) return null;
+    if (isBindingOpenComment((STAGED_DOM?.view(startNode) ?? startNode).data)) return null;
     if ((STAGED_DOM?.view(startNode) ?? startNode).parentNode === null || (STAGED_DOM?.view(startNode) ?? startNode).parentNode !== (STAGED_DOM?.view(endNode) ?? endNode).parentNode)
       return null;
     const openDepth = hydrationMarkerMultiplicity(
@@ -24171,7 +26634,7 @@ function validateRootHtmlNesting(container, body) {
     }
   }
 }
-function makeRoot(container, rootBlock, currentBody, currentKey, idState, outputHandler, ownerToken, errorOptions) {
+function makeRoot(container, rootBlock, currentBody, currentKey, idState, outputHandler, ownerToken, signalOwner, errorOptions) {
   let root;
   let unmounted = false;
   let nestedRootRenderChain = -1;
@@ -24190,6 +26653,7 @@ function makeRoot(container, rootBlock, currentBody, currentKey, idState, output
   };
   const renderOwner = {
     current: rootBlock,
+    signalOwner,
     retry: noop,
     request: null,
     generation: 0,
@@ -24389,6 +26853,7 @@ function makeRoot(container, rootBlock, currentBody, currentKey, idState, output
         else VIEW_TRANSITION_DRIVER?.refreshPendingOwner(renderOwner);
       }
       renderOwner.nativeRetry?.clear();
+      if (renderOwner.retrySignalOwners !== void 0) clearSignalRetryOwners(renderOwner);
       renderOwner.retryKey = null;
       renderOwner.request = null;
       if (renderOwner.transaction?.aborted === true) renderOwner.transaction = null;
@@ -24398,6 +26863,15 @@ function makeRoot(container, rootBlock, currentBody, currentKey, idState, output
     unmount() {
       if (arguments.length > 0) warnRootUnmountArgument();
       if (unmounted) return;
+      let presentationRefs = null;
+      if (renderOwner.bindingLeases !== void 0)
+        for (const lease of renderOwner.bindingLeases) {
+          const frame = PRESENTATION_PREPARATIONS.get(lease);
+          if (frame?.revision !== void 0) {
+            collectVisibleSubtreeRefs(frame.scope, presentationRefs ??= []);
+          }
+        }
+      if (presentationRefs !== null) renderOwner.generation++;
       if (!inFlush && CURRENT_BLOCK === null && !inNestedUpdateCallback() && EFFECT_EVENT_LIFECYCLE_DEPTH === 0) {
         VIEW_TRANSITION_DRIVER?.interrupt();
         if (unmounted) return;
@@ -24405,12 +26879,25 @@ function makeRoot(container, rootBlock, currentBody, currentKey, idState, output
       if (!inFlush && CURRENT_BLOCK === null && !inNestedUpdateCallback() && EFFECT_EVENT_LIFECYCLE_DEPTH === 0) {
         UPDATE_CHAIN_ID++;
       }
-      if (process.env.NODE_ENV !== "production" && (inFlush || CURRENT_BLOCK !== null || EFFECT_BODY_DEPTH > 0 || EFFECT_EVENT_LIFECYCLE_DEPTH > 0)) {
+      if (process.env.NODE_ENV !== "production" && !renderOwner.preservePresentation && (inFlush || CURRENT_BLOCK !== null || EFFECT_BODY_DEPTH > 0 || EFFECT_EVENT_LIFECYCLE_DEPTH > 0)) {
         warnRootLifecycleUnmount();
       }
       unmounted = true;
       renderOwner.disposed = true;
+      if (renderOwner.bindingLeases !== void 0) {
+        for (const lease of renderOwner.bindingLeases) {
+          releaseBindingHandoff(lease);
+          PRESENTATION_PREPARATIONS.delete(lease);
+          try {
+            if (!renderOwner.preservePresentation) lease.retire();
+          } catch (error) {
+            if (!reportUncaughtError(rootBlock, error)) console.error(error);
+          }
+        }
+        renderOwner.bindingLeases.clear();
+      }
       renderOwner.nativeRetry?.clear();
+      if (renderOwner.retrySignalOwners !== void 0) clearSignalRetryOwners(renderOwner);
       renderOwner.retry = noop;
       if (renderOwner.transition !== void 0) TRANSITION_SWAP_DRIVER.discardRoot(renderOwner);
       renderOwner.generation++;
@@ -24424,13 +26911,9 @@ function makeRoot(container, rootBlock, currentBody, currentKey, idState, output
             __devtoolsUnregisterRoot(
               rootBlock
             );
-          unmountBlock(
-            rootBlock,
-            /*detachDom*/
-            false
-          );
+          withRefDetachSuppression(presentationRefs, () => unmountBlock(rootBlock, false));
           drainRefDetaches();
-          clearRootContainer(container);
+          if (!renderOwner.preservePresentation) clearRootContainer(container);
           drainDeferredPassiveUnmounts();
           rootBlock = null;
           currentBody = null;
@@ -24461,20 +26944,24 @@ function makeRoot(container, rootBlock, currentBody, currentKey, idState, output
 }
 function createRootWithOutputHandler(container, options, outputHandler) {
   assertValidRootContainer(container);
+  if (options?.bindingLeases !== void 0) throw new Error(formatClientError(76));
   options = warnCreateRootElementOption(options);
   const ownerToken = claimRootContainer(container);
   registerDelegationTarget(container, true);
+  const rootPrefix = (options?.identifierPrefix ?? "") + "r" + (nextClientRootId++).toString(36) + "-";
   return makeRoot(
     container,
     null,
     null,
     null,
     {
-      prefix: (options?.identifierPrefix ?? "") + "r" + (nextClientRootId++).toString(36) + "-",
-      next: 0
+      prefix: rootPrefix,
+      next: 0,
+      signalState: { prefix: options?.signalInstancePrefix ?? rootPrefix, next: 0 }
     },
     outputHandler,
     ownerToken,
+    options?.signalOwner ?? (signalDocumentEnabled ? documentSignalOwner(container) : void 0),
     options
   );
 }
@@ -24514,6 +27001,15 @@ function hydrateRoot(container, bodyOrElement, propsOrOptions, rootOptions) {
     body = ROOT_RENDERABLE_BODY;
     props = bodyOrElement;
   }
+  const bindingLeases = rootOptions?.bindingLeases?.map((handle) => {
+    const capability = handle;
+    const lease = capability[BINDING_HANDOFF]?.();
+    if (lease === void 0 || !lease.active() || lease.owner !== void 0 || !container.contains(lease.root))
+      throw new Error(formatClientError(77));
+    return lease;
+  });
+  if (bindingLeases !== void 0 && new Set(bindingLeases).size !== bindingLeases.length)
+    throw new Error(formatClientError(78));
   const nativeSidecar = findHydrateSeedSidecar(container, NATIVE_SIGNAL_SEED_ATTR);
   const nativeManifest = nativeSidecar === null ? void 0 : parseNativeSignalManifest(
     (STAGED_DOM?.view(nativeSidecar) ?? nativeSidecar).textContent || ""
@@ -24541,7 +27037,11 @@ function hydrateRoot(container, bodyOrElement, propsOrOptions, rootOptions) {
   }
   const idState = {
     prefix: rootOptions?.identifierPrefix ?? "",
-    next: 0
+    next: rootOptions?.identifierSeed ?? 0,
+    signalState: {
+      prefix: rootOptions?.signalInstancePrefix ?? rootOptions?.identifierPrefix ?? "",
+      next: 0
+    }
   };
   rootBlock.idState = idState;
   registerRootErrorHandlers(rootBlock, rootOptions);
@@ -24567,9 +27067,15 @@ function hydrateRoot(container, bodyOrElement, propsOrOptions, rootOptions) {
     idState,
     renderReturnedValue,
     ownerToken,
+    rootOptions?.signalOwner ?? (signalDocumentEnabled ? documentSignalOwner(container) : void 0),
     rootOptions
   );
   const owner = idState.renderOwner;
+  if (bindingLeases !== void 0) {
+    owner.bindingLeases = new Set(bindingLeases);
+    owner.bindingContainer = container;
+    for (const lease of bindingLeases) claimBindingHandoff(lease, owner);
+  }
   const adopt = () => {
     if (owner.disposed) return;
     if (rootBlock.disposed) {
@@ -24593,11 +27099,29 @@ function hydrateRoot(container, bodyOrElement, propsOrOptions, rootOptions) {
     owner.transaction.hydrating = true;
     createdInRootRender(rootBlock);
     journalRootProperty(idState, "next", idState.next);
-    idState.next = 0;
+    idState.next = rootOptions?.identifierSeed ?? 0;
     let firstNode = getFirstChild(container);
     while (firstNode !== null && (firstNode.nodeType === 10 || isRendererHydrationStyle(firstNode)))
       firstNode = getNextSibling(firstNode);
     const hydration = new HydrationCapability(rootBlock, firstNode, seeds);
+    if (bindingLeases?.some((lease) => lease.revision !== void 0)) {
+      const attempted = rootBlock;
+      hydration.retryPresentation = () => {
+        if (owner.disposed || owner.current !== attempted) return;
+        const refs = [];
+        collectVisibleSubtreeRefs(attempted, refs);
+        withRefDetachSuppression(refs, () => unmountBlock(attempted, false));
+        queueMicrotask(() => {
+          if (!owner.disposed && owner.current === attempted) adopt();
+        });
+      };
+    }
+    if (firstNode?.nodeType === 8 && (STAGED_DOM?.view(firstNode) ?? firstNode).data === body[BINDING_VIEW_ROOT]) {
+      rootBlock.startMarker = firstNode;
+      rootBlock.endMarker = hydration.close(firstNode);
+      hydration.claimRootRemainder(getNextSibling(rootBlock.endMarker));
+      hydration.node = getNextSibling(firstNode);
+    }
     if (nativeManifest !== void 0)
       hydration.nativeAdoption = ownNativeAdoption(rootBlock, nativeManifest);
     hydration.passthroughRanges = body[HYDRATION_RANGE_BOUNDARY] === "passthrough";
@@ -24618,7 +27142,22 @@ function hydrateRoot(container, bodyOrElement, propsOrOptions, rootOptions) {
       hydration.finishRoot();
       completed = true;
     } catch (error) {
-      if (error instanceof NativeAdoptionMiss) {
+      if (error instanceof PresentationAdoptionMiss) {
+        rollbackRootRender(owner.transaction);
+        const refs = [];
+        collectVisibleSubtreeRefs(rootBlock, refs);
+        withRefDetachSuppression(refs, () => unmountBlock(rootBlock, false));
+        if (error.retry && error.lease?.active()) {
+          retryPresentationMiss(error, () => {
+            if (!owner.disposed) adopt();
+          });
+        } else {
+          owner.preservePresentation = true;
+          root.unmount();
+          if (!Object.prototype.hasOwnProperty.call(error, "failure")) throw error;
+          if (!reportUncaughtError(rootBlock, error.failure)) throw error.failure;
+        }
+      } else if (error instanceof NativeAdoptionMiss) {
         nativeRecovery = error;
         rollbackRootRender(owner.transaction);
         unmountBlock(rootBlock, false);
@@ -24642,13 +27181,13 @@ function hydrateRoot(container, bodyOrElement, propsOrOptions, rootOptions) {
     }
     if (nativeRecovery !== void 0 && !owner.disposed) {
       noteRecoverableHydrationError(() => nativeRecovery, rootBlock);
-      idState.next = 0;
+      idState.next = rootOptions?.identifierSeed ?? 0;
       if (isElementDescriptor(bodyOrElement)) root.render(bodyOrElement);
       else root.render(body, props);
       return;
     }
     if (!completed) return;
-    if (hydration.hasAdjacentRangePair) hydration.coalesce();
+    if (hydration.hasAdjacentRangePair && !hydration.presentation) hydration.coalesce();
     owner.retry = () => {
       if (!rootBlock.disposed) scheduleRender(rootBlock);
     };
@@ -24661,6 +27200,34 @@ function hydrateRoot(container, bodyOrElement, propsOrOptions, rootOptions) {
   adopt();
   return root;
 }
+function createIndependentHydrateActivator(body) {
+  return (context) => {
+    const content = (_props, scope, extra) => {
+      body(context.captures, scope, extra);
+    };
+    const framed = (_props, scope) => {
+      tryBlock(scope, 0, scope.block.parentNode, content, null, null, scope.block.endMarker);
+    };
+    const adapter = (_props, scope) => {
+      componentSlotVoid(scope, 0, scope.block.parentNode, framed, void 0, scope.block.endMarker);
+    };
+    const root = hydrateRoot(context.element, adapter, context.captures, {
+      identifierPrefix: context.manifest.boundaryId + "-",
+      identifierSeed: context.manifest.idSeed,
+      signalInstancePrefix: context.manifest.boundaryId,
+      ...context.signalOwner === void 0 ? {} : { signalOwner: context.signalOwner }
+    });
+    for (const replay of context.intents) {
+      if (!isHydrationSelectionIntentCurrent(replay)) continue;
+      const originalTarget = replay.event.target;
+      if (originalTarget === null || originalTarget.nodeType !== 1 || !context.element.contains(originalTarget))
+        continue;
+      const target = originalTarget;
+      target.dispatchEvent(cloneHydrationReplayEvent(replay.event, target));
+    }
+    return root;
+  };
+}
 const _resourceHints = /* @__PURE__ */ new Set();
 function hasHeadHint(key) {
   if (_resourceHints.has(key)) return true;
@@ -25066,7 +27633,17 @@ export {
   bagOf,
   beginNativeReadScope,
   beginNativeReadWitness,
+  beginPresentationHydration,
+  bindPresentationView,
   bindRendererRegionOwner,
+  bindSignalAttribute,
+  bindSignalChecked,
+  bindSignalChild,
+  bindSignalHostPropSources,
+  bindSignalText,
+  bindSignalValue,
+  bindingChildSlot,
+  bindingText,
   callWithReceiver,
   canSplitStyleProperties,
   child,
@@ -25086,7 +27663,10 @@ export {
   componentSlotVoid,
   createContext,
   createElement,
+  createElementAt,
+  createElementFromConfig,
   createHostContextRequest,
+  createIndependentHydrateActivator,
   createPortal,
   createRoot,
   createScopedElement,
@@ -25096,10 +27676,13 @@ export {
   descriptorChildren,
   devEventListener,
   devHtmlNesting,
+  documentSignalOwner2 as documentSignalOwner,
   drainFrag,
   drainPassiveEffects,
   enableNativeReadCollection,
+  enableSignalBindings,
   endNativeReadScope,
+  endPresentationHydration,
   errorBlock,
   evt0,
   evt0u,
@@ -25139,6 +27722,7 @@ export {
   hydrateRoot,
   ifBlock,
   injectStyle,
+  installStreamedSignalOwnerActivator,
   invokeManualHook,
   isChildrenBlock,
   isHydratingStyle,
@@ -25148,6 +27732,7 @@ export {
   lazy,
   manualHook,
   mapSlot,
+  markBindingChildren,
   markChildrenBlock,
   markDangerouslySetInnerHTMLChildren,
   markNativeChangeDiagnosticStatic,
@@ -25168,6 +27753,7 @@ export {
   nativeCreateScopedElement,
   nativeCreateScopedValue,
   nativeLocalHook,
+  nativeProjectionBinding,
   nativePuMemo,
   nativePuPub,
   nativePuTake0,
@@ -25186,6 +27772,10 @@ export {
   preinitModule,
   preload,
   preloadModule,
+  presentationFailure,
+  presentationHostWrite,
+  presentationStructure,
+  presentationWrite,
   provideContext,
   puMiss,
   puPub,
@@ -25218,6 +27808,8 @@ export {
   setAttribute,
   setAttributeIfChanged,
   setAutoFocus,
+  setBindingClass,
+  setBindingClassIfChanged,
   setBooleanAttribute,
   setBooleanAttributeIfChanged,
   setChecked,