@absolutejs/absolute 0.19.0-beta.808 → 0.19.0-beta.809

package/dist/chunk-sd39p726.js

@@ -1,619 +0,0 @@
-// @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