@wular/pnext 0.1.5 → 0.1.7

package/dist/server/_chunks/index-sv8m6789.js

@@ -0,0 +1,266 @@
+// @bun
+import {
+  activateTestProxy
+} from "./index-2wfv4kvx.js";
+import {
+  nextCompatEnabled
+} from "./index-eeaanp2e.js";
+import {
+  findProxyFiles,
+  setProxyRewriteObserver
+} from "./index-kq8kpzye.js";
+import {
+  getNextConfig
+} from "./index-6e4fqv30.js";
+import {
+  readText,
+  toPosixPath
+} from "./index-20ppawv7.js";
+import {
+  recordCanonicalUrl
+} from "./index-en7n9f7m.js";
+import {
+  getWorkUnit,
+  legacyRequestAPIs
+} from "./index-grta8ap3.js";
+import {
+  moduleExportNames
+} from "./index-z4z9zv3b.js";
+import {
+  setProxyExtensions,
+  setProxyResponseProtocol
+} from "./index-zqpqyg8p.js";
+
+// src/compat/register/proxy.ts
+import path from "path";
+
+// src/compat/protocol.ts
+var ROUTER_VARY = [
+  "rsc",
+  "next-router-state-tree",
+  "next-router-prefetch",
+  "next-router-segment-prefetch"
+];
+var rewrites = new WeakMap;
+function recordRewrite(from, to) {
+  const unit = getWorkUnit();
+  if (!unit)
+    return;
+  if (from.pathname === to.pathname && from.search === to.search)
+    return;
+  const query = to.search.replace(/^\?/, "");
+  rewrites.set(unit, {
+    ...to.pathname !== from.pathname ? { path: to.pathname } : {},
+    ...query ? { query } : {}
+  });
+}
+var CACHE_BUSTING_REDIRECT_HEADER = "x-pnext-cache-bust";
+var APP_ROUTE_KINDS = new Set([
+  "html",
+  "data",
+  "route-handler"
+]);
+var protocolFinalizer = (ctx) => {
+  if (!APP_ROUTE_KINDS.has(ctx.routeKind))
+    return;
+  if (!isPlainRedirect(ctx))
+    mergeVary(ctx.headers, ROUTER_VARY);
+  normalizeRscRedirectStatus(ctx);
+  applyRewrittenHeaders(ctx);
+  applyEdgeRuntimeHeader(ctx);
+};
+function isPlainRedirect(ctx) {
+  if (ctx.status < 300 || ctx.status >= 400 || !ctx.headers.has("location"))
+    return false;
+  return ctx.request.headers.get("rsc") !== "1" && !ctx.request.headers.has("next-router-prefetch") && !ctx.request.headers.has("next-router-segment-prefetch");
+}
+function applyEdgeRuntimeHeader(ctx) {
+  const runtime = ctx.hints?.runtime;
+  if (runtime === "edge" || runtime === "experimental-edge") {
+    ctx.headers.set("x-edge-runtime", "1");
+  }
+}
+function mergeVary(headers, values) {
+  const existing = headers.get("vary");
+  const present = new Set((existing ?? "").split(",").map((token) => token.trim().toLowerCase()).filter(Boolean));
+  const merged = existing ? existing.split(",").map((token) => token.trim()).filter(Boolean) : [];
+  for (const value of values) {
+    if (present.has(value.toLowerCase()))
+      continue;
+    present.add(value.toLowerCase());
+    merged.push(value);
+  }
+  if (merged.length > 0)
+    headers.set("vary", merged.join(", "));
+}
+function applyRewrittenHeaders(ctx) {
+  if (ctx.request.headers.get("rsc") !== "1")
+    return;
+  const unit = getWorkUnit();
+  if (!unit)
+    return;
+  const info = rewrites.get(unit);
+  if (!info)
+    return;
+  if (info.path !== undefined)
+    ctx.headers.set("x-nextjs-rewritten-path", info.path);
+  if (info.query !== undefined)
+    ctx.headers.set("x-nextjs-rewritten-query", info.query);
+}
+function normalizeRscRedirectStatus(ctx) {
+  if (ctx.headers.has(CACHE_BUSTING_REDIRECT_HEADER)) {
+    ctx.headers.delete(CACHE_BUSTING_REDIRECT_HEADER);
+    return;
+  }
+  if (ctx.routeKind !== "html")
+    return;
+  if (ctx.request.headers.get("rsc") !== "1")
+    return;
+  if (ctx.request.headers.has("x-pnext-soft-nav"))
+    return;
+  if (!ctx.headers.has("location"))
+    return;
+  if (ctx.status !== 307 && ctx.status !== 308)
+    return;
+  ctx.status = 200;
+}
+function isValidFlightRouterState(value) {
+  if (!Array.isArray(value))
+    return false;
+  const [segment, parallelRoutes] = value;
+  if (typeof segment !== "string" && !Array.isArray(segment))
+    return false;
+  if (typeof parallelRoutes !== "object" || parallelRoutes === null)
+    return false;
+  if (Array.isArray(parallelRoutes))
+    return false;
+  return Object.values(parallelRoutes).every(isValidFlightRouterState);
+}
+var routerStateTreeInterceptor = (request) => Promise.resolve(validateRouterStateTree(request));
+function validateRouterStateTree(request) {
+  if (request.headers.get("rsc") !== "1")
+    return;
+  if (request.headers.has("x-pnext-soft-nav"))
+    return;
+  const header = request.headers.get("next-router-state-tree");
+  if (header === null)
+    return;
+  let tree;
+  try {
+    tree = JSON.parse(decodeURIComponent(header));
+  } catch {
+    try {
+      tree = JSON.parse(header);
+    } catch {
+      return new Response("Internal Server Error", { status: 500 });
+    }
+  }
+  return isValidFlightRouterState(tree) ? undefined : new Response("Internal Server Error", { status: 500 });
+}
+function protocolInterceptors(config) {
+  if (!nextCompatEnabled(config))
+    return [];
+  return [routerStateTreeInterceptor];
+}
+function protocolFinalizers(config) {
+  if (!nextCompatEnabled(config))
+    return [];
+  return [protocolFinalizer];
+}
+
+// src/compat/register/proxy.ts
+function registerProxyExtensions(_config) {
+  setProxyResponseProtocol({
+    nextHeader: "x-middleware-next",
+    rewriteHeader: "x-middleware-rewrite"
+  });
+  setProxyExtensions({
+    names: ["proxy", "middleware"],
+    validateFiles: validateNextProxyFiles,
+    handlerExport: (module) => module.proxy ?? module.default ?? module.middleware,
+    skipUrlNormalize: () => getNextConfig().skipProxyUrlNormalize === true,
+    locale: proxyLocale,
+    onExternalRewrite: (request) => activateTestProxy(request.headers),
+    clientMaxBodySize: proxyClientMaxBodySize
+  });
+  setProxyRewriteObserver((from, to) => {
+    recordCanonicalUrl(from);
+    recordRewrite(from, to);
+  });
+}
+var DEFAULT_PROXY_CLIENT_MAX_BODY_SIZE = 10 * 1024 * 1024;
+function proxyClientMaxBodySize() {
+  const experimental = getNextConfig().experimental ?? {};
+  const raw = experimental.proxyClientMaxBodySize ?? experimental.middlewareClientMaxBodySize;
+  if (typeof raw === "number" && raw > 0)
+    return raw;
+  if (typeof raw === "string") {
+    const match = /^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)?$/i.exec(raw.trim());
+    if (match?.[1]) {
+      const unit = (match[2] ?? "b").toLowerCase();
+      const multiplier = unit === "gb" ? 1024 ** 3 : unit === "mb" ? 1024 ** 2 : unit === "kb" ? 1024 : 1;
+      const bytes = Math.floor(Number(match[1]) * multiplier);
+      if (bytes > 0)
+        return bytes;
+    }
+  }
+  return DEFAULT_PROXY_CLIENT_MAX_BODY_SIZE;
+}
+function proxyLocale(url) {
+  const i18n = getNextConfig().i18n;
+  if (!Array.isArray(i18n?.locales))
+    return "";
+  const locales = i18n.locales.filter((locale) => typeof locale === "string");
+  const dataLocale = /^\/_next\/data\/[^/]+\/([^/]+)(?:\/|$)/.exec(url.pathname)?.[1];
+  const candidate = dataLocale ?? url.pathname.split("/")[1];
+  return locales.find((locale) => locale.toLowerCase() === candidate?.toLowerCase()) ?? "";
+}
+async function validateNextProxyFiles(config) {
+  const files = findProxyFiles(config, ["proxy", "middleware"]);
+  const middleware = files.find((file) => path.basename(file).startsWith("middleware."));
+  const proxy = files.find((file) => path.basename(file).startsWith("proxy."));
+  if (middleware && proxy) {
+    throw new Error(`Both middleware file "${relativeProxyPath(config, middleware)}" and proxy file "${relativeProxyPath(config, proxy)}" are detected. Please use "${relativeProxyPath(config, proxy)}" only.`);
+  }
+  if (middleware && !proxy && !legacyRequestAPIs()) {
+    console.warn('The "middleware" file convention is deprecated. Please use "proxy" instead.');
+  }
+  await Promise.all(files.map((file) => validateNextProxyFile(config, file)));
+}
+async function validateNextProxyFile(config, file) {
+  const source = await readText(file);
+  const name = path.basename(file).split(".")[0];
+  const exports = moduleExportNames(source, file);
+  const validExport = exports.includes("default") || (name === "proxy" ? exports.includes("proxy") : exports.includes("middleware"));
+  if (!validExport) {
+    throw new Error(proxyMissingExportError(config, file));
+  }
+  if (name === "proxy" && hasRuntimeConfig(source)) {
+    throw new Error(`Route segment config is not allowed in Proxy file at "${relativeProxyPath(config, file)}". Proxy always runs on Node.js runtime. Learn more: https://nextjs.org/docs/messages/middleware-to-proxy`);
+  }
+}
+function proxyMissingExportError(config, file) {
+  const name = path.basename(file).split(".")[0] === "middleware" ? "middleware" : "proxy";
+  const migrationReason = name === "proxy" ? "- You are migrating from `middleware` to `proxy`, but haven't updated the exported function.\n" : "";
+  const target = name === "proxy" ? "proxy (previously called middleware)" : "middleware";
+  return `The file "${relativeProxyPath(config, file)}" must export a function, either as a default export or as a named "${name}" export.
+This function is what Next.js runs for every request handled by this ${target}.
+
+Why this happens:
+${migrationReason}- The file exists but doesn't export a function.
+- The export is not a function (e.g., an object or constant).
+- There's a syntax error preventing the export from being recognized.
+
+To fix it:
+- Ensure this file has either a default or "${name}" function export.
+
+Learn more: https://nextjs.org/docs/messages/middleware-to-proxy`;
+}
+function hasRuntimeConfig(source) {
+  return /\bexport\s+const\s+config\s*=/.test(source) && /\bruntime\s*:/.test(source);
+}
+function relativeProxyPath(config, file) {
+  return `./${toPosixPath(path.relative(config.root, file))}`;
+}
+
+export { recordRewrite, CACHE_BUSTING_REDIRECT_HEADER, protocolInterceptors, protocolFinalizers, registerProxyExtensions };

package/dist/server/_chunks/index-tgcakdxc.js

@@ -0,0 +1,125 @@
+// @bun
+import {
+  use
+} from "./index-h4xy648y.js";
+import {
+  useActionState
+} from "./index-68m3mwbd.js";
+import {
+  setSuspenseParity
+} from "./index-w6h8m6vp.js";
+import {
+  useOptimistic,
+  useTransition
+} from "./index-j2zrcp1k.js";
+
+// src/compat/react/preact.ts
+import ReactCompat from "preact/compat";
+setSuspenseParity({
+  beforeThrowSafety: applyAsyncClientComponent,
+  afterThrowSafety: applyThenableChildren
+});
+function applyThenableChildren(vnode) {
+  const props = vnode.props;
+  const children = props.children;
+  const resolved = thenableChildren(children);
+  if (resolved !== children)
+    props.children = resolved;
+}
+function thenableChildren(value) {
+  if (value && typeof value.then === "function") {
+    return ReactCompat.createElement(ReactCompat.Suspense, { fallback: null }, ReactCompat.createElement(ThenableChild, {
+      value
+    }));
+  }
+  if (!Array.isArray(value))
+    return value;
+  let changed = false;
+  const children = value.map((child) => {
+    const resolved = thenableChildren(child);
+    if (resolved !== child)
+      changed = true;
+    return resolved;
+  });
+  return changed ? children : value;
+}
+function ThenableChild({ value }) {
+  return use(value);
+}
+var asyncClientComponents = new WeakMap;
+function applyAsyncClientComponent(vnode) {
+  if (typeof window === "undefined" || typeof vnode.type !== "function")
+    return;
+  const component = vnode.type;
+  if (component.constructor.name !== "AsyncFunction")
+    return;
+  const renderComponent = component;
+  let wrapper = asyncClientComponents.get(component);
+  if (!wrapper) {
+    wrapper = (props) => {
+      const [result] = ReactCompat.useState(() => Promise.resolve(renderComponent(props)));
+      return ReactCompat.createElement(ReactCompat.Suspense, { fallback: null }, ReactCompat.createElement(ThenableChild, { value: result }));
+    };
+    asyncClientComponents.set(component, wrapper);
+  }
+  vnode.type = wrapper;
+}
+var preactUseSyncExternalStore = ReactCompat.useSyncExternalStore;
+function serverSnapshotAware(subscribe, getSnapshot, getServerSnapshot) {
+  if (typeof window === "undefined") {
+    if (!getServerSnapshot)
+      throw new Error("Missing getServerSnapshot, which is required for server-rendered content. Will revert to client rendering.");
+    return getServerSnapshot();
+  }
+  return preactUseSyncExternalStore(subscribe, getSnapshot);
+}
+var useSyncExternalStore = serverSnapshotAware;
+var preact_default = Object.assign(ReactCompat, { use, useActionState, useOptimistic, useTransition });
+if (true)
+  ReactCompat.useSyncExternalStore = useSyncExternalStore;
+var Children = ReactCompat.Children;
+var Component = ReactCompat.Component;
+var Fragment = ReactCompat.Fragment;
+var PureComponent = ReactCompat.PureComponent;
+var StrictMode = ReactCompat.StrictMode;
+var Suspense = ReactCompat.Suspense;
+var SuspenseList = ReactCompat.SuspenseList;
+var cloneElement = ReactCompat.cloneElement;
+var createContext = ReactCompat.createContext;
+var createElement = ReactCompat.createElement;
+var createFactory = ReactCompat.createFactory;
+var createPortal = ReactCompat.createPortal;
+var createRef = ReactCompat.createRef;
+var findDOMNode = ReactCompat.findDOMNode;
+var flushSync = ReactCompat.flushSync;
+var forwardRef = ReactCompat.forwardRef;
+var hydrate = ReactCompat.hydrate;
+var isFragment = ReactCompat.isFragment;
+var isMemo = ReactCompat.isMemo;
+var isValidElement = ReactCompat.isValidElement;
+var lazy = (loader) => {
+  const component = ReactCompat.lazy(loader);
+  component[Symbol.for("pnext.lazy")] = true;
+  return component;
+};
+var memo = ReactCompat.memo;
+var render = ReactCompat.render;
+var startTransition = ReactCompat.startTransition;
+var unmountComponentAtNode = ReactCompat.unmountComponentAtNode;
+var unstable_batchedUpdates = ReactCompat.unstable_batchedUpdates;
+var useCallback = ReactCompat.useCallback;
+var useContext = ReactCompat.useContext;
+var useDebugValue = ReactCompat.useDebugValue;
+var useDeferredValue = ReactCompat.useDeferredValue;
+var useEffect = ReactCompat.useEffect;
+var useId = ReactCompat.useId;
+var useImperativeHandle = ReactCompat.useImperativeHandle;
+var useInsertionEffect = ReactCompat.useInsertionEffect;
+var useLayoutEffect = ReactCompat.useLayoutEffect;
+var useMemo = ReactCompat.useMemo;
+var useReducer = ReactCompat.useReducer;
+var useRef = ReactCompat.useRef;
+var useState = ReactCompat.useState;
+var version = ReactCompat.version;
+
+export { useSyncExternalStore, preact_default, Children, Component, Fragment, PureComponent, StrictMode, Suspense, SuspenseList, cloneElement, createContext, createElement, createFactory, createPortal, createRef, findDOMNode, flushSync, forwardRef, hydrate, isFragment, isMemo, isValidElement, lazy, memo, render, startTransition, unmountComponentAtNode, unstable_batchedUpdates, useCallback, useContext, useDebugValue, useDeferredValue, useEffect, useId, useImperativeHandle, useInsertionEffect, useLayoutEffect, useMemo, useReducer, useRef, useState, version };

package/dist/server/_chunks/index-tgsfjmep.js

@@ -0,0 +1,74 @@
+// @bun
+// src/compat/next/image/patterns.ts
+function makePathnameRegex(pathname) {
+  let source = "";
+  const escaped = pathname.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  source = escaped.replace(/\/\*\*/g, "(?:/.*)?").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*");
+  return new RegExp(`^${source}$`);
+}
+function hasLocalMatch(localPatterns, url) {
+  if (localPatterns === undefined)
+    return true;
+  return localPatterns.some((pattern) => {
+    if (pattern.pathname !== undefined && !makePathnameRegex(pattern.pathname).test(url.pathname)) {
+      return false;
+    }
+    if (pattern.search !== undefined && pattern.search !== url.search)
+      return false;
+    return true;
+  });
+}
+function hasRemoteMatch(domains, remotePatterns, url) {
+  if (domains.includes(url.hostname))
+    return true;
+  return remotePatterns.some((pattern) => {
+    if (pattern.protocol !== undefined && pattern.protocol !== url.protocol.replace(/:$/, "")) {
+      return false;
+    }
+    if (pattern.hostname !== undefined && !matchHostname(pattern.hostname, url.hostname)) {
+      return false;
+    }
+    if (pattern.port !== undefined && pattern.port !== "" && pattern.port !== url.port) {
+      return false;
+    }
+    if (pattern.pathname !== undefined && !makePathnameRegex(pattern.pathname).test(url.pathname)) {
+      return false;
+    }
+    if (pattern.search !== undefined && pattern.search !== "" && pattern.search !== url.search) {
+      return false;
+    }
+    return true;
+  });
+}
+function matchHostname(pattern, hostname) {
+  if (pattern.startsWith("**.")) {
+    const suffix = pattern.slice(2);
+    return hostname.endsWith(suffix) && hostname.length > suffix.length;
+  }
+  if (pattern.startsWith("*.")) {
+    const suffix = pattern.slice(1);
+    if (!hostname.endsWith(suffix))
+      return false;
+    const sub = hostname.slice(0, -suffix.length);
+    return sub.length > 0 && !sub.includes(".");
+  }
+  return pattern === hostname;
+}
+function manifestLocalPatterns(localPatterns) {
+  const patterns = localPatterns ?? [{ pathname: undefined, search: "" }];
+  const entries = patterns.map((pattern) => ({
+    pathname: compileLocalPathname(pattern.pathname),
+    search: pattern.search ?? ""
+  }));
+  return entries;
+}
+function compileLocalPathname(pathname) {
+  if (pathname === undefined || pathname === "**") {
+    return "^(?:(?!(?:^|\\/)\\.{1,2}(?:\\/|$))(?:(?:(?!(?:^|\\/)\\.{1,2}(?:\\/|$)).)*?)\\/?)$";
+  }
+  const base = pathname.replace(/\/\*\*$/, "");
+  const escaped = base.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\//g, "\\/");
+  return `^(?:${escaped}(?:\\/(?!\\.{1,2}(?:\\/|$))(?:(?:(?!(?:^|\\/)\\.{1,2}(?:\\/|$)).)*?)|$))$`;
+}
+
+export { hasLocalMatch, hasRemoteMatch, manifestLocalPatterns };

package/dist/server/_chunks/index-tq0pc7eg.js

@@ -0,0 +1,154 @@
+// @bun
+import {
+  recordUseCacheLife,
+  recordUseCacheTags
+} from "./index-eajaspjk.js";
+import {
+  bumpRevalidationEvent,
+  cachedData,
+  currentRenderCacheMeta,
+  insideDataCacheProducer,
+  insideUnstableCacheProducer,
+  markPathRevalidated,
+  markTagRevalidated,
+  markTagStale,
+  recordCacheNoStore,
+  recordCacheRevalidate,
+  recordCacheTags
+} from "./index-9n2914ww.js";
+import {
+  getNextConfig
+} from "./index-6e4fqv30.js";
+import {
+  currentRequest,
+  getWorkUnit
+} from "./index-grta8ap3.js";
+import {
+  isPrerendering
+} from "./index-kresp2n8.js";
+import {
+  PostponeError
+} from "./index-e3a6yx84.js";
+
+// src/compat/next/cache.ts
+function refresh() {
+  const phase = getWorkUnit()?.phase;
+  if (phase !== "action" || insideDataCacheProducer()) {
+    throw new Error("refresh can only be called from within a Server Action");
+  }
+  bumpRevalidationEvent();
+}
+var unstable_refresh = refresh;
+function assertRevalidateOutsideRender(expression) {
+  const route = currentRenderCacheMeta()?.route ?? "/";
+  const suffix = "which is unsupported. To ensure revalidation is performed consistently it must always " + "happen outside of renders and cached functions. See more info here: " + "https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering";
+  if (insideDataCacheProducer()) {
+    throw new Error(insideUnstableCacheProducer() ? `Route ${route} used "${expression}" inside a function cached with "unstable_cache(...)" ${suffix}` : `Route ${route} used "${expression}" inside a "use cache" ${suffix}`);
+  }
+  if (getWorkUnit()?.phase !== "render" || isPrerendering())
+    return;
+  throw new Error(`Route ${route} used "${expression}" during render ${suffix}`);
+}
+function revalidatePath(path, type) {
+  assertRevalidateOutsideRender(`revalidatePath ${path}`);
+  markPathRevalidated(path, type);
+}
+function revalidateTag(tag, profile) {
+  assertRevalidateOutsideRender(`revalidateTag ${tag}`);
+  if (profile === undefined) {
+    console.warn(`Warning: "revalidateTag" without the second argument is now deprecated. Use updateTag(tag) for read-your-writes semantics, or pass a cache profile (e.g. revalidateTag(tag, 'max')).`);
+    markTagRevalidated(tag);
+    return;
+  }
+  const resolved = typeof profile === "string" ? resolveCacheLifeProfile(profile) : profile;
+  if (!resolved || resolved.expire === 0 || resolved.revalidate === 0) {
+    markTagRevalidated(tag);
+    return;
+  }
+  markTagStale(tag);
+}
+function updateTag(tag) {
+  const request = currentRequest();
+  const inServerAction = request?.method?.toUpperCase?.() === "POST" && Boolean(request.headers?.get?.("next-action"));
+  if (!inServerAction) {
+    throw new Error("updateTag can only be called from within a Server Action. Use revalidateTag or expireTag for other contexts.");
+  }
+  markTagRevalidated(tag);
+}
+var unstable_expirePath = revalidatePath;
+var unstable_expireTag = (tag) => {
+  assertRevalidateOutsideRender(`expireTag ${tag}`);
+  markTagRevalidated(tag);
+};
+var expirePath = revalidatePath;
+var expireTag = unstable_expireTag;
+function unstable_cache(fn, keyParts, options = {}) {
+  const { revalidate } = options;
+  if (revalidate !== undefined && revalidate !== false && (typeof revalidate !== "number" || revalidate < 0 || !Number.isFinite(revalidate))) {
+    throw new Error(`Invalid revalidate value "${String(revalidate)}" on "unstable_cache(${fn.toString().slice(0, 60)})", must be a non-negative number or false`);
+  }
+  const baseKey = keyParts?.length ? keyParts.join(",") : fn.toString();
+  return (...args) => {
+    recordCacheTags(options.tags ?? []);
+    if (typeof options.revalidate === "number")
+      recordCacheRevalidate(options.revalidate);
+    return cachedData(`${baseKey}:${JSON.stringify(args)}`, () => fn(...args), {
+      tags: options.tags,
+      revalidateSeconds: typeof options.revalidate === "number" ? options.revalidate : undefined
+    });
+  };
+}
+function unstable_noStore() {
+  recordCacheNoStore();
+}
+function cacheTag(...tags) {
+  recordUseCacheTags(tags);
+  recordCacheTags(tags);
+}
+var DEFAULT_EXPIRE_TIME = 31536000;
+var builtInCacheLifeProfiles = {
+  default: { revalidate: 900, expire: DEFAULT_EXPIRE_TIME, stale: 300 },
+  seconds: { revalidate: 1, expire: 60, stale: 30 },
+  minutes: { revalidate: 60, expire: 3600, stale: 300 },
+  hours: { revalidate: 3600, expire: 86400, stale: 300 },
+  days: { revalidate: 86400, expire: 604800, stale: 300 },
+  weeks: { revalidate: 604800, expire: 2592000, stale: 300 },
+  max: { revalidate: 2592000, expire: DEFAULT_EXPIRE_TIME, stale: 300 }
+};
+function resolveCacheLifeProfile(name) {
+  const config = getNextConfig();
+  const overrides = config.cacheLife;
+  const custom = overrides?.[name];
+  const builtIn = builtInCacheLifeProfiles[name];
+  if (!custom && !builtIn)
+    return;
+  const expireTime = typeof config.expireTime === "number" ? config.expireTime : DEFAULT_EXPIRE_TIME;
+  const merged = { ...builtIn, ...custom };
+  return {
+    ...merged,
+    expire: merged.expire ?? expireTime
+  };
+}
+function cacheLife(profile) {
+  const resolved = typeof profile === "string" ? resolveCacheLifeProfile(profile) : {
+    revalidate: typeof profile?.revalidate === "number" ? profile.revalidate : undefined,
+    expire: typeof profile?.expire === "number" ? profile.expire : undefined,
+    stale: typeof profile?.stale === "number" ? profile.stale : undefined
+  };
+  if (!resolved)
+    return;
+  const { revalidate, expire, stale } = resolved;
+  recordUseCacheLife({
+    ...revalidate !== undefined ? { revalidateSeconds: revalidate } : {},
+    ...expire !== undefined ? { expireSeconds: expire } : {},
+    ...stale !== undefined ? { staleSeconds: stale } : {}
+  });
+  if (revalidate !== undefined)
+    recordCacheRevalidate(revalidate);
+  if (isPrerendering() && stale === 0)
+    throw new PostponeError("cacheLife");
+}
+var unstable_cacheTag = cacheTag;
+var unstable_cacheLife = cacheLife;
+
+export { refresh, unstable_refresh, revalidatePath, revalidateTag, updateTag, unstable_expirePath, unstable_expireTag, expirePath, expireTag, unstable_cache, unstable_noStore, cacheTag, cacheLife, unstable_cacheTag, unstable_cacheLife };

package/dist/server/_chunks/index-tq1f96v7.js

@@ -0,0 +1,51 @@
+// @bun
+import {
+  traceEnabled
+} from "./index-vz0km5qk.js";
+
+// src/cli/boot/trace.ts
+import { loadavg, cpus, arch, platform } from "os";
+import { readdirSync } from "fs";
+import path from "path";
+var enabled = traceEnabled("boot");
+var marks = [];
+var cacheAtStart = enabled ? cacheState() : "cold";
+function cacheState() {
+  return countTopLevel(path.join(".pnext", "dev", "cache")) > 0 ? "warm" : "cold";
+}
+var rss = () => typeof process.memoryUsage.rss === "function" ? process.memoryUsage.rss() : process.memoryUsage().rss;
+function markBoot(name) {
+  if (enabled)
+    marks.push([name, performance.now(), rss()]);
+}
+function traceHeader() {
+  const load = loadavg().map((value) => value.toFixed(1)).join(" ");
+  const packages = countTopLevel("node_modules");
+  return [
+    `  runtime          ${typeof Bun !== "undefined" ? `bun ${Bun.version}` : `node ${process.version}`} \xB7 ${platform()} ${arch()} \xB7 ${cpus().length} cpus \xB7 load ${load}`,
+    `  app              ${packages} node_modules entries \xB7 .pnext/dev cache ${cacheAtStart}`
+  ];
+}
+function countTopLevel(dir) {
+  try {
+    return readdirSync(path.resolve(dir)).length;
+  } catch {
+    return 0;
+  }
+}
+function printBootTrace() {
+  if (!enabled || marks.length === 0)
+    return;
+  const lines = ["boot trace (ms since process start):", ...traceHeader()];
+  let previous = 0;
+  for (const [name, at, rss2] of marks) {
+    const mb = (rss2 / 1048576).toFixed(0).padStart(5);
+    lines.push(`  ${name.padEnd(16)} +${(at - previous).toFixed(1).padStart(7)}  @${at.toFixed(1)}  rss ${mb} MB`);
+    previous = at;
+  }
+  lines.push(`  total            @${performance.now().toFixed(1)}`);
+  console.log(lines.join(`
+`));
+}
+
+export { markBoot, printBootTrace };