npm - @absolutejs/absolute - Versions diffs - 0.19.0-beta.365 → 0.19.0-beta.367 - Mend

@absolutejs/absolute 0.19.0-beta.365 → 0.19.0-beta.367

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (27) hide show

package/dist/angular/browser.js +8 -12
package/dist/angular/browser.js.map +4 -4
package/dist/angular/index.js +4420 -4465
package/dist/angular/index.js.map +8 -8
package/dist/build.js +576 -24
package/dist/build.js.map +10 -4
package/dist/client/index.js +44 -45
package/dist/client/index.js.map +4 -4
package/dist/index.js +9572 -9596
package/dist/index.js.map +13 -12
package/dist/react/components/browser/index.js +18 -6
package/dist/react/components/index.js +35 -16
package/dist/react/components/index.js.map +6 -5
package/dist/react/index.js +1762 -1794
package/dist/react/index.js.map +12 -12
package/dist/react/server.js +571 -3
package/dist/react/server.js.map +11 -4
package/dist/src/core/pageHandlers.d.ts +1 -1
package/dist/src/react/index.d.ts +1 -1
package/dist/src/react/streamingSlotCollection.d.ts +9 -0
package/dist/svelte/index.js +1881 -1926
package/dist/svelte/index.js.map +8 -8
package/dist/vue/components/index.js +8 -12
package/dist/vue/components/index.js.map +5 -5
package/dist/vue/index.js +1929 -1976
package/dist/vue/index.js.map +8 -8
package/package.json +1 -1

package/dist/build.js CHANGED Viewed

@@ -170019,10 +170019,10 @@ var routePropsCache, cacheRouteData = (pagePath, data) => {
     result = injectBeforeClose(result, `<script type="module" src="${indexPath}"></script>`);
   }
   return result;
-}, renderAngularApp = async (deps, PageComponent, providers, document) => {
+}, renderAngularApp = async (deps, PageComponent, providers, document2) => {
   const bootstrap = (context) => deps.bootstrapApplication(PageComponent, { providers }, context);
   return withSuppressedAngularDevLogs(() => deps.renderApplication(bootstrap, {
-    document,
+    document: document2,
     platformProviders: [],
     url: "/"
   }));
@@ -170187,9 +170187,9 @@ var angularIslandSelector = "abs-angular-island", getAngularIslandSelector = (_i
     { provide: deps.APP_BASE_HREF, useValue: "/" },
     { provide: propsToken, useValue: props }
   ];
-  const document = `<!DOCTYPE html><html><body><${selector}></${selector}></body></html>`;
+  const document2 = `<!DOCTYPE html><html><body><${selector}></${selector}></body></html>`;
   const html = await withSuppressedAngularDevLogs(() => deps.renderApplication((context) => deps.bootstrapApplication(WrapperComponent, { providers }, context), {
-    document,
+    document: document2,
     platformProviders: [],
     url: "/"
   }));
@@ -172556,7 +172556,7 @@ ${registrations}
     ({ tsLibDir } = cached);
     cached.lastUsed = Date.now();
   } else {
-    const tsPath = __require.resolve("typescript");
+    const tsPath = __require.resolve("/home/alexkahn/abs/absolutejs/node_modules/typescript/lib/typescript.js");
     const tsRootDir = dirname8(tsPath);
     tsLibDir = tsRootDir.endsWith("lib") ? tsRootDir : resolve15(tsRootDir, "lib");
     const config = readConfiguration("./tsconfig.json");
@@ -176076,6 +176076,568 @@ var init_pageHandler = __esm(() => {
   setSsrContextGetter(() => angularSsrContext.getStore());
 });
+// src/client/streamSwap.ts
+var streamSwapRuntime = () => {
+  if (window.__ABS_SLOT_RUNTIME__ === true)
+    return;
+  window.__ABS_SLOT_RUNTIME__ = true;
+  window.__ABS_SLOT_PENDING__ = window.__ABS_SLOT_PENDING__ ?? {};
+  const pending = window.__ABS_SLOT_PENDING__;
+  const apply = (id, html) => {
+    const node = document.getElementById(`slot-${id}`);
+    if (!node) {
+      pending[id] = html;
+      return;
+    }
+    node.innerHTML = html;
+    delete pending[id];
+  };
+  const flush = () => {
+    for (const id in pending) {
+      if (!Object.prototype.hasOwnProperty.call(pending, id))
+        continue;
+      apply(id, pending[id] ?? "");
+    }
+  };
+  window.__ABS_SLOT_ENQUEUE__ = (id, html) => {
+    apply(id, html);
+  };
+  if (typeof MutationObserver === "function") {
+    const observer = new MutationObserver(flush);
+    const root = document.documentElement ?? document.body ?? document;
+    observer.observe(root, { childList: true, subtree: true });
+  }
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", flush, { once: true });
+  }
+  flush();
+}, stripFunctionWrapper = (value) => {
+  const start = value.indexOf("{");
+  const end = value.lastIndexOf("}");
+  if (start < 0 || end <= start)
+    return "";
+  return value.slice(start + 1, end);
+}, getStreamSwapRuntimeScript = () => `(function(){${stripFunctionWrapper(streamSwapRuntime.toString())}})();`;
+// src/utils/escapeScriptContent.ts
+var ESCAPE_LOOKUP, ESCAPE_REGEX, escapeScriptContent = (content) => content.replace(ESCAPE_REGEX, (char) => {
+  const escaped = ESCAPE_LOOKUP[char];
+  return escaped !== undefined ? escaped : char;
+});
+var init_escapeScriptContent = __esm(() => {
+  ESCAPE_LOOKUP = {
+    "\u2028": "\\u2028",
+    "\u2029": "\\u2029",
+    "&": "\\u0026",
+    "<": "\\u003C",
+    ">": "\\u003E"
+  };
+  ESCAPE_REGEX = /[&><\u2028\u2029]/g;
+});
+// src/utils/streamingSlots.ts
+var SLOT_ID_PREFIX = "abs-slot-", SLOT_PLACEHOLDER_PREFIX = "slot-", CLOSING_HEAD_TAG2 = "</head>", CLOSING_HEAD_TAG_LENGTH, CLOSING_PAGE_TAG_REGEX, STREAMING_RUNTIME_GLOBAL = "__ABS_SLOT_ENQUEUE__", STREAMING_PENDING_GLOBAL = "__ABS_SLOT_PENDING__", STREAM_TAIL_LOOKBEHIND = 128, STREAMING_SLOT_TIMEOUT_MS = 5000, STREAMING_SLOT_MAX_PER_RESPONSE = 128, STREAMING_SLOT_MAX_HTML_BYTES = 64000, createSlotPlaceholderId = (id) => `${SLOT_PLACEHOLDER_PREFIX}${id}`, createSlotPatchStatement = (id, html) => `(window.${STREAMING_RUNTIME_GLOBAL}||function(i,h){window.${STREAMING_PENDING_GLOBAL}=window.${STREAMING_PENDING_GLOBAL}||{};window.${STREAMING_PENDING_GLOBAL}[i]=h;})(${JSON.stringify(id)},${JSON.stringify(html)});`, createNonceAttr = (nonce) => nonce ? ` nonce="${nonce}"` : "", createStreamingSlotId = () => `${SLOT_ID_PREFIX}${Math.random().toString(36).slice(2, 10)}`, getStreamingSlotsRuntimeScript = () => getStreamSwapRuntimeScript(), renderStreamingSlotsRuntimeTag = (nonce) => `<script${createNonceAttr(nonce)}>${escapeScriptContent(getStreamingSlotsRuntimeScript())}</script>`, renderStreamingSlotPlaceholder = (id, fallbackHtml = "") => `<div id="${createSlotPlaceholderId(id)}" data-absolute-slot="true">${fallbackHtml}</div>`, renderStreamingSlotPatchTag = (id, html, nonce) => `<script${createNonceAttr(nonce)}>${escapeScriptContent(createSlotPatchStatement(id, html))}</script>`, injectHtmlIntoHead = (html, injection) => {
+  const closingHeadIndex = html.indexOf(CLOSING_HEAD_TAG2);
+  if (closingHeadIndex >= 0) {
+    return `${html.slice(0, closingHeadIndex)}${injection}${html.slice(closingHeadIndex)}`;
+  }
+  return `${html}${injection}`;
+}, toUint8 = (value, encoder) => encoder.encode(value), currentStreamingSlotPolicy, clonePolicy = (policy) => ({
+  ...policy
+}), normalizeSlotBytes = (value, fallback) => {
+  if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+    return Math.floor(value);
+  }
+  return fallback;
+}, normalizeSlotText = (value, fallback) => typeof value === "string" ? value : fallback, normalizeSlotError = (value, fallback) => typeof value === "string" ? value : fallback, hasPolicyValue = (policy, key) => Object.prototype.hasOwnProperty.call(policy, key), applyStreamingSlotPolicyOverrides = (base, overridePolicy = {}) => ({
+  timeoutMs: hasPolicyValue(overridePolicy, "timeoutMs") ? normalizeSlotBytes(overridePolicy.timeoutMs, base.timeoutMs) : base.timeoutMs,
+  fallbackHtml: hasPolicyValue(overridePolicy, "fallbackHtml") ? normalizeSlotText(overridePolicy.fallbackHtml, "") : base.fallbackHtml,
+  errorHtml: hasPolicyValue(overridePolicy, "errorHtml") ? normalizeSlotError(overridePolicy.errorHtml) : base.errorHtml,
+  maxSlotsPerResponse: hasPolicyValue(overridePolicy, "maxSlotsPerResponse") ? normalizeSlotBytes(overridePolicy.maxSlotsPerResponse, base.maxSlotsPerResponse) : base.maxSlotsPerResponse,
+  maxSlotHtmlSizeBytes: hasPolicyValue(overridePolicy, "maxSlotHtmlSizeBytes") ? normalizeSlotBytes(overridePolicy.maxSlotHtmlSizeBytes, base.maxSlotHtmlSizeBytes) : base.maxSlotHtmlSizeBytes,
+  onError: hasPolicyValue(overridePolicy, "onError") ? overridePolicy.onError : base.onError,
+  onSlotMetric: hasPolicyValue(overridePolicy, "onSlotMetric") ? overridePolicy.onSlotMetric : base.onSlotMetric
+}), createCombinedSlotErrorHandler = (policyOnError, enhancerOnError) => {
+  if (!policyOnError && !enhancerOnError)
+    return;
+  return (error, slot) => {
+    policyOnError?.(error, slot);
+    enhancerOnError?.(error, slot);
+  };
+}, createCombinedSlotMetricHandler = (policyOnSlotMetric, callOnSlotMetric) => {
+  if (!policyOnSlotMetric && !callOnSlotMetric)
+    return;
+  return (metric) => {
+    policyOnSlotMetric?.(metric);
+    callOnSlotMetric?.(metric);
+  };
+}, resolveStreamingSlotPolicy = (overridePolicy = {}) => {
+  const base = getStreamingSlotPolicy();
+  return applyStreamingSlotPolicyOverrides(base, overridePolicy);
+}, getStreamingSlotPolicy = () => clonePolicy(currentStreamingSlotPolicy), setStreamingSlotPolicy = (policy = {}) => {
+  const base = getStreamingSlotPolicy();
+  currentStreamingSlotPolicy = applyStreamingSlotPolicyOverrides(base, policy);
+}, withStreamingSlotPolicy = async (policy, callback) => {
+  const previous = getStreamingSlotPolicy();
+  setStreamingSlotPolicy(policy);
+  try {
+    return await callback();
+  } finally {
+    currentStreamingSlotPolicy = previous;
+  }
+}, emitSlotMetric = (metric, onSlotMetric) => {
+  onSlotMetric?.(metric);
+}, createTimeoutError = (slot, timeoutMs) => {
+  const error = new Error(`Streaming slot "${slot.id}" timed out after ${timeoutMs}ms`);
+  error.__absTimeout = true;
+  return error;
+}, toStreamingSlot = (slot, policy) => ({
+  errorHtml: slot.errorHtml === undefined ? policy.errorHtml : slot.errorHtml,
+  fallbackHtml: normalizeSlotText(slot.fallbackHtml, policy.fallbackHtml),
+  id: slot.id ?? createStreamingSlotId(),
+  timeoutMs: normalizeSlotBytes(slot.timeoutMs, policy.timeoutMs),
+  resolve: slot.resolve
+}), prepareSlots = ({
+  policy,
+  slots,
+  onError,
+  onSlotMetric
+}) => {
+  const preparedSlots = slots.map((slot) => toStreamingSlot(slot, policy));
+  const maxSlotsPerResponse = policy.maxSlotsPerResponse;
+  if (maxSlotsPerResponse === 0) {
+    const error = new Error("Streaming slot limit is set to 0");
+    for (const slot of preparedSlots) {
+      onError?.(error, slot);
+      emitSlotMetric({
+        type: "dropped",
+        slotId: slot.id,
+        reason: "maxSlotsPerResponse is 0"
+      }, onSlotMetric);
+    }
+    return [];
+  }
+  if (preparedSlots.length <= maxSlotsPerResponse) {
+    preparedSlots.forEach((slot) => emitSlotMetric({
+      type: "prepared",
+      slotId: slot.id
+    }, onSlotMetric));
+    return preparedSlots;
+  }
+  const keptSlots = preparedSlots.slice(0, maxSlotsPerResponse);
+  const droppedSlots = preparedSlots.slice(maxSlotsPerResponse);
+  droppedSlots.forEach((slot) => {
+    onError?.(new Error(`Streaming slot "${slot.id}" dropped because ${maxSlotsPerResponse} slots is the configured maximum`), slot);
+    emitSlotMetric({
+      type: "dropped",
+      slotId: slot.id,
+      reason: `maxSlotsPerResponse is ${maxSlotsPerResponse}`
+    }, onSlotMetric);
+  });
+  keptSlots.forEach((slot) => emitSlotMetric({
+    type: "prepared",
+    slotId: slot.id
+  }, onSlotMetric));
+  return keptSlots;
+}, htmlByteLength = (value, encoder) => encoder.encode(value).length, 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 = typeof slot.timeoutMs === "number" && slot.timeoutMs > 0 ? await Promise.race([
+      maybeAsyncValue,
+      new Promise((_, reject) => setTimeout(() => {
+        reject(createTimeoutError(slot, slot.timeoutMs ?? 0));
+      }, slot.timeoutMs))
+    ]) : await maybeAsyncValue;
+    const html = typeof resolved === "string" ? resolved : `${resolved}`;
+    if (safePolicy.maxSlotHtmlSizeBytes > 0 && htmlByteLength(html, encoder) > safePolicy.maxSlotHtmlSizeBytes) {
+      const bytes2 = htmlByteLength(html, encoder);
+      const error = new Error(`Streaming slot "${slot.id}" exceeded max payload size of ${safePolicy.maxSlotHtmlSizeBytes} bytes`);
+      const durationMs2 = Date.now() - start;
+      onError?.(error, slot);
+      emitSlotMetric({
+        type: "size_exceeded",
+        slotId: slot.id,
+        durationMs: durationMs2,
+        bytes: bytes2,
+        error
+      }, onSlotMetric);
+      const fallbackHtml = typeof slot.errorHtml === "string" ? slot.errorHtml : null;
+      return {
+        html: fallbackHtml,
+        id: slot.id,
+        durationMs: durationMs2,
+        bytes: fallbackHtml === null ? 0 : htmlByteLength(fallbackHtml, encoder)
+      };
+    }
+    const durationMs = Date.now() - start;
+    const bytes = htmlByteLength(html, encoder);
+    emitSlotMetric({
+      type: "resolved",
+      slotId: slot.id,
+      durationMs,
+      bytes
+    }, onSlotMetric);
+    return {
+      html,
+      id: slot.id,
+      durationMs,
+      bytes
+    };
+  } catch (error) {
+    const durationMs = Date.now() - start;
+    onError?.(error, slot);
+    emitSlotMetric({
+      type: error?.__absTimeout === true ? "timeout" : "error",
+      slotId: slot.id,
+      durationMs,
+      error
+    }, onSlotMetric);
+    if (typeof slot.errorHtml === "string") {
+      const html = slot.errorHtml;
+      return {
+        html,
+        id: slot.id,
+        durationMs,
+        bytes: htmlByteLength(html, encoder)
+      };
+    }
+    return {
+      html: null,
+      id: slot.id,
+      durationMs,
+      bytes: 0
+    };
+  }
+}, nextResolvedSlot = async (pending) => {
+  const wrapped = pending.map((promise) => promise.then((result) => ({
+    original: promise,
+    result
+  })));
+  return Promise.race(wrapped);
+}, streamChunkToString2 = (value, decoder) => typeof value === "string" ? value : decoder.decode(value, { stream: true }), 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({
+    policy: effectivePolicy,
+    slots,
+    onError: combinedOnError,
+    onSlotMetric: combinedOnSlotMetric
+  });
+  const encoder = new TextEncoder;
+  return new ReadableStream({
+    async start(controller) {
+      try {
+        let header = headerHtml;
+        if (preparedSlots.length > 0 && !header.includes(STREAMING_RUNTIME_GLOBAL)) {
+          header = injectHtmlIntoHead(header, renderStreamingSlotsRuntimeTag(nonce));
+        }
+        controller.enqueue(toUint8(header, encoder));
+        const pending = preparedSlots.map((slot) => {
+          const fallback = renderStreamingSlotPlaceholder(slot.id, slot.fallbackHtml ?? "");
+          controller.enqueue(toUint8(fallback, encoder));
+          return resolveSlot(slot, combinedOnError, effectivePolicy, combinedOnSlotMetric);
+        });
+        while (pending.length > 0) {
+          const { original, result } = await nextResolvedSlot(pending);
+          const index = pending.indexOf(original);
+          if (index >= 0)
+            pending.splice(index, 1);
+          if (result.html === null)
+            continue;
+          emitSlotMetric({
+            type: "patched",
+            slotId: result.id,
+            durationMs: result.durationMs,
+            bytes: result.bytes
+          }, combinedOnSlotMetric);
+          controller.enqueue(toUint8(renderStreamingSlotPatchTag(result.id, result.html, nonce), encoder));
+        }
+        if (footerHtml.length > 0) {
+          controller.enqueue(toUint8(footerHtml, encoder));
+        }
+        controller.close();
+      } catch (error) {
+        controller.error(error);
+      }
+    }
+  });
+}, injectStreamingRuntimeIntoStream = (stream, nonce) => {
+  const runtimeTag = renderStreamingSlotsRuntimeTag(nonce);
+  const encoder = new TextEncoder;
+  const decoder = new TextDecoder;
+  const lookbehind = CLOSING_HEAD_TAG_LENGTH - 1;
+  return new ReadableStream({
+    async start(controller) {
+      const reader = stream.getReader();
+      let injected = false;
+      let pending = "";
+      try {
+        for (;; ) {
+          const { done, value } = await reader.read();
+          if (done)
+            break;
+          if (!value)
+            continue;
+          pending += streamChunkToString2(value, decoder);
+          if (injected) {
+            controller.enqueue(encoder.encode(pending));
+            pending = "";
+            continue;
+          }
+          const headIndex = pending.indexOf(CLOSING_HEAD_TAG2);
+          if (headIndex >= 0) {
+            const withRuntime = `${pending.slice(0, headIndex)}${runtimeTag}${pending.slice(headIndex)}`;
+            controller.enqueue(encoder.encode(withRuntime));
+            pending = "";
+            injected = true;
+            continue;
+          }
+          if (pending.length > lookbehind) {
+            const safeText = pending.slice(0, pending.length - lookbehind);
+            controller.enqueue(encoder.encode(safeText));
+            pending = pending.slice(-lookbehind);
+          }
+        }
+        pending += decoder.decode();
+        if (!injected) {
+          pending = injectHtmlIntoHead(pending, runtimeTag);
+        }
+        if (pending.length > 0) {
+          controller.enqueue(encoder.encode(pending));
+        }
+        controller.close();
+      } catch (error) {
+        controller.error(error);
+      }
+    }
+  });
+}, appendStreamingSlotPatchesToStream = (stream, slots = [], {
+  injectRuntime = true,
+  nonce,
+  onError,
+  onSlotMetric,
+  policy
+} = {}) => {
+  const resolvedPolicy = resolveStreamingSlotPolicy(policy);
+  const combinedOnError = createCombinedSlotErrorHandler(resolvedPolicy.onError, onError);
+  const combinedOnSlotMetric = createCombinedSlotMetricHandler(resolvedPolicy.onSlotMetric, onSlotMetric);
+  const effectivePolicy = {
+    ...resolvedPolicy,
+    onSlotMetric: combinedOnSlotMetric
+  };
+  const preparedSlots = prepareSlots({
+    policy: effectivePolicy,
+    slots,
+    onError: combinedOnError,
+    onSlotMetric: combinedOnSlotMetric
+  });
+  if (preparedSlots.length === 0)
+    return stream;
+  const source = injectRuntime ? injectStreamingRuntimeIntoStream(stream, nonce) : stream;
+  const encoder = new TextEncoder;
+  const decoder = new TextDecoder;
+  const reader = source.getReader();
+  const pending = preparedSlots.map((slot) => resolveSlot(slot, combinedOnError, effectivePolicy, combinedOnSlotMetric));
+  return new ReadableStream({
+    async start(controller) {
+      let baseDone = false;
+      let baseRead = reader.read();
+      let tail = "";
+      let footer = "";
+      try {
+        while (!baseDone || pending.length > 0) {
+          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
+            })));
+          }
+          if (racers.length === 0)
+            break;
+          const winner = await Promise.race(racers);
+          if (winner.kind === "base") {
+            if (winner.done) {
+              baseDone = true;
+              tail += decoder.decode();
+              const footerStart = tail.search(CLOSING_PAGE_TAG_REGEX);
+              if (footerStart >= 0) {
+                const content = tail.slice(0, footerStart);
+                footer = tail.slice(footerStart);
+                if (content.length > 0) {
+                  controller.enqueue(encoder.encode(content));
+                }
+              } else if (tail.length > 0) {
+                controller.enqueue(encoder.encode(tail));
+              }
+              tail = "";
+            } else if (winner.value) {
+              tail += streamChunkToString2(winner.value, decoder);
+              if (tail.length > STREAM_TAIL_LOOKBEHIND) {
+                const content = tail.slice(0, tail.length - STREAM_TAIL_LOOKBEHIND);
+                controller.enqueue(encoder.encode(content));
+                tail = tail.slice(-STREAM_TAIL_LOOKBEHIND);
+              }
+              baseRead = reader.read();
+            }
+            continue;
+          }
+          const index = pending.indexOf(winner.original);
+          if (index >= 0)
+            pending.splice(index, 1);
+          if (winner.result.html === null)
+            continue;
+          emitSlotMetric({
+            type: "patched",
+            slotId: winner.result.id,
+            durationMs: winner.result.durationMs,
+            bytes: winner.result.bytes
+          }, combinedOnSlotMetric);
+          controller.enqueue(encoder.encode(renderStreamingSlotPatchTag(winner.result.id, winner.result.html, nonce)));
+        }
+        if (footer.length > 0)
+          controller.enqueue(encoder.encode(footer));
+        controller.close();
+      } catch (error) {
+        controller.error(error);
+      }
+    }
+  });
+};
+var init_streamingSlots = __esm(() => {
+  init_escapeScriptContent();
+  CLOSING_HEAD_TAG_LENGTH = CLOSING_HEAD_TAG2.length;
+  CLOSING_PAGE_TAG_REGEX = /<\/body>\s*<\/html>\s*$/i;
+  currentStreamingSlotPolicy = {
+    timeoutMs: STREAMING_SLOT_TIMEOUT_MS,
+    fallbackHtml: "",
+    errorHtml: undefined,
+    maxSlotsPerResponse: STREAMING_SLOT_MAX_PER_RESPONSE,
+    maxSlotHtmlSizeBytes: STREAMING_SLOT_MAX_HTML_BYTES
+  };
+});
+// src/core/streamingSlotRegistrar.ts
+var registrar = null, setStreamingSlotRegistrar = (nextRegistrar) => {
+  registrar = nextRegistrar;
+}, registerStreamingSlot = (slot) => {
+  registrar?.(slot);
+};
+// src/core/streamingSlotRegistry.ts
+var asyncLocalStorage, isServerRuntime = () => typeof process !== "undefined" && typeof process.versions?.node === "string", ensureAsyncLocalStorage = async () => {
+  if (typeof asyncLocalStorage !== "undefined")
+    return asyncLocalStorage;
+  if (!isServerRuntime()) {
+    asyncLocalStorage = null;
+    return asyncLocalStorage;
+  }
+  const mod = await import("async_hooks");
+  asyncLocalStorage = new mod.AsyncLocalStorage;
+  return asyncLocalStorage;
+}, registerStreamingSlot2 = (slot) => {
+  if (!asyncLocalStorage)
+    return;
+  const store = asyncLocalStorage.getStore();
+  if (!store)
+    return;
+  store.set(slot.id, slot);
+}, runWithStreamingSlotRegistry = async (task) => {
+  const storage = await ensureAsyncLocalStorage();
+  if (!storage) {
+    return {
+      result: await task(),
+      slots: []
+    };
+  }
+  return storage.run(new Map, async () => {
+    const result = await task();
+    const store = storage.getStore();
+    return {
+      result,
+      slots: store ? [...store.values()] : []
+    };
+  });
+};
+var init_streamingSlotRegistry = __esm(() => {
+  setStreamingSlotRegistrar(registerStreamingSlot2);
+});
+// src/core/responseEnhancers.ts
+var toResponse = async (responseLike) => await responseLike, cloneHeaders = (response) => {
+  const headers = new Headers(response.headers);
+  return headers;
+}, enhanceHtmlResponseWithStreamingSlots = (response, { nonce, onError, streamingSlots = [], policy } = {}) => {
+  if (!response.body || streamingSlots.length === 0) {
+    return response;
+  }
+  const body = appendStreamingSlotPatchesToStream(response.body, streamingSlots, {
+    nonce,
+    onError,
+    policy
+  });
+  return new Response(body, {
+    headers: cloneHeaders(response),
+    status: response.status,
+    statusText: response.statusText
+  });
+}, withStreamingSlots = async (responseLike, options = {}) => enhanceHtmlResponseWithStreamingSlots(await toResponse(responseLike), options), mergeStreamingSlots = (registered, explicit) => {
+  const merged = new Map;
+  for (const slot of registered)
+    merged.set(slot.id, slot);
+  for (const slot of explicit)
+    merged.set(slot.id, slot);
+  return [...merged.values()];
+}, withRegisteredStreamingSlots = async (renderResponse, options = {}) => {
+  const { result, slots } = await runWithStreamingSlotRegistry(renderResponse);
+  const explicit = options.streamingSlots ?? [];
+  return withStreamingSlots(result, {
+    ...options,
+    streamingSlots: mergeStreamingSlots(slots, explicit)
+  });
+};
+var init_responseEnhancers = __esm(() => {
+  init_streamingSlots();
+  init_streamingSlotRegistry();
+});
+// src/react/streamingSlotCollection.tsx
+import { createContext, useContext } from "react";
+import { jsxDEV } from "react/jsx-dev-runtime";
+var StreamingSlotCollectorContext, StreamingSlotCollectorProvider = ({
+  children,
+  collector
+}) => /* @__PURE__ */ jsxDEV(StreamingSlotCollectorContext.Provider, {
+  value: collector,
+  children
+}, undefined, false, undefined, this), useStreamingSlotCollector = () => useContext(StreamingSlotCollectorContext);
+var init_streamingSlotCollection = __esm(() => {
+  StreamingSlotCollectorContext = createContext(null);
+});
 // src/react/pageHandler.ts
 var ssrDirty2 = false, buildDirtyResponse = (index, maybeProps) => {
   const propsScript = maybeProps ? `window.__INITIAL_PROPS__=${JSON.stringify(maybeProps)};` : "";
@@ -176094,7 +176656,9 @@ var ssrDirty2 = false, buildDirtyResponse = (index, maybeProps) => {
   try {
     const { createElement: createElement2 } = await import("react");
     const { renderToReadableStream } = await import("react-dom/server");
-    const element = maybeProps !== undefined ? createElement2(PageComponent, maybeProps) : createElement2(PageComponent);
+    const slotCollector = new Map;
+    const pageElement = maybeProps !== undefined ? createElement2(PageComponent, maybeProps) : createElement2(PageComponent);
+    const element = createElement2(StreamingSlotCollectorProvider, { collector: slotCollector }, pageElement);
     const propsScript = maybeProps ? `window.__INITIAL_PROPS__=${JSON.stringify(maybeProps)};` : "";
     const refreshSetup = "window.__REFRESH_BUFFER__=[];window.$RefreshReg$=function(t,i){window.__REFRESH_BUFFER__.push([t,i])};window.$RefreshSig$=function(){return function(t){return t}};";
     const stream = await renderToReadableStream(element, {
@@ -176108,8 +176672,10 @@ var ssrDirty2 = false, buildDirtyResponse = (index, maybeProps) => {
       await stream.allReady;
     }
     const htmlStream = injectIslandPageContextStream(stream);
-    return new Response(htmlStream, {
+    return withStreamingSlots(new Response(htmlStream, {
       headers: { "Content-Type": "text/html" }
+    }), {
+      streamingSlots: [...slotCollector.values()]
     });
   } catch (error) {
     console.error("[SSR] React render error:", error);
@@ -176126,23 +176692,9 @@ var ssrDirty2 = false, buildDirtyResponse = (index, maybeProps) => {
   ssrDirty2 = true;
 };
 var init_pageHandler2 = __esm(() => {
+  init_responseEnhancers();
   init_resolveConvention();
-});
-// src/utils/escapeScriptContent.ts
-var ESCAPE_LOOKUP, ESCAPE_REGEX, escapeScriptContent = (content) => content.replace(ESCAPE_REGEX, (char) => {
-  const escaped = ESCAPE_LOOKUP[char];
-  return escaped !== undefined ? escaped : char;
-});
-var init_escapeScriptContent = __esm(() => {
-  ESCAPE_LOOKUP = {
-    "\u2028": "\\u2028",
-    "\u2029": "\\u2029",
-    "&": "\\u0026",
-    "<": "\\u003C",
-    ">": "\\u003E"
-  };
-  ESCAPE_REGEX = /[&><\u2028\u2029]/g;
+  init_streamingSlotCollection();
 });
 // src/svelte/renderToReadableStream.ts
@@ -179151,5 +179703,5 @@ export {
   build
 };
-//# debugId=F6A1E9B26F37A45164756E2164756E21
+//# debugId=DF9EA1EB950C542E64756E2164756E21
 //# sourceMappingURL=build.js.map