nuxt-nightly 4.2.0-29331232.6f9cb0d2 → 4.2.0-29331654.df559ad9

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

@@ -3,9 +3,6 @@ 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>>;
@@ -63,10 +60,6 @@ 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 {
     /**
@@ -78,8 +71,6 @@ export interface AsyncDataExecuteOptions {
     cause?: AsyncDataRefreshCause;
     /** @internal */
     cachedData?: any;
-    signal?: AbortSignal;
-    timeout?: number;
 }
 export interface _AsyncData<DataT, ErrorT> {
     data: Ref<DataT>;
@@ -98,8 +89,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: 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>;
+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>;
 /**
  * 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}
@@ -107,8 +98,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: 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>;
+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>;
 /**
  * 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 +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 useLazyAsyncData
  */
-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>;
+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>;
 /**
  * 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}
@@ -125,8 +116,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: 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>;
+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>;
 /** @since 3.1.0 */
 export declare function useNuxtData<DataT = any>(key: string): {
     data: Ref<DataT | undefined>;
@@ -142,5 +133,4 @@ 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,17 +174,7 @@ 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: () => {
-      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);
-    }
+    clear: () => clearNuxtDataByKey(nuxtApp, key.value)
   };
   const asyncDataPromise = Promise.resolve(nuxtApp._asyncDataPromises[key.value]).then(() => asyncReturn);
   Object.assign(asyncDataPromise, asyncReturn);
@@ -290,6 +280,9 @@ 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;
   }
 }
@@ -303,13 +296,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 : (nuxtApp2, options2) => {
-    const value = nuxtApp2.ssrContext._sharedPrerenderCache.get(key);
+  const handler = import.meta.client || !import.meta.prerender || !nuxtApp.ssrContext?._sharedPrerenderCache ? _handler : () => {
+    const value = nuxtApp.ssrContext._sharedPrerenderCache.get(key);
     if (value) {
       return value;
     }
-    const promise = Promise.resolve().then(() => nuxtApp2.runWithContext(() => _handler(nuxtApp2, options2)));
-    nuxtApp2.ssrContext._sharedPrerenderCache.set(key, promise);
+    const promise = Promise.resolve().then(() => nuxtApp.runWithContext(() => _handler(nuxtApp)));
+    nuxtApp.ssrContext._sharedPrerenderCache.set(key, promise);
     return promise;
   };
   const _ref = options.deep ? ref : shallowRef;
@@ -334,6 +327,7 @@ 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" });
@@ -347,31 +341,19 @@ 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 {
-            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);
+            resolve(handler(nuxtApp));
           } 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);
@@ -389,20 +371,16 @@ function createAsyncData(nuxtApp, key, _handler, options, initialCachedData) {
         asyncData.error.value = void 0;
         asyncData.status.value = "success";
       }).catch((error) => {
-        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;
+        if (promise.cancelled) {
+          return nuxtApp._asyncDataPromises[key];
         }
         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;
         }
@@ -450,40 +428,3 @@ 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'>, Omit<ComputedFetchOptions<R, M, DataT>, 'timeout'> {
+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> {
     key?: MaybeRefOrGetter<string>;
     $fetch?: typeof globalThis.$fetch;
     watch?: MultiWatchSources | false;

package/dist/app/composables/fetch.js

@@ -22,7 +22,6 @@ export function useFetch(request, arg1, arg2) {
     getCachedData,
     deep,
     dedupe,
-    timeout,
     ...fetchOptions
   } = opts;
   const _fetchOptions = reactive({
@@ -40,7 +39,6 @@ export function useFetch(request, arg1, arg2) {
     getCachedData,
     deep,
     dedupe,
-    timeout,
     watch: watchSources === false ? [] : [...watchSources || [], _fetchOptions]
   };
   if (import.meta.dev) {
@@ -53,7 +51,16 @@ export function useFetch(request, arg1, arg2) {
     watch(key, setImmediate, { flush: "sync", once: true });
     watch([...watchSources || [], _fetchOptions], setImmediate, { flush: "sync", once: true });
   }
-  const asyncData = useAsyncData(watchSources === false ? key.value : key, (_, { signal }) => {
+  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);
+    }
     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] === "/");
@@ -61,7 +68,9 @@ export function useFetch(request, arg1, arg2) {
         _$fetch = useRequestFetch();
       }
     }
-    return _$fetch(_request.value, { signal, ..._fetchOptions });
+    return _$fetch(_request.value, { signal: controller.signal, ..._fetchOptions }).finally(() => {
+      clearTimeout(timeoutId);
+    });
   }, _asyncDataOptions);
   return asyncData;
 }

package/dist/app/nuxt.d.ts

@@ -123,8 +123,6 @@ 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 { getRenderer } from "../utils/renderer/build-files.js";
+import { getEntryIds, 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,7 +18,6 @@ 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";
@@ -78,7 +77,7 @@ export default defineRenderHandler(async (event) => {
     }
   }
   if (process.env.NUXT_INLINE_STYLES) {
-    for (const id of entryIds) {
+    for (const id of await getEntryIds()) {
       ssrContext.modules.add(id);
     }
   }

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

@@ -20,3 +20,4 @@ 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,19 +10,21 @@ 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 precomputed = import.meta.dev ? void 0 : await getPrecomputedDependencies();
-  const renderer = createRenderer(createSSRApp, {
-    precomputed,
-    manifest: import.meta.dev ? await getClientManifest() : void 0,
+  const options = {
+    manifest,
     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) {
@@ -33,7 +35,7 @@ export const getSSRRenderer = lazyCachedFunction(async () => {
   return renderer;
 });
 const getSPARenderer = lazyCachedFunction(async () => {
-  const precomputed = import.meta.dev ? void 0 : await getPrecomputedDependencies();
+  const manifest = await getClientManifest();
   const spaTemplate = await import("#spa-template").then((r) => r.template).catch(() => "").then((r) => {
     if (spaLoadingTemplateOutside) {
       const APP_SPA_LOADER_OPEN_TAG = `<${appSpaLoaderTag}${propsToString(appSpaLoaderAttrs)}>`;
@@ -45,13 +47,13 @@ const getSPARenderer = lazyCachedFunction(async () => {
       return APP_ROOT_OPEN_TAG + r + APP_ROOT_CLOSE_TAG;
     }
   });
-  const renderer = createRenderer(() => () => {
-  }, {
-    precomputed,
-    manifest: import.meta.dev ? await getClientManifest() : void 0,
+  const options = {
+    manifest,
     renderToString: () => spaTemplate,
     buildAssetsURL
-  });
+  };
+  const renderer = createRenderer(() => () => {
+  }, options);
   const result = await renderer.renderToString({});
   const renderToString = (ssrContext) => {
     const config = useRuntimeConfig(ssrContext.event);
@@ -84,3 +86,12 @@ 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-29331232.6f9cb0d2";
+const version = "4.2.0-29331654.df559ad9";
 
 const createImportProtectionPatterns = (nuxt, options) => {
   const patterns = [];
@@ -4206,8 +4206,7 @@ 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/nuxt/entry-ids.mjs": () => `export default []`
+      "#internal/entry-chunk.mjs": () => `export const entryFileName = undefined`
     },
     routeRules: {
       "/__nuxt_error": { cache: false }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-nightly",
-  "version": "4.2.0-29331232.6f9cb0d2",
+  "version": "4.2.0-29331654.df559ad9",
   "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-29331232.6f9cb0d2",
-    "@nuxt/schema": "npm:@nuxt/schema-nightly@4.2.0-29331232.6f9cb0d2",
+    "@nuxt/kit": "npm:@nuxt/kit-nightly@4.2.0-29331654.df559ad9",
+    "@nuxt/schema": "npm:@nuxt/schema-nightly@4.2.0-29331654.df559ad9",
     "@nuxt/telemetry": "^2.6.6",
-    "@nuxt/vite-builder": "npm:@nuxt/vite-builder-nightly@4.2.0-29331232.6f9cb0d2",
+    "@nuxt/vite-builder": "npm:@nuxt/vite-builder-nightly@4.2.0-29331654.df559ad9",
     "@unhead/vue": "^2.0.14",
     "@vue/shared": "^3.5.22",
     "c12": "^3.3.0",
@@ -112,7 +112,6 @@
     "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",