octane 0.2.11 → 0.2.13

package/dist/dom-tables.d.ts

@@ -11,6 +11,4 @@ export const HTML_ONLY_TAGS: Set<string>;
 export const MATHML_ONLY_TAGS: Set<string>;
 export const ATTRIBUTE_ALIASES: Map<string, string>;
 export function isEnumeratedBooleanAttr(name: string): boolean;
-export function isUnitlessStyleProp(name: string): boolean;
-export function cssStyleValue(name: string, value: unknown): string;
-export function hyphenateStyleName(name: string): string;
+export { isUnitlessStyleProp, cssStyleValue, hyphenateStyleName } from './style-values.js';

package/dist/dom-tables.js

@@ -365,97 +365,7 @@ function isEnumeratedBooleanAttr(name) {
   }
   return false;
 }
-const UNITLESS_STYLE_PROPS = /* @__PURE__ */ new Set();
-for (const base of [
-  "animationIterationCount",
-  "aspectRatio",
-  "borderImageOutset",
-  "borderImageSlice",
-  "borderImageWidth",
-  "boxFlex",
-  "boxFlexGroup",
-  "boxOrdinalGroup",
-  "columnCount",
-  "columns",
-  "flex",
-  "flexGrow",
-  "flexPositive",
-  "flexShrink",
-  "flexNegative",
-  "flexOrder",
-  "gridArea",
-  "gridRow",
-  "gridRowEnd",
-  "gridRowSpan",
-  "gridRowStart",
-  "gridColumn",
-  "gridColumnEnd",
-  "gridColumnSpan",
-  "gridColumnStart",
-  "fontWeight",
-  "lineClamp",
-  "lineHeight",
-  "opacity",
-  "order",
-  "orphans",
-  "scale",
-  "tabSize",
-  "widows",
-  "zIndex",
-  "zoom",
-  "fillOpacity",
-  "floodOpacity",
-  "stopOpacity",
-  "strokeDasharray",
-  "strokeDashoffset",
-  "strokeMiterlimit",
-  "strokeOpacity",
-  "strokeWidth"
-]) {
-  const c = base.toLowerCase();
-  UNITLESS_STYLE_PROPS.add(c);
-  UNITLESS_STYLE_PROPS.add("webkit" + c);
-  UNITLESS_STYLE_PROPS.add("ms" + c);
-  UNITLESS_STYLE_PROPS.add("moz" + c);
-  UNITLESS_STYLE_PROPS.add("o" + c);
-}
-const unitlessStylePropCache = /* @__PURE__ */ new Map();
-function isUnitlessStyleProp(name) {
-  const cached = unitlessStylePropCache.get(name);
-  if (cached !== void 0) return cached;
-  const result = UNITLESS_STYLE_PROPS.has(name.replaceAll("-", "").toLowerCase());
-  unitlessStylePropCache.set(name, result);
-  return result;
-}
-function cssStyleValue(name, value) {
-  if (typeof value === "number" && value !== 0 && name.charCodeAt(0) !== 45 && !isUnitlessStyleProp(name)) {
-    return value + "px";
-  }
-  return typeof value === "string" ? value.trim() : "" + value;
-}
-function hyphenateStyleName(name) {
-  if (name === "cssFloat") return "float";
-  if (name.charCodeAt(0) === 45) return name;
-  let hasUpper = false;
-  for (let i = 0; i < name.length; i++) {
-    const c = name.charCodeAt(i);
-    if (c >= 65 && c <= 90) {
-      hasUpper = true;
-      break;
-    }
-  }
-  if (!hasUpper) return name;
-  let out = "";
-  for (let i = 0; i < name.length; i++) {
-    const c = name.charCodeAt(i);
-    if (c >= 65 && c <= 90) out += "-" + String.fromCharCode(c + 32);
-    else out += name[i];
-  }
-  if (out.charCodeAt(0) === 109 && out.charCodeAt(1) === 115 && out.charCodeAt(2) === 45) {
-    out = "-" + out;
-  }
-  return out;
-}
+import { isUnitlessStyleProp, cssStyleValue, hyphenateStyleName } from "./style-values.js";
 export {
   ATTRIBUTE_ALIASES,
   BOOLEAN_ATTR_PROPS,

package/dist/error-codes.client.generated.d.ts

@@ -41,6 +41,15 @@ type ClientErrorArguments = {
     62: [];
     63: [];
     64: [];
+    66: [];
+    67: [unknown];
+    72: [];
+    74: [];
+    75: [];
+    76: [];
+    77: [];
+    78: [];
+    79: [];
 };
 export declare function formatClientError<Code extends keyof ClientErrorArguments>(code: Code, ...args: ClientErrorArguments[Code]): string;
 export {};

package/dist/error-codes.client.generated.js

@@ -192,6 +192,39 @@ function formatClientError(code, ...args) {
         );
       case 64:
         return formatDevErrorMessage("Multiple errors were thrown during act.", args);
+      case 66:
+        return formatDevErrorMessage(
+          "An independent Hydrate boundary cannot change ownership after mount.",
+          args
+        );
+      case 67:
+        return formatDevErrorMessage('Signal control identity mismatch for "%s".', args);
+      case 72:
+        return formatDevErrorMessage(
+          "Octane DOM binding text range does not match its template.",
+          args
+        );
+      case 74:
+        return formatDevErrorMessage("Unsupported Octane signal binding ABI.", args);
+      case 75:
+        return formatDevErrorMessage(
+          "Hydration binding leases require a supported fixed native view without structural regions or unsupported writers.",
+          args
+        );
+      case 76:
+        return formatDevErrorMessage(
+          "DOM binding hydration leases are supported only by hydrateRoot().",
+          args
+        );
+      case 77:
+        return formatDevErrorMessage(
+          "Hydration binding leases require active fixed native views owned by this container.",
+          args
+        );
+      case 78:
+        return formatDevErrorMessage("A hydration binding lease can be claimed only once.", args);
+      case 79:
+        return formatDevErrorMessage("Unsupported native signal transition.", args);
       default:
         return formatUnknownDevErrorMessage(code);
     }

package/dist/error-codes.server.generated.d.ts

@@ -31,6 +31,12 @@ type ServerErrorArguments = {
     58: [];
     59: [unknown];
     60: [];
+    65: [];
+    68: [];
+    69: [];
+    70: [];
+    71: [];
+    73: [];
 };
 export declare function formatServerError<Code extends keyof ServerErrorArguments>(code: Code, ...args: ServerErrorArguments[Code]): string;
 export {};

package/dist/error-codes.server.generated.js

@@ -130,6 +130,30 @@ function formatServerError(code, ...args) {
           "A component suspended without a Suspense boundary during synchronous server rendering. Use prerender() or a streaming renderer to await it.",
           args
         );
+      case 65:
+        return formatDevErrorMessage(
+          "Internal SSR invariant violated: ASYNC_SCOPE is not an extension of the active frame's async scope. Please file an Octane issue.",
+          args
+        );
+      case 68:
+        return formatDevErrorMessage(
+          "A signal control cannot join values from different document owners.",
+          args
+        );
+      case 69:
+        return formatDevErrorMessage(
+          "Independent Hydrate requires a build manifest in RenderOptions.",
+          args
+        );
+      case 70:
+        return formatDevErrorMessage(
+          "Independent Hydrate activation chunk is missing from the build manifest.",
+          args
+        );
+      case 71:
+        return formatDevErrorMessage("Unsupported Octane server signal binding ABI.", args);
+      case 73:
+        return formatDevErrorMessage("Octane DOM bindings require unique list keys.", args);
       default:
         return formatUnknownDevErrorMessage(code);
     }

package/dist/hydration/control-capture.d.ts

@@ -0,0 +1,62 @@
+/** @internal Shared inline mailbox record; its activation queue has one owner. */
+export type EarlyHydrationIntent = readonly [
+    Event,
+    Element,
+    Element,
+    string,
+    string | null,
+    string | null,
+    Element?,
+    string?
+];
+/** @internal Captured control state and activation require the same DOM authority. */
+export declare function isEarlyHydrationIntentCurrent([event, target, boundary, id, when, events]: EarlyHydrationIntent, ownerDocument: Document): boolean;
+export interface HydrationControlSnapshot {
+    /** Advances for every captured input, including a clear-to-empty-string edit. */
+    readonly editRevision: number;
+    /** Advances independently when the platform reports a selection change. */
+    readonly selectionRevision: number;
+    /** Advances for edits, selection, focus, and composition changes. */
+    readonly revision: number;
+    readonly value: string;
+    readonly checked?: boolean;
+    readonly selectedValues?: readonly string[];
+    readonly selectionStart: number | null;
+    readonly selectionEnd: number | null;
+    readonly selectionDirection: 'forward' | 'backward' | 'none' | null;
+    readonly focused: boolean;
+    readonly composing: boolean;
+}
+/** Opaque revision token captured before an asynchronous local restoration read. */
+export interface HydrationControlCandidate {
+    readonly control: Element;
+    readonly bindingId: string | null;
+    readonly boundaryId: string | null;
+    readonly snapshot: HydrationControlSnapshot;
+}
+export interface HydrationControlCandidateValue {
+    readonly value?: string;
+    readonly checked?: boolean;
+    readonly selectedValues?: readonly string[];
+}
+/**
+ * @internal Snapshot the live platform state used by an island's atomic input
+ * handoff. The current DOM is authoritative; the counters only decide whether
+ * the state changed while ownership was being transferred.
+ */
+export declare function snapshotHydrationControl(control: Element): HydrationControlSnapshot | null;
+/**
+ * Capture the exact DOM/edit authority an async storage read is allowed to replace.
+ * A focus, selection, composition, input (including clear), node replacement, or
+ * boundary rebinding before apply makes the candidate stale.
+ */
+export declare function captureHydrationControlCandidate(control: Element): HydrationControlCandidate | null;
+/** Apply one local candidate only while the captured DOM revision still owns the value. */
+export declare function applyHydrationControlCandidate(candidate: HydrationControlCandidate, value: HydrationControlCandidateValue): boolean;
+/** @internal Retire only the exact early state an activating owner adopted. */
+export declare function consumeHydrationControl(control: Element, revision: number): boolean;
+/**
+ * @internal Own only native control state. Island activation remains optional:
+ * leave its mailbox intact so a later full bootstrap can claim every intent.
+ */
+export declare function initializeHydrationControlCapture(ownerDocument?: Document): void;

package/dist/hydration/control-capture.js

@@ -0,0 +1,223 @@
+import { HYDRATE_INDEPENDENT_ATTR, HYDRATE_INPUT_ATTR } from "../hydration-markers.js";
+import {
+  EARLY_HYDRATION_INTENTS_KEY,
+  HYDRATE_INTERACTION_EVENTS_ATTR
+} from "./interaction-config.js";
+import {
+  claimEarlyHydrationControlCapture,
+  clearEarlyHydrationControlRevision,
+  publishHydrationControlSignalValues,
+  readEarlyHydrationControlRevision
+} from "../signals/early-values.js";
+const HYDRATE_MARKER_SELECTOR = "[data-octane-hydrate-id]";
+const HYDRATE_CONTROL_DOCUMENTS = /* @__PURE__ */ new WeakSet();
+function isEarlyHydrationIntentCurrent([event, target, boundary, id, when, events], ownerDocument) {
+  return event.target === target && target.isConnected && boundary.isConnected && target.ownerDocument === ownerDocument && boundary.ownerDocument === ownerDocument && target.closest(`[${HYDRATE_INDEPENDENT_ATTR}]`) === boundary && boundary.getAttribute("data-octane-hydrate-id") === id && boundary.getAttribute("data-octane-hydrate-when") === when && boundary.getAttribute(HYDRATE_INTERACTION_EVENTS_ATTR) === events;
+}
+function isHydrationElement(target) {
+  return target !== null && target.nodeType === 1;
+}
+const HYDRATE_CONTROL_RECORDS = /* @__PURE__ */ new WeakMap();
+function hydrationControl(target) {
+  if (!isHydrationElement(target)) return null;
+  const tag = target.localName;
+  return tag === "input" || tag === "textarea" || tag === "select" || target.isContentEditable ? target : null;
+}
+function hydrationControlRecord(control) {
+  let record = HYDRATE_CONTROL_RECORDS.get(control);
+  if (record === void 0) {
+    const revision = readEarlyHydrationControlRevision(control);
+    record = { editRevision: revision, selectionRevision: 0, revision, composing: false };
+    HYDRATE_CONTROL_RECORDS.set(control, record);
+  }
+  return record;
+}
+function recordHydrationControlEvent(event) {
+  const control = hydrationControl(event.target);
+  if (control === null) return;
+  const record = hydrationControlRecord(control);
+  switch (event.type) {
+    case "input":
+      record.editRevision++;
+      record.revision++;
+      publishHydrationControlSignalValues(control, record.revision);
+      break;
+    case "compositionstart":
+      record.composing = true;
+      record.revision++;
+      break;
+    case "compositionupdate":
+      record.revision++;
+      break;
+    case "compositionend":
+      record.composing = false;
+      record.revision++;
+      break;
+    case "focusin":
+    case "focusout":
+      record.revision++;
+  }
+}
+function recordHydrationSelection(event) {
+  const ownerDocument = event.currentTarget;
+  const control = hydrationControl(ownerDocument.activeElement);
+  if (control === null) return;
+  const record = hydrationControlRecord(control);
+  record.selectionRevision++;
+  record.revision++;
+}
+function snapshotHydrationControl(control) {
+  if (hydrationControl(control) === null) return null;
+  const record = HYDRATE_CONTROL_RECORDS.get(control);
+  const earlyRevision = record === void 0 ? readEarlyHydrationControlRevision(control) : 0;
+  const input = control;
+  let value;
+  let checked;
+  let selectedValues;
+  let selectionStart = null;
+  let selectionEnd = null;
+  let selectionDirection = null;
+  if (control.localName === "select") {
+    const select = input;
+    value = select.value;
+    if (select.multiple)
+      selectedValues = Array.from(select.selectedOptions, (option) => option.value);
+  } else if (control.isContentEditable) {
+    value = control.textContent ?? "";
+  } else {
+    value = input.value;
+    if (control.localName === "input") checked = input.checked;
+    try {
+      selectionStart = input.selectionStart;
+      selectionEnd = input.selectionEnd;
+      selectionDirection = input.selectionDirection;
+    } catch {
+    }
+  }
+  return {
+    editRevision: record?.editRevision ?? earlyRevision,
+    selectionRevision: record?.selectionRevision ?? 0,
+    revision: record?.revision ?? earlyRevision,
+    value,
+    ...checked === void 0 ? {} : { checked },
+    ...selectedValues === void 0 ? {} : { selectedValues },
+    selectionStart,
+    selectionEnd,
+    selectionDirection,
+    focused: control.ownerDocument.activeElement === control,
+    composing: record?.composing ?? false
+  };
+}
+function captureHydrationControlCandidate(control) {
+  const snapshot = snapshotHydrationControl(control);
+  if (snapshot === null) return null;
+  initializeHydrationControlCapture(control.ownerDocument);
+  return {
+    control,
+    bindingId: control.getAttribute(HYDRATE_INPUT_ATTR),
+    boundaryId: control.closest(HYDRATE_MARKER_SELECTOR)?.getAttribute("data-octane-hydrate-id") ?? null,
+    snapshot
+  };
+}
+function sameHydrationControlValue(left, right) {
+  if (left.value !== right.value || left.checked !== right.checked) return false;
+  const a = left.selectedValues;
+  const b = right.selectedValues;
+  if (a === void 0 || b === void 0) return a === b;
+  if (a.length !== b.length) return false;
+  for (let index = 0; index < a.length; index++) if (a[index] !== b[index]) return false;
+  return true;
+}
+function applyHydrationControlCandidate(candidate, value) {
+  const control = candidate.control;
+  if (!control.isConnected || control.getAttribute(HYDRATE_INPUT_ATTR) !== candidate.bindingId || (control.closest(HYDRATE_MARKER_SELECTOR)?.getAttribute("data-octane-hydrate-id") ?? null) !== candidate.boundaryId) {
+    return false;
+  }
+  const current = snapshotHydrationControl(control);
+  if (current === null || current.revision !== candidate.snapshot.revision || current.editRevision !== candidate.snapshot.editRevision || current.composing || !sameHydrationControlValue(current, candidate.snapshot)) {
+    return false;
+  }
+  if (control.localName === "select") {
+    const select = control;
+    if (select.multiple && value.selectedValues !== void 0) {
+      const selected = new Set(value.selectedValues);
+      for (const option of select.options) option.selected = selected.has(option.value);
+    } else if (value.value !== void 0) {
+      select.value = value.value;
+    } else {
+      return false;
+    }
+  } else if (control.isContentEditable) {
+    if (value.value === void 0) return false;
+    control.textContent = value.value;
+  } else {
+    const input = control;
+    if (value.value !== void 0) input.value = value.value;
+    else if (control.localName !== "input" || value.checked === void 0) return false;
+    if (control.localName === "input" && value.checked !== void 0) {
+      input.checked = value.checked;
+    }
+  }
+  if (current.focused && current.selectionStart !== null && current.selectionEnd !== null && control.localName !== "select" && !control.isContentEditable) {
+    try {
+      control.setSelectionRange(
+        current.selectionStart,
+        current.selectionEnd,
+        current.selectionDirection ?? void 0
+      );
+    } catch {
+    }
+  }
+  const record = hydrationControlRecord(control);
+  record.editRevision++;
+  record.revision++;
+  publishHydrationControlSignalValues(control, record.revision);
+  return true;
+}
+function consumeHydrationControl(control, revision) {
+  initializeHydrationControlCapture(control.ownerDocument);
+  const record = hydrationControlRecord(control);
+  if (record.revision !== revision) return false;
+  record.editRevision = 0;
+  record.selectionRevision = 0;
+  clearEarlyHydrationControlRevision(control);
+  return true;
+}
+function initializeHydrationControlCapture(ownerDocument) {
+  const targetDocument = ownerDocument ?? (typeof document === "undefined" ? void 0 : document);
+  if (targetDocument === void 0 || HYDRATE_CONTROL_DOCUMENTS.has(targetDocument)) return;
+  HYDRATE_CONTROL_DOCUMENTS.add(targetDocument);
+  const mailbox = targetDocument[EARLY_HYDRATION_INTENTS_KEY];
+  const target = typeof mailbox?.stop === "function" ? targetDocument.defaultView ?? targetDocument : targetDocument;
+  const record = target === targetDocument ? recordHydrationControlEvent : (event) => {
+    if (event.target?.ownerDocument === targetDocument)
+      recordHydrationControlEvent(event);
+  };
+  for (const event of [
+    "input",
+    "compositionstart",
+    "compositionupdate",
+    "compositionend",
+    "focusin",
+    "focusout"
+  ]) {
+    target.addEventListener(event, record, true);
+  }
+  targetDocument.addEventListener("selectionchange", recordHydrationSelection, true);
+  claimEarlyHydrationControlCapture(targetDocument);
+  for (const intent of mailbox?.q ?? []) {
+    const [event] = intent;
+    const control = hydrationControl(event.target);
+    if (control === null || !isEarlyHydrationIntentCurrent(intent, targetDocument)) continue;
+    if (event.type === "input" && readEarlyHydrationControlRevision(control) > 0) continue;
+    recordHydrationControlEvent(event);
+  }
+}
+export {
+  applyHydrationControlCandidate,
+  captureHydrationControlCandidate,
+  consumeHydrationControl,
+  initializeHydrationControlCapture,
+  isEarlyHydrationIntentCurrent,
+  snapshotHydrationControl
+};

package/dist/hydration/document-lifecycle.d.ts

@@ -0,0 +1,23 @@
+import type { SignalOwner } from '../signals/types.js';
+import type { IndependentHydrateLifecycle } from './independent-island.js';
+import type { StreamedSignalResults } from './streamed-signals.js';
+export interface SignalDocumentLifecycleOptions {
+    readonly document: Document;
+    readonly buildId: string;
+    readonly documentId: string;
+    readonly signalOwner?: SignalOwner;
+    readonly streamedHydration?: Pick<StreamedSignalResults, 'suspend'>;
+    readonly independentHydration?: IndependentHydrateLifecycle;
+    /** Host-owned identity carrier. Null, mismatch, or failure retires persisted state. */
+    readonly readIdentity?: () => {
+        readonly buildId: string;
+        readonly documentId: string;
+    } | null;
+    readonly onMismatch?: () => void;
+}
+/** Optional feature-local lifetime for one executing document, never an account manager. */
+export declare function installSignalDocumentLifecycle(options: SignalDocumentLifecycleOptions): {
+    signalOwner: SignalOwner;
+    whenActive(): Promise<boolean>;
+    dispose: () => void;
+};

package/dist/hydration/document-lifecycle.js

@@ -0,0 +1,80 @@
+import { documentSignalOwner } from "../signals/document-owner.js";
+import { createSignalOwnerLifecycle } from "../signals/facade.js";
+function installSignalDocumentLifecycle(options) {
+  const document = options.document;
+  const view = document.defaultView;
+  if (!view || !options.buildId || !options.documentId) {
+    throw new TypeError("A signal document lifecycle requires a live document and build identity.");
+  }
+  const signalOwner = options.signalOwner ?? documentSignalOwner(document);
+  const owner = createSignalOwnerLifecycle(signalOwner);
+  let frozen = false;
+  let disposed = false;
+  let waiting;
+  let wake;
+  const compatible = () => {
+    if (owner.retired || view.document !== document) return false;
+    try {
+      if (options.readIdentity !== void 0) {
+        const identity = options.readIdentity();
+        return identity?.buildId === options.buildId && identity.documentId === options.documentId;
+      }
+      const data = JSON.parse(document.getElementById("__octane_data")?.textContent || "null");
+      return data?.clientBuild?.version === 1 && data.clientBuild.buildId === options.buildId && data.streamedSignals?.buildId === options.buildId && data.streamedSignals.documentId === options.documentId;
+    } catch {
+      return false;
+    }
+  };
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    view.removeEventListener("pagehide", hide);
+    view.removeEventListener("pageshow", show);
+    owner.retire();
+    options.streamedHydration?.suspend();
+    options.independentHydration?.();
+    wake?.(false);
+    wake = void 0;
+  };
+  const hide = (event) => {
+    if (!event.persisted) {
+      dispose();
+      return;
+    }
+    if (disposed || frozen) return;
+    frozen = true;
+    waiting = new Promise((resolve) => {
+      wake = resolve;
+    });
+    owner.freeze();
+    options.streamedHydration?.suspend();
+    options.independentHydration?.pause();
+  };
+  const show = (event) => {
+    if (!event.persisted || disposed || !frozen) return;
+    if (!compatible()) {
+      dispose();
+      (options.onMismatch ?? (() => view.location.reload()))();
+      return;
+    }
+    frozen = false;
+    owner.resume();
+    if (disposed || frozen) return;
+    options.independentHydration?.resume();
+    wake?.(true);
+    wake = void 0;
+    waiting = void 0;
+  };
+  view.addEventListener("pagehide", hide);
+  view.addEventListener("pageshow", show);
+  return {
+    signalOwner,
+    whenActive() {
+      return disposed ? Promise.resolve(false) : waiting ?? Promise.resolve(true);
+    },
+    dispose
+  };
+}
+export {
+  installSignalDocumentLifecycle
+};

package/dist/hydration/event-capture.d.ts

@@ -1,4 +1,5 @@
-export declare const HYDRATE_SUPPORTED_INTERACTION_EVENTS: readonly ["auxclick", "beforeinput", "click", "compositionend", "compositionstart", "compositionupdate", "contextmenu", "dblclick", "focusin", "input", "keydown", "keyup", "mousedown", "mouseenter", "mouseover", "mouseup", "pointerdown", "pointerenter", "pointerover", "pointerup", "touchend", "touchstart"];
+export { applyHydrationControlCandidate, captureHydrationControlCandidate, consumeHydrationControl, snapshotHydrationControl, type HydrationControlCandidate, type HydrationControlCandidateValue, type HydrationControlSnapshot, } from './control-capture.js';
+export { HYDRATE_SUPPORTED_INTERACTION_EVENTS } from './interaction-config.js';
 /**
  * @internal Keep trusted focusing, touch activation, editing, and IME work on
  * the original event. Replaying an untrusted clone cannot restore those native
@@ -8,7 +9,21 @@ export declare function shouldPreventHydrationInteractionDefault(event: Event):
 export interface HydrationReplayIntent {
     event: Event;
     path: number[];
+    /** An explicitly leased native listener receives the original event, never a replay. */
+    earlyBinding?: true;
+    /** Captured author opt-in; never inferred again from a later DOM version. */
+    selection?: HydrationSelectionIntent;
 }
+interface HydrationSelectionIntent {
+    control: Element;
+    boundary: Element;
+    group: string;
+    sequence: number;
+}
+/** @internal A changed selection control cannot authorize an old click. */
+export declare function isHydrationSelectionIntentCurrent(intent: HydrationReplayIntent): boolean;
+/** @internal Replace only the immediately preceding captured selection. */
+export declare function appendHydrationReplayIntent(queue: HydrationReplayIntent[], intent: HydrationReplayIntent): void;
 export type HydrationIntentBoundaryStatus = 'hydrated' | 'never' | 'dormant' | 'handles';
 export type HydrationIntentBoundary = (eventType: string, intent?: HydrationReplayIntent) => HydrationIntentBoundaryStatus;
 /**
@@ -16,6 +31,8 @@ export type HydrationIntentBoundary = (eventType: string, intent?: HydrationRepl
  * Renderer stream sentinels are omitted so the address survives their reveal.
  */
 export declare function hydrationEventPathWithin(root: Element, target: EventTarget | null): number[] | null;
+/** @internal Interpret the SSR strategy without invoking a registered boundary. */
+export declare function hydrationMarkerInteractionStatus(marker: Element, eventType: string): HydrationIntentBoundaryStatus;
 /**
  * Install document-level capture for deferred-hydration interaction intent.
  * Calling this function more than once for the same document is a no-op.
@@ -25,6 +42,8 @@ export declare function hydrationEventPathWithin(root: Element, target: EventTar
  * boundary also invokes it as a synchronous fallback.
  */
 export declare function initializeHydrationEventCapture(ownerDocument?: Document): void;
+/** @internal Enable independent ownership without adding hit tests to ordinary hydration. */
+export declare function initializeIndependentHydrationEventCapture(ownerDocument: Document): void;
 /** @internal Runtime bridge for a mounted deferred-hydration boundary. */
 export declare function registerHydrationIntentBoundary(marker: Element, boundary: HydrationIntentBoundary): void;
 /** @internal Runtime bridge for a removed deferred-hydration boundary. */