octane 0.2.12 → 0.2.13

package/dist/cjs/hydration/event-capture.cjs

@@ -18,12 +18,20 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var event_capture_exports = {};
 __export(event_capture_exports, {
-  HYDRATE_SUPPORTED_INTERACTION_EVENTS: () => HYDRATE_SUPPORTED_INTERACTION_EVENTS,
+  HYDRATE_SUPPORTED_INTERACTION_EVENTS: () => import_interaction_config2.HYDRATE_SUPPORTED_INTERACTION_EVENTS,
+  appendHydrationReplayIntent: () => appendHydrationReplayIntent,
+  applyHydrationControlCandidate: () => import_control_capture2.applyHydrationControlCandidate,
+  captureHydrationControlCandidate: () => import_control_capture2.captureHydrationControlCandidate,
+  consumeHydrationControl: () => import_control_capture2.consumeHydrationControl,
   hydrationEventPathWithin: () => hydrationEventPathWithin,
+  hydrationMarkerInteractionStatus: () => hydrationMarkerInteractionStatus,
   initializeHydrationEventCapture: () => initializeHydrationEventCapture,
+  initializeIndependentHydrationEventCapture: () => initializeIndependentHydrationEventCapture,
+  isHydrationSelectionIntentCurrent: () => isHydrationSelectionIntentCurrent,
   markDelegatedDynamicHydrationIntent: () => markDelegatedDynamicHydrationIntent,
   registerHydrationIntentBoundary: () => registerHydrationIntentBoundary,
   shouldPreventHydrationInteractionDefault: () => shouldPreventHydrationInteractionDefault,
+  snapshotHydrationControl: () => import_control_capture2.snapshotHydrationControl,
   takeDelegatedDynamicHydrationIntent: () => takeDelegatedDynamicHydrationIntent,
   takePendingHydrationIntents: () => takePendingHydrationIntents,
   unregisterHydrationIntentBoundary: () => unregisterHydrationIntentBoundary,
@@ -31,7 +39,12 @@ __export(event_capture_exports, {
 });
 module.exports = __toCommonJS(event_capture_exports);
 var import_interaction_config = require("./interaction-config.cjs");
+var import_hydration_markers = require("../hydration-markers.cjs");
+var import_dom_binding_handoff = require("../dom-binding-handoff.cjs");
+var import_control_capture = require("./control-capture.cjs");
+var import_control_capture2 = require("./control-capture.cjs");
 var import_stream_protocol = require("../stream-protocol.cjs");
+var import_interaction_config2 = require("./interaction-config.cjs");
 const HYDRATE_MARKER_SELECTOR = "[data-octane-hydrate-id]";
 const HYDRATE_WHEN_ATTR = "data-octane-hydrate-when";
 function isHydrationNode(target) {
@@ -40,44 +53,39 @@ 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"
-];
 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 && !import_interaction_config.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[${import_interaction_config.HYDRATE_SELECTION_ATTR}]`);
+  if (control === null || control.type !== "button" || control.closest(`[${import_hydration_markers.HYDRATE_INDEPENDENT_ATTR}]`) !== boundary)
+    return;
+  const group = control.getAttribute(import_interaction_config.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(import_interaction_config.HYDRATE_SELECTION_ATTR) === group && intent.event.target.closest(`[${import_hydration_markers.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();
@@ -85,6 +93,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(import_stream_protocol.HYDRATE_STREAM_TOKEN_ATTR);
@@ -109,6 +118,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";
@@ -118,17 +130,39 @@ function markerStatus(marker, eventType) {
   const events = custom === null ? import_interaction_config.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(`[${import_hydration_markers.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(import_hydration_markers.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;
@@ -151,8 +185,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 ((0, import_dom_binding_handoff.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();
@@ -162,21 +212,45 @@ 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[import_interaction_config.EARLY_HYDRATION_INTENTS_KEY];
+  mailbox?.stop?.();
+  (0, import_control_capture.initializeHydrationControlCapture)(targetDocument);
+  const queued = mailbox?.q.splice(0);
+  host[import_interaction_config.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++) {
+  for (let i = 0; i < import_interaction_config.HYDRATE_SUPPORTED_INTERACTION_EVENTS.length; i++) {
     targetDocument.addEventListener(
-      HYDRATE_SUPPORTED_INTERACTION_EVENTS[i],
+      import_interaction_config.HYDRATE_SUPPORTED_INTERACTION_EVENTS[i],
       handleEarlyHydrationIntent,
       true
     );
   }
+  if (queued !== void 0) {
+    for (const entry of queued) {
+      const [event, , boundary, , , , control, group] = entry;
+      const sequence = advanceIndependentIntentSequence(targetDocument);
+      if (!(0, import_control_capture.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);
@@ -201,11 +275,19 @@ function markDelegatedDynamicHydrationIntent(marker) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   HYDRATE_SUPPORTED_INTERACTION_EVENTS,
+  appendHydrationReplayIntent,
+  applyHydrationControlCandidate,
+  captureHydrationControlCandidate,
+  consumeHydrationControl,
   hydrationEventPathWithin,
+  hydrationMarkerInteractionStatus,
   initializeHydrationEventCapture,
+  initializeIndependentHydrationEventCapture,
+  isHydrationSelectionIntentCurrent,
   markDelegatedDynamicHydrationIntent,
   registerHydrationIntentBoundary,
   shouldPreventHydrationInteractionDefault,
+  snapshotHydrationControl,
   takeDelegatedDynamicHydrationIntent,
   takePendingHydrationIntents,
   unregisterHydrationIntentBoundary,

package/dist/cjs/hydration/interaction-config.cjs

@@ -18,11 +18,54 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var interaction_config_exports = {};
 __export(interaction_config_exports, {
+  EARLY_HYDRATION_INTENTS_KEY: () => EARLY_HYDRATION_INTENTS_KEY,
+  EARLY_HYDRATION_INTENTS_LIMIT: () => EARLY_HYDRATION_INTENTS_LIMIT,
   HYDRATE_DEFAULT_INTERACTION_EVENTS: () => HYDRATE_DEFAULT_INTERACTION_EVENTS,
-  HYDRATE_INTERACTION_EVENTS_ATTR: () => HYDRATE_INTERACTION_EVENTS_ATTR
+  HYDRATE_INTERACTION_EVENTS_ATTR: () => HYDRATE_INTERACTION_EVENTS_ATTR,
+  HYDRATE_NATIVE_DEFAULT_INTERACTION_EVENTS: () => HYDRATE_NATIVE_DEFAULT_INTERACTION_EVENTS,
+  HYDRATE_SELECTION_ATTR: () => HYDRATE_SELECTION_ATTR,
+  HYDRATE_SUPPORTED_INTERACTION_EVENTS: () => HYDRATE_SUPPORTED_INTERACTION_EVENTS
 });
 module.exports = __toCommonJS(interaction_config_exports);
 const HYDRATE_INTERACTION_EVENTS_ATTR = "data-octane-hydrate-interaction-events";
+const HYDRATE_SELECTION_ATTR = "data-octane-hydrate-selection";
+const EARLY_HYDRATION_INTENTS_KEY = "__octaneEarlyHydrationIntents";
+const EARLY_HYDRATION_INTENTS_LIMIT = 256;
+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"
+];
+const HYDRATE_NATIVE_DEFAULT_INTERACTION_EVENTS = [
+  "beforeinput",
+  "compositionend",
+  "compositionstart",
+  "compositionupdate",
+  "input",
+  "mousedown",
+  "pointerdown",
+  "touchend",
+  "touchstart"
+];
 const HYDRATE_DEFAULT_INTERACTION_EVENTS = [
   "pointerenter",
   "focusin",
@@ -38,6 +81,11 @@ const HYDRATE_DEFAULT_INTERACTION_EVENTS = [
 ];
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  EARLY_HYDRATION_INTENTS_KEY,
+  EARLY_HYDRATION_INTENTS_LIMIT,
   HYDRATE_DEFAULT_INTERACTION_EVENTS,
-  HYDRATE_INTERACTION_EVENTS_ATTR
+  HYDRATE_INTERACTION_EVENTS_ATTR,
+  HYDRATE_NATIVE_DEFAULT_INTERACTION_EVENTS,
+  HYDRATE_SELECTION_ATTR,
+  HYDRATE_SUPPORTED_INTERACTION_EVENTS
 });

package/dist/cjs/hydration-markers.cjs

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var hydration_markers_exports = {};
+__export(hydration_markers_exports, {
+  HYDRATE_INDEPENDENT_ATTR: () => HYDRATE_INDEPENDENT_ATTR,
+  HYDRATE_INPUT_ATTR: () => HYDRATE_INPUT_ATTR,
+  INDEPENDENT_HYDRATE_MANIFEST_ATTR: () => INDEPENDENT_HYDRATE_MANIFEST_ATTR,
+  SIGNAL_CONTROL_ATTR: () => SIGNAL_CONTROL_ATTR
+});
+module.exports = __toCommonJS(hydration_markers_exports);
+const INDEPENDENT_HYDRATE_MANIFEST_ATTR = "data-octane-independent";
+const HYDRATE_INDEPENDENT_ATTR = "data-octane-hydrate-independent";
+const HYDRATE_INPUT_ATTR = "data-octane-input";
+const SIGNAL_CONTROL_ATTR = "data-octane-signal-control";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HYDRATE_INDEPENDENT_ATTR,
+  HYDRATE_INPUT_ATTR,
+  INDEPENDENT_HYDRATE_MANIFEST_ATTR,
+  SIGNAL_CONTROL_ATTR
+});

package/dist/cjs/independent-hydration-protocol.cjs

@@ -0,0 +1,106 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key2 of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key2) && key2 !== except)
+        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var independent_hydration_protocol_exports = {};
+__export(independent_hydration_protocol_exports, {
+  createIndependentHydrateManifest: () => createIndependentHydrateManifest,
+  isIndependentHydrateManifest: () => isIndependentHydrateManifest,
+  serializeIndependentHydrateManifest: () => serializeIndependentHydrateManifest
+});
+module.exports = __toCommonJS(independent_hydration_protocol_exports);
+var import_data_encoding = require("./data-encoding.cjs");
+function plainRecord(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return false;
+  return Reflect.ownKeys(value).every((key2) => {
+    if (typeof key2 !== "string") return false;
+    const descriptor = Object.getOwnPropertyDescriptor(value, key2);
+    return descriptor.enumerable && "value" in descriptor;
+  });
+}
+function key(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 1024;
+}
+function uniqueKeys(value) {
+  return Array.isArray(value) && value.every(key) && new Set(value).size === value.length;
+}
+function captures(value, count) {
+  if (!Array.isArray(value) || value.length !== count) return false;
+  try {
+    for (const capture of value) (0, import_data_encoding.decodeSignalValue)(capture);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isIndependentHydrateManifest(value) {
+  if (!plainRecord(value)) return false;
+  const allowed = /* @__PURE__ */ new Set([
+    "version",
+    "buildId",
+    "boundaryId",
+    "moduleId",
+    "exportName",
+    "captureSchema",
+    "captures",
+    "hookSeed",
+    "idSeed",
+    "signalSites",
+    "styles",
+    "parentDependencies"
+  ]);
+  if (!Object.keys(value).every((name) => allowed.has(name))) return false;
+  if (value.version !== 1 || !key(value.buildId) || !key(value.boundaryId) || !key(value.moduleId) || !key(value.exportName) || !Number.isSafeInteger(value.hookSeed) || value.hookSeed < 0 || !Number.isSafeInteger(value.idSeed) || value.idSeed < 0 || value.parentDependencies !== false || !uniqueKeys(value.signalSites) || !uniqueKeys(value.styles) || !Array.isArray(value.captureSchema)) {
+    return false;
+  }
+  const names = /* @__PURE__ */ new Set();
+  for (const capture of value.captureSchema) {
+    if (!plainRecord(capture) || Object.keys(capture).length !== 2 || !key(capture.name) || capture.type !== "json" || names.has(capture.name)) {
+      return false;
+    }
+    names.add(capture.name);
+  }
+  return captures(value.captures, value.captureSchema.length);
+}
+function createIndependentHydrateManifest(template, values, instanceBoundaryId, buildId, build) {
+  const manifest = {
+    ...template,
+    buildId,
+    boundaryId: instanceBoundaryId,
+    moduleId: build.moduleId,
+    captures: values.map((value) => (0, import_data_encoding.encodeSignalValue)(value)),
+    styles: build.styles
+  };
+  if (!isIndependentHydrateManifest(manifest)) {
+    throw new TypeError("Invalid independent Hydrate manifest inputs.");
+  }
+  return Object.freeze(manifest);
+}
+function serializeIndependentHydrateManifest(manifest) {
+  if (!isIndependentHydrateManifest(manifest)) {
+    throw new TypeError("Invalid independent Hydrate manifest.");
+  }
+  return JSON.stringify(manifest).replace(/&/g, "\\u0026").replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createIndependentHydrateManifest,
+  isIndependentHydrateManifest,
+  serializeIndependentHydrateManifest
+});

package/dist/cjs/index.cjs

@@ -27,6 +27,7 @@ __export(index_exports, {
   HMR: () => import_runtime.HMR,
   HYDRATION_RANGE_BOUNDARY: () => import_runtime.HYDRATION_RANGE_BOUNDARY,
   Hydrate: () => import_runtime.Hydrate,
+  ServerCallUncertainError: () => import_server_rpc_protocol.ServerCallUncertainError,
   StrictMode: () => import_compatibility.StrictMode,
   Suspense: () => import_runtime.Suspense,
   TsrxErrorBoundary: () => import_runtime.TsrxErrorBoundary,
@@ -63,6 +64,7 @@ __export(index_exports, {
   bag8: () => import_runtime.bag8,
   bag9: () => import_runtime.bag9,
   bagOf: () => import_runtime.bagOf,
+  batchServerCalls: () => import_server_rpc_batch_client.batchServerCalls,
   bindRendererRegionOwner: () => import_runtime.bindRendererRegionOwner,
   child: () => import_runtime.child,
   childSlot: () => import_runtime.childSlot,
@@ -249,6 +251,8 @@ var import_behavior_root = require("./behavior-root.cjs");
 var import_sub_slot = require("./sub-slot.cjs");
 var import_runtime = require("./runtime.cjs");
 var import_server_rpc_client = require("./server-rpc-client.cjs");
+var import_server_rpc_protocol = require("./server-rpc-protocol.cjs");
+var import_server_rpc_batch_client = require("./server-rpc-batch-client.cjs");
 var import_method_dep = require("./method-dep.cjs");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -261,6 +265,7 @@ var import_method_dep = require("./method-dep.cjs");
   HMR,
   HYDRATION_RANGE_BOUNDARY,
   Hydrate,
+  ServerCallUncertainError,
   StrictMode,
   Suspense,
   TsrxErrorBoundary,
@@ -297,6 +302,7 @@ var import_method_dep = require("./method-dep.cjs");
   bag8,
   bag9,
   bagOf,
+  batchServerCalls,
   bindRendererRegionOwner,
   child,
   childSlot,