nuxt-nightly 4.2.0-29331207.25e91a2b → 4.2.0-29331232.6f9cb0d2

package/dist/app/composables/asyncData.d.ts

@@ -3,6 +3,9 @@ import type { NuxtApp } from '../nuxt.js';
 import type { NuxtError } from './error.js';
 export type AsyncDataRequestStatus = 'idle' | 'pending' | 'success' | 'error';
 export type _Transform<Input = any, Output = any> = (input: Input) => Output | Promise<Output>;
+export type AsyncDataHandler<ResT> = (nuxtApp: NuxtApp, options: {
+    signal: AbortSignal;
+}) => Promise<ResT>;
 export type PickFrom<T, K extends Array<string>> = T extends Array<any> ? T : T extends Record<string, any> ? keyof T extends K[number] ? T : K[number] extends never ? T : Pick<T, K[number]> : T;
 export type KeysOf<T> = Array<T extends T ? keyof T extends string ? keyof T : never : never>;
 export type KeyOfRes<Transform extends _Transform> = KeysOf<ReturnType<Transform>>;
@@ -60,6 +63,10 @@ export interface AsyncDataOptions<ResT, DataT = ResT, PickKeys extends KeysOf<Da
      * @default 'cancel'
      */
     dedupe?: 'cancel' | 'defer';
+    /**
+     * A timeout in milliseconds after which the request will be aborted if it has not resolved yet.
+     */
+    timeout?: number;
 }
 export interface AsyncDataExecuteOptions {
     /**
@@ -71,6 +78,8 @@ export interface AsyncDataExecuteOptions {
     cause?: AsyncDataRefreshCause;
     /** @internal */
     cachedData?: any;
+    signal?: AbortSignal;
+    timeout?: number;
 }
 export interface _AsyncData<DataT, ErrorT> {
     data: Ref<DataT>;
@@ -89,8 +98,8 @@ export type AsyncData<Data, Error> = _AsyncData<Data, Error> & Promise<_AsyncDat
  * @param handler An asynchronous function that must return a truthy value (for example, it should not be `undefined` or `null`) or the request may be duplicated on the client side.
  * @param options customize the behavior of useAsyncData
  */
-export declare function useAsyncData<ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined>(handler: (ctx?: NuxtApp) => Promise<ResT>, options?: AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
-export declare function useAsyncData<ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = DataT>(handler: (ctx?: NuxtApp) => Promise<ResT>, options?: AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
+export declare function useAsyncData<ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined>(handler: AsyncDataHandler<ResT>, options?: AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
+export declare function useAsyncData<ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = DataT>(handler: AsyncDataHandler<ResT>, options?: AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
 /**
  * Provides access to data that resolves asynchronously in an SSR-friendly composable.
  * See {@link https://nuxt.com/docs/4.x/api/composables/use-async-data}
@@ -98,8 +107,8 @@ export declare function useAsyncData<ResT, NuxtErrorDataT = unknown, DataT = Res
  * @param handler An asynchronous function that must return a truthy value (for example, it should not be `undefined` or `null`) or the request may be duplicated on the client side.
  * @param options customize the behavior of useAsyncData
  */
-export declare function useAsyncData<ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined>(key: MaybeRefOrGetter<string>, handler: (ctx?: NuxtApp) => Promise<ResT>, options?: AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
-export declare function useAsyncData<ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = DataT>(key: MaybeRefOrGetter<string>, handler: (ctx?: NuxtApp) => Promise<ResT>, options?: AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
+export declare function useAsyncData<ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined>(key: MaybeRefOrGetter<string>, handler: AsyncDataHandler<ResT>, options?: AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
+export declare function useAsyncData<ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = DataT>(key: MaybeRefOrGetter<string>, handler: AsyncDataHandler<ResT>, options?: AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
 /**
  * Provides access to data that resolves asynchronously in an SSR-friendly composable.
  * See {@link https://nuxt.com/docs/4.x/api/composables/use-lazy-async-data}
@@ -107,8 +116,8 @@ export declare function useAsyncData<ResT, NuxtErrorDataT = unknown, DataT = Res
  * @param handler An asynchronous function that must return a truthy value (for example, it should not be `undefined` or `null`) or the request may be duplicated on the client side.
  * @param options customize the behavior of useLazyAsyncData
  */
-export declare function useLazyAsyncData<ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined>(handler: (ctx?: NuxtApp) => Promise<ResT>, options?: Omit<AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>, 'lazy'>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
-export declare function useLazyAsyncData<ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = DataT>(handler: (ctx?: NuxtApp) => Promise<ResT>, options?: Omit<AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>, 'lazy'>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
+export declare function useLazyAsyncData<ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined>(handler: AsyncDataHandler<ResT>, options?: Omit<AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>, 'lazy'>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
+export declare function useLazyAsyncData<ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = DataT>(handler: AsyncDataHandler<ResT>, options?: Omit<AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>, 'lazy'>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
 /**
  * Provides access to data that resolves asynchronously in an SSR-friendly composable.
  * See {@link https://nuxt.com/docs/4.x/api/composables/use-lazy-async-data}
@@ -116,8 +125,8 @@ export declare function useLazyAsyncData<ResT, NuxtErrorDataT = unknown, DataT =
  * @param handler An asynchronous function that must return a truthy value (for example, it should not be `undefined` or `null`) or the request may be duplicated on the client side.
  * @param options customize the behavior of useLazyAsyncData
  */
-export declare function useLazyAsyncData<ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined>(key: MaybeRefOrGetter<string>, handler: (ctx?: NuxtApp) => Promise<ResT>, options?: Omit<AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>, 'lazy'>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
-export declare function useLazyAsyncData<ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = DataT>(key: MaybeRefOrGetter<string>, handler: (ctx?: NuxtApp) => Promise<ResT>, options?: Omit<AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>, 'lazy'>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
+export declare function useLazyAsyncData<ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined>(key: MaybeRefOrGetter<string>, handler: AsyncDataHandler<ResT>, options?: Omit<AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>, 'lazy'>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
+export declare function useLazyAsyncData<ResT, NuxtErrorDataT = unknown, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = DataT>(key: MaybeRefOrGetter<string>, handler: AsyncDataHandler<ResT>, options?: Omit<AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>, 'lazy'>): AsyncData<PickFrom<DataT, PickKeys> | DefaultT, (NuxtErrorDataT extends Error | NuxtError ? NuxtErrorDataT : NuxtError<NuxtErrorDataT>) | undefined>;
 /** @since 3.1.0 */
 export declare function useNuxtData<DataT = any>(key: string): {
     data: Ref<DataT | undefined>;
@@ -133,4 +142,5 @@ export type CreatedAsyncData<ResT, NuxtErrorDataT = unknown, DataT = ResT, Defau
     _init: boolean;
     _deps: number;
     _execute: (opts?: AsyncDataExecuteOptions) => Promise<void>;
+    _abortController?: AbortController;
 };

package/dist/app/composables/asyncData.js

@@ -174,7 +174,17 @@ You can use a different key or move the call to a composable to ensure the optio
       return nuxtApp._asyncData[key.value].execute(...args2);
     },
     execute: (...args2) => asyncReturn.refresh(...args2),
-    clear: () => clearNuxtDataByKey(nuxtApp, key.value)
+    clear: () => {
+      const entry = nuxtApp._asyncData[key.value];
+      if (entry?._abortController) {
+        try {
+          entry._abortController.abort(new DOMException("AsyncData aborted by user.", "AbortError"));
+        } finally {
+          entry._abortController = void 0;
+        }
+      }
+      clearNuxtDataByKey(nuxtApp, key.value);
+    }
   };
   const asyncDataPromise = Promise.resolve(nuxtApp._asyncDataPromises[key.value]).then(() => asyncReturn);
   Object.assign(asyncDataPromise, asyncReturn);
@@ -280,9 +290,6 @@ function clearNuxtDataByKey(nuxtApp, key) {
     nuxtApp._asyncData[key].status.value = "idle";
   }
   if (key in nuxtApp._asyncDataPromises) {
-    if (nuxtApp._asyncDataPromises[key]) {
-      nuxtApp._asyncDataPromises[key].cancelled = true;
-    }
     nuxtApp._asyncDataPromises[key] = void 0;
   }
 }
@@ -296,13 +303,13 @@ function pick(obj, keys) {
 function createAsyncData(nuxtApp, key, _handler, options, initialCachedData) {
   nuxtApp.payload._errors[key] ??= void 0;
   const hasCustomGetCachedData = options.getCachedData !== getDefaultCachedData;
-  const handler = import.meta.client || !import.meta.prerender || !nuxtApp.ssrContext?._sharedPrerenderCache ? _handler : () => {
-    const value = nuxtApp.ssrContext._sharedPrerenderCache.get(key);
+  const handler = import.meta.client || !import.meta.prerender || !nuxtApp.ssrContext?._sharedPrerenderCache ? _handler : (nuxtApp2, options2) => {
+    const value = nuxtApp2.ssrContext._sharedPrerenderCache.get(key);
     if (value) {
       return value;
     }
-    const promise = Promise.resolve().then(() => nuxtApp.runWithContext(() => _handler(nuxtApp)));
-    nuxtApp.ssrContext._sharedPrerenderCache.set(key, promise);
+    const promise = Promise.resolve().then(() => nuxtApp2.runWithContext(() => _handler(nuxtApp2, options2)));
+    nuxtApp2.ssrContext._sharedPrerenderCache.set(key, promise);
     return promise;
   };
   const _ref = options.deep ? ref : shallowRef;
@@ -327,7 +334,6 @@ function createAsyncData(nuxtApp, key, _handler, options, initialCachedData) {
         if ((opts.dedupe ?? options.dedupe) === "defer") {
           return nuxtApp._asyncDataPromises[key];
         }
-        nuxtApp._asyncDataPromises[key].cancelled = true;
       }
       if (granularCachedData || opts.cause === "initial" || nuxtApp.isHydrating) {
         const cachedData = "cachedData" in opts ? opts.cachedData : options.getCachedData(key, nuxtApp, { cause: opts.cause ?? "refresh:manual" });
@@ -341,19 +347,31 @@ function createAsyncData(nuxtApp, key, _handler, options, initialCachedData) {
       if (pendingWhenIdle) {
         asyncData.pending.value = true;
       }
+      if (asyncData._abortController) {
+        asyncData._abortController.abort(new DOMException("AsyncData request cancelled by deduplication", "AbortError"));
+      }
+      asyncData._abortController = new AbortController();
       asyncData.status.value = "pending";
       const promise = new Promise(
         (resolve, reject) => {
           try {
-            resolve(handler(nuxtApp));
+            const timeout = opts.timeout ?? options.timeout;
+            const mergedSignal = mergeAbortSignals([asyncData._abortController?.signal, opts?.signal], timeout);
+            if (mergedSignal.aborted) {
+              const reason = mergedSignal.reason;
+              reject(reason instanceof Error ? reason : new DOMException(String(reason ?? "Aborted"), "AbortError"));
+              return;
+            }
+            mergedSignal.addEventListener("abort", () => {
+              const reason = mergedSignal.reason;
+              reject(reason instanceof Error ? reason : new DOMException(String(reason ?? "Aborted"), "AbortError"));
+            }, { once: true });
+            return Promise.resolve(handler(nuxtApp, { signal: mergedSignal })).then(resolve, reject);
           } catch (err) {
             reject(err);
           }
         }
       ).then(async (_result) => {
-        if (promise.cancelled) {
-          return nuxtApp._asyncDataPromises[key];
-        }
         let result = _result;
         if (options.transform) {
           result = await options.transform(_result);
@@ -371,16 +389,20 @@ function createAsyncData(nuxtApp, key, _handler, options, initialCachedData) {
         asyncData.error.value = void 0;
         asyncData.status.value = "success";
       }).catch((error) => {
-        if (promise.cancelled) {
-          return nuxtApp._asyncDataPromises[key];
+        if (nuxtApp._asyncDataPromises[key] && nuxtApp._asyncDataPromises[key] !== promise) {
+          return;
+        }
+        if (asyncData._abortController?.signal.aborted) {
+          return;
+        }
+        if (typeof DOMException !== "undefined" && error instanceof DOMException && error.name === "AbortError") {
+          asyncData.status.value = "idle";
+          return;
         }
         asyncData.error.value = createError(error);
         asyncData.data.value = unref(options.default());
         asyncData.status.value = "error";
       }).finally(() => {
-        if (promise.cancelled) {
-          return;
-        }
         if (pendingWhenIdle) {
           asyncData.pending.value = false;
         }
@@ -428,3 +450,40 @@ function createHash(_handler, options) {
     getCachedData: options.getCachedData ? hash(options.getCachedData) : void 0
   };
 }
+function mergeAbortSignals(signals, timeout) {
+  const list = signals.filter((s) => !!s);
+  if (typeof timeout === "number" && timeout >= 0) {
+    const timeoutSignal = AbortSignal.timeout?.(timeout);
+    if (timeoutSignal) {
+      list.push(timeoutSignal);
+    }
+  }
+  if (AbortSignal.any) {
+    return AbortSignal.any(list);
+  }
+  const controller = new AbortController();
+  for (const sig of list) {
+    if (sig.aborted) {
+      const reason = sig.reason ?? new DOMException("Aborted", "AbortError");
+      try {
+        controller.abort(reason);
+      } catch {
+        controller.abort();
+      }
+      return controller.signal;
+    }
+  }
+  const onAbort = () => {
+    const abortedSignal = list.find((s) => s.aborted);
+    const reason = abortedSignal?.reason ?? new DOMException("Aborted", "AbortError");
+    try {
+      controller.abort(reason);
+    } catch {
+      controller.abort();
+    }
+  };
+  for (const sig of list) {
+    sig.addEventListener?.("abort", onAbort, { once: true });
+  }
+  return controller.signal;
+}

package/dist/app/composables/fetch.d.ts

@@ -11,7 +11,7 @@ interface NitroFetchOptions<R extends NitroFetchRequest, M extends AvailableRout
     method?: M;
 }
 type ComputedFetchOptions<R extends NitroFetchRequest, M extends AvailableRouterMethod<R>, DataT = any> = ComputedOptions<NitroFetchOptions<R, M, DataT>>;
-export interface UseFetchOptions<ResT, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined, R extends NitroFetchRequest = string & {}, M extends AvailableRouterMethod<R> = AvailableRouterMethod<R>> extends Omit<AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>, 'watch'>, ComputedFetchOptions<R, M, DataT> {
+export interface UseFetchOptions<ResT, DataT = ResT, PickKeys extends KeysOf<DataT> = KeysOf<DataT>, DefaultT = undefined, R extends NitroFetchRequest = string & {}, M extends AvailableRouterMethod<R> = AvailableRouterMethod<R>> extends Omit<AsyncDataOptions<ResT, DataT, PickKeys, DefaultT>, 'watch'>, Omit<ComputedFetchOptions<R, M, DataT>, 'timeout'> {
     key?: MaybeRefOrGetter<string>;
     $fetch?: typeof globalThis.$fetch;
     watch?: MultiWatchSources | false;

package/dist/app/composables/fetch.js

@@ -22,6 +22,7 @@ export function useFetch(request, arg1, arg2) {
     getCachedData,
     deep,
     dedupe,
+    timeout,
     ...fetchOptions
   } = opts;
   const _fetchOptions = reactive({
@@ -39,6 +40,7 @@ export function useFetch(request, arg1, arg2) {
     getCachedData,
     deep,
     dedupe,
+    timeout,
     watch: watchSources === false ? [] : [...watchSources || [], _fetchOptions]
   };
   if (import.meta.dev) {
@@ -51,16 +53,7 @@ export function useFetch(request, arg1, arg2) {
     watch(key, setImmediate, { flush: "sync", once: true });
     watch([...watchSources || [], _fetchOptions], setImmediate, { flush: "sync", once: true });
   }
-  let controller;
-  const asyncData = useAsyncData(watchSources === false ? key.value : key, () => {
-    controller?.abort?.(new DOMException("Request aborted as another request to the same endpoint was initiated.", "AbortError"));
-    controller = typeof AbortController !== "undefined" ? new AbortController() : {};
-    const timeoutLength = toValue(opts.timeout);
-    let timeoutId;
-    if (timeoutLength) {
-      timeoutId = setTimeout(() => controller.abort(new DOMException("Request aborted due to timeout.", "AbortError")), timeoutLength);
-      controller.signal.onabort = () => clearTimeout(timeoutId);
-    }
+  const asyncData = useAsyncData(watchSources === false ? key.value : key, (_, { signal }) => {
     let _$fetch = opts.$fetch || globalThis.$fetch;
     if (import.meta.server && !opts.$fetch) {
       const isLocalFetch = typeof _request.value === "string" && _request.value[0] === "/" && (!toValue(opts.baseURL) || toValue(opts.baseURL)[0] === "/");
@@ -68,9 +61,7 @@ export function useFetch(request, arg1, arg2) {
         _$fetch = useRequestFetch();
       }
     }
-    return _$fetch(_request.value, { signal: controller.signal, ..._fetchOptions }).finally(() => {
-      clearTimeout(timeoutId);
-    });
+    return _$fetch(_request.value, { signal, ..._fetchOptions });
   }, _asyncDataOptions);
   return asyncData;
 }

package/dist/app/nuxt.d.ts

@@ -123,6 +123,8 @@ interface _NuxtApp {
         _execute: (opts?: AsyncDataExecuteOptions) => Promise<void>;
         /** @internal */
         _hash?: Record<string, string | undefined>;
+        /** @internal */
+        _abortController?: AbortController;
     } | undefined>;
     /** @internal */
     _loadingIndicator?: LoadingIndicator;

package/dist/core/runtime/nitro/handlers/renderer.js

@@ -10,7 +10,7 @@ import { getQuery as getURLQuery, joinURL } from "ufo";
 import { propsToString, renderSSRHead } from "@unhead/vue/server";
 import destr from "destr";
 import { defineRenderHandler, getRouteRules, useNitroApp } from "nitropack/runtime";
-import { getEntryIds, getRenderer } from "../utils/renderer/build-files.js";
+import { getRenderer } from "../utils/renderer/build-files.js";
 import { payloadCache } from "../utils/cache.js";
 import { renderPayloadJsonScript, renderPayloadResponse, renderPayloadScript, splitPayload } from "../utils/renderer/payload.js";
 import { createSSRContext, setSSRError } from "../utils/renderer/app.js";
@@ -18,6 +18,7 @@ import { renderInlineStyles } from "../utils/renderer/inline-styles.js";
 import { replaceIslandTeleports } from "../utils/renderer/islands.js";
 import { renderSSRHeadOptions } from "#internal/unhead.config.mjs";
 import { appHead, appTeleportAttrs, appTeleportTag, componentIslands, appManifest as isAppManifestEnabled } from "#internal/nuxt.config.mjs";
+import entryIds from "#internal/nuxt/entry-ids.mjs";
 import { entryFileName } from "#internal/entry-chunk.mjs";
 import { buildAssetsURL, publicAssetsURL } from "#internal/nuxt/paths";
 import { relative } from "pathe";
@@ -77,7 +78,7 @@ export default defineRenderHandler(async (event) => {
     }
   }
   if (process.env.NUXT_INLINE_STYLES) {
-    for (const id of await getEntryIds()) {
+    for (const id of entryIds) {
       ssrContext.modules.add(id);
     }
   }

package/dist/core/runtime/nitro/utils/renderer/build-files.d.ts

@@ -20,4 +20,3 @@ export declare function getRenderer(ssrContext: NuxtSSRContext): Promise<{
     }>;
 }>;
 export declare const getSSRStyles: () => Promise<Record<string, () => Promise<string[]>>>;
-export declare const getEntryIds: () => Promise<string[]>;

package/dist/core/runtime/nitro/utils/renderer/build-files.js

@@ -10,21 +10,19 @@ const APP_ROOT_OPEN_TAG = `<${appRootTag}${propsToString(appRootAttrs)}>`;
 const APP_ROOT_CLOSE_TAG = `</${appRootTag}>`;
 const getServerEntry = () => import("#build/dist/server/server.mjs").then((r) => r.default || r);
 const getClientManifest = () => import("#build/dist/server/client.manifest.mjs").then((r) => r.default || r).then((r) => typeof r === "function" ? r() : r);
+const getPrecomputedDependencies = () => import("#build/dist/server/client.precomputed.mjs").then((r) => r.default || r).then((r) => typeof r === "function" ? r() : r);
 export const getSSRRenderer = lazyCachedFunction(async () => {
-  const manifest = await getClientManifest();
-  if (!manifest) {
-    throw new Error("client.manifest is not available");
-  }
   const createSSRApp = await getServerEntry();
   if (!createSSRApp) {
     throw new Error("Server bundle is not available");
   }
-  const options = {
-    manifest,
+  const precomputed = import.meta.dev ? void 0 : await getPrecomputedDependencies();
+  const renderer = createRenderer(createSSRApp, {
+    precomputed,
+    manifest: import.meta.dev ? await getClientManifest() : void 0,
     renderToString,
     buildAssetsURL
-  };
-  const renderer = createRenderer(createSSRApp, options);
+  });
   async function renderToString(input, context) {
     const html = await _renderToString(input, context);
     if (import.meta.dev && process.env.NUXT_VITE_NODE_OPTIONS) {
@@ -35,7 +33,7 @@ export const getSSRRenderer = lazyCachedFunction(async () => {
   return renderer;
 });
 const getSPARenderer = lazyCachedFunction(async () => {
-  const manifest = await getClientManifest();
+  const precomputed = import.meta.dev ? void 0 : await getPrecomputedDependencies();
   const spaTemplate = await import("#spa-template").then((r) => r.template).catch(() => "").then((r) => {
     if (spaLoadingTemplateOutside) {
       const APP_SPA_LOADER_OPEN_TAG = `<${appSpaLoaderTag}${propsToString(appSpaLoaderAttrs)}>`;
@@ -47,13 +45,13 @@ const getSPARenderer = lazyCachedFunction(async () => {
       return APP_ROOT_OPEN_TAG + r + APP_ROOT_CLOSE_TAG;
     }
   });
-  const options = {
-    manifest,
+  const renderer = createRenderer(() => () => {
+  }, {
+    precomputed,
+    manifest: import.meta.dev ? await getClientManifest() : void 0,
     renderToString: () => spaTemplate,
     buildAssetsURL
-  };
-  const renderer = createRenderer(() => () => {
-  }, options);
+  });
   const result = await renderer.renderToString({});
   const renderToString = (ssrContext) => {
     const config = useRuntimeConfig(ssrContext.event);
@@ -86,12 +84,3 @@ export function getRenderer(ssrContext) {
   return process.env.NUXT_NO_SSR || ssrContext.noSSR ? getSPARenderer() : getSSRRenderer();
 }
 export const getSSRStyles = lazyCachedFunction(() => import("#build/dist/server/styles.mjs").then((r) => r.default || r));
-export const getEntryIds = () => getClientManifest().then((r) => {
-  const entryIds = [];
-  for (const entry of Object.values(r)) {
-    if (entry._globalCSS) {
-      entryIds.push(entry.src);
-    }
-  }
-  return entryIds;
-});

package/dist/index.mjs

@@ -3830,7 +3830,7 @@ function addDeclarationTemplates(ctx, options) {
   });
 }
 
-const version = "4.2.0-29331207.25e91a2b";
+const version = "4.2.0-29331232.6f9cb0d2";
 
 const createImportProtectionPatterns = (nuxt, options) => {
   const patterns = [];
@@ -4206,7 +4206,8 @@ async function initNitro(nuxt) {
       "#internal/nuxt/app-config": () => nuxt.vfs["#build/app.config.mjs"]?.replace(/\/\*\* client \*\*\/[\s\S]*\/\*\* client-end \*\*\//, "") || "",
       "#spa-template": async () => `export const template = ${JSON.stringify(await spaLoadingTemplate(nuxt))}`,
       // this will be overridden in vite plugin
-      "#internal/entry-chunk.mjs": () => `export const entryFileName = undefined`
+      "#internal/entry-chunk.mjs": () => `export const entryFileName = undefined`,
+      "#internal/nuxt/entry-ids.mjs": () => `export default []`
     },
     routeRules: {
       "/__nuxt_error": { cache: false }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-nightly",
-  "version": "4.2.0-29331207.25e91a2b",
+  "version": "4.2.0-29331232.6f9cb0d2",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nuxt/nuxt.git",
@@ -67,10 +67,10 @@
     "@nuxt/cli": "npm:@nuxt/cli-nightly@latest",
     "@nuxt/devalue": "^2.0.2",
     "@nuxt/devtools": "^2.6.5",
-    "@nuxt/kit": "npm:@nuxt/kit-nightly@4.2.0-29331207.25e91a2b",
-    "@nuxt/schema": "npm:@nuxt/schema-nightly@4.2.0-29331207.25e91a2b",
+    "@nuxt/kit": "npm:@nuxt/kit-nightly@4.2.0-29331232.6f9cb0d2",
+    "@nuxt/schema": "npm:@nuxt/schema-nightly@4.2.0-29331232.6f9cb0d2",
     "@nuxt/telemetry": "^2.6.6",
-    "@nuxt/vite-builder": "npm:@nuxt/vite-builder-nightly@4.2.0-29331207.25e91a2b",
+    "@nuxt/vite-builder": "npm:@nuxt/vite-builder-nightly@4.2.0-29331232.6f9cb0d2",
     "@unhead/vue": "^2.0.14",
     "@vue/shared": "^3.5.22",
     "c12": "^3.3.0",
@@ -112,6 +112,7 @@
     "radix3": "^1.1.2",
     "scule": "^1.3.0",
     "semver": "^7.7.2",
+    "seroval": "^1.3.2",
     "std-env": "^3.9.0",
     "tinyglobby": "^0.2.15",
     "ufo": "^1.6.1",