@absolutejs/absolute 0.19.0-beta.783 → 0.19.0-beta.785

package/dist/chunk-sd39p726.js

@@ -0,0 +1,619 @@
+// @bun
+import {
+  escapeScriptContent
+} from "./chunk-851whwc7.js";
+import {
+  getStreamSwapRuntimeScript
+} from "./chunk-s6defjk2.js";
+import {
+  BASE_36_RADIX,
+  RANDOM_ID_END_INDEX
+} from "./chunk-qh75agse.js";
+
+// src/utils/streamingSlots.ts
+var SLOT_ID_PREFIX = "abs-slot-";
+var CLOSING_BODY_TAG = "</body>";
+var CLOSING_HEAD_TAG = "</head>";
+var CLOSING_BODY_TAG_LENGTH = CLOSING_BODY_TAG.length;
+var CLOSING_HEAD_TAG_LENGTH = CLOSING_HEAD_TAG.length;
+var CLOSING_PAGE_TAG_REGEX = /<\/body>\s*<\/html>\s*$/i;
+var STREAMING_RUNTIME_GLOBAL = "__ABS_SLOT_ENQUEUE__";
+var STREAMING_PENDING_GLOBAL = "__ABS_SLOT_PENDING__";
+var STREAM_TAIL_LOOKBEHIND = 128;
+var STREAMING_SLOT_TIMEOUT_MS = 5000;
+var STREAMING_SLOT_MAX_PER_RESPONSE = 128;
+var STREAMING_SLOT_MAX_HTML_BYTES = 64000;
+var createSlotPatchStatement = (id, payload) => `(window.${STREAMING_RUNTIME_GLOBAL}||function(i,p){window.${STREAMING_PENDING_GLOBAL}=window.${STREAMING_PENDING_GLOBAL}||{};window.${STREAMING_PENDING_GLOBAL}[i]=p;})(${JSON.stringify(id)},${JSON.stringify(payload)});`;
+var createNonceAttr = (nonce) => nonce ? ` nonce="${nonce}"` : "";
+var createStreamingSlotId = () => `${SLOT_ID_PREFIX}${Math.random().toString(BASE_36_RADIX).slice(2, RANDOM_ID_END_INDEX)}`;
+var getStreamingSlotsRuntimeScript = () => getStreamSwapRuntimeScript();
+var injectHtmlIntoBody = (html, injection) => {
+  const closingBodyIndex = html.indexOf(CLOSING_BODY_TAG);
+  if (closingBodyIndex >= 0) {
+    return `${html.slice(0, closingBodyIndex)}${injection}${html.slice(closingBodyIndex)}`;
+  }
+  return `${html}${injection}`;
+};
+var injectHtmlIntoHead = (html, injection) => {
+  const closingHeadIndex = html.indexOf(CLOSING_HEAD_TAG);
+  if (closingHeadIndex >= 0) {
+    return `${html.slice(0, closingHeadIndex)}${injection}${html.slice(closingHeadIndex)}`;
+  }
+  return `${html}${injection}`;
+};
+var renderStreamingSlotPatchTag = (id, payload, nonce) => `<script${createNonceAttr(nonce)}>${escapeScriptContent(createSlotPatchStatement(id, payload))}</script>`;
+var renderStreamingSlotPlaceholder = (id, fallbackHtml = "") => `<div id="${id}" data-absolute-slot="true" data-absolute-slot-state="fallback">${fallbackHtml}</div>`;
+var renderStreamingSlotsRuntimeTag = (nonce, runtimePreludeScript) => {
+  const runtimeBody = [
+    runtimePreludeScript?.trim() ? runtimePreludeScript.trim() : "",
+    getStreamingSlotsRuntimeScript()
+  ].filter(Boolean).join(";");
+  return `<script${createNonceAttr(nonce)}>${escapeScriptContent(runtimeBody)}</script>`;
+};
+var toUint8 = (value, encoder) => encoder.encode(value);
+var isRecord = (value) => Boolean(value) && typeof value === "object";
+var isSafeHtmlLike = (value) => isRecord(value) && typeof value.changingThisBreaksApplicationSecurity === "string";
+var normalizeSafeHtml = (value) => {
+  if (isSafeHtmlLike(value)) {
+    return value.changingThisBreaksApplicationSecurity;
+  }
+  return value;
+};
+var currentStreamingSlotPolicy = {
+  errorHtml: undefined,
+  fallbackHtml: "",
+  maxSlotHtmlSizeBytes: STREAMING_SLOT_MAX_HTML_BYTES,
+  maxSlotsPerResponse: STREAMING_SLOT_MAX_PER_RESPONSE,
+  timeoutMs: STREAMING_SLOT_TIMEOUT_MS
+};
+var clonePolicy = (policy) => ({
+  ...policy
+});
+var normalizeSlotBytes = (value, fallback) => {
+  if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+    return Math.floor(value);
+  }
+  return fallback;
+};
+var normalizeSlotText = (value, fallback) => {
+  const normalizedValue = normalizeSafeHtml(value);
+  return typeof normalizedValue === "string" ? normalizedValue : fallback;
+};
+var normalizeSlotError = (value, fallback = undefined) => {
+  const safeValue = normalizeSafeHtml(value);
+  if (typeof safeValue === "string")
+    return safeValue;
+  return fallback;
+};
+var hasPolicyValue = (policy, key) => Object.prototype.hasOwnProperty.call(policy, key);
+var applyStreamingSlotPolicyOverrides = (base, overridePolicy = {}) => ({
+  errorHtml: hasPolicyValue(overridePolicy, "errorHtml") ? normalizeSlotError(overridePolicy.errorHtml) : base.errorHtml,
+  fallbackHtml: hasPolicyValue(overridePolicy, "fallbackHtml") ? normalizeSlotText(overridePolicy.fallbackHtml, "") : base.fallbackHtml,
+  maxSlotHtmlSizeBytes: hasPolicyValue(overridePolicy, "maxSlotHtmlSizeBytes") ? normalizeSlotBytes(overridePolicy.maxSlotHtmlSizeBytes, base.maxSlotHtmlSizeBytes) : base.maxSlotHtmlSizeBytes,
+  maxSlotsPerResponse: hasPolicyValue(overridePolicy, "maxSlotsPerResponse") ? normalizeSlotBytes(overridePolicy.maxSlotsPerResponse, base.maxSlotsPerResponse) : base.maxSlotsPerResponse,
+  onError: hasPolicyValue(overridePolicy, "onError") ? overridePolicy.onError : base.onError,
+  onSlotMetric: hasPolicyValue(overridePolicy, "onSlotMetric") ? overridePolicy.onSlotMetric : base.onSlotMetric,
+  timeoutMs: hasPolicyValue(overridePolicy, "timeoutMs") ? normalizeSlotBytes(overridePolicy.timeoutMs, base.timeoutMs) : base.timeoutMs
+});
+var createCombinedSlotErrorHandler = (policyOnError, enhancerOnError) => {
+  if (!policyOnError && !enhancerOnError)
+    return;
+  return (error, slot) => {
+    policyOnError?.(error, slot);
+    enhancerOnError?.(error, slot);
+  };
+};
+var createCombinedSlotMetricHandler = (policyOnSlotMetric, callOnSlotMetric) => {
+  if (!policyOnSlotMetric && !callOnSlotMetric)
+    return;
+  return (metric) => {
+    policyOnSlotMetric?.(metric);
+    callOnSlotMetric?.(metric);
+  };
+};
+var resolveStreamingSlotPolicy = (overridePolicy = {}) => {
+  const base = getStreamingSlotPolicy();
+  return applyStreamingSlotPolicyOverrides(base, overridePolicy);
+};
+var getStreamingSlotPolicy = () => clonePolicy(currentStreamingSlotPolicy);
+var setStreamingSlotPolicy = (policy = {}) => {
+  const base = getStreamingSlotPolicy();
+  currentStreamingSlotPolicy = applyStreamingSlotPolicyOverrides(base, policy);
+};
+var withStreamingSlotPolicy = async (policy, callback) => {
+  const previous = getStreamingSlotPolicy();
+  setStreamingSlotPolicy(policy);
+  try {
+    return await callback();
+  } finally {
+    currentStreamingSlotPolicy = previous;
+  }
+};
+var emitSlotMetric = (metric, onSlotMetric) => {
+  onSlotMetric?.(metric);
+};
+var createTimeoutError = (slot, timeoutMs) => {
+  const error = Object.assign(new Error(`Streaming slot "${slot.id}" timed out after ${timeoutMs}ms`), { __absTimeout: true });
+  return error;
+};
+var isSlotPatchPayloadObject = (value) => isRecord(value) && ("html" in value);
+var isTimeoutError = (error) => isRecord(error) && error.__absTimeout === true;
+var toStreamingSlot = (slot, policy) => ({
+  errorHtml: slot.errorHtml === undefined ? policy.errorHtml : slot.errorHtml,
+  fallbackHtml: normalizeSlotText(slot.fallbackHtml, policy.fallbackHtml),
+  id: slot.id ?? createStreamingSlotId(),
+  resolve: slot.resolve,
+  timeoutMs: normalizeSlotBytes(slot.timeoutMs, policy.timeoutMs)
+});
+var prepareSlots = ({
+  policy,
+  slots,
+  onError,
+  onSlotMetric
+}) => {
+  const preparedSlots = slots.map((slot) => toStreamingSlot(slot, policy));
+  const emitPreparedSlotMetric = (slot) => {
+    emitSlotMetric({
+      slotId: slot.id,
+      type: "prepared"
+    }, onSlotMetric);
+  };
+  const dropPreparedSlot = (slot, reason) => {
+    onError?.(new Error(reason), slot);
+    emitSlotMetric({
+      reason,
+      slotId: slot.id,
+      type: "dropped"
+    }, onSlotMetric);
+  };
+  const { maxSlotsPerResponse } = policy;
+  if (maxSlotsPerResponse === 0) {
+    preparedSlots.forEach((slot) => dropPreparedSlot(slot, "maxSlotsPerResponse is 0"));
+    return [];
+  }
+  if (preparedSlots.length <= maxSlotsPerResponse) {
+    preparedSlots.forEach(emitPreparedSlotMetric);
+    return preparedSlots;
+  }
+  const keptSlots = preparedSlots.slice(0, maxSlotsPerResponse);
+  const droppedSlots = preparedSlots.slice(maxSlotsPerResponse);
+  droppedSlots.forEach((slot) => {
+    dropPreparedSlot(slot, `Streaming slot "${slot.id}" dropped because ${maxSlotsPerResponse} slots is the configured maximum`);
+  });
+  keptSlots.forEach(emitPreparedSlotMetric);
+  return keptSlots;
+};
+var htmlByteLength = (value, encoder) => encoder.encode(value).length;
+var normalizeSlotPatchPayload = (value) => {
+  const safeValue = normalizeSafeHtml(value);
+  if (isSlotPatchPayloadObject(safeValue) && typeof safeValue.html === "string") {
+    return {
+      ...safeValue,
+      html: normalizeSlotText(safeValue.html, "")
+    };
+  }
+  return typeof safeValue === "string" ? safeValue : `${safeValue}`;
+};
+var getPayloadHtml = (payload) => typeof payload === "string" ? payload : payload.html;
+var enqueueEncodedText = (controller, encoder, value) => {
+  if (value.length === 0) {
+    return;
+  }
+  controller.enqueue(encoder.encode(value));
+};
+var readStreamingRuntimeChunk = async (reader) => {
+  const { done, value } = await reader.read();
+  if (done || !value) {
+    return { done, value: undefined };
+  }
+  return { done, value };
+};
+var applyBaseWinnerState = (state, winner, handleResolved) => {
+  if (!state.handled && winner.kind === "slot") {
+    handleResolved(winner);
+  }
+  return state;
+};
+var resolveOversizedSlotPayload = (input) => {
+  const {
+    encoder,
+    html,
+    maxSlotHtmlSizeBytes,
+    onError,
+    onSlotMetric,
+    slot,
+    start
+  } = input;
+  const bytes = htmlByteLength(html, encoder);
+  if (bytes <= maxSlotHtmlSizeBytes) {
+    return null;
+  }
+  const error = new Error(`Streaming slot "${slot.id}" exceeded max payload size of ${maxSlotHtmlSizeBytes} bytes`);
+  const durationMs = Date.now() - start;
+  onError?.(error, slot);
+  emitSlotMetric({
+    bytes,
+    durationMs,
+    error,
+    slotId: slot.id,
+    type: "size_exceeded"
+  }, onSlotMetric);
+  const fallbackHtml = normalizeSlotError(slot.errorHtml, undefined);
+  return {
+    bytes: fallbackHtml === undefined ? 0 : htmlByteLength(fallbackHtml, encoder),
+    durationMs,
+    id: slot.id,
+    payload: fallbackHtml === undefined ? null : fallbackHtml
+  };
+};
+var raceWithTimeout = (promise, slot) => {
+  const { timeoutMs } = slot;
+  if (typeof timeoutMs !== "number" || timeoutMs <= 0) {
+    return promise;
+  }
+  const { promise: timeoutPromise, reject } = Promise.withResolvers();
+  setTimeout(() => {
+    reject(createTimeoutError(slot, timeoutMs));
+  }, timeoutMs);
+  return Promise.race([promise, timeoutPromise]);
+};
+var resolveSlot = async (slot, onError, policy, onSlotMetric) => {
+  const safePolicy = policy ?? getStreamingSlotPolicy();
+  const encoder = new TextEncoder;
+  const start = Date.now();
+  try {
+    const maybeAsyncValue = Promise.resolve(slot.resolve());
+    const resolved = await raceWithTimeout(maybeAsyncValue, slot);
+    const payload = normalizeSlotPatchPayload(resolved);
+    const html = getPayloadHtml(payload);
+    const oversizedResult = safePolicy.maxSlotHtmlSizeBytes > 0 ? resolveOversizedSlotPayload({
+      encoder,
+      html,
+      maxSlotHtmlSizeBytes: safePolicy.maxSlotHtmlSizeBytes,
+      onError,
+      onSlotMetric,
+      slot,
+      start
+    }) : null;
+    if (oversizedResult) {
+      return oversizedResult;
+    }
+    const durationMs = Date.now() - start;
+    const bytes = htmlByteLength(html, encoder);
+    emitSlotMetric({
+      bytes,
+      durationMs,
+      slotId: slot.id,
+      type: "resolved"
+    }, onSlotMetric);
+    return {
+      bytes,
+      durationMs,
+      id: slot.id,
+      payload
+    };
+  } catch (error) {
+    const durationMs = Date.now() - start;
+    onError?.(error, slot);
+    emitSlotMetric({
+      durationMs,
+      error,
+      slotId: slot.id,
+      type: isTimeoutError(error) ? "timeout" : "error"
+    }, onSlotMetric);
+    const html = normalizeSlotError(slot.errorHtml, undefined);
+    if (html) {
+      return {
+        bytes: htmlByteLength(html, encoder),
+        durationMs,
+        id: slot.id,
+        payload: html
+      };
+    }
+    return {
+      bytes: 0,
+      durationMs,
+      id: slot.id,
+      payload: null
+    };
+  }
+};
+var nextResolvedSlot = async (pending) => {
+  const wrapped = pending.map((promise) => promise.then((result) => ({
+    original: promise,
+    result
+  })));
+  return Promise.race(wrapped);
+};
+var streamChunkToString = (value, decoder) => typeof value === "string" ? value : decoder.decode(value, { stream: true });
+var appendStreamingSlotPatchesToStream = (stream, slots = [], {
+  injectRuntime = true,
+  nonce,
+  onError,
+  onSlotMetric,
+  policy,
+  runtimePreludeScript,
+  runtimePlacement = "head"
+} = {}) => {
+  const resolvedPolicy = resolveStreamingSlotPolicy(policy);
+  const combinedOnError = createCombinedSlotErrorHandler(resolvedPolicy.onError, onError);
+  const combinedOnSlotMetric = createCombinedSlotMetricHandler(resolvedPolicy.onSlotMetric, onSlotMetric);
+  const effectivePolicy = {
+    ...resolvedPolicy,
+    onSlotMetric: combinedOnSlotMetric
+  };
+  const preparedSlots = prepareSlots({
+    onError: combinedOnError,
+    onSlotMetric: combinedOnSlotMetric,
+    policy: effectivePolicy,
+    slots
+  });
+  if (preparedSlots.length === 0)
+    return stream;
+  const source = injectRuntime ? injectStreamingRuntimeIntoStream(stream, nonce, runtimePlacement, runtimePreludeScript) : stream;
+  const encoder = new TextEncoder;
+  const decoder = new TextDecoder;
+  const reader = source.getReader();
+  const pending = preparedSlots.map((slot) => resolveSlot(slot, combinedOnError, effectivePolicy, combinedOnSlotMetric));
+  const createRaceCandidates = (baseDone, baseRead) => {
+    const racers = [];
+    if (!baseDone) {
+      racers.push(baseRead.then(({ done, value }) => ({
+        done,
+        kind: "base",
+        value
+      })));
+    }
+    if (pending.length > 0) {
+      racers.push(nextResolvedSlot(pending).then((resolved) => ({
+        kind: "slot",
+        ...resolved
+      })));
+    }
+    return racers;
+  };
+  const flushTailLookbehind = (controller, tail) => {
+    if (tail.length <= STREAM_TAIL_LOOKBEHIND) {
+      return tail;
+    }
+    const content = tail.slice(0, tail.length - STREAM_TAIL_LOOKBEHIND);
+    controller.enqueue(encoder.encode(content));
+    return tail.slice(-STREAM_TAIL_LOOKBEHIND);
+  };
+  const finalizeCompletedBaseWinner = (controller, decodedTail, baseRead) => {
+    const footerStart = decodedTail.search(CLOSING_PAGE_TAG_REGEX);
+    if (footerStart < 0) {
+      enqueueEncodedText(controller, encoder, decodedTail);
+      return {
+        baseDone: true,
+        baseRead,
+        footer: "",
+        handled: true,
+        tail: ""
+      };
+    }
+    const content = decodedTail.slice(0, footerStart);
+    const nextFooter = decodedTail.slice(footerStart);
+    enqueueEncodedText(controller, encoder, content);
+    return {
+      baseDone: true,
+      baseRead,
+      footer: nextFooter,
+      handled: true,
+      tail: ""
+    };
+  };
+  const handleBaseWinner = (controller, winner, baseRead, tail, footer) => {
+    if (winner.kind !== "base") {
+      return { baseDone: false, baseRead, footer, handled: false, tail };
+    }
+    if (winner.done) {
+      return finalizeCompletedBaseWinner(controller, tail + decoder.decode(), baseRead);
+    }
+    if (!winner.value) {
+      return { baseDone: false, baseRead, footer, handled: true, tail };
+    }
+    const nextTail = flushTailLookbehind(controller, tail + streamChunkToString(winner.value, decoder));
+    return {
+      baseDone: false,
+      baseRead: reader.read(),
+      footer,
+      handled: true,
+      tail: nextTail
+    };
+  };
+  const handleResolvedSlot = (controller, winner) => {
+    const index = pending.indexOf(winner.original);
+    if (index >= 0)
+      pending.splice(index, 1);
+    if (winner.result.payload === null) {
+      return;
+    }
+    emitSlotMetric({
+      bytes: winner.result.bytes,
+      durationMs: winner.result.durationMs,
+      slotId: winner.result.id,
+      type: "patched"
+    }, combinedOnSlotMetric);
+    controller.enqueue(encoder.encode(renderStreamingSlotPatchTag(winner.result.id, winner.result.payload, nonce)));
+  };
+  const runPatchedStreamLoop = async (controller) => {
+    let baseDone = false;
+    let baseRead = reader.read();
+    let tail = "";
+    let footer = "";
+    const readNextRaceWinner = async () => {
+      const racers = createRaceCandidates(baseDone, baseRead);
+      if (racers.length === 0) {
+        return footer;
+      }
+      const winner = await Promise.race(racers);
+      const baseWinnerState = applyBaseWinnerState(handleBaseWinner(controller, winner, baseRead, tail, footer), winner, (slotWinner) => {
+        handleResolvedSlot(controller, slotWinner);
+      });
+      ({ baseDone, baseRead, footer, tail } = baseWinnerState);
+      if (baseDone && pending.length === 0) {
+        return footer;
+      }
+      return readNextRaceWinner();
+    };
+    return readNextRaceWinner();
+  };
+  return new ReadableStream({
+    async start(controller) {
+      try {
+        const footer = await runPatchedStreamLoop(controller);
+        enqueueEncodedText(controller, encoder, footer);
+        controller.close();
+      } catch (error) {
+        controller.error(error);
+      }
+    }
+  });
+};
+var injectStreamingRuntimeIntoStream = (stream, nonce, runtimePlacement = "head", runtimePreludeScript) => {
+  const runtimeTag = renderStreamingSlotsRuntimeTag(nonce, runtimePreludeScript);
+  const encoder = new TextEncoder;
+  const decoder = new TextDecoder;
+  const closingTag = runtimePlacement === "body" ? CLOSING_BODY_TAG : CLOSING_HEAD_TAG;
+  const lookbehind = (runtimePlacement === "body" ? CLOSING_BODY_TAG_LENGTH : CLOSING_HEAD_TAG_LENGTH) - 1;
+  const flushRuntimeLookbehind = (controller, pending) => {
+    if (pending.length <= lookbehind) {
+      return pending;
+    }
+    const safeText = pending.slice(0, pending.length - lookbehind);
+    controller.enqueue(encoder.encode(safeText));
+    return pending.slice(-lookbehind);
+  };
+  const injectRuntimeIntoPending = (pending) => runtimePlacement === "body" ? injectHtmlIntoBody(pending, runtimeTag) : injectHtmlIntoHead(pending, runtimeTag);
+  const processRuntimePending = (controller, pending, injected) => {
+    if (injected) {
+      controller.enqueue(encoder.encode(pending));
+      return { injected, pending: "" };
+    }
+    const closingTagIndex = pending.indexOf(closingTag);
+    if (closingTagIndex >= 0) {
+      const withRuntime = `${pending.slice(0, closingTagIndex)}${runtimeTag}${pending.slice(closingTagIndex)}`;
+      controller.enqueue(encoder.encode(withRuntime));
+      return { injected: true, pending: "" };
+    }
+    return {
+      injected,
+      pending: flushRuntimeLookbehind(controller, pending)
+    };
+  };
+  return new ReadableStream({
+    async start(controller) {
+      const reader = stream.getReader();
+      let injected = false;
+      let pending = "";
+      const enqueuePending = () => enqueueEncodedText(controller, encoder, pending);
+      const consumeRuntimeChunk = async () => {
+        const { done, value } = await readStreamingRuntimeChunk(reader);
+        if (done || !value) {
+          return done;
+        }
+        pending += streamChunkToString(value, decoder);
+        ({ injected, pending } = processRuntimePending(controller, pending, injected));
+        return false;
+      };
+      const runRuntimeInjectionLoop = async () => {
+        const done = await consumeRuntimeChunk();
+        if (done) {
+          return;
+        }
+        await runRuntimeInjectionLoop();
+      };
+      try {
+        await runRuntimeInjectionLoop();
+        pending += decoder.decode();
+        pending = injected ? pending : injectRuntimeIntoPending(pending);
+        enqueuePending();
+        controller.close();
+      } catch (error) {
+        controller.error(error);
+      }
+    }
+  });
+};
+var streamOutOfOrderSlots = ({
+  footerHtml = "",
+  headerHtml = "",
+  nonce,
+  policy,
+  onSlotMetric,
+  onError,
+  slots
+}) => {
+  const resolvedPolicy = resolveStreamingSlotPolicy(policy);
+  const combinedOnError = createCombinedSlotErrorHandler(resolvedPolicy.onError, onError);
+  const combinedOnSlotMetric = createCombinedSlotMetricHandler(resolvedPolicy.onSlotMetric, onSlotMetric);
+  const effectivePolicy = {
+    ...resolvedPolicy,
+    onSlotMetric: combinedOnSlotMetric
+  };
+  const preparedSlots = prepareSlots({
+    onError: combinedOnError,
+    onSlotMetric: combinedOnSlotMetric,
+    policy: effectivePolicy,
+    slots
+  });
+  const encoder = new TextEncoder;
+  const createPendingSlots = (controller) => preparedSlots.map((slot) => {
+    const fallback = renderStreamingSlotPlaceholder(slot.id, normalizeSlotText(slot.fallbackHtml, ""));
+    controller.enqueue(toUint8(fallback, encoder));
+    return resolveSlot(slot, combinedOnError, effectivePolicy, combinedOnSlotMetric);
+  });
+  const handleResolvedPreparedSlot = async (controller, pending) => {
+    const { original, result } = await nextResolvedSlot(pending);
+    const index = pending.indexOf(original);
+    if (index >= 0)
+      pending.splice(index, 1);
+    if (result.payload === null) {
+      return;
+    }
+    emitSlotMetric({
+      bytes: result.bytes,
+      durationMs: result.durationMs,
+      slotId: result.id,
+      type: "patched"
+    }, combinedOnSlotMetric);
+    controller.enqueue(toUint8(renderStreamingSlotPatchTag(result.id, result.payload, nonce), encoder));
+  };
+  const streamPreparedSlots = async (controller) => {
+    const pending = createPendingSlots(controller);
+    const streamNextPreparedSlot = async () => {
+      if (pending.length === 0) {
+        return;
+      }
+      await handleResolvedPreparedSlot(controller, pending);
+      await streamNextPreparedSlot();
+    };
+    await streamNextPreparedSlot();
+  };
+  const resolveHeaderHtml = () => {
+    const needsRuntimeTag = preparedSlots.length > 0 && !headerHtml.includes(STREAMING_RUNTIME_GLOBAL);
+    if (!needsRuntimeTag) {
+      return headerHtml;
+    }
+    return injectHtmlIntoHead(headerHtml, renderStreamingSlotsRuntimeTag(nonce));
+  };
+  return new ReadableStream({
+    async start(controller) {
+      try {
+        const header = resolveHeaderHtml();
+        controller.enqueue(toUint8(header, encoder));
+        await streamPreparedSlots(controller);
+        enqueueEncodedText(controller, encoder, footerHtml);
+        controller.close();
+      } catch (error) {
+        controller.error(error);
+      }
+    }
+  });
+};
+
+export { createStreamingSlotId, getStreamingSlotsRuntimeScript, injectHtmlIntoBody, injectHtmlIntoHead, renderStreamingSlotPatchTag, renderStreamingSlotPlaceholder, renderStreamingSlotsRuntimeTag, getStreamingSlotPolicy, setStreamingSlotPolicy, withStreamingSlotPolicy, appendStreamingSlotPatchesToStream, injectStreamingRuntimeIntoStream, streamOutOfOrderSlots };
+
+//# debugId=469B6C14F150BF0864756E2164756E21
+//# sourceMappingURL=chunk-sd39p726.js.map