@depup/nuxt 4.2.2-depup.0

package/dist/app/nuxt.js

@@ -0,0 +1,279 @@
+import { effectScope, getCurrentInstance, getCurrentScope, hasInjectionContext, reactive, shallowReactive } from "vue";
+import { createHooks } from "hookable";
+import { getContext } from "unctx";
+import { appId, chunkErrorEvent, multiApp } from "#build/nuxt.config.mjs";
+export function getNuxtAppCtx(id = appId || "nuxt-app") {
+  return getContext(id, {
+    asyncContext: !!__NUXT_ASYNC_CONTEXT__ && import.meta.server
+  });
+}
+export const NuxtPluginIndicator = "__nuxt_plugin";
+export function createNuxtApp(options) {
+  let hydratingCount = 0;
+  const nuxtApp = {
+    _id: options.id || appId || "nuxt-app",
+    _scope: effectScope(),
+    provide: void 0,
+    versions: {
+      get nuxt() {
+        return __NUXT_VERSION__;
+      },
+      get vue() {
+        return nuxtApp.vueApp.version;
+      }
+    },
+    payload: shallowReactive({
+      ...options.ssrContext?.payload || {},
+      data: shallowReactive({}),
+      state: reactive({}),
+      once: /* @__PURE__ */ new Set(),
+      _errors: shallowReactive({})
+    }),
+    static: {
+      data: {}
+    },
+    runWithContext(fn) {
+      if (nuxtApp._scope.active && !getCurrentScope()) {
+        return nuxtApp._scope.run(() => callWithNuxt(nuxtApp, fn));
+      }
+      return callWithNuxt(nuxtApp, fn);
+    },
+    isHydrating: import.meta.client,
+    deferHydration() {
+      if (!nuxtApp.isHydrating) {
+        return () => {
+        };
+      }
+      hydratingCount++;
+      let called = false;
+      return () => {
+        if (called) {
+          return;
+        }
+        called = true;
+        hydratingCount--;
+        if (hydratingCount === 0) {
+          nuxtApp.isHydrating = false;
+          return nuxtApp.callHook("app:suspense:resolve");
+        }
+      };
+    },
+    _asyncDataPromises: {},
+    _asyncData: shallowReactive({}),
+    _payloadRevivers: {},
+    ...options
+  };
+  if (import.meta.server) {
+    nuxtApp.payload.serverRendered = true;
+  }
+  if (import.meta.server && nuxtApp.ssrContext) {
+    nuxtApp.payload.path = nuxtApp.ssrContext.url;
+    nuxtApp.ssrContext.nuxt = nuxtApp;
+    nuxtApp.ssrContext.payload = nuxtApp.payload;
+    nuxtApp.ssrContext.config = {
+      public: nuxtApp.ssrContext.runtimeConfig.public,
+      app: nuxtApp.ssrContext.runtimeConfig.app
+    };
+  }
+  if (import.meta.client) {
+    const __NUXT__ = multiApp ? window.__NUXT__?.[nuxtApp._id] : window.__NUXT__;
+    if (__NUXT__) {
+      for (const key in __NUXT__) {
+        switch (key) {
+          case "data":
+          case "state":
+          case "_errors":
+            Object.assign(nuxtApp.payload[key], __NUXT__[key]);
+            break;
+          default:
+            nuxtApp.payload[key] = __NUXT__[key];
+        }
+      }
+    }
+  }
+  nuxtApp.hooks = createHooks();
+  nuxtApp.hook = nuxtApp.hooks.hook;
+  if (import.meta.server) {
+    const contextCaller = async function(hooks, args) {
+      for (const hook of hooks) {
+        await nuxtApp.runWithContext(() => hook(...args));
+      }
+    };
+    nuxtApp.hooks.callHook = (name, ...args) => nuxtApp.hooks.callHookWith(contextCaller, name, ...args);
+  }
+  nuxtApp.callHook = nuxtApp.hooks.callHook;
+  nuxtApp.provide = (name, value) => {
+    const $name = "$" + name;
+    defineGetter(nuxtApp, $name, value);
+    defineGetter(nuxtApp.vueApp.config.globalProperties, $name, value);
+  };
+  defineGetter(nuxtApp.vueApp, "$nuxt", nuxtApp);
+  defineGetter(nuxtApp.vueApp.config.globalProperties, "$nuxt", nuxtApp);
+  if (import.meta.client) {
+    if (chunkErrorEvent) {
+      window.addEventListener(chunkErrorEvent, (event) => {
+        nuxtApp.callHook("app:chunkError", { error: event.payload });
+        if (event.payload.message.includes("Unable to preload CSS")) {
+          event.preventDefault();
+        }
+      });
+    }
+    window.useNuxtApp ||= useNuxtApp;
+    const unreg = nuxtApp.hook("app:error", (...args) => {
+      console.error("[nuxt] error caught during app initialization", ...args);
+    });
+    nuxtApp.hook("app:mounted", unreg);
+  }
+  const runtimeConfig = import.meta.server ? options.ssrContext.runtimeConfig : nuxtApp.payload.config;
+  nuxtApp.provide("config", import.meta.client && import.meta.dev ? wrappedConfig(runtimeConfig) : runtimeConfig);
+  return nuxtApp;
+}
+export function registerPluginHooks(nuxtApp, plugin) {
+  if (plugin.hooks) {
+    nuxtApp.hooks.addHooks(plugin.hooks);
+  }
+}
+export async function applyPlugin(nuxtApp, plugin) {
+  if (typeof plugin === "function") {
+    const { provide } = await nuxtApp.runWithContext(() => plugin(nuxtApp)) || {};
+    if (provide && typeof provide === "object") {
+      for (const key in provide) {
+        nuxtApp.provide(key, provide[key]);
+      }
+    }
+  }
+}
+export async function applyPlugins(nuxtApp, plugins) {
+  const resolvedPlugins = /* @__PURE__ */ new Set();
+  const unresolvedPlugins = [];
+  const parallels = [];
+  let error = void 0;
+  let promiseDepth = 0;
+  async function executePlugin(plugin) {
+    const unresolvedPluginsForThisPlugin = plugin.dependsOn?.filter((name) => plugins.some((p) => p._name === name) && !resolvedPlugins.has(name)) ?? [];
+    if (unresolvedPluginsForThisPlugin.length > 0) {
+      unresolvedPlugins.push([new Set(unresolvedPluginsForThisPlugin), plugin]);
+    } else {
+      const promise = applyPlugin(nuxtApp, plugin).then(async () => {
+        if (plugin._name) {
+          resolvedPlugins.add(plugin._name);
+          await Promise.all(unresolvedPlugins.map(async ([dependsOn, unexecutedPlugin]) => {
+            if (dependsOn.has(plugin._name)) {
+              dependsOn.delete(plugin._name);
+              if (dependsOn.size === 0) {
+                promiseDepth++;
+                await executePlugin(unexecutedPlugin);
+              }
+            }
+          }));
+        }
+      }).catch((e) => {
+        if (!plugin.parallel && !nuxtApp.payload.error) {
+          throw e;
+        }
+        error ||= e;
+      });
+      if (plugin.parallel) {
+        parallels.push(promise);
+      } else {
+        await promise;
+      }
+    }
+  }
+  for (const plugin of plugins) {
+    if (import.meta.server && nuxtApp.ssrContext?.islandContext && plugin.env?.islands === false) {
+      continue;
+    }
+    registerPluginHooks(nuxtApp, plugin);
+  }
+  for (const plugin of plugins) {
+    if (import.meta.server && nuxtApp.ssrContext?.islandContext && plugin.env?.islands === false) {
+      continue;
+    }
+    await executePlugin(plugin);
+  }
+  await Promise.all(parallels);
+  if (promiseDepth) {
+    for (let i = 0; i < promiseDepth; i++) {
+      await Promise.all(parallels);
+    }
+  }
+  if (error) {
+    throw nuxtApp.payload.error || error;
+  }
+}
+// @__NO_SIDE_EFFECTS__
+export function defineNuxtPlugin(plugin) {
+  if (typeof plugin === "function") {
+    return plugin;
+  }
+  const _name = plugin._name || plugin.name;
+  delete plugin.name;
+  return Object.assign(plugin.setup || (() => {
+  }), plugin, { [NuxtPluginIndicator]: true, _name });
+}
+export const definePayloadPlugin = defineNuxtPlugin;
+export function isNuxtPlugin(plugin) {
+  return typeof plugin === "function" && NuxtPluginIndicator in plugin;
+}
+export function callWithNuxt(nuxt, setup, args) {
+  const fn = () => args ? setup(...args) : setup();
+  const nuxtAppCtx = getNuxtAppCtx(nuxt._id);
+  if (import.meta.server) {
+    return nuxt.vueApp.runWithContext(() => nuxtAppCtx.callAsync(nuxt, fn));
+  } else {
+    nuxtAppCtx.set(nuxt);
+    return nuxt.vueApp.runWithContext(fn);
+  }
+}
+export function tryUseNuxtApp(id) {
+  let nuxtAppInstance;
+  if (hasInjectionContext()) {
+    nuxtAppInstance = getCurrentInstance()?.appContext.app.$nuxt;
+  }
+  nuxtAppInstance ||= getNuxtAppCtx(id).tryUse();
+  return nuxtAppInstance || null;
+}
+export function useNuxtApp(id) {
+  const nuxtAppInstance = tryUseNuxtApp(id);
+  if (!nuxtAppInstance) {
+    if (import.meta.dev) {
+      throw new Error("[nuxt] A composable that requires access to the Nuxt instance was called outside of a plugin, Nuxt hook, Nuxt middleware, or Vue setup function. This is probably not a Nuxt bug. Find out more at `https://nuxt.com/docs/4.x/guide/concepts/auto-imports#vue-and-nuxt-composables`.");
+    } else {
+      throw new Error("[nuxt] instance unavailable");
+    }
+  }
+  return nuxtAppInstance;
+}
+// @__NO_SIDE_EFFECTS__
+export function useRuntimeConfig(_event) {
+  return useNuxtApp().$config;
+}
+function defineGetter(obj, key, val) {
+  Object.defineProperty(obj, key, { get: () => val });
+}
+export function defineAppConfig(config) {
+  return config;
+}
+const loggedKeys = /* @__PURE__ */ new Set();
+function wrappedConfig(runtimeConfig) {
+  if (!import.meta.dev || import.meta.server) {
+    return runtimeConfig;
+  }
+  const keys = [];
+  for (const key in runtimeConfig) {
+    keys.push(`\`${key}\``);
+  }
+  const lastKey = keys.pop();
+  return new Proxy(runtimeConfig, {
+    get(target, p, receiver) {
+      if (typeof p === "string" && p !== "public" && !(p in target) && !p.startsWith("__v")) {
+        if (!loggedKeys.has(p)) {
+          loggedKeys.add(p);
+          console.warn(`[nuxt] Could not access \`${p}\`. The only available runtime config keys on the client side are ${keys.join(", ")} and ${lastKey}. See https://nuxt.com/docs/4.x/guide/going-further/runtime-config for more information.`);
+        }
+      }
+      return Reflect.get(target, p, receiver);
+    }
+  });
+}

package/dist/app/plugins/browser-devtools-timing.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../nuxt.js").Plugin<Record<string, unknown>> & import("../nuxt.js").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/app/plugins/browser-devtools-timing.client.js

@@ -0,0 +1,23 @@
+import { defineNuxtPlugin } from "../nuxt.js";
+export default defineNuxtPlugin({
+  name: "nuxt:browser-devtools-timing",
+  enforce: "pre",
+  setup(nuxtApp) {
+    nuxtApp.hooks.beforeEach((event) => {
+      event.__startTime = performance.now();
+    });
+    nuxtApp.hooks.afterEach((event) => {
+      performance.measure(event.name, {
+        // @ts-expect-error __startTime is not a public API
+        start: event.__startTime,
+        detail: {
+          devtools: {
+            dataType: "track-entry",
+            track: "nuxt",
+            color: "tertiary-dark"
+          }
+        }
+      });
+    });
+  }
+});

package/dist/app/plugins/check-if-layout-used.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../nuxt.js").Plugin<Record<string, unknown>> & import("../nuxt.js").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/app/plugins/check-if-layout-used.js

@@ -0,0 +1,28 @@
+import { nextTick } from "vue";
+import { defineNuxtPlugin } from "../nuxt.js";
+import { onNuxtReady } from "../composables/ready.js";
+import { useError } from "../composables/error.js";
+import layouts from "#build/layouts";
+export default defineNuxtPlugin({
+  name: "nuxt:checkIfLayoutUsed",
+  setup(nuxtApp) {
+    const error = useError();
+    function checkIfLayoutUsed() {
+      if (!error.value && !nuxtApp._isNuxtLayoutUsed && Object.keys(layouts).length > 0) {
+        console.warn("[nuxt] Your project has layouts but the `<NuxtLayout />` component has not been used.");
+      }
+    }
+    if (import.meta.server) {
+      nuxtApp.hook("app:rendered", ({ renderResult }) => {
+        if (renderResult?.html) {
+          nextTick(checkIfLayoutUsed);
+        }
+      });
+    } else {
+      onNuxtReady(checkIfLayoutUsed);
+    }
+  },
+  env: {
+    islands: false
+  }
+});

package/dist/app/plugins/check-outdated-build.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../nuxt.js").Plugin<Record<string, unknown>> & import("../nuxt.js").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/app/plugins/check-outdated-build.client.js

@@ -0,0 +1,39 @@
+import { defineNuxtPlugin } from "../nuxt.js";
+import { getAppManifest } from "../composables/manifest.js";
+import { onNuxtReady } from "../composables/ready.js";
+import { buildAssetsURL } from "#internal/nuxt/paths";
+import { outdatedBuildInterval } from "#build/nuxt.config.mjs";
+export default defineNuxtPlugin((nuxtApp) => {
+  if (import.meta.test) {
+    return;
+  }
+  let timeout;
+  async function getLatestManifest() {
+    let currentManifest;
+    try {
+      currentManifest = await getAppManifest();
+    } catch (e) {
+      const err = e;
+      if (!("status" in err && (err.status === 404 || err.status === 403))) {
+        throw err;
+      }
+    }
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+    timeout = setTimeout(getLatestManifest, outdatedBuildInterval);
+    try {
+      const meta = await $fetch(buildAssetsURL("builds/latest.json") + `?${Date.now()}`);
+      if (meta.id !== currentManifest?.id) {
+        nuxtApp.hooks.callHook("app:manifest:update", meta);
+        if (timeout) {
+          clearTimeout(timeout);
+        }
+      }
+    } catch {
+    }
+  }
+  onNuxtReady(() => {
+    timeout = setTimeout(getLatestManifest, outdatedBuildInterval);
+  });
+});

package/dist/app/plugins/chunk-reload-immediate.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../nuxt.js").Plugin<Record<string, unknown>> & import("../nuxt.js").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/app/plugins/chunk-reload-immediate.client.js

@@ -0,0 +1,20 @@
+import { joinURL } from "ufo";
+import { defineNuxtPlugin, useRuntimeConfig } from "../nuxt.js";
+import { reloadNuxtApp } from "../composables/chunk.js";
+import { addRouteMiddleware } from "../composables/router.js";
+export default defineNuxtPlugin({
+  name: "nuxt:chunk-reload-immediate",
+  setup(nuxtApp) {
+    let currentlyNavigationTo = null;
+    addRouteMiddleware((to) => {
+      currentlyNavigationTo = to;
+    });
+    const config = useRuntimeConfig();
+    function reloadAppAtPath(to) {
+      const path = joinURL(config.app.baseURL, to.fullPath);
+      reloadNuxtApp({ path, persistState: true });
+    }
+    nuxtApp.hook("app:chunkError", () => reloadAppAtPath(currentlyNavigationTo ?? nuxtApp._route));
+    nuxtApp.hook("app:manifest:update", () => reloadAppAtPath(nuxtApp._route));
+  }
+});

package/dist/app/plugins/chunk-reload.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../nuxt.js").Plugin<Record<string, unknown>> & import("../nuxt.js").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/app/plugins/chunk-reload.client.js

@@ -0,0 +1,30 @@
+import { joinURL } from "ufo";
+import { defineNuxtPlugin, useRuntimeConfig } from "../nuxt.js";
+import { useRouter } from "../composables/router.js";
+import { reloadNuxtApp } from "../composables/chunk.js";
+export default defineNuxtPlugin({
+  name: "nuxt:chunk-reload",
+  setup(nuxtApp) {
+    const router = useRouter();
+    const config = useRuntimeConfig();
+    const chunkErrors = /* @__PURE__ */ new Set();
+    router.beforeEach(() => {
+      chunkErrors.clear();
+    });
+    nuxtApp.hook("app:chunkError", ({ error }) => {
+      chunkErrors.add(error);
+    });
+    function reloadAppAtPath(to) {
+      const path = joinURL(config.app.baseURL, to.fullPath);
+      reloadNuxtApp({ path, persistState: true });
+    }
+    nuxtApp.hook("app:manifest:update", () => {
+      router.beforeResolve(reloadAppAtPath);
+    });
+    router.onError((error, to) => {
+      if (chunkErrors.has(error)) {
+        reloadAppAtPath(to);
+      }
+    });
+  }
+});

package/dist/app/plugins/cross-origin-prefetch.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../nuxt.js").Plugin<Record<string, unknown>> & import("../nuxt.js").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/app/plugins/cross-origin-prefetch.client.js

@@ -0,0 +1,37 @@
+import { ref } from "vue";
+import { defineNuxtPlugin } from "../nuxt.js";
+import { useHead } from "../composables/head.js";
+const SUPPORTED_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:"]);
+export default defineNuxtPlugin({
+  name: "nuxt:cross-origin-prefetch",
+  setup(nuxtApp) {
+    const externalURLs = ref(/* @__PURE__ */ new Set());
+    function generateRules() {
+      return {
+        type: "speculationrules",
+        key: "speculationrules",
+        innerHTML: JSON.stringify({
+          prefetch: [
+            {
+              source: "list",
+              urls: [...externalURLs.value],
+              requires: ["anonymous-client-ip-when-cross-origin"]
+            }
+          ]
+        })
+      };
+    }
+    const head = useHead({
+      script: [generateRules()]
+    });
+    nuxtApp.hook("link:prefetch", (url) => {
+      for (const protocol of SUPPORTED_PROTOCOLS) {
+        if (url.startsWith(protocol) && SUPPORTED_PROTOCOLS.has(new URL(url).protocol)) {
+          externalURLs.value.add(url);
+          head?.patch({ script: [generateRules()] });
+          return;
+        }
+      }
+    });
+  }
+});

package/dist/app/plugins/debug-hooks.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../nuxt.js").Plugin<Record<string, unknown>> & import("../nuxt.js").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/app/plugins/debug-hooks.js

@@ -0,0 +1,9 @@
+import { createDebugger } from "hookable";
+import { defineNuxtPlugin } from "../nuxt.js";
+export default defineNuxtPlugin({
+  name: "nuxt:debug:hooks",
+  enforce: "pre",
+  setup(nuxtApp) {
+    createDebugger(nuxtApp.hooks, { tag: "nuxt-app" });
+  }
+});

package/dist/app/plugins/dev-server-logs.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../nuxt.js").Plugin<Record<string, unknown>> & import("../nuxt.js").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/app/plugins/dev-server-logs.js

@@ -0,0 +1,60 @@
+import { createConsola } from "consola";
+import { parse } from "devalue";
+import { h } from "vue";
+import { defineNuxtPlugin } from "../nuxt.js";
+import { devLogs, devRootDir } from "#build/nuxt.config.mjs";
+const devRevivers = import.meta.server ? {} : {
+  VNode: (data) => h(data.type, data.props),
+  URL: (data) => new URL(data)
+};
+export default defineNuxtPlugin(async (nuxtApp) => {
+  if (import.meta.test) {
+    return;
+  }
+  if (import.meta.server) {
+    nuxtApp.ssrContext.event.context._payloadReducers = nuxtApp.ssrContext._payloadReducers;
+    return;
+  }
+  if (devLogs !== "silent") {
+    const logger = createConsola({
+      formatOptions: {
+        colors: true,
+        date: true
+      }
+    });
+    nuxtApp.hook("dev:ssr-logs", (logs) => {
+      for (const log of logs) {
+        logger.log(normalizeServerLog({ ...log }));
+      }
+    });
+  }
+  if (typeof window !== "undefined") {
+    const nuxtLogsElement = document.querySelector(`[data-nuxt-logs="${nuxtApp._id}"]`);
+    const content = nuxtLogsElement?.textContent;
+    const logs = content ? parse(content, { ...devRevivers, ...nuxtApp._payloadRevivers }) : [];
+    await nuxtApp.hooks.callHook("dev:ssr-logs", logs);
+  }
+});
+function normalizeFilenames(stack) {
+  if (!stack) {
+    return "";
+  }
+  let message = "";
+  for (const item of stack) {
+    const source = item.source.replace(`${devRootDir}/`, "");
+    if (item.function) {
+      message += `  at ${item.function} (${source})
+`;
+    } else {
+      message += `  at ${source}
+`;
+    }
+  }
+  return message;
+}
+function normalizeServerLog(log) {
+  log.additional = normalizeFilenames(log.stack);
+  log.tag = "ssr";
+  delete log.stack;
+  return log;
+}

package/dist/app/plugins/navigation-repaint.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../nuxt.js").Plugin<Record<string, unknown>> & import("../nuxt.js").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/app/plugins/navigation-repaint.client.js

@@ -0,0 +1,16 @@
+import { defineNuxtPlugin } from "../nuxt.js";
+import { onNuxtReady } from "../composables/ready.js";
+import { useRouter } from "../composables/router.js";
+export default defineNuxtPlugin(() => {
+  const router = useRouter();
+  onNuxtReady(() => {
+    router.beforeResolve(async () => {
+      await new Promise((resolve) => {
+        setTimeout(resolve, 100);
+        requestAnimationFrame(() => {
+          setTimeout(resolve, 0);
+        });
+      });
+    });
+  });
+});

package/dist/app/plugins/payload.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../nuxt.js").Plugin<Record<string, unknown>> & import("../nuxt.js").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/app/plugins/payload.client.js

@@ -0,0 +1,50 @@
+import { defineNuxtPlugin } from "../nuxt.js";
+import { loadPayload } from "../composables/payload.js";
+import { onNuxtReady } from "../composables/ready.js";
+import { useRouter } from "../composables/router.js";
+import { getAppManifest } from "../composables/manifest.js";
+import { appManifest as isAppManifestEnabled, purgeCachedData } from "#build/nuxt.config.mjs";
+export default defineNuxtPlugin({
+  name: "nuxt:payload",
+  setup(nuxtApp) {
+    if (import.meta.dev) {
+      return;
+    }
+    const staticKeysToRemove = /* @__PURE__ */ new Set();
+    useRouter().beforeResolve(async (to, from) => {
+      if (to.path === from.path) {
+        return;
+      }
+      const payload = await loadPayload(to.path);
+      if (!payload) {
+        return;
+      }
+      if (purgeCachedData) {
+        for (const key of staticKeysToRemove) {
+          delete nuxtApp.static.data[key];
+        }
+      }
+      for (const key in payload.data) {
+        if (purgeCachedData) {
+          if (!(key in nuxtApp.static.data)) {
+            staticKeysToRemove.add(key);
+          }
+        }
+        nuxtApp.static.data[key] = payload.data[key];
+      }
+    });
+    onNuxtReady(() => {
+      nuxtApp.hooks.hook("link:prefetch", async (url) => {
+        const { hostname } = new URL(url, window.location.href);
+        if (hostname === window.location.hostname) {
+          await loadPayload(url).catch(() => {
+            console.warn("[nuxt] Error preloading payload for", url);
+          });
+        }
+      });
+      if (isAppManifestEnabled && navigator.connection?.effectiveType !== "slow-2g") {
+        setTimeout(getAppManifest, 1e3);
+      }
+    });
+  }
+});

package/dist/app/plugins/preload.server.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../nuxt.js").Plugin<Record<string, unknown>> & import("../nuxt.js").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/app/plugins/preload.server.js

@@ -0,0 +1,13 @@
+import { defineNuxtPlugin } from "../nuxt.js";
+export default defineNuxtPlugin({
+  name: "nuxt:webpack-preload",
+  setup(nuxtApp) {
+    nuxtApp.vueApp.mixin({
+      beforeCreate() {
+        const { modules } = this.$nuxt.ssrContext;
+        const { __moduleIdentifier } = this.$options;
+        modules.add(__moduleIdentifier);
+      }
+    });
+  }
+});

package/dist/app/plugins/restore-state.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../nuxt.js").Plugin<Record<string, unknown>> & import("../nuxt.js").ObjectPlugin<Record<string, unknown>>;
+export default _default;