octane 0.2.12 → 0.2.13

package/dist/hydration/event-capture.js

@@ -1,7 +1,23 @@
 import {
+  EARLY_HYDRATION_INTENTS_KEY,
   HYDRATE_DEFAULT_INTERACTION_EVENTS,
-  HYDRATE_INTERACTION_EVENTS_ATTR
+  HYDRATE_INTERACTION_EVENTS_ATTR,
+  HYDRATE_NATIVE_DEFAULT_INTERACTION_EVENTS,
+  HYDRATE_SELECTION_ATTR,
+  HYDRATE_SUPPORTED_INTERACTION_EVENTS
 } from "./interaction-config.js";
+import { HYDRATE_INDEPENDENT_ATTR } from "../hydration-markers.js";
+import { hasBindingHandoffEvent } from "../dom-binding-handoff.js";
+import {
+  initializeHydrationControlCapture,
+  isEarlyHydrationIntentCurrent
+} from "./control-capture.js";
+import {
+  applyHydrationControlCandidate,
+  captureHydrationControlCandidate,
+  consumeHydrationControl,
+  snapshotHydrationControl
+} from "./control-capture.js";
 import { HYDRATE_STREAM_TOKEN_ATTR, isRendererStreamBoundaryTemplate } from "../stream-protocol.js";
 const HYDRATE_MARKER_SELECTOR = "[data-octane-hydrate-id]";
 const HYDRATE_WHEN_ATTR = "data-octane-hydrate-when";
@@ -11,44 +27,40 @@ function isHydrationNode(target) {
 function isHydrationElement(target) {
   return isHydrationNode(target) && target.nodeType === 1;
 }
-const HYDRATE_SUPPORTED_INTERACTION_EVENTS = [
-  "auxclick",
-  "beforeinput",
-  "click",
-  "compositionend",
-  "compositionstart",
-  "compositionupdate",
-  "contextmenu",
-  "dblclick",
-  "focusin",
-  "input",
-  "keydown",
-  "keyup",
-  "mousedown",
-  "mouseenter",
-  "mouseover",
-  "mouseup",
-  "pointerdown",
-  "pointerenter",
-  "pointerover",
-  "pointerup",
-  "touchend",
-  "touchstart"
-];
+import { HYDRATE_SUPPORTED_INTERACTION_EVENTS as HYDRATE_SUPPORTED_INTERACTION_EVENTS2 } from "./interaction-config.js";
 function shouldPreventHydrationInteractionDefault(event) {
-  switch (event.type) {
-    case "beforeinput":
-    case "compositionend":
-    case "compositionstart":
-    case "compositionupdate":
-    case "input":
-    case "mousedown":
-    case "pointerdown":
-    case "touchend":
-    case "touchstart":
-      return false;
-    default:
-      return event.cancelable;
+  return event.cancelable && !HYDRATE_NATIVE_DEFAULT_INTERACTION_EVENTS.includes(event.type);
+}
+let independentIntentSequences;
+function advanceIndependentIntentSequence(ownerDocument) {
+  const sequence = (independentIntentSequences?.get(ownerDocument) ?? 0) + 1;
+  (independentIntentSequences ??= /* @__PURE__ */ new WeakMap()).set(ownerDocument, sequence);
+  return sequence;
+}
+function captureHydrationSelectionIntent(event, target, boundary, sequence) {
+  const click = event;
+  if (event.type !== "click" || click.button !== 0 || click.altKey || click.ctrlKey || click.metaKey || click.shiftKey)
+    return;
+  const control = target.closest(`button[${HYDRATE_SELECTION_ATTR}]`);
+  if (control === null || control.type !== "button" || control.closest(`[${HYDRATE_INDEPENDENT_ATTR}]`) !== boundary)
+    return;
+  const group = control.getAttribute(HYDRATE_SELECTION_ATTR);
+  if (!group) return;
+  return { control, boundary, group, sequence };
+}
+function isHydrationSelectionIntentCurrent(intent) {
+  const selection = intent.selection;
+  if (selection === void 0) return true;
+  const { control, boundary, group } = selection;
+  return isHydrationElement(intent.event.target) && intent.event.target.isConnected && control.isConnected && boundary.isConnected && control.contains(intent.event.target) && control.type === "button" && control.getAttribute(HYDRATE_SELECTION_ATTR) === group && intent.event.target.closest(`[${HYDRATE_INDEPENDENT_ATTR}]`) === boundary;
+}
+function appendHydrationReplayIntent(queue, intent) {
+  const selection = intent.selection;
+  const previous = queue[queue.length - 1];
+  if (selection !== void 0 && previous?.selection !== void 0 && selection.sequence === previous.selection.sequence + 1 && selection.boundary === previous.selection.boundary && selection.group === previous.selection.group && isHydrationSelectionIntentCurrent(previous)) {
+    queue[queue.length - 1] = intent;
+  } else {
+    queue.push(intent);
   }
 }
 const HYDRATE_BOUNDARIES = /* @__PURE__ */ new WeakMap();
@@ -56,6 +68,7 @@ const HYDRATE_PENDING_INTENTS = /* @__PURE__ */ new WeakMap();
 const HYDRATE_DELEGATED_DYNAMIC_MARKERS = /* @__PURE__ */ new WeakSet();
 const HYDRATE_HANDLED_INTENT_EVENTS = /* @__PURE__ */ new WeakSet();
 const HYDRATE_INTENT_DOCUMENTS = /* @__PURE__ */ new WeakSet();
+let independentHydrationDocuments;
 function hydrationEventPathWithin(root, target) {
   if (!isHydrationNode(target)) return null;
   const streamToken = root.getAttribute(HYDRATE_STREAM_TOKEN_ATTR);
@@ -80,6 +93,9 @@ function hydrationEventPathWithin(root, target) {
 function markerStatus(marker, eventType) {
   const boundary = HYDRATE_BOUNDARIES.get(marker);
   if (boundary !== void 0) return boundary(eventType);
+  return hydrationMarkerInteractionStatus(marker, eventType);
+}
+function hydrationMarkerInteractionStatus(marker, eventType) {
   const when = marker.getAttribute(HYDRATE_WHEN_ATTR);
   if (when === null) return "hydrated";
   if (when === "never") return "never";
@@ -89,17 +105,39 @@ function markerStatus(marker, eventType) {
   const events = custom === null ? HYDRATE_DEFAULT_INTERACTION_EVENTS : custom.split(/\s+/).filter(Boolean);
   return events.includes(eventType) ? "handles" : "dormant";
 }
-function handleEarlyHydrationIntent(event) {
+function handleEarlyHydrationIntent(event, capturedSelection) {
   const target = event.target;
   if (!isHydrationElement(target)) return;
+  if ((event.type === "pointerenter" || event.type === "mouseenter") && independentHydrationDocuments?.has(target.ownerDocument)) {
+    const boundary = target.closest(HYDRATE_MARKER_SELECTOR);
+    const pointer = event;
+    if (boundary !== null && typeof pointer.clientX === "number" && typeof pointer.clientY === "number") {
+      const hit = target.ownerDocument.elementFromPoint?.(pointer.clientX, pointer.clientY);
+      const independent2 = hit?.closest(`[${HYDRATE_INDEPENDENT_ATTR}]`);
+      if (independent2 && independent2 !== boundary && boundary.contains(independent2)) {
+        HYDRATE_HANDLED_INTENT_EVENTS.add(event);
+        return;
+      }
+    }
+  }
   const markers = [];
   let marker = target.closest(HYDRATE_MARKER_SELECTOR);
+  let independent = null;
   let matches = false;
   while (marker !== null) {
     markers.push(marker);
     matches ||= markerStatus(marker, event.type) === "handles";
+    if (marker.hasAttribute(HYDRATE_INDEPENDENT_ATTR)) {
+      independent = marker;
+      HYDRATE_HANDLED_INTENT_EVENTS.add(event);
+      break;
+    }
     marker = marker.parentElement?.closest(HYDRATE_MARKER_SELECTOR) ?? null;
   }
+  if (independent !== null) {
+    const link = target.closest("a[href],area[href]");
+    if (link !== null && independent.contains(link)) return;
+  }
   if (!matches || markers.length === 0) return;
   markers.reverse();
   let candidate = null;
@@ -122,8 +160,24 @@ function handleEarlyHydrationIntent(event) {
   }
   const path = hydrationEventPathWithin(candidate, event.target);
   if (path === null) return;
-  const intent = { event, path };
+  const sequence = independent !== null && capturedSelection === void 0 ? advanceIndependentIntentSequence(target.ownerDocument) : 0;
+  const selection = candidate === independent ? capturedSelection === void 0 ? captureHydrationSelectionIntent(event, target, candidate, sequence) : capturedSelection : void 0;
+  const intent = selection ? { event, path, selection } : { event, path };
   HYDRATE_HANDLED_INTENT_EVENTS.add(event);
+  if (hasBindingHandoffEvent(event)) {
+    intent.earlyBinding = true;
+    const activate = () => {
+      if (candidateBoundary !== void 0) candidateBoundary(event.type, intent);
+      else {
+        const pending = HYDRATE_PENDING_INTENTS.get(candidate) ?? [];
+        appendHydrationReplayIntent(pending, intent);
+        HYDRATE_PENDING_INTENTS.set(candidate, pending);
+      }
+    };
+    if (event.isTrusted) setTimeout(activate, 0);
+    else queueMicrotask(activate);
+    return;
+  }
   if (event.bubbles) {
     if (shouldPreventHydrationInteractionDefault(event)) event.preventDefault();
     event.stopPropagation();
@@ -133,13 +187,22 @@ function handleEarlyHydrationIntent(event) {
     candidateBoundary(event.type, intent);
   } else {
     const pending = HYDRATE_PENDING_INTENTS.get(candidate) ?? [];
-    pending.push(intent);
+    appendHydrationReplayIntent(pending, intent);
     HYDRATE_PENDING_INTENTS.set(candidate, pending);
   }
 }
 function initializeHydrationEventCapture(ownerDocument) {
   const targetDocument = ownerDocument ?? (typeof document === "undefined" ? void 0 : document);
   if (targetDocument === void 0 || HYDRATE_INTENT_DOCUMENTS.has(targetDocument)) return;
+  const host = targetDocument;
+  const mailbox = host[EARLY_HYDRATION_INTENTS_KEY];
+  mailbox?.stop?.();
+  initializeHydrationControlCapture(targetDocument);
+  const queued = mailbox?.q.splice(0);
+  host[EARLY_HYDRATION_INTENTS_KEY] = { version: 1, q: [], claimed: true };
+  if (mailbox?.overflow) {
+    throw new RangeError("Early independent Hydrate intent queue overflow; reload the document.");
+  }
   HYDRATE_INTENT_DOCUMENTS.add(targetDocument);
   for (let i = 0; i < HYDRATE_SUPPORTED_INTERACTION_EVENTS.length; i++) {
     targetDocument.addEventListener(
@@ -148,6 +211,21 @@ function initializeHydrationEventCapture(ownerDocument) {
       true
     );
   }
+  if (queued !== void 0) {
+    for (const entry of queued) {
+      const [event, , boundary, , , , control, group] = entry;
+      const sequence = advanceIndependentIntentSequence(targetDocument);
+      if (!isEarlyHydrationIntentCurrent(entry, targetDocument)) continue;
+      const selection = control === void 0 || group === void 0 ? null : { control, boundary, group, sequence };
+      if (selection !== null && !isHydrationSelectionIntentCurrent({ event, path: [], selection }))
+        continue;
+      handleEarlyHydrationIntent(event, selection);
+    }
+  }
+}
+function initializeIndependentHydrationEventCapture(ownerDocument) {
+  (independentHydrationDocuments ??= /* @__PURE__ */ new WeakSet()).add(ownerDocument);
+  initializeHydrationEventCapture(ownerDocument);
 }
 function registerHydrationIntentBoundary(marker, boundary) {
   HYDRATE_BOUNDARIES.set(marker, boundary);
@@ -170,12 +248,20 @@ function markDelegatedDynamicHydrationIntent(marker) {
   HYDRATE_DELEGATED_DYNAMIC_MARKERS.add(marker);
 }
 export {
-  HYDRATE_SUPPORTED_INTERACTION_EVENTS,
+  HYDRATE_SUPPORTED_INTERACTION_EVENTS2 as HYDRATE_SUPPORTED_INTERACTION_EVENTS,
+  appendHydrationReplayIntent,
+  applyHydrationControlCandidate,
+  captureHydrationControlCandidate,
+  consumeHydrationControl,
   hydrationEventPathWithin,
+  hydrationMarkerInteractionStatus,
   initializeHydrationEventCapture,
+  initializeIndependentHydrationEventCapture,
+  isHydrationSelectionIntentCurrent,
   markDelegatedDynamicHydrationIntent,
   registerHydrationIntentBoundary,
   shouldPreventHydrationInteractionDefault,
+  snapshotHydrationControl,
   takeDelegatedDynamicHydrationIntent,
   takePendingHydrationIntents,
   unregisterHydrationIntentBoundary,

package/dist/hydration/independent-island.d.ts

@@ -0,0 +1,45 @@
+import type { SignalOwner } from '../signals/types.js';
+import { type IndependentHydrateManifest } from '../independent-hydration-protocol.js';
+import { type HydrationReplayIntent } from './event-capture.js';
+export interface IndependentHydrateActivationContext {
+    readonly element: Element;
+    readonly manifest: IndependentHydrateManifest;
+    readonly captures: readonly unknown[];
+    readonly intents: readonly HydrationReplayIntent[];
+    readonly signalOwner?: SignalOwner;
+}
+export type IndependentHydrateActivator = (context: IndependentHydrateActivationContext) => void | {
+    unmount(): void;
+} | Promise<void | {
+    unmount(): void;
+}>;
+export interface IndependentHydrateRegistration {
+    readonly load: () => Promise<Record<string, unknown>>;
+    readonly loadStyles: (styles: readonly string[]) => void | Promise<void>;
+    readonly signalOwner?: SignalOwner;
+    readonly onError?: (error: unknown) => void;
+}
+export interface IndependentHydrateBootstrapOptions {
+    /** Executing client build authority, not a value adopted from a sidecar. */
+    readonly buildId?: string;
+    readonly loadModule: (moduleId: string) => Promise<Record<string, unknown>>;
+    readonly loadStyles: (styles: readonly string[]) => void | Promise<void>;
+    readonly signalOwner?: SignalOwner;
+    readonly onError?: (error: unknown) => void;
+}
+export interface IndependentHydrateLifecycle {
+    (): void;
+    pause(): void;
+    resume(): void;
+}
+/**
+ * Register one compiler/bundler-proven island with the pre-root intent capture.
+ * Loading this island never evaluates its lexical parent or a sibling module.
+ */
+export declare function registerIndependentHydrationIsland(element: Element, manifest: IndependentHydrateManifest, registration: IndependentHydrateRegistration): IndependentHydrateLifecycle;
+/**
+ * Register every inert SSR sidecar before a parent root can claim its DOM.
+ * Module resolution is host-owned so a bundler can map exact emitted chunk IDs
+ * without retaining the lexical parent module.
+ */
+export declare function bootstrapIndependentHydration(root: ParentNode, options: IndependentHydrateBootstrapOptions): IndependentHydrateLifecycle;

package/dist/hydration/independent-island.js

@@ -0,0 +1,233 @@
+import { decodeSignalValue } from "../data-encoding.js";
+import {
+  HYDRATE_INDEPENDENT_ATTR,
+  INDEPENDENT_HYDRATE_MANIFEST_ATTR
+} from "../hydration-markers.js";
+import {
+  isIndependentHydrateManifest
+} from "../independent-hydration-protocol.js";
+import {
+  appendHydrationReplayIntent,
+  hydrationMarkerInteractionStatus,
+  initializeIndependentHydrationEventCapture,
+  isHydrationSelectionIntentCurrent,
+  registerHydrationIntentBoundary,
+  takePendingHydrationIntents,
+  unregisterHydrationIntentBoundary
+} from "./event-capture.js";
+function registerIndependentHydrationIsland(element, manifest, registration) {
+  if (!isIndependentHydrateManifest(manifest)) {
+    throw new TypeError("Invalid independent Hydrate manifest.");
+  }
+  if (element.getAttribute("data-octane-hydrate-id") !== manifest.boundaryId) {
+    throw new Error("Independent Hydrate boundary identity mismatch.");
+  }
+  element.setAttribute(HYDRATE_INDEPENDENT_ATTR, "");
+  initializeIndependentHydrationEventCapture(element.ownerDocument);
+  let generation = 0;
+  let active = false;
+  let hydrated = false;
+  let replayReady = false;
+  let disposed = false;
+  let paused = false;
+  let root;
+  const intents = takePendingHydrationIntents(element) ?? [];
+  const activate = () => {
+    if (disposed || paused || active || hydrated) return;
+    active = true;
+    const attempt = ++generation;
+    void Promise.resolve().then(() => {
+      if (!disposed && generation === attempt) return registration.loadStyles(manifest.styles);
+    }).then(() => {
+      if (!disposed && generation === attempt) return registration.load();
+    }).then((module) => {
+      if (disposed || generation !== attempt || module === void 0) return;
+      const candidate = module[manifest.exportName];
+      if (typeof candidate !== "function") {
+        throw new TypeError("Independent Hydrate activation export is not a function.");
+      }
+      replayReady = true;
+      const replays = intents.splice(0);
+      for (let index = replays.length - 1; index >= 0; index--) {
+        if (!isHydrationSelectionIntentCurrent(replays[index])) replays.splice(index, 1);
+      }
+      return candidate({
+        element,
+        manifest,
+        captures: manifest.captures.map((value) => decodeSignalValue(value)),
+        intents: replays,
+        ...registration.signalOwner === void 0 ? {} : { signalOwner: registration.signalOwner }
+      });
+    }).then((value) => {
+      if (disposed || generation !== attempt) {
+        if (value && typeof value === "object") value.unmount();
+        return;
+      }
+      if (value && typeof value === "object") root = value;
+      hydrated = true;
+      active = false;
+    }).catch((error) => {
+      if (disposed || generation !== attempt) return;
+      active = false;
+      replayReady = false;
+      registration.onError?.(error);
+    });
+  };
+  const boundary = (eventType, intent) => {
+    if (hydrated || replayReady) return "hydrated";
+    if (disposed) return "never";
+    const status = hydrationMarkerInteractionStatus(element, eventType);
+    if (status === "never") return status;
+    if (intent !== void 0) {
+      appendHydrationReplayIntent(intents, intent);
+      activate();
+    }
+    return status;
+  };
+  registerHydrationIntentBoundary(element, boundary);
+  if (intents.length !== 0) activate();
+  return Object.assign(
+    () => {
+      if (disposed) return;
+      disposed = true;
+      generation++;
+      unregisterHydrationIntentBoundary(element, boundary);
+      root?.unmount();
+    },
+    {
+      pause() {
+        if (disposed || paused) return;
+        paused = true;
+        if (!replayReady) {
+          generation++;
+          active = false;
+        }
+      },
+      resume() {
+        if (disposed || !paused) return;
+        paused = false;
+        if (intents.length) activate();
+      }
+    }
+  );
+}
+function bootstrapIndependentHydration(root, options) {
+  const cleanups = /* @__PURE__ */ new Map();
+  const selector = `script[type="application/json"][${INDEPENDENT_HYDRATE_MANIFEST_ATTR}]`;
+  const ownerDocument = root.nodeType === 9 ? root : root.ownerDocument;
+  initializeIndependentHydrationEventCapture(ownerDocument);
+  let disposed = false;
+  let paused = false;
+  const register = (sidecar, documentComplete = false) => {
+    if (disposed || paused || !root.contains(sidecar) || !documentComplete && !sidecar.textContent)
+      return;
+    try {
+      let manifest;
+      try {
+        manifest = JSON.parse(sidecar.textContent || "null");
+      } catch (error) {
+        if (!documentComplete && ownerDocument.readyState === "loading") return;
+        throw error;
+      }
+      if (!isIndependentHydrateManifest(manifest)) {
+        throw new TypeError("Invalid independent Hydrate sidecar.");
+      }
+      if (options.buildId !== void 0 && manifest.buildId !== options.buildId) {
+        throw new Error("Independent Hydrate build identity mismatch.");
+      }
+      const element = sidecar.parentElement;
+      if (element === null) throw new Error("Independent Hydrate sidecar has no boundary.");
+      if (cleanups.has(element))
+        throw new Error("Independent Hydrate boundary already registered.");
+      cleanups.set(
+        element,
+        registerIndependentHydrationIsland(element, manifest, {
+          load: () => options.loadModule(manifest.moduleId),
+          loadStyles: options.loadStyles,
+          ...options.signalOwner === void 0 ? {} : { signalOwner: options.signalOwner },
+          ...options.onError === void 0 ? {} : { onError: options.onError }
+        })
+      );
+      sidecar.remove();
+    } catch (error) {
+      options.onError?.(error);
+    }
+  };
+  const scan = (node) => {
+    if (node.nodeType !== 1) return;
+    const element = node;
+    if (element.matches(selector)) register(element);
+    else for (const sidecar of element.querySelectorAll(selector)) register(sidecar);
+  };
+  const observer = new (ownerDocument.defaultView?.MutationObserver ?? MutationObserver)(
+    (records) => {
+      if (disposed || paused) return;
+      let removedBoundary = false;
+      for (const record of records) {
+        if (record.type === "characterData") {
+          const parent = record.target.parentElement;
+          if (parent?.matches(selector)) register(parent);
+          continue;
+        }
+        if (record.target.nodeType === 1 && record.target.matches(selector)) {
+          register(record.target);
+        }
+        for (const node of record.addedNodes) scan(node);
+        for (const node of record.removedNodes) {
+          if (node.nodeType === 1 && !node.matches(selector)) removedBoundary = true;
+        }
+      }
+      if (removedBoundary) {
+        for (const [element, cleanup] of cleanups) {
+          if (root.contains(element)) continue;
+          cleanups.delete(element);
+          cleanup();
+        }
+      }
+    }
+  );
+  observer.observe(root, { childList: true, subtree: true, characterData: true });
+  const complete = () => {
+    for (const sidecar of root.querySelectorAll(selector)) register(sidecar, true);
+  };
+  if (ownerDocument.readyState === "loading") {
+    ownerDocument.addEventListener("DOMContentLoaded", complete, { once: true });
+  }
+  for (const sidecar of root.querySelectorAll(selector)) register(sidecar);
+  return Object.assign(
+    () => {
+      if (disposed) return;
+      disposed = true;
+      observer.disconnect();
+      ownerDocument.removeEventListener("DOMContentLoaded", complete);
+      for (const cleanup of cleanups.values()) cleanup();
+      cleanups.clear();
+    },
+    {
+      pause() {
+        if (disposed || paused) return;
+        paused = true;
+        observer.disconnect();
+        for (const cleanup of cleanups.values()) cleanup.pause();
+      },
+      resume() {
+        if (disposed || !paused) return;
+        paused = false;
+        for (const [element, cleanup] of cleanups) {
+          if (root.contains(element)) cleanup.resume();
+          else {
+            cleanup();
+            cleanups.delete(element);
+          }
+        }
+        observer.observe(root, { childList: true, subtree: true, characterData: true });
+        for (const sidecar of root.querySelectorAll(selector))
+          register(sidecar, ownerDocument.readyState !== "loading");
+      }
+    }
+  );
+}
+export {
+  bootstrapIndependentHydration,
+  registerIndependentHydrationIsland
+};

package/dist/hydration/index.d.ts

@@ -1,6 +1,13 @@
 export { condition } from './condition.js';
+export { decodeSignalValue } from '../data-encoding.js';
 export type { HydrationCondition } from './condition.js';
-export { initializeHydrationEventCapture } from './event-capture.js';
+export { applyHydrationControlCandidate, captureHydrationControlCandidate, initializeHydrationEventCapture, type HydrationControlCandidate, type HydrationControlCandidateValue, } from './event-capture.js';
+export { bootstrapIndependentHydration, registerIndependentHydrationIsland, type IndependentHydrateActivationContext, type IndependentHydrateActivator, type IndependentHydrateBootstrapOptions, type IndependentHydrateRegistration, type IndependentHydrateLifecycle, } from './independent-island.js';
+export { createIndependentHydrateManifest, isIndependentHydrateManifest, serializeIndependentHydrateManifest, type IndependentHydrateBuildRecord, type IndependentHydrateCapture, type IndependentHydrateManifest, type IndependentHydrateManifestTemplate, } from '../independent-hydration-protocol.js';
+export { createStreamedRegionReceiver, StreamedReceiverError, type HistoricalFrameLease, type StreamedFrameDisposition, type StreamedRegionReceiver, type StreamedRegionReceiverOptions, type StreamedRegionRegistration, type StreamedResultConsumer, } from './stream-receiver.js';
+export { createStreamedResultReceiver, type StreamedResultReceiver, type StreamedResultReceiverOptions, } from './stream-result-receiver.js';
+export { installStreamedRendererGlobal, readStreamedRendererResponse, STREAMED_RENDERER_RECEIVER, type StreamedRendererGlobal, type StreamedRendererDeliveryOptions, type StreamedRendererReadOptions, } from './stream-delivery.js';
+export { decodeStreamedRendererFrame, encodeStreamedRendererFrameForScript, isStreamFrameIdentity, isStreamedRendererFrame, sameStreamFrameIdentity, streamFrameIdentityKey, type StreamedRegionPlacementFrame, type StreamedRendererFrame, type StreamedSignalResultFrame, type StreamFrameIdentity, } from '../streamed-signals-protocol.js';
 export { idle } from './idle.js';
 export type { IdleHydrationOptions } from './idle.js';
 export { interaction } from './interaction.js';

package/dist/hydration/index.js

@@ -1,5 +1,39 @@
 import { condition } from "./condition.js";
-import { initializeHydrationEventCapture } from "./event-capture.js";
+import { decodeSignalValue } from "../data-encoding.js";
+import {
+  applyHydrationControlCandidate,
+  captureHydrationControlCandidate,
+  initializeHydrationEventCapture
+} from "./event-capture.js";
+import {
+  bootstrapIndependentHydration,
+  registerIndependentHydrationIsland
+} from "./independent-island.js";
+import {
+  createIndependentHydrateManifest,
+  isIndependentHydrateManifest,
+  serializeIndependentHydrateManifest
+} from "../independent-hydration-protocol.js";
+import {
+  createStreamedRegionReceiver,
+  StreamedReceiverError
+} from "./stream-receiver.js";
+import {
+  createStreamedResultReceiver
+} from "./stream-result-receiver.js";
+import {
+  installStreamedRendererGlobal,
+  readStreamedRendererResponse,
+  STREAMED_RENDERER_RECEIVER
+} from "./stream-delivery.js";
+import {
+  decodeStreamedRendererFrame,
+  encodeStreamedRendererFrameForScript,
+  isStreamFrameIdentity,
+  isStreamedRendererFrame,
+  sameStreamFrameIdentity,
+  streamFrameIdentityKey
+} from "../streamed-signals-protocol.js";
 import { idle } from "./idle.js";
 import { interaction } from "./interaction.js";
 import { load } from "./load.js";
@@ -7,12 +41,32 @@ import { media } from "./media.js";
 import { never } from "./never.js";
 import { visible } from "./visible.js";
 export {
+  STREAMED_RENDERER_RECEIVER,
+  StreamedReceiverError,
+  applyHydrationControlCandidate,
+  bootstrapIndependentHydration,
+  captureHydrationControlCandidate,
   condition,
+  createIndependentHydrateManifest,
+  createStreamedRegionReceiver,
+  createStreamedResultReceiver,
+  decodeSignalValue,
+  decodeStreamedRendererFrame,
+  encodeStreamedRendererFrameForScript,
   idle,
   initializeHydrationEventCapture,
+  installStreamedRendererGlobal,
   interaction,
+  isIndependentHydrateManifest,
+  isStreamFrameIdentity,
+  isStreamedRendererFrame,
   load,
   media,
   never,
+  readStreamedRendererResponse,
+  registerIndependentHydrationIsland,
+  sameStreamFrameIdentity,
+  serializeIndependentHydrateManifest,
+  streamFrameIdentityKey,
   visible
 };

package/dist/hydration/interaction-config.d.ts

@@ -1,2 +1,7 @@
 export declare const HYDRATE_INTERACTION_EVENTS_ATTR = "data-octane-hydrate-interaction-events";
+export declare const HYDRATE_SELECTION_ATTR = "data-octane-hydrate-selection";
+export declare const EARLY_HYDRATION_INTENTS_KEY = "__octaneEarlyHydrationIntents";
+export declare const EARLY_HYDRATION_INTENTS_LIMIT = 256;
+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 declare const HYDRATE_NATIVE_DEFAULT_INTERACTION_EVENTS: readonly string[];
 export declare const HYDRATE_DEFAULT_INTERACTION_EVENTS: readonly ["pointerenter", "focusin", "pointerdown", "touchstart", "touchend", "beforeinput", "input", "compositionstart", "compositionupdate", "compositionend", "click"];