npm - @absolutejs/absolute - Versions diffs - 0.19.0-beta.350 → 0.19.0-beta.352 - Mend

@absolutejs/absolute 0.19.0-beta.350 → 0.19.0-beta.352

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 (16) hide show

package/dist/angular/index.js +239 -23
package/dist/angular/index.js.map +4 -4
package/dist/index.js +300 -23
package/dist/index.js.map +7 -6
package/dist/react/index.js +239 -23
package/dist/react/index.js.map +4 -4
package/dist/src/core/responseEnhancers.d.ts +3 -2
package/dist/src/utils/index.d.ts +1 -0
package/dist/src/utils/streamingSlotMetricSink.d.ts +18 -0
package/dist/src/utils/streamingSlots.d.ts +38 -2
package/dist/src/vue/index.d.ts +2 -0
package/dist/svelte/index.js +239 -23
package/dist/svelte/index.js.map +4 -4
package/dist/vue/index.js +358 -80
package/dist/vue/index.js.map +9 -7
package/package.json +7 -7

package/dist/vue/index.js CHANGED Viewed

@@ -361,12 +361,12 @@ var CONVENTIONS_KEY = "__absoluteConventions", isConventionsMap = (value) => Boo
   });
   return { body, styles };
 }, renderVueError = async (conventionPath, errorProps) => {
-  const { createSSRApp, h } = await import("vue");
+  const { createSSRApp, h: h3 } = await import("vue");
   const { renderToString } = await import("vue/server-renderer");
   const mod = await import(conventionPath);
   const ErrorComponent = mod.default;
   const app = createSSRApp({
-    render: () => h(ErrorComponent, errorProps)
+    render: () => h3(ErrorComponent, errorProps)
   });
   const rawBody = await renderToString(app);
   const { styles, body } = unescapeVueStyles(rawBody);
@@ -429,12 +429,12 @@ var CONVENTIONS_KEY = "__absoluteConventions", isConventionsMap = (value) => Boo
     status: 404
   });
 }, renderVueNotFound = async (conventionPath) => {
-  const { createSSRApp, h } = await import("vue");
+  const { createSSRApp, h: h3 } = await import("vue");
   const { renderToString } = await import("vue/server-renderer");
   const mod = await import(conventionPath);
   const NotFoundComponent = mod.default;
   const app = createSSRApp({
-    render: () => h(NotFoundComponent)
+    render: () => h3(NotFoundComponent)
   });
   const rawBody = await renderToString(app);
   const { styles, body } = unescapeVueStyles(rawBody);
@@ -553,10 +553,10 @@ var ssrDirty = false, isRecord = (value) => typeof value === "object" && value !
       };
     };
     const resolvedPage = await resolvePageComponent();
-    const { createSSRApp, h } = await import("vue");
+    const { createSSRApp, h: h3 } = await import("vue");
     const { renderToWebStream } = await import("vue/server-renderer");
     const app = createSSRApp({
-      render: () => h(resolvedPage.component, maybeProps ?? null)
+      render: () => h3(resolvedPage.component, maybeProps ?? null)
     });
     const bodyStream = renderToWebStream(app);
     const head = `<!DOCTYPE html><html>${headTag}<body><div id="root">`;
@@ -1681,7 +1681,7 @@ function sha1(str) {
   words32[len >> 5] |= 128 << 24 - len % 32;
   words32[(len + 64 >> 9 << 4) + 15] = len;
   for (let i = 0;i < words32.length; i += 16) {
-    const h0 = a, h1 = b, h2 = c, h3 = d, h4 = e;
+    const h0 = a, h1 = b, h22 = c, h3 = d, h4 = e;
     for (let j = 0;j < 80; j++) {
       if (j < 16) {
         w[j] = words32[i + j];
@@ -1700,7 +1700,7 @@ function sha1(str) {
     }
     a = add32(a, h0);
     b = add32(b, h1);
-    c = add32(c, h2);
+    c = add32(c, h22);
     d = add32(d, h3);
     e = add32(e, h4);
   }
@@ -30398,14 +30398,14 @@ var init_islands2 = __esm(() => {
 import { createElement } from "react";
 import { renderToStaticMarkup } from "react-dom/server";
 import { render as renderSvelte } from "svelte/server";
-import { createSSRApp, h } from "vue";
+import { createSSRApp, h as h3 } from "vue";
 import { renderToString as renderVueToString } from "vue/server-renderer";
 var renderReactIslandToHtml = (component, props) => renderToStaticMarkup(createElement(component, props)), renderSvelteIslandToHtml = (component, props) => {
   const { body } = renderSvelte(component, { props });
   return body;
 }, renderVueIslandToHtml = (component, props) => {
   const app = createSSRApp({
-    render: () => h(component, props)
+    render: () => h3(component, props)
   });
   return renderVueToString(app);
 };
@@ -30782,6 +30782,105 @@ var init_renderIslandMarkup = __esm(() => {
   resolvedServerBuildComponentCache = new Map;
 });
+// src/vue/components/Image.vue
+var Image_default = "../Image-0pe96k20.vue";
+// src/vue/components/SuspenseSlot.ts
+import { defineComponent as defineComponent2, h as h2 } from "vue";
+// src/vue/components/StreamSlot.ts
+import { defineComponent, h } from "vue";
+// src/core/streamingSlotRegistry.ts
+var asyncLocalStorage;
+var isServerRuntime = () => typeof process !== "undefined" && typeof process.versions?.node === "string";
+var 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;
+};
+var registerStreamingSlot = (slot) => {
+  if (!asyncLocalStorage)
+    return;
+  const store = asyncLocalStorage.getStore();
+  if (!store)
+    return;
+  store.set(slot.id, slot);
+};
+var 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()] : []
+    };
+  });
+};
+// src/vue/components/StreamSlot.ts
+var StreamSlot = defineComponent({
+  name: "AbsoluteStreamSlot",
+  props: {
+    className: { default: undefined, type: String },
+    errorHtml: { default: undefined, type: String },
+    fallbackHtml: { default: "", type: String },
+    id: { required: true, type: String },
+    resolve: {
+      required: true,
+      type: Function
+    },
+    timeoutMs: { default: undefined, type: Number }
+  },
+  setup(props) {
+    if (typeof window === "undefined") {
+      registerStreamingSlot({
+        errorHtml: props.errorHtml,
+        fallbackHtml: props.fallbackHtml,
+        id: props.id,
+        resolve: props.resolve,
+        timeoutMs: props.timeoutMs
+      });
+    }
+    return () => h("div", {
+      class: props.className,
+      "data-absolute-slot": "true",
+      id: `slot-${props.id}`,
+      innerHTML: props.fallbackHtml
+    });
+  }
+});
+// src/vue/components/SuspenseSlot.ts
+var SuspenseSlot = defineComponent2({
+  name: "AbsoluteSuspenseSlot",
+  props: {
+    className: { default: undefined, type: String },
+    errorHtml: { default: undefined, type: String },
+    fallbackHtml: { default: "", type: String },
+    id: { required: true, type: String },
+    resolve: {
+      required: true,
+      type: Function
+    },
+    timeoutMs: { default: undefined, type: Number }
+  },
+  setup(props) {
+    return () => h2(StreamSlot, props);
+  }
+});
 // src/client/streamSwap.ts
 var streamSwapRuntime = () => {
   if (window.__ABS_SLOT_RUNTIME__ === true)
@@ -30837,6 +30936,9 @@ 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 createSlotPlaceholderId = (id) => `${SLOT_PLACEHOLDER_PREFIX}${id}`;
 var 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)});`;
 var createNonceAttr = (nonce) => nonce ? ` nonce="${nonce}"` : "";
@@ -30853,32 +30955,197 @@ var injectHtmlIntoHead = (html, injection) => {
   return `${html}${injection}`;
 };
 var toUint8 = (value, encoder) => encoder.encode(value);
-var toStreamingSlot = (slot) => ({
-  ...slot,
-  id: slot.id ?? createStreamingSlotId()
+var currentStreamingSlotPolicy = {
+  timeoutMs: STREAMING_SLOT_TIMEOUT_MS,
+  fallbackHtml: "",
+  errorHtml: undefined,
+  maxSlotsPerResponse: STREAMING_SLOT_MAX_PER_RESPONSE,
+  maxSlotHtmlSizeBytes: STREAMING_SLOT_MAX_HTML_BYTES
+};
+var clonePolicy = (policy) => ({
+  ...policy
 });
-var resolveSlot = async (slot, onError) => {
+var normalizeSlotBytes = (value, fallback) => {
+  if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+    return Math.floor(value);
+  }
+  return fallback;
+};
+var normalizeSlotText = (value, fallback) => typeof value === "string" ? value : fallback;
+var normalizeSlotError = (value, fallback) => typeof value === "string" ? value : fallback;
+var hasPolicyValue = (policy, key) => Object.prototype.hasOwnProperty.call(policy, key);
+var 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
+});
+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 {
-    const resolved = slot.resolve();
-    const html = typeof slot.timeoutMs === "number" && slot.timeoutMs > 0 ? await Promise.race([
-      Promise.resolve(resolved),
-      new Promise((_, reject) => setTimeout(() => reject(new Error(`Streaming slot "${slot.id}" timed out after ${slot.timeoutMs}ms`)), slot.timeoutMs))
-    ]) : await resolved;
+    return await callback();
+  } finally {
+    currentStreamingSlotPolicy = previous;
+  }
+};
+var emitSlotMetric = (metric, onSlotMetric) => {
+  onSlotMetric?.(metric);
+};
+var createTimeoutError = (slot, timeoutMs) => {
+  const error = new Error(`Streaming slot "${slot.id}" timed out after ${timeoutMs}ms`);
+  error.__absTimeout = true;
+  return error;
+};
+var 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
+});
+var 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;
+};
+var htmlByteLength = (value, encoder) => encoder.encode(value).length;
+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 = 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
+      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: slot.errorHtml,
-        id: slot.id
+        html,
+        id: slot.id,
+        durationMs,
+        bytes: htmlByteLength(html, encoder)
       };
     }
     return {
       html: null,
-      id: slot.id
+      id: slot.id,
+      durationMs,
+      bytes: 0
     };
   }
 };
@@ -30894,23 +31161,37 @@ 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({
+    policy: effectivePolicy,
+    slots,
+    onError: combinedOnError,
+    onSlotMetric: combinedOnSlotMetric
+  });
   const encoder = new TextEncoder;
   return new ReadableStream({
     async start(controller) {
       try {
         let header = headerHtml;
-        if (!header.includes(STREAMING_RUNTIME_GLOBAL)) {
+        if (preparedSlots.length > 0 && !header.includes(STREAMING_RUNTIME_GLOBAL)) {
           header = injectHtmlIntoHead(header, renderStreamingSlotsRuntimeTag(nonce));
         }
         controller.enqueue(toUint8(header, encoder));
-        const pending = slots.map((slot) => {
-          const resolvedSlot = toStreamingSlot(slot);
-          const fallback = renderStreamingSlotPlaceholder(resolvedSlot.id, resolvedSlot.fallbackHtml ?? "");
+        const pending = preparedSlots.map((slot) => {
+          const fallback = renderStreamingSlotPlaceholder(slot.id, slot.fallbackHtml ?? "");
           controller.enqueue(toUint8(fallback, encoder));
-          return resolveSlot(resolvedSlot, onError);
+          return resolveSlot(slot, combinedOnError, effectivePolicy, combinedOnSlotMetric);
         });
         while (pending.length > 0) {
           const { original, result } = await nextResolvedSlot(pending);
@@ -30919,6 +31200,12 @@ var streamOutOfOrderSlots = ({
             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) {
@@ -30982,12 +31269,33 @@ var injectStreamingRuntimeIntoStream = (stream, nonce) => {
     }
   });
 };
-var appendStreamingSlotPatchesToStream = (stream, slots = [], { injectRuntime = true, nonce, onError } = {}) => {
+var 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 = slots.map((slot) => resolveSlot(slot, onError));
+  const pending = preparedSlots.map((slot) => resolveSlot(slot, combinedOnError, effectivePolicy, combinedOnSlotMetric));
   return new ReadableStream({
     async start(controller) {
       let baseDone = false;
@@ -31044,6 +31352,12 @@ var appendStreamingSlotPatchesToStream = (stream, slots = [], { injectRuntime =
             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)
@@ -31056,59 +31370,20 @@ var appendStreamingSlotPatchesToStream = (stream, slots = [], { injectRuntime =
   });
 };
-// src/core/streamingSlotRegistry.ts
-var asyncLocalStorage;
-var isServerRuntime = () => typeof process !== "undefined" && typeof process.versions?.node === "string";
-var 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;
-};
-var registerStreamingSlot = (slot) => {
-  if (!asyncLocalStorage)
-    return;
-  const store = asyncLocalStorage.getStore();
-  if (!store)
-    return;
-  store.set(slot.id, slot);
-};
-var 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()] : []
-    };
-  });
-};
 // src/core/responseEnhancers.ts
 var toResponse = async (responseLike) => await responseLike;
 var cloneHeaders = (response) => {
   const headers = new Headers(response.headers);
   return headers;
 };
-var enhanceHtmlResponseWithStreamingSlots = (response, { nonce, onError, streamingSlots = [] } = {}) => {
+var enhanceHtmlResponseWithStreamingSlots = (response, { nonce, onError, streamingSlots = [], policy } = {}) => {
   if (!response.body || streamingSlots.length === 0) {
     return response;
   }
   const body = appendStreamingSlotPatchesToStream(response.body, streamingSlots, {
     nonce,
-    onError
+    onError,
+    policy
   });
   return new Response(body, {
     headers: cloneHeaders(response),
@@ -31141,7 +31416,7 @@ var wrapPageHandlerWithStreamingSlots = (handler) => (...args) => withRegistered
 init_pageHandler();
 // src/vue/Island.ts
-import { defineComponent, h as h2, onServerPrefetch } from "vue";
+import { defineComponent as defineComponent3, h as h4, onServerPrefetch } from "vue";
 // src/client/preserveIslandMarkup.ts
 init_islandMarkupAttributes();
@@ -31229,7 +31504,7 @@ var preserveIslandMarkup = (props) => {
 // src/vue/Island.ts
 init_islandMarkupAttributes();
 init_renderIslandMarkup();
-var defineRuntimeIslandComponent = (setup) => defineComponent({
+var defineRuntimeIslandComponent = (setup) => defineComponent3({
   name: "AbsoluteIsland",
   props: {
     component: {
@@ -31261,7 +31536,7 @@ var Island = defineRuntimeIslandComponent((props) => {
   });
   return () => {
     const preserved = isBrowser ? preserveIslandMarkup(props) : null;
-    return h2("div", {
+    return h4("div", {
       ...preserved?.attributes ?? markerAttributes,
       "data-allow-mismatch": "",
       innerHTML: isBrowser ? preserved?.innerHTML : html
@@ -31271,8 +31546,8 @@ var Island = defineRuntimeIslandComponent((props) => {
 // src/vue/createIsland.ts
 init_islandMarkupAttributes();
 init_renderIslandMarkup();
-import { defineComponent as defineComponent2, h as h3, onServerPrefetch as onServerPrefetch2 } from "vue";
-var defineRuntimeIslandComponent2 = (setup) => defineComponent2({
+import { defineComponent as defineComponent4, h as h5, onServerPrefetch as onServerPrefetch2 } from "vue";
+var defineRuntimeIslandComponent2 = (setup) => defineComponent4({
   name: "AbsoluteIsland",
   props: {
     component: {
@@ -31302,7 +31577,7 @@ var createTypedIsland = (registry) => defineRuntimeIslandComponent2((props) => {
     const result = await renderIslandResult(registry, props);
     ({ attributes: markerAttributes, html } = result);
   });
-  return () => h3("div", {
+  return () => h5("div", {
     ...markerAttributes,
     "data-allow-mismatch": "",
     innerHTML: isBrowser ? undefined : html
@@ -31453,8 +31728,11 @@ export {
   useIslandStore,
   handleVuePageRequest2 as handleVuePageRequest,
   createTypedIsland,
-  Island
+  SuspenseSlot,
+  StreamSlot,
+  Island,
+  Image_default as Image
 };
-//# debugId=DC8489D31EE81ABA64756E2164756E21
+//# debugId=5FAE5FAF19D8DFBB64756E2164756E21
 //# sourceMappingURL=index.js.map