octane 0.2.11 → 0.2.13

package/dist/hydration/interaction-config.js

@@ -1,4 +1,42 @@
 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",
@@ -13,6 +51,11 @@ const HYDRATE_DEFAULT_INTERACTION_EVENTS = [
   "click"
 ];
 export {
+  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/hydration/stream-delivery.d.ts

@@ -0,0 +1,32 @@
+import { type StreamedResultReceiver } from './stream-result-receiver.js';
+type StreamedDeliveryReceiver = Pick<StreamedResultReceiver, 'receive' | 'failSelection'>;
+/** Stable realm slot used by CSP-nonced server frame calls. */
+export declare const STREAMED_RENDERER_RECEIVER = "__octaneStreamedRenderer";
+export interface StreamedRendererGlobal {
+    receive(frame: unknown): void;
+}
+export interface StreamedRendererDeliveryOptions {
+    readonly maxFrameBytes?: number;
+    /** Includes style/composition waits; also caps unfinished inline result channels. */
+    readonly maxPendingFrames?: number;
+    readonly maxPendingBytes?: number;
+    /** Maximum queue/placement and inline result lifetime; readers also bound the response. */
+    readonly timeoutMs?: number;
+}
+export interface StreamedRendererReadOptions extends StreamedRendererDeliveryOptions {
+    readonly maxTotalBytes?: number;
+    readonly signal?: AbortSignal;
+}
+/**
+ * Install the pre-module frame entrypoint. A host calls this before any
+ * renderer-owned frame script; replacing a receiver already owned by another
+ * document is an error rather than a silent authority transfer.
+ */
+export declare function installStreamedRendererGlobal(receiver: StreamedDeliveryReceiver, target?: Record<string, unknown>, options?: StreamedRendererDeliveryOptions): () => void;
+/**
+ * Incrementally consume the same newline-delimited frame protocol used by the
+ * initial document stream. A bounded cross-channel window permits independent
+ * progress; a full window applies backpressure before accepting another frame.
+ */
+export declare function readStreamedRendererResponse(response: Response, receiver: StreamedDeliveryReceiver, options?: StreamedRendererReadOptions): Promise<void>;
+export {};

package/dist/hydration/stream-delivery.js

@@ -0,0 +1,333 @@
+import {
+  isStreamedRendererFrame,
+  streamFrameIdentityKey
+} from "../streamed-signals-protocol.js";
+import {
+  StreamedReceiverError
+} from "./stream-result-receiver.js";
+const STREAMED_RENDERER_RECEIVER = "__octaneStreamedRenderer";
+const DEFAULT_MAX_FRAME_BYTES = 4 * 1024 * 1024;
+const DEFAULT_MAX_TOTAL_BYTES = 64 * 1024 * 1024;
+const DEFAULT_PENDING_BYTES = 16 * 1024 * 1024;
+const DEFAULT_PENDING_FRAMES = 64;
+const DEFAULT_TIMEOUT_MS = 3e4;
+function positiveLimit(value, fallback) {
+  const limit = value ?? fallback;
+  if (!Number.isSafeInteger(limit) || limit <= 0) {
+    throw new RangeError("Streamed renderer response limits must be positive safe integers.");
+  }
+  return limit;
+}
+function createDelivery(receiver, options, delivered) {
+  const maxFrameBytes = positiveLimit(options.maxFrameBytes, DEFAULT_MAX_FRAME_BYTES);
+  const maxPendingBytes = positiveLimit(options.maxPendingBytes, DEFAULT_PENDING_BYTES);
+  const maxPendingFrames = positiveLimit(options.maxPendingFrames, DEFAULT_PENDING_FRAMES);
+  const timeoutMs = positiveLimit(options.timeoutMs, DEFAULT_TIMEOUT_MS);
+  const tails = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Set();
+  const aborters = /* @__PURE__ */ new Set();
+  const waiters = /* @__PURE__ */ new Set();
+  let pendingBytes = 0;
+  let closed;
+  const notify = () => {
+    for (const wake of waiters) wake();
+    waiters.clear();
+  };
+  function validateSize(bytes) {
+    if (bytes > maxFrameBytes || bytes > maxPendingBytes)
+      throw new StreamedReceiverError(
+        "overflow",
+        "A streamed renderer frame exceeded its byte budget."
+      );
+  }
+  return {
+    async room(bytes) {
+      validateSize(bytes);
+      while (pending.size >= maxPendingFrames || pendingBytes + bytes > maxPendingBytes) {
+        if (closed !== void 0) throw closed;
+        await new Promise((resolve) => waiters.add(resolve));
+      }
+      if (closed !== void 0) throw closed;
+    },
+    enqueue(frame, bytes) {
+      if (closed !== void 0) return Promise.reject(closed);
+      try {
+        validateSize(bytes);
+        if (pending.size >= maxPendingFrames || pendingBytes + bytes > maxPendingBytes)
+          throw new StreamedReceiverError(
+            "overflow",
+            "Streamed renderer delivery exceeded its pending budget."
+          );
+      } catch (error) {
+        receiver.failSelection(frame.identity, error);
+        throw error;
+      }
+      const key = JSON.stringify([streamFrameIdentityKey(frame.identity), frame.channel]);
+      const previous = tails.get(key) ?? Promise.resolve();
+      let canceled;
+      let abort;
+      const cancellation = new Promise((_, reject) => {
+        abort = (error) => {
+          canceled = error;
+          try {
+            receiver.failSelection(frame.identity, error);
+          } catch {
+          }
+          reject(error);
+        };
+        aborters.add(abort);
+      });
+      const timer = setTimeout(
+        () => abort(new StreamedReceiverError("timeout", "Streamed renderer delivery timed out.")),
+        timeoutMs
+      );
+      const work = previous.catch(() => {
+      }).then(() => {
+        if (canceled !== void 0) throw canceled;
+        return receiver.receive(frame);
+      });
+      const delivery = Promise.race([work, cancellation]).then((disposition) => {
+        if (canceled !== void 0) throw canceled;
+        delivered?.(frame, disposition);
+      }).catch((cause) => {
+        const error = cause instanceof StreamedReceiverError ? cause : new StreamedReceiverError("protocol", "Streamed renderer delivery failed.");
+        try {
+          receiver.failSelection(frame.identity, error);
+        } catch {
+        }
+        throw error;
+      }).finally(() => {
+        clearTimeout(timer);
+        aborters.delete(abort);
+        pending.delete(delivery);
+        pendingBytes -= bytes;
+        if (tails.get(key) === delivery) tails.delete(key);
+        notify();
+      });
+      pending.add(delivery);
+      pendingBytes += bytes;
+      tails.set(key, delivery);
+      void delivery.catch(() => {
+      });
+      return delivery;
+    },
+    async drain() {
+      while (pending.size !== 0) await Promise.allSettled([...pending]);
+    },
+    close(error) {
+      if (closed !== void 0) return;
+      closed = error;
+      for (const abort of aborters) abort(error);
+      notify();
+    }
+  };
+}
+function installStreamedRendererGlobal(receiver, target = globalThis, options = {}) {
+  const previous = Object.getOwnPropertyDescriptor(target, STREAMED_RENDERER_RECEIVER);
+  const early = previous?.value;
+  if (previous !== void 0 && (early === null || typeof early !== "object" || early.version !== 1 || !Array.isArray(early.frames) || typeof early.receive !== "function")) {
+    throw new Error("An Octane streamed renderer receiver is already installed in this realm.");
+  }
+  if (early?.overflow === true) {
+    throw new Error("The pre-module streamed renderer mailbox overflowed.");
+  }
+  const maxOpenResults = positiveLimit(options.maxPendingFrames, DEFAULT_PENDING_FRAMES);
+  const resultTimeoutMs = positiveLimit(options.timeoutMs, DEFAULT_TIMEOUT_MS);
+  const openResults = /* @__PURE__ */ new Map();
+  function forgetResult(identity) {
+    const key = streamFrameIdentityKey(identity);
+    const result = openResults.get(key);
+    if (result === void 0) return;
+    clearTimeout(result.timer);
+    openResults.delete(key);
+  }
+  const delivery = createDelivery(receiver, options, (frame, disposition) => {
+    if (disposition === "stale" || frame.channel !== "result") return;
+    if (frame.kind === "complete" || frame.kind === "error") {
+      forgetResult(frame.identity);
+    } else if (frame.kind === "open") {
+      if (openResults.size >= maxOpenResults)
+        throw new StreamedReceiverError(
+          "overflow",
+          "Streamed renderer exceeded its open result budget."
+        );
+      const timer = setTimeout(() => {
+        forgetResult(frame.identity);
+        try {
+          receiver.failSelection(
+            frame.identity,
+            new StreamedReceiverError("timeout", "Streamed renderer result timed out.")
+          );
+        } catch {
+        }
+      }, resultTimeoutMs);
+      openResults.set(streamFrameIdentityKey(frame.identity), { identity: frame.identity, timer });
+    }
+  });
+  let removed = false;
+  const entrypoint = Object.freeze({
+    receive(frame) {
+      if (removed) return;
+      if (!isStreamedRendererFrame(frame)) {
+        void receiver.receive(frame).catch(() => {
+        });
+        return;
+      }
+      try {
+        void delivery.enqueue(frame, new TextEncoder().encode(JSON.stringify(frame)).byteLength).catch(() => forgetResult(frame.identity));
+      } catch {
+        forgetResult(frame.identity);
+      }
+    }
+  });
+  Object.defineProperty(target, STREAMED_RENDERER_RECEIVER, {
+    value: entrypoint,
+    configurable: true
+  });
+  if (early !== void 0) {
+    for (const frame of early.frames) entrypoint.receive(frame);
+    early.frames.length = 0;
+  }
+  return () => {
+    removed = true;
+    const error = new StreamedReceiverError(
+      "terminal",
+      "Streamed renderer entrypoint was removed."
+    );
+    delivery.close(error);
+    for (const { identity, timer } of openResults.values()) {
+      clearTimeout(timer);
+      try {
+        receiver.failSelection(identity, error);
+      } catch {
+      }
+    }
+    openResults.clear();
+    if (target[STREAMED_RENDERER_RECEIVER] !== entrypoint) return;
+    delete target[STREAMED_RENDERER_RECEIVER];
+  };
+}
+async function readStreamedRendererResponse(response, receiver, options = {}) {
+  if (response.body === null) throw new Error("The streamed renderer response has no body.");
+  const maxFrameBytes = positiveLimit(options.maxFrameBytes, DEFAULT_MAX_FRAME_BYTES);
+  const maxTotalBytes = positiveLimit(options.maxTotalBytes, DEFAULT_MAX_TOTAL_BYTES);
+  const timeoutMs = positiveLimit(options.timeoutMs, DEFAULT_TIMEOUT_MS);
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  const openResults = /* @__PURE__ */ new Map();
+  const delivery = createDelivery(receiver, options, (frame, disposition) => {
+    if (disposition === "stale" || frame.channel !== "result") return;
+    const key = streamFrameIdentityKey(frame.identity);
+    if (frame.kind === "open") openResults.set(key, frame.identity);
+    else if (frame.kind === "complete" || frame.kind === "error") openResults.delete(key);
+  });
+  let frameParts = [];
+  let frameBytes = 0;
+  let totalBytes = 0;
+  let finished = false;
+  let failure;
+  function failOpenResults(error) {
+    let failed = false;
+    for (const identity of openResults.values())
+      failed = receiver.failSelection(identity, error) || failed;
+    openResults.clear();
+    return failed;
+  }
+  const acceptLine = async () => {
+    if (frameBytes === 0) return;
+    const bytes = frameParts.length === 1 ? frameParts[0] : (() => {
+      const joined = new Uint8Array(frameBytes);
+      let offset = 0;
+      for (const part of frameParts) {
+        joined.set(part, offset);
+        offset += part.byteLength;
+      }
+      return joined;
+    })();
+    const frame = JSON.parse(decoder.decode(bytes));
+    if (!isStreamedRendererFrame(frame))
+      throw new StreamedReceiverError("protocol", "Malformed streamed renderer frame.");
+    await delivery.room(frameBytes);
+    void delivery.enqueue(frame, frameBytes).catch((error) => {
+      failure ??= error;
+    });
+  };
+  const abort = () => {
+    failure ??= new StreamedReceiverError("terminal", "Streamed renderer response was canceled.");
+    delivery.close(failure);
+    failOpenResults(failure);
+    void reader.cancel(options.signal?.reason).catch(() => {
+    });
+  };
+  const timer = setTimeout(() => {
+    failure ??= new StreamedReceiverError("timeout", "Streamed renderer response timed out.");
+    abort();
+  }, timeoutMs);
+  options.signal?.addEventListener("abort", abort, { once: true });
+  if (options.signal?.aborted) abort();
+  try {
+    for (; ; ) {
+      if (failure !== void 0 && options.signal?.aborted) throw failure;
+      options.signal?.throwIfAborted();
+      const next = await reader.read();
+      if (next.done) break;
+      totalBytes += next.value.byteLength;
+      if (totalBytes > maxTotalBytes) {
+        throw new Error("The streamed renderer response exceeded its total byte budget.");
+      }
+      let start = 0;
+      for (let index = 0; index < next.value.byteLength; index++) {
+        if (next.value[index] !== 10) continue;
+        const part = next.value.subarray(start, index);
+        if (part.byteLength > 0) frameParts.push(part);
+        frameBytes += part.byteLength;
+        if (frameBytes > maxFrameBytes) {
+          throw new Error("A streamed renderer frame exceeded its byte budget.");
+        }
+        await acceptLine();
+        frameParts = [];
+        frameBytes = 0;
+        start = index + 1;
+      }
+      const tail = next.value.subarray(start);
+      if (tail.byteLength > 0) frameParts.push(tail);
+      frameBytes += tail.byteLength;
+      if (frameBytes > maxFrameBytes) {
+        throw new Error("A streamed renderer frame exceeded its byte budget.");
+      }
+    }
+    if (frameBytes !== 0) throw new Error("The streamed renderer response ended mid-frame.");
+    await delivery.drain();
+    const terminalError = new StreamedReceiverError(
+      "terminal",
+      "The streamed renderer response ended before a result terminal."
+    );
+    if (failOpenResults(terminalError)) failure ??= terminalError;
+    if (failure !== void 0) throw failure;
+    finished = true;
+  } catch (cause) {
+    const error = cause instanceof StreamedReceiverError ? cause : new StreamedReceiverError(
+      "protocol",
+      cause instanceof Error ? cause.message : "Streamed renderer response failed."
+    );
+    delivery.close(error);
+    failOpenResults(error);
+    throw error;
+  } finally {
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", abort);
+    if (!finished) {
+      try {
+        void reader.cancel().catch(() => {
+        });
+      } catch {
+      }
+    }
+    reader.releaseLock();
+  }
+}
+export {
+  STREAMED_RENDERER_RECEIVER,
+  installStreamedRendererGlobal,
+  readStreamedRendererResponse
+};

package/dist/hydration/stream-receiver.d.ts

@@ -0,0 +1,26 @@
+import { type StreamedRegionPlacementFrame, type StreamFrameIdentity } from '../streamed-signals-protocol.js';
+import type { ScopeSeed } from '../signals/types.js';
+import { type StreamedResultReceiver, type StreamedResultReceiverOptions as StreamedRegionReceiverOptions } from './stream-result-receiver.js';
+export { StreamedReceiverError, type StreamedFrameDisposition, type StreamedResultReceiverOptions as StreamedRegionReceiverOptions, type StreamedResultConsumer, } from './stream-result-receiver.js';
+export interface HistoricalFrameLease {
+    release(): void;
+}
+export interface StreamedRegionRegistration {
+    readonly identity: StreamFrameIdentity;
+    readonly start: Comment;
+    readonly end: Comment;
+    readonly contentRevision: number;
+    /** Re-read immediately before commit; active renderer ownership forbids HTML placement. */
+    readonly isActive: () => boolean;
+    /** Resolve compiler-proven styles. Completion means every identity is ready to paint. */
+    readonly loadStyles: (styles: readonly string[]) => void | Promise<void>;
+    /** Acquire the exact historical values that produced this candidate range. */
+    readonly adoptHistoricalFrame: (frame: ScopeSeed) => HistoricalFrameLease;
+    /** Renderer-specific stable-ID delta application; generic DOM morph/append is forbidden. */
+    readonly applyDelta?: (frame: StreamedRegionPlacementFrame) => void;
+}
+export interface StreamedRegionReceiver extends StreamedResultReceiver {
+    registerRegion(registration: StreamedRegionRegistration): () => void;
+}
+/** Accept streamed results and place registered renderer-owned HTML ranges. */
+export declare function createStreamedRegionReceiver(options: StreamedRegionReceiverOptions): StreamedRegionReceiver;

package/dist/hydration/stream-receiver.js

@@ -0,0 +1,204 @@
+import { HYDRATE_INPUT_ATTR } from "../hydration-markers.js";
+import { rendererRangeClose } from "../stream-protocol.js";
+import {
+  sameStreamFrameIdentity
+} from "../streamed-signals-protocol.js";
+import { snapshotHydrationControl } from "./control-capture.js";
+import {
+  createStreamedResultReceiverState,
+  StreamedReceiverError
+} from "./stream-result-receiver.js";
+import {
+  StreamedReceiverError as StreamedReceiverError2
+} from "./stream-result-receiver.js";
+function rangeNodes(start, end) {
+  if (start.parentNode === null || start.parentNode !== end.parentNode) {
+    throw new StreamedReceiverError("placement", "The streamed region range is detached.");
+  }
+  const nodes = [];
+  for (let node = start.nextSibling; node !== null && node !== end; node = node.nextSibling) {
+    nodes.push(node);
+  }
+  if (end.previousSibling !== start && nodes.length === 0) {
+    throw new StreamedReceiverError("placement", "The streamed region range is malformed.");
+  }
+  return nodes;
+}
+function keyedControls(nodes) {
+  const controls = /* @__PURE__ */ new Map();
+  const visit = (element) => {
+    const key = element.getAttribute(HYDRATE_INPUT_ATTR);
+    if (key !== null) {
+      if (controls.has(key)) {
+        throw new StreamedReceiverError("placement", `Duplicate streamed control key "${key}".`);
+      }
+      controls.set(key, element);
+    }
+    for (const child of element.children) visit(child);
+  };
+  for (const node of nodes) if (node.nodeType === 1) visit(node);
+  return controls;
+}
+function compatibleControl(current, incoming) {
+  return current.localName === incoming.localName && current.namespaceURI === incoming.namespaceURI && (current.localName !== "input" || current.type === incoming.type);
+}
+function restoreControl(control) {
+  const { element, snapshot } = control;
+  if (!snapshot.focused || !element.isConnected) return;
+  try {
+    element.focus({ preventScroll: true });
+  } catch {
+    return;
+  }
+  if (snapshot.composing || snapshot.selectionStart === null || snapshot.selectionEnd === null)
+    return;
+  try {
+    element.setSelectionRange(
+      snapshot.selectionStart,
+      snapshot.selectionEnd,
+      snapshot.selectionDirection ?? void 0
+    );
+  } catch {
+  }
+}
+function placeFullRegion(registration, html) {
+  const { start, end } = registration;
+  const oldNodes = rangeNodes(start, end);
+  const oldControls = keyedControls(oldNodes);
+  const snapshots = /* @__PURE__ */ new Map();
+  for (const [key, element] of oldControls) {
+    const snapshot = snapshotHydrationControl(element);
+    if (snapshot !== null) snapshots.set(key, { element, snapshot });
+  }
+  const template = start.ownerDocument.createElement("template");
+  template.innerHTML = html;
+  const incomingOpen = template.content.firstChild;
+  const incomingClose = rendererRangeClose(incomingOpen);
+  if (incomingOpen === null || incomingClose === null || incomingClose !== template.content.lastChild) {
+    throw new StreamedReceiverError(
+      "placement",
+      "A full streamed region must be one balanced range."
+    );
+  }
+  const incomingNodes = [];
+  for (let node = incomingOpen.nextSibling; node !== incomingClose; node = node.nextSibling) {
+    incomingNodes.push(node);
+  }
+  const incomingControls = keyedControls(incomingNodes);
+  for (const [key, preserved] of snapshots) {
+    const replacement = incomingControls.get(key);
+    if ((preserved.snapshot.editRevision > 0 || preserved.snapshot.focused || preserved.snapshot.composing) && (replacement === void 0 || !compatibleControl(preserved.element, replacement))) {
+      throw new StreamedReceiverError(
+        "placement",
+        `Streamed HTML cannot preserve live control "${key}".`
+      );
+    }
+  }
+  const parent = end.parentNode;
+  for (const node of incomingNodes) parent.insertBefore(node, end);
+  const preservedElements = /* @__PURE__ */ new Set();
+  for (const [key, replacement] of incomingControls) {
+    const current = oldControls.get(key);
+    if (current === void 0 || !compatibleControl(current, replacement)) continue;
+    replacement.parentNode.replaceChild(current, replacement);
+    preservedElements.add(current);
+  }
+  for (const node of oldNodes) {
+    if (node.nodeType === 1 && preservedElements.has(node)) continue;
+    node.parentNode?.removeChild(node);
+  }
+  for (const preserved of snapshots.values()) restoreControl(preserved);
+}
+async function commitPlacement(state, frame, isCurrent) {
+  const registration = state.region;
+  if (!isCurrent(state, frame.identity) || registration === void 0 || registration.isActive() || !sameStreamFrameIdentity(state.identity, frame.identity) || frame.contentRevision <= state.contentRevision || frame.mode === "delta" && frame.baseRevision !== state.contentRevision) {
+    return "stale";
+  }
+  try {
+    await registration.loadStyles(frame.styles);
+  } catch {
+    throw new StreamedReceiverError("styles", "Required streamed region styles are unavailable.");
+  }
+  if (!isCurrent(state, frame.identity) || state.region !== registration || registration.isActive() || !sameStreamFrameIdentity(state.identity, frame.identity) || frame.contentRevision <= state.contentRevision || frame.mode === "delta" && frame.baseRevision !== state.contentRevision) {
+    return "stale";
+  }
+  for (const element of keyedControls(rangeNodes(registration.start, registration.end)).values()) {
+    if (!snapshotHydrationControl(element)?.composing) continue;
+    state.pendingPlacement?.cancel();
+    return new Promise((resolve, reject) => {
+      const cleanup = () => {
+        element.removeEventListener("compositionend", resume);
+        if (state.pendingPlacement === pending) state.pendingPlacement = void 0;
+      };
+      const pending = {
+        cancel() {
+          cleanup();
+          resolve("stale");
+        }
+      };
+      const resume = () => {
+        cleanup();
+        void commitPlacement(state, frame, isCurrent).then(resolve, reject);
+      };
+      state.pendingPlacement = pending;
+      element.addEventListener("compositionend", resume, { once: true });
+    });
+  }
+  let lease;
+  try {
+    lease = registration.adoptHistoricalFrame(frame.historicalFrame);
+  } catch {
+    throw new StreamedReceiverError("historical-frame", "Historical read-frame adoption failed.");
+  }
+  try {
+    if (frame.mode === "delta") {
+      if (registration.applyDelta === void 0) {
+        throw new StreamedReceiverError(
+          "placement",
+          "This region does not support renderer deltas."
+        );
+      }
+      registration.applyDelta(frame);
+    } else {
+      placeFullRegion(registration, frame.html);
+    }
+  } catch (error) {
+    lease.release();
+    throw error;
+  }
+  state.historical?.release();
+  state.historical = lease;
+  state.contentRevision = frame.contentRevision;
+  return "accepted";
+}
+function createStreamedRegionReceiver(options) {
+  const { receiver, current } = createStreamedResultReceiverState(options, commitPlacement);
+  const registerRegion = (registration) => {
+    const state = current(registration.identity);
+    if (state === void 0) {
+      throw new StreamedReceiverError("identity", "Register the exact current selection first.");
+    }
+    if (registration.start.parentNode !== registration.end.parentNode) {
+      throw new StreamedReceiverError(
+        "placement",
+        "The streamed region markers do not share a parent."
+      );
+    }
+    if (!Number.isSafeInteger(registration.contentRevision) || registration.contentRevision < 0) {
+      throw new StreamedReceiverError(
+        "identity",
+        "Streamed region content revisions must be nonnegative safe integers."
+      );
+    }
+    state.region = registration;
+    state.contentRevision = registration.contentRevision;
+    return () => {
+      if (state.region === registration) state.region = void 0;
+    };
+  };
+  return { ...receiver, registerRegion };
+}
+export {
+  StreamedReceiverError2 as StreamedReceiverError,
+  createStreamedRegionReceiver
+};