@depup/nuxt 4.3.0-depup.0 → 4.4.2-depup.1

package/dist/app/composables/asyncData.js

@@ -6,195 +6,234 @@ import { getUserCaller, toArray } from "../utils.js";
 import { clientOnlySymbol } from "../components/client-only.js";
 import { createError } from "./error.js";
 import { onNuxtReady } from "./ready.js";
+import { defineKeyedFunctionFactory } from "../../compiler/runtime";
 import { asyncDataDefaults, granularCachedData, pendingWhenIdle, purgeCachedData } from "#build/nuxt.config.mjs";
-export function useAsyncData(...args) {
-  const autoKey = typeof args[args.length - 1] === "string" ? args.pop() : void 0;
-  if (_isAutoKeyNeeded(args[0], args[1])) {
-    args.unshift(autoKey);
-  }
-  let [_key, _handler, options = {}] = args;
-  let keyChanging = false;
-  const key = computed(() => toValue(_key));
-  if (typeof key.value !== "string") {
-    throw new TypeError("[nuxt] [useAsyncData] key must be a string.");
-  }
-  if (typeof _handler !== "function") {
-    throw new TypeError("[nuxt] [useAsyncData] handler must be a function.");
-  }
-  const nuxtApp = useNuxtApp();
-  options.server ??= true;
-  options.default ??= getDefault;
-  options.getCachedData ??= getDefaultCachedData;
-  options.lazy ??= false;
-  options.immediate ??= true;
-  options.deep ??= asyncDataDefaults.deep;
-  options.dedupe ??= "cancel";
-  const functionName = options._functionName || "useAsyncData";
-  const currentData = nuxtApp._asyncData[key.value];
-  if (import.meta.dev && currentData) {
-    const warnings = [];
-    const values = createHash(_handler, options);
-    if (values.handler !== currentData._hash?.handler) {
-      warnings.push(`different handler`);
-    }
-    for (const opt of ["transform", "pick", "getCachedData"]) {
-      if (values[opt] !== currentData._hash[opt]) {
-        warnings.push(`different \`${opt}\` option`);
+export const createUseAsyncData = defineKeyedFunctionFactory({
+  name: "createUseAsyncData",
+  factory(options = {}) {
+    function useAsyncData2(...args) {
+      const autoKey = typeof args[args.length - 1] === "string" ? args.pop() : void 0;
+      if (_isAutoKeyNeeded(args[0], args[1])) {
+        args.unshift(autoKey);
       }
-    }
-    if (currentData._default.toString() !== options.default.toString()) {
-      warnings.push(`different \`default\` value`);
-    }
-    if (options.deep && isShallow(currentData.data)) {
-      warnings.push(`mismatching \`deep\` option`);
-    }
-    if (warnings.length) {
-      const caller = getUserCaller();
-      const explanation = caller ? ` (used at ${caller.source}:${caller.line}:${caller.column})` : "";
-      console.warn(`[nuxt] [${functionName}] Incompatible options detected for "${key.value}"${explanation}:
-${warnings.map((w) => `- ${w}`).join("\n")}
-You can use a different key or move the call to a composable to ensure the options are shared across calls.`);
-    }
-  }
-  function createInitialFetch() {
-    const initialFetchOptions = { cause: "initial", dedupe: options.dedupe };
-    if (!nuxtApp._asyncData[key.value]?._init) {
-      initialFetchOptions.cachedData = options.getCachedData(key.value, nuxtApp, { cause: "initial" });
-      nuxtApp._asyncData[key.value] = createAsyncData(nuxtApp, key.value, _handler, options, initialFetchOptions.cachedData);
-    }
-    return () => nuxtApp._asyncData[key.value].execute(initialFetchOptions);
-  }
-  const initialFetch = createInitialFetch();
-  const asyncData = nuxtApp._asyncData[key.value];
-  asyncData._deps++;
-  const fetchOnServer = options.server !== false && nuxtApp.payload.serverRendered;
-  if (import.meta.server && fetchOnServer && options.immediate) {
-    const promise = initialFetch();
-    if (getCurrentInstance()) {
-      onServerPrefetch(() => promise);
-    } else {
-      nuxtApp.hook("app:created", async () => {
-        await promise;
-      });
-    }
-  }
-  if (import.meta.client) {
-    let unregister = function(key2) {
-      const data = nuxtApp._asyncData[key2];
-      if (data?._deps) {
-        data._deps--;
-        if (data._deps === 0) {
-          data?._off();
+      let [_key, _handler, opts = {}] = args;
+      let keyChanging = false;
+      const key = computed(() => toValue(_key));
+      if (typeof key.value !== "string") {
+        throw new TypeError("[nuxt] [useAsyncData] key must be a string.");
+      }
+      if (typeof _handler !== "function") {
+        throw new TypeError("[nuxt] [useAsyncData] handler must be a function.");
+      }
+      const shouldFactoryOptionsOverride = typeof options === "function";
+      const nuxtApp = useNuxtApp();
+      const factoryOptions = shouldFactoryOptionsOverride ? options(opts) : options;
+      if (!shouldFactoryOptionsOverride) {
+        for (const key2 in factoryOptions) {
+          if (factoryOptions[key2] === void 0) {
+            continue;
+          }
+          if (opts[key2] !== void 0) {
+            continue;
+          }
+          opts[key2] = factoryOptions[key2];
         }
       }
-    };
-    const instance = getCurrentInstance();
-    if (instance && fetchOnServer && options.immediate && !instance.sp) {
-      instance.sp = [];
-    }
-    if (import.meta.dev && !nuxtApp.isHydrating && !nuxtApp._processingMiddleware && (!instance || instance?.isMounted)) {
-      console.warn(`[nuxt] [${functionName}] Component is already mounted, please use $fetch instead. See https://nuxt.com/docs/4.x/getting-started/data-fetching`);
-    }
-    if (instance && !instance._nuxtOnBeforeMountCbs) {
-      instance._nuxtOnBeforeMountCbs = [];
-      const cbs = instance._nuxtOnBeforeMountCbs;
-      onBeforeMount(() => {
-        cbs.forEach((cb) => {
-          cb();
-        });
-        cbs.splice(0, cbs.length);
-      });
-      onUnmounted(() => cbs.splice(0, cbs.length));
-    }
-    const isWithinClientOnly = instance && (instance._nuxtClientOnly || inject(clientOnlySymbol, false));
-    if (fetchOnServer && nuxtApp.isHydrating && (asyncData.error.value || asyncData.data.value !== void 0)) {
-      if (pendingWhenIdle) {
-        asyncData.pending.value = false;
+      opts.server ??= true;
+      opts.default ??= getDefault;
+      opts.getCachedData ??= getDefaultCachedData;
+      opts.lazy ??= false;
+      opts.immediate ??= true;
+      opts.deep ??= asyncDataDefaults.deep;
+      opts.dedupe ??= "cancel";
+      if (shouldFactoryOptionsOverride) {
+        for (const key2 in factoryOptions) {
+          if (factoryOptions[key2] === void 0) {
+            continue;
+          }
+          opts[key2] = factoryOptions[key2];
+        }
       }
-      asyncData.status.value = asyncData.error.value ? "error" : "success";
-    } else if (instance && (!isWithinClientOnly && nuxtApp.payload.serverRendered && nuxtApp.isHydrating || options.lazy) && options.immediate) {
-      instance._nuxtOnBeforeMountCbs.push(initialFetch);
-    } else if (options.immediate && asyncData.status.value !== "success") {
-      initialFetch();
-    }
-    const hasScope = getCurrentScope();
-    const unsubKeyWatcher = watch(key, (newKey, oldKey) => {
-      if ((newKey || oldKey) && newKey !== oldKey) {
-        keyChanging = true;
-        const hadData = nuxtApp._asyncData[oldKey]?.data.value !== void 0;
-        const wasRunning = nuxtApp._asyncDataPromises[oldKey] !== void 0;
-        const initialFetchOptions = { cause: "initial", dedupe: options.dedupe };
-        if (!nuxtApp._asyncData[newKey]?._init) {
-          let initialValue;
-          if (oldKey && hadData) {
-            initialValue = nuxtApp._asyncData[oldKey].data.value;
-          } else {
-            initialValue = options.getCachedData(newKey, nuxtApp, { cause: "initial" });
-            initialFetchOptions.cachedData = initialValue;
+      const functionName = import.meta.dev ? factoryOptions._functionName || "useAsyncData" : "";
+      const currentData = nuxtApp._asyncData[key.value];
+      if (import.meta.dev && currentData) {
+        const warnings = [];
+        const values = createHash(_handler, opts);
+        if (values.handler !== currentData._hash?.handler) {
+          warnings.push(`different handler`);
+        }
+        for (const opt of ["transform", "pick", "getCachedData"]) {
+          if (values[opt] !== currentData._hash[opt]) {
+            warnings.push(`different \`${opt}\` option`);
           }
-          nuxtApp._asyncData[newKey] = createAsyncData(nuxtApp, newKey, _handler, options, initialValue);
         }
-        nuxtApp._asyncData[newKey]._deps++;
-        if (oldKey) {
-          unregister(oldKey);
+        if (currentData._default.toString() !== opts.default.toString()) {
+          warnings.push(`different \`default\` value`);
         }
-        if (options.immediate || hadData || wasRunning) {
-          nuxtApp._asyncData[newKey].execute(initialFetchOptions);
+        if (opts.deep && isShallow(currentData.data)) {
+          warnings.push(`mismatching \`deep\` option`);
+        }
+        if (warnings.length) {
+          const caller = getUserCaller();
+          const explanation = caller ? ` (used at ${caller.source}:${caller.line}:${caller.column})` : "";
+          console.warn(`[nuxt] [${functionName}] Incompatible options detected for "${key.value}"${explanation}:
+${warnings.map((w) => `- ${w}`).join("\n")}
+You can use a different key or move the call to a composable to ensure the options are shared across calls.`);
         }
-        queuePostFlushCb(() => {
-          keyChanging = false;
-        });
-      }
-    }, { flush: "sync" });
-    const unsubParamsWatcher = options.watch ? watch(options.watch, () => {
-      if (keyChanging) {
-        return;
       }
-      if (nuxtApp._asyncData[key.value]?._execute.isPending()) {
-        queuePostFlushCb(() => {
-          nuxtApp._asyncData[key.value]?._execute.flush();
-        });
+      function createInitialFetch() {
+        const initialFetchOptions = { cause: "initial", dedupe: opts.dedupe };
+        if (!nuxtApp._asyncData[key.value]?._init) {
+          initialFetchOptions.cachedData = opts.getCachedData(key.value, nuxtApp, { cause: "initial" });
+          nuxtApp._asyncData[key.value] = buildAsyncData(nuxtApp, key.value, _handler, opts, initialFetchOptions.cachedData);
+        }
+        return () => nuxtApp._asyncData[key.value].execute(initialFetchOptions);
       }
-      nuxtApp._asyncData[key.value]?._execute({ cause: "watch", dedupe: options.dedupe });
-    }) : () => {
-    };
-    if (hasScope) {
-      onScopeDispose(() => {
-        unsubKeyWatcher();
-        unsubParamsWatcher();
-        unregister(key.value);
-      });
-    }
-  }
-  const asyncReturn = {
-    data: writableComputedRef(() => nuxtApp._asyncData[key.value]?.data),
-    pending: writableComputedRef(() => nuxtApp._asyncData[key.value]?.pending),
-    status: writableComputedRef(() => nuxtApp._asyncData[key.value]?.status),
-    error: writableComputedRef(() => nuxtApp._asyncData[key.value]?.error),
-    refresh: (...args2) => {
-      if (!nuxtApp._asyncData[key.value]?._init) {
-        const initialFetch2 = createInitialFetch();
-        return initialFetch2();
+      const initialFetch = createInitialFetch();
+      const asyncData = nuxtApp._asyncData[key.value];
+      asyncData._deps++;
+      const fetchOnServer = opts.server !== false && nuxtApp.payload.serverRendered;
+      if (import.meta.server && fetchOnServer && opts.immediate) {
+        const promise = initialFetch();
+        if (getCurrentInstance()) {
+          onServerPrefetch(() => promise);
+        } else {
+          nuxtApp.hook("app:created", async () => {
+            await promise;
+          });
+        }
       }
-      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;
+      if (import.meta.client) {
+        let unregister = function(key2) {
+          const data = nuxtApp._asyncData[key2];
+          if (data?._deps) {
+            data._deps--;
+            if (data._deps === 0) {
+              data?._off();
+            }
+          }
+        };
+        const instance = getCurrentInstance();
+        if (instance && fetchOnServer && opts.immediate && !instance.sp) {
+          instance.sp = [];
+        }
+        if (import.meta.dev && !nuxtApp.isHydrating && !nuxtApp._processingMiddleware && (!instance || instance?.isMounted)) {
+          console.warn(`[nuxt] [${functionName}] Component is already mounted, please use $fetch instead. See https://nuxt.com/docs/4.x/getting-started/data-fetching`);
+        }
+        if (instance && !instance._nuxtOnBeforeMountCbs) {
+          instance._nuxtOnBeforeMountCbs = [];
+          const cbs = instance._nuxtOnBeforeMountCbs;
+          onBeforeMount(() => {
+            cbs.forEach((cb) => {
+              cb();
+            });
+            cbs.splice(0, cbs.length);
+          });
+          onUnmounted(() => cbs.splice(0, cbs.length));
+        }
+        const isWithinClientOnly = instance && (instance._nuxtClientOnly || inject(clientOnlySymbol, false));
+        if (fetchOnServer && nuxtApp.isHydrating && (asyncData.error.value || asyncData.data.value !== void 0)) {
+          if (pendingWhenIdle) {
+            asyncData.pending.value = false;
+          }
+          asyncData.status.value = asyncData.error.value ? "error" : "success";
+        } else if (instance && (!isWithinClientOnly && nuxtApp.payload.serverRendered && nuxtApp.isHydrating || opts.lazy) && opts.immediate) {
+          instance._nuxtOnBeforeMountCbs.push(initialFetch);
+        } else if (opts.immediate && asyncData.status.value !== "success") {
+          initialFetch();
+        }
+        const hasScope = getCurrentScope();
+        const unsubKeyWatcher = watch(key, (newKey, oldKey) => {
+          if ((newKey || oldKey) && newKey !== oldKey) {
+            keyChanging = true;
+            const hadData = nuxtApp._asyncData[oldKey]?.data.value !== void 0;
+            const wasRunning = nuxtApp._asyncDataPromises[oldKey] !== void 0;
+            const initialFetchOptions = { cause: "initial", dedupe: opts.dedupe };
+            if (!nuxtApp._asyncData[newKey]?._init) {
+              let initialValue;
+              if (oldKey && hadData) {
+                initialValue = nuxtApp._asyncData[oldKey].data.value;
+              } else {
+                initialValue = opts.getCachedData(newKey, nuxtApp, { cause: "initial" });
+                initialFetchOptions.cachedData = initialValue;
+              }
+              nuxtApp._asyncData[newKey] = buildAsyncData(nuxtApp, newKey, _handler, opts, initialValue);
+            }
+            nuxtApp._asyncData[newKey]._deps++;
+            if (oldKey) {
+              unregister(oldKey);
+            }
+            if (opts.immediate || hadData || wasRunning) {
+              nuxtApp._asyncData[newKey].execute(initialFetchOptions);
+            }
+            queuePostFlushCb(() => {
+              keyChanging = false;
+            });
+          }
+        }, { flush: "sync" });
+        const unsubParamsWatcher = opts.watch ? watch(opts.watch, () => {
+          if (keyChanging) {
+            return;
+          }
+          if (nuxtApp._asyncData[key.value]?._execute.isPending()) {
+            queuePostFlushCb(() => {
+              nuxtApp._asyncData[key.value]?._execute.flush();
+            });
+          }
+          nuxtApp._asyncData[key.value]?._execute({ cause: "watch", dedupe: opts.dedupe });
+        }) : () => {
+        };
+        if (hasScope) {
+          onScopeDispose(() => {
+            unsubKeyWatcher();
+            unsubParamsWatcher();
+            unregister(key.value);
+          });
         }
       }
-      clearNuxtDataByKey(nuxtApp, key.value);
+      const asyncReturn = {
+        data: writableComputedRef(() => nuxtApp._asyncData[key.value]?.data),
+        pending: writableComputedRef(() => nuxtApp._asyncData[key.value]?.pending),
+        status: writableComputedRef(() => nuxtApp._asyncData[key.value]?.status),
+        error: writableComputedRef(() => nuxtApp._asyncData[key.value]?.error),
+        refresh: (...args2) => {
+          if (!nuxtApp._asyncData[key.value]?._init) {
+            const initialFetch2 = createInitialFetch();
+            return initialFetch2();
+          }
+          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);
+        }
+      };
+      const asyncDataPromise = Promise.resolve(nuxtApp._asyncDataPromises[key.value]).then(() => asyncReturn);
+      Object.assign(asyncDataPromise, asyncReturn);
+      Object.defineProperties(asyncDataPromise, {
+        then: { enumerable: true, value: asyncDataPromise.then.bind(asyncDataPromise) },
+        catch: { enumerable: true, value: asyncDataPromise.catch.bind(asyncDataPromise) },
+        finally: { enumerable: true, value: asyncDataPromise.finally.bind(asyncDataPromise) }
+      });
+      return asyncDataPromise;
     }
-  };
-  const asyncDataPromise = Promise.resolve(nuxtApp._asyncDataPromises[key.value]).then(() => asyncReturn);
-  Object.assign(asyncDataPromise, asyncReturn);
-  return asyncDataPromise;
-}
+    return useAsyncData2;
+  }
+});
+export const useAsyncData = createUseAsyncData.__nuxt_factory();
+export const useLazyAsyncData = createUseAsyncData.__nuxt_factory({
+  lazy: true,
+  // @ts-expect-error private property
+  _functionName: "useLazyAsyncData"
+});
 function writableComputedRef(getter) {
   return computed({
     get() {
@@ -208,17 +247,6 @@ function writableComputedRef(getter) {
     }
   });
 }
-export function useLazyAsyncData(...args) {
-  const autoKey = typeof args[args.length - 1] === "string" ? args.pop() : void 0;
-  if (_isAutoKeyNeeded(args[0], args[1])) {
-    args.unshift(autoKey);
-  }
-  const [key, handler, options = {}] = args;
-  if (import.meta.dev) {
-    options._functionName ||= "useLazyAsyncData";
-  }
-  return useAsyncData(key, handler, { ...options, lazy: true }, null);
-}
 function _isAutoKeyNeeded(keyOrFetcher, fetcher) {
   if (typeof keyOrFetcher === "string") {
     return false;
@@ -305,7 +333,7 @@ function pick(obj, keys) {
   }
   return newObj;
 }
-function createAsyncData(nuxtApp, key, _handler, options, initialCachedData) {
+function buildAsyncData(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) => {

package/dist/app/composables/chunk.js

@@ -1,4 +1,3 @@
-import destr from "destr";
 import { useNuxtApp } from "../nuxt.js";
 export function reloadNuxtApp(options = {}) {
   if (import.meta.server) {
@@ -7,7 +6,7 @@ export function reloadNuxtApp(options = {}) {
   const path = options.path || window.location.pathname;
   let handledPath = {};
   try {
-    handledPath = destr(sessionStorage.getItem("nuxt:reload") || "{}");
+    handledPath = JSON.parse(sessionStorage.getItem("nuxt:reload") || "{}");
   } catch {
   }
   if (options.force || handledPath?.path !== path || handledPath?.expires < Date.now()) {

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

@@ -7,6 +7,20 @@ export interface CookieOptions<T = any> extends _CookieOptions {
     default?: () => T | Ref<T>;
     watch?: boolean | 'shallow';
     readonly?: boolean;
+    /**
+     * Refresh cookie expiration even when the value remains unchanged.
+     *
+     * By default, a cookie is only rewritten when its value changes.
+     * When `refresh` is set to `true`, the cookie will be re-written
+     * on every explicit assignment (e.g. `cookie.value = cookie.value`),
+     * extending its expiration even if the value is the same.
+     *
+     * Note: the expiration is not refreshed automatically — you must
+     * assign to `cookie.value` to trigger the refresh.
+     *
+     * @default false
+     */
+    refresh?: boolean;
 }
 export interface CookieRef<T> extends Ref<T> {
 }

package/dist/app/composables/cookie.js

@@ -1,24 +1,42 @@
 import { customRef, getCurrentScope, nextTick, onScopeDispose, ref, watch } from "vue";
 import { parse, serialize } from "cookie-es";
-import { deleteCookie, getCookie, getRequestHeader, setCookie } from "h3";
-import destr from "destr";
+import { deleteCookie, getCookie, getRequestHeader, setCookie } from "@nuxt/nitro-server/h3";
 import { isEqual } from "ohash";
 import { klona } from "klona";
 import { useNuxtApp } from "../nuxt.js";
 import { useRequestEvent } from "./ssr.js";
 import { cookieStore } from "#build/nuxt.config.mjs";
+function parseCookieValue(value) {
+  if (value === "undefined") {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(value);
+    if (typeof parsed === "number" && String(parsed) !== value) {
+      return value;
+    }
+    return parsed;
+  } catch {
+    return value;
+  }
+}
 const CookieDefaults = {
   path: "/",
   watch: true,
-  decode: (val) => {
-    const decoded = decodeURIComponent(val);
-    const parsed = destr(decoded);
-    if (typeof parsed === "number" && (!Number.isFinite(parsed) || String(parsed) !== decoded)) {
-      return decoded;
+  decode: (val) => parseCookieValue(decodeURIComponent(val)),
+  encode: (val) => {
+    if (typeof val !== "string" || val === "undefined") {
+      return encodeURIComponent(JSON.stringify(val));
     }
-    return parsed;
+    try {
+      if (typeof JSON.parse(val) !== "string") {
+        return encodeURIComponent(JSON.stringify(val));
+      }
+    } catch {
+    }
+    return encodeURIComponent(val);
   },
-  encode: (val) => encodeURIComponent(typeof val === "string" ? val : JSON.stringify(val))
+  refresh: false
 };
 const store = import.meta.client && cookieStore ? globalThis.cookieStore : void 0;
 export function useCookie(name, _opts) {
@@ -34,7 +52,7 @@ export function useCookie(name, _opts) {
   const hasExpired = delay !== void 0 && delay <= 0;
   const shouldSetInitialClientCookie = import.meta.client && (hasExpired || cookies[name] === void 0 || cookies[name] === null);
   const cookieValue = klona(hasExpired ? void 0 : cookies[name] ?? opts.default?.());
-  const cookie = import.meta.client && delay && !hasExpired ? cookieRef(cookieValue, delay, opts.watch && opts.watch !== "shallow") : ref(cookieValue);
+  const cookie = import.meta.client && delay && !hasExpired ? cookieRef(cookieValue, delay, opts.watch && opts.watch !== "shallow") : import.meta.server ? cookieServerRef(name, cookieValue) : ref(cookieValue);
   if (import.meta.dev && hasExpired) {
     console.warn(`[nuxt] not setting cookie \`${name}\` as it has already expired.`);
   }
@@ -99,7 +117,7 @@ export function useCookie(name, _opts) {
           if (watchPaused) {
             return;
           }
-          callback();
+          callback(opts.refresh);
         },
         { deep: opts.watch !== "shallow" }
       );
@@ -110,7 +128,12 @@ export function useCookie(name, _opts) {
   } else if (import.meta.server) {
     const nuxtApp = useNuxtApp();
     const writeFinalCookieValue = () => {
-      if (opts.readonly || isEqual(cookie.value, cookies[name])) {
+      const valueIsSame = isEqual(cookie.value, cookies[name]);
+      if (opts.readonly || valueIsSame && !opts.refresh) {
+        return;
+      }
+      nuxtApp._cookiesChanged ||= {};
+      if (valueIsSame && opts.refresh && !nuxtApp._cookiesChanged[name]) {
         return;
       }
       nuxtApp._cookies ||= {};
@@ -137,7 +160,12 @@ export function refreshCookie(name) {
   if (import.meta.server || store || typeof BroadcastChannel === "undefined") {
     return;
   }
-  new BroadcastChannel(`nuxt:cookies:${name}`)?.postMessage({ refresh: true });
+  try {
+    const channel = new BroadcastChannel(`nuxt:cookies:${name}`);
+    channel.postMessage({ refresh: true });
+    channel.close();
+  } catch {
+  }
 }
 function readRawCookies(opts = {}) {
   if (import.meta.server) {
@@ -183,20 +211,23 @@ function cookieRef(value, delay, shouldWatch) {
     if (shouldWatch) {
       unsubscribe = watch(internalRef, trigger);
     }
-    function createExpirationTimeout() {
-      elapsed = 0;
-      clearTimeout(timeout);
+    function scheduleTimeout() {
       const timeRemaining = delay - elapsed;
       const timeoutLength = timeRemaining < MAX_TIMEOUT_DELAY ? timeRemaining : MAX_TIMEOUT_DELAY;
       timeout = setTimeout(() => {
         elapsed += timeoutLength;
         if (elapsed < delay) {
-          return createExpirationTimeout();
+          return scheduleTimeout();
         }
         internalRef.value = void 0;
         trigger();
       }, timeoutLength);
     }
+    function createExpirationTimeout() {
+      elapsed = 0;
+      clearTimeout(timeout);
+      scheduleTimeout();
+    }
     return {
       get() {
         track();
@@ -210,3 +241,21 @@ function cookieRef(value, delay, shouldWatch) {
     };
   });
 }
+function cookieServerRef(name, value) {
+  const internalRef = ref(value);
+  const nuxtApp = useNuxtApp();
+  return customRef((track, trigger) => {
+    return {
+      get() {
+        track();
+        return internalRef.value;
+      },
+      set(newValue) {
+        nuxtApp._cookiesChanged ||= {};
+        nuxtApp._cookiesChanged[name] = true;
+        internalRef.value = newValue;
+        trigger();
+      }
+    };
+  });
+}

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

@@ -1,10 +1,10 @@
-import type { H3Error } from 'h3';
+import type { H3Error } from '@nuxt/nitro-server/h3';
 import type { Ref } from 'vue';
 import type { NuxtPayload } from '../nuxt.js';
 export declare const NUXT_ERROR_SIGNATURE = "__nuxt_error";
 /** @since 3.0.0 */
 export declare const useError: () => Ref<NuxtPayload["error"]>;
-export interface NuxtError<DataT = unknown> extends Omit<H3Error<DataT>, 'statusCode' | 'statusMessage'> {
+export interface NuxtError<DataT = unknown> extends Omit<H3Error<DataT>, 'statusCode' | 'statusMessage'>, Error {
     error?: true;
     status?: number;
     statusText?: string;

package/dist/app/composables/error.js

@@ -1,4 +1,4 @@
-import { createError as createH3Error } from "h3";
+import { createError as createH3Error } from "@nuxt/nitro-server/h3";
 import { toRef } from "vue";
 import { useNuxtApp } from "../nuxt.js";
 import { useRouter } from "./router.js";
@@ -38,5 +38,15 @@ export const createError = (error) => {
     configurable: false,
     writable: false
   });
+  Object.defineProperty(nuxtError, "status", {
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    get: () => nuxtError.statusCode,
+    configurable: true
+  });
+  Object.defineProperty(nuxtError, "statusText", {
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    get: () => nuxtError.statusMessage,
+    configurable: true
+  });
   return nuxtError;
 };