@wular/pnext 0.1.6 → 0.1.8

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

@@ -0,0 +1,30 @@
+// @bun
+// src/compat/next/preferred-region.ts
+import { readFileSync } from "fs";
+var PREFERRED_REGION_RE = /\bexport\s+const\s+preferredRegion\s*=\s*(\[[^\]]*\]|['"][^'"]*['"])/;
+function preferredRegionForRoute(route) {
+  for (const file of routeSources(route)) {
+    let source;
+    try {
+      source = readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    const match = PREFERRED_REGION_RE.exec(source);
+    if (!match?.[1])
+      continue;
+    return parsePreferredRegion(match[1]);
+  }
+  return;
+}
+function routeSources(route) {
+  return [...new Set([route.file, ...route.sourceFiles])].filter(Boolean);
+}
+function parsePreferredRegion(literal) {
+  if (literal.startsWith("[")) {
+    return Array.from(literal.matchAll(/['"]([^'"]*)['"]/g), (m) => m[1] ?? "");
+  }
+  return [literal.slice(1, -1)];
+}
+
+export { preferredRegionForRoute };

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

@@ -0,0 +1,100 @@
+// @bun
+import {
+  useSyncExternalStore
+} from "./index-tgcakdxc.js";
+import {
+  useActionState
+} from "./index-68m3mwbd.js";
+import {
+  registerResourceHint
+} from "./index-yhxkxghe.js";
+
+// src/compat/react/dom.ts
+import ReactCompat from "preact/compat";
+var ReactDomCompat = Object.assign(ReactCompat, {
+  preload,
+  preconnect,
+  prefetchDNS,
+  preinit
+});
+var dom_default = ReactDomCompat;
+var render = ReactCompat.render;
+var hydrate = ReactCompat.hydrate;
+var createPortal = ReactCompat.createPortal;
+var findDOMNode = ReactCompat.findDOMNode;
+var flushSync = ReactCompat.flushSync;
+var unmountComponentAtNode = ReactCompat.unmountComponentAtNode;
+var unstable_batchedUpdates = ReactCompat.unstable_batchedUpdates;
+var version = ReactCompat.version;
+function preload(href, options) {
+  registerResourceHint({
+    rel: "preload",
+    url: href,
+    ...options?.as ? { as: options.as } : {},
+    ...options?.type ? { type: options.type } : {},
+    ...options?.fetchPriority ? { fetchPriority: options.fetchPriority } : {},
+    ...options?.media ? { media: options.media } : {},
+    ...options?.nonce ? { nonce: options.nonce } : {},
+    ...options?.crossOrigin ? { crossOrigin: options.crossOrigin } : {}
+  });
+}
+function preconnect(href, options) {
+  registerResourceHint({
+    rel: "preconnect",
+    url: href,
+    ...options?.crossOrigin ? { crossOrigin: options.crossOrigin } : {}
+  });
+}
+function prefetchDNS(href) {
+  registerResourceHint({ rel: "dns-prefetch", url: href });
+}
+function preinit(href, options) {
+  registerResourceHint({
+    rel: "preload",
+    url: href,
+    ...options?.as ? { as: options.as } : {},
+    ...options?.crossOrigin ? { crossOrigin: options.crossOrigin } : {}
+  });
+}
+var useFormState = useActionState;
+var NOT_PENDING = {
+  pending: false,
+  data: null,
+  method: null,
+  action: null
+};
+var pendingStack = [];
+var listeners = new Set;
+var storeVersion = 0;
+function __pnextPushFormStatus(status) {
+  pendingStack.push(status);
+  notify();
+  return () => {
+    const index = pendingStack.indexOf(status);
+    if (index !== -1)
+      pendingStack.splice(index, 1);
+    notify();
+  };
+}
+function notify() {
+  storeVersion += 1;
+  for (const listener of [...listeners])
+    listener();
+}
+function subscribe(listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+function useFormStatus() {
+  useSyncExternalStore(subscribe, () => storeVersion, () => storeVersion);
+  return pendingStack.length > 0 ? pendingStack[pendingStack.length - 1] : NOT_PENDING;
+}
+function requestFormReset(form) {
+  if (form && typeof form.reset === "function")
+    form.reset();
+}
+Object.assign(ReactDomCompat, { useFormState, useFormStatus, requestFormReset });
+
+export { render, hydrate, createPortal, findDOMNode, flushSync, unmountComponentAtNode, unstable_batchedUpdates, version, preload, preconnect, prefetchDNS, preinit, useFormState, __pnextPushFormStatus, useFormStatus, requestFormReset, dom_default };

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

@@ -0,0 +1,66 @@
+// @bun
+import {
+  currentRenderCacheMeta
+} from "./index-akkrvjn6.js";
+import {
+  legacyRequestAPIs
+} from "./index-grta8ap3.js";
+
+// src/compat/next/legacy-request-apis.ts
+var PROMISE_PROPS = new Set(["then", "catch", "finally", "constructor"]);
+var warned = new Set;
+function withSyncAccess(promise, api, produce) {
+  let value;
+  const resolve = () => value ??= produce();
+  return new Proxy(promise, {
+    get(target, prop) {
+      if (PROMISE_PROPS.has(prop) || prop === Symbol.toStringTag) {
+        const own = Reflect.get(target, prop, target);
+        return typeof own === "function" ? own.bind(target) : own;
+      }
+      warnSyncApiAccess(api, prop);
+      const source = resolve();
+      const read = Reflect.get(source, prop, source);
+      return typeof read === "function" ? read.bind(source) : read;
+    }
+  });
+}
+function withSyncProps(promise, kind, value) {
+  if (!legacyRequestAPIs())
+    return promise;
+  for (const key of Object.keys(value)) {
+    if (key in promise)
+      continue;
+    Object.defineProperty(promise, key, {
+      get() {
+        warnSyncPropAccess(kind, key);
+        return value[key];
+      },
+      enumerable: true,
+      configurable: true
+    });
+  }
+  return promise;
+}
+function warnSyncApiAccess(api, prop) {
+  const expression = prop === Symbol.iterator ? `\`...${api}()\` or similar iteration` : `\`${api}().${String(prop)}\``;
+  warnSyncAccess(expression, `${api}()`, "value");
+}
+function warnSyncPropAccess(kind, key) {
+  warnSyncAccess(`\`${kind}.${key}\``, kind, "properties");
+}
+function warnSyncAccess(expression, subject, noun) {
+  const route = currentRenderCacheMeta()?.route;
+  const key = `${route ?? ""}|${expression}|${callsite()}`;
+  if (warned.has(key))
+    return;
+  warned.add(key);
+  console.warn(`${route ? `Route "${route}" ` : "This route "}used ${expression}. ` + `\`${subject}\` should be awaited before using its ${noun}. ` + "Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis");
+}
+function callsite() {
+  const frames = new Error().stack?.split(`
+`).slice(1) ?? [];
+  return frames.find((frame) => !frame.includes("legacy-request-apis")) ?? "";
+}
+
+export { withSyncAccess, withSyncProps };

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

@@ -0,0 +1,110 @@
+// @bun
+import {
+  getNextConfig
+} from "./index-m63czgq5.js";
+
+// src/compat/mdx/compile.ts
+import { existsSync } from "fs";
+import { createRequire } from "module";
+import path from "path";
+import { pathToFileURL } from "url";
+var cachedModule;
+async function loadMdx() {
+  if (cachedModule !== undefined)
+    return cachedModule;
+  try {
+    const specifier = "@mdx-js/mdx";
+    cachedModule = await import(specifier);
+  } catch {
+    cachedModule = null;
+  }
+  return cachedModule;
+}
+function mdxOptionsFromConfig() {
+  const config = getNextConfig();
+  return config.mdxOptions ?? {};
+}
+function resolveMdxComponents(root) {
+  const bases = [root, path.join(root, "src")];
+  const names = [
+    "mdx-components.tsx",
+    "mdx-components.ts",
+    "mdx-components.jsx",
+    "mdx-components.js",
+    "mdx-components.mjs"
+  ];
+  for (const base of bases) {
+    for (const name of names) {
+      const candidate = path.join(base, name);
+      if (existsSync(candidate))
+        return candidate;
+    }
+  }
+  return;
+}
+function interopDefault(module) {
+  return module?.default ?? module;
+}
+var UNRESOLVED_PLUGIN = Symbol("pnext.mdx.unresolved-plugin");
+async function resolvePlugin(entry, resolveFrom) {
+  if (typeof entry === "function")
+    return entry;
+  if (typeof entry === "string") {
+    return loadPlugin(entry, resolveFrom);
+  }
+  if (Array.isArray(entry) && typeof entry[0] === "string") {
+    const tuple = entry;
+    const plugin = await loadPlugin(tuple[0], resolveFrom);
+    if (plugin === UNRESOLVED_PLUGIN)
+      return UNRESOLVED_PLUGIN;
+    return [plugin, ...tuple.slice(1)];
+  }
+  return entry;
+}
+async function loadPlugin(name, resolveFrom) {
+  let resolved;
+  try {
+    resolved = resolveFrom.resolve(name);
+  } catch {
+    console.warn(`pnext: MDX plugin '${name}' is configured but not installed; skipping it. Install it to apply this remark/rehype/recma plugin.`);
+    return UNRESOLVED_PLUGIN;
+  }
+  try {
+    return interopDefault(await import(pathToFileURL(resolved).href));
+  } catch (error) {
+    console.warn(`pnext: MDX plugin '${name}' failed to load and was skipped: ${error instanceof Error ? error.message : String(error)}. ` + "Ensure it is installed in the app\u2019s node_modules (not only Bun\u2019s auto-install cache).");
+    return UNRESOLVED_PLUGIN;
+  }
+}
+async function resolvePlugins(plugins, resolveFrom) {
+  const resolved = await Promise.all(plugins.map((entry) => resolvePlugin(entry, resolveFrom)));
+  return resolved.filter((entry) => entry !== UNRESOLVED_PLUGIN);
+}
+async function compileMdx(source, filePath, root) {
+  const mdx = await loadMdx();
+  if (!mdx) {
+    throw new Error("MDX support requires the '@mdx-js/mdx' package. Install it to render .mdx files.");
+  }
+  const userOptions = mdxOptionsFromConfig();
+  const provider = resolveMdxComponents(root);
+  const resolveFrom = createRequire(path.join(root, "noop.js"));
+  const [remarkPlugins, rehypePlugins, recmaPlugins] = await Promise.all([
+    resolvePlugins(userOptions.remarkPlugins ?? [], resolveFrom),
+    resolvePlugins(userOptions.rehypePlugins ?? [], resolveFrom),
+    resolvePlugins(userOptions.recmaPlugins ?? [], resolveFrom)
+  ]);
+  const compiled = await mdx.compile({ value: source, path: filePath }, {
+    jsx: true,
+    jsxImportSource: "preact",
+    format: "mdx",
+    development: false,
+    remarkPlugins,
+    rehypePlugins,
+    recmaPlugins,
+    ...userOptions.remarkRehypeOptions ? { remarkRehypeOptions: userOptions.remarkRehypeOptions } : {},
+    ...userOptions.providerImportSource ? { providerImportSource: userOptions.providerImportSource } : provider ? { providerImportSource: provider } : {}
+  });
+  return { code: compiled.toString() };
+}
+
+export { mdxOptionsFromConfig, resolveMdxComponents, compileMdx };

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

@@ -0,0 +1,47 @@
+// @bun
+// src/utils/html.ts
+function escapeHtml(value) {
+  return stringifyHtmlValue(value).replace(/[&<>"']/g, (char) => {
+    switch (char) {
+      case "&":
+        return "&amp;";
+      case "<":
+        return "&lt;";
+      case ">":
+        return "&gt;";
+      case '"':
+        return "&quot;";
+      case "'":
+        return "&#x27;";
+      default:
+        return char;
+    }
+  });
+}
+function stringifyHtmlValue(value) {
+  if (value === undefined || value === null)
+    return "";
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  if (value instanceof URL)
+    return value.href;
+  if (value instanceof Date)
+    return value.toISOString();
+  if (typeof value !== "object")
+    return "";
+  const stringifier = value.toString;
+  if (!stringifier || stringifier === Object.prototype.toString)
+    return "";
+  const stringified = stringifier.call(value);
+  if (typeof stringified === "string")
+    return stringified;
+  if (typeof stringified === "number" || typeof stringified === "boolean" || typeof stringified === "bigint") {
+    return String(stringified);
+  }
+  return "";
+}
+
+export { escapeHtml, stringifyHtmlValue };

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

@@ -0,0 +1,56 @@
+// @bun
+// src/render/resource-hints.ts
+var HINT_LISTENER = Symbol.for("pnext.resourceHintListener");
+var RENDER_BUFFER_SCOPE = Symbol.for("pnext.renderBufferScope");
+var RENDER_BUFFER_STRAYS = Symbol.for("pnext.renderBufferStrays");
+var newRenderBufferFrame = () => ({ hints: [], head: [], deferred: [] });
+var globals = globalThis;
+function frame() {
+  const scope = globals[RENDER_BUFFER_SCOPE];
+  return scope?.getStore() ?? (globals[RENDER_BUFFER_STRAYS] ??= newRenderBufferFrame());
+}
+function renderBuffer(kind) {
+  return frame()[kind];
+}
+function takeRenderBuffer(kind) {
+  const active = frame();
+  const buffer = active[kind];
+  active[kind] = [];
+  return buffer;
+}
+function clearRenderBuffer(kind) {
+  frame()[kind] = [];
+  const strays = globals[RENDER_BUFFER_STRAYS];
+  if (strays)
+    strays[kind] = [];
+}
+function setResourceHintListener(listener) {
+  globalThis[HINT_LISTENER] = listener;
+}
+function registerResourceHint(hint) {
+  if (typeof window !== "undefined")
+    return;
+  const listener = globalThis[HINT_LISTENER];
+  listener?.(hint);
+  const hints = renderBuffer("hints");
+  if (hints.some((existing) => resourceHintKey(existing) === resourceHintKey(hint)))
+    return;
+  hints.push(hint);
+}
+function clearResourceHints() {
+  clearRenderBuffer("hints");
+}
+function takeResourceHints() {
+  return takeRenderBuffer("hints");
+}
+function resourceHintKey(hint) {
+  if (hint.rel === "preload" && hint.as === "image") {
+    const srcSet = hint.attributes?.imagesrcset;
+    const first = typeof srcSet === "string" ? srcSet.split(/[\s,]+/)[0] : undefined;
+    return `image:${first || hint.url || ""}`;
+  }
+  const attributes = Object.entries(hint.attributes ?? {}).sort(([a], [b]) => a.localeCompare(b));
+  return JSON.stringify({ ...hint, attributes });
+}
+
+export { RENDER_BUFFER_SCOPE, newRenderBufferFrame, renderBuffer, takeRenderBuffer, clearRenderBuffer, setResourceHintListener, registerResourceHint, clearResourceHints, takeResourceHints };

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

@@ -0,0 +1,86 @@
+// @bun
+import { join as __pnextJoin } from "node:path";
+const __PNEXT_PACKAGE_ROOT__ = __pnextJoin(import.meta.dirname, "../../..");
+import {
+  hasModuleDirective
+} from "./index-jbj7ehef.js";
+import {
+  readText
+} from "./index-4da76t62.js";
+import {
+  pathToFileHref
+} from "./index-71885zaq.js";
+import {
+  clientReferenceId
+} from "./index-ras0sdab.js";
+import {
+  moduleExportNames,
+  moduleExportStars
+} from "./index-x9c55pzy.js";
+import {
+  resolveImport
+} from "./index-d1jsmhhk.js";
+
+// src/client/reference-stub.ts
+import path from "path";
+var clientReferenceRuntimeFile = path.resolve(__PNEXT_PACKAGE_ROOT__ + "/src/client", "reference.ts");
+function clientReferenceModuleSource(sourceFile, exportNames, options = {}) {
+  const portable = options.portable;
+  const located = portable ? `decodeURIComponent(new URL(${JSON.stringify(path.relative(path.dirname(portable.from), portable.target).split(path.sep).join("/"))}, import.meta.url).pathname)` : undefined;
+  const file = !located ? JSON.stringify(sourceFile) : portable?.real ? `__pnextRealpath(${located})` : located;
+  const reference = (exportName) => `createReference({ id: ${JSON.stringify(`c-${clientReferenceId(sourceFile, exportName)}`)}, file: ${file}, exportName: ${JSON.stringify(exportName)} })`;
+  const defaultExport = exportNames.includes("default") ? `export default ${reference("default")};` : "";
+  const namedExports = exportNames.filter((name) => name !== "default").map((name) => `export const ${name} = ${reference(name)};`);
+  const symbol = options.inlineSymbol ? `const clientReferenceSymbol = Symbol.for('pnext.clientReference');` : `import { clientReferenceSymbol } from ${JSON.stringify(pathToFileHref(clientReferenceRuntimeFile))};`;
+  const realpath = portable?.real ? `import { realpathSync as __pnextRealpath } from 'node:fs';
+` : "";
+  return `${realpath}${symbol}
+
+function createReference(reference) {
+  function ClientReference({ children }) {
+    return children ?? null;
+  }
+  ClientReference[clientReferenceSymbol] = reference;
+  return ClientReference;
+}
+
+${defaultExport}
+${namedExports.join(`
+`)}
+`;
+}
+async function clientReferenceExportNames(config, file, source, visited = new Set) {
+  const key = path.resolve(file);
+  if (visited.has(key))
+    return [];
+  visited.add(key);
+  const text = source ?? await readText(file);
+  const names = new Set(moduleExportNames(text, file));
+  if (names.size === 0) {
+    for (const match of text.matchAll(/\bexports\.([A-Za-z_$][\w$]*)\s*=/g)) {
+      if (match[1] !== "__esModule")
+        names.add(match[1]);
+    }
+    if (/\bmodule\.exports\s*=/.test(text))
+      names.add("default");
+  }
+  for (const specifier of moduleExportStars(text, file)) {
+    const resolved = resolveImport(config.root, file, specifier, config.workspaceRoot);
+    if (!resolved || !isInside(config.workspaceRoot, resolved))
+      continue;
+    for (const name of await clientReferenceExportNames(config, resolved, undefined, visited)) {
+      if (name !== "default")
+        names.add(name);
+    }
+  }
+  return [...names];
+}
+function hasUseClientDirective(source) {
+  return hasModuleDirective(source, "use client");
+}
+function isInside(root, file) {
+  const relative = path.relative(root, file);
+  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+
+export { clientReferenceModuleSource, clientReferenceExportNames, hasUseClientDirective };

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

@@ -0,0 +1,11 @@
+// @bun
+// src/routing/request-environment.ts
+var current;
+function setRequestRuntime(runtime) {
+  current = runtime;
+}
+function getRequestRuntime() {
+  return current;
+}
+
+export { setRequestRuntime, getRequestRuntime };

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

@@ -0,0 +1,154 @@
+// @bun
+import {
+  recordUseCacheLife,
+  recordUseCacheTags
+} from "./index-j0m1jxqa.js";
+import {
+  bumpRevalidationEvent,
+  cachedData,
+  currentRenderCacheMeta,
+  insideDataCacheProducer,
+  insideUnstableCacheProducer,
+  markPathRevalidated,
+  markTagRevalidated,
+  markTagStale,
+  recordCacheNoStore,
+  recordCacheRevalidate,
+  recordCacheTags
+} from "./index-akkrvjn6.js";
+import {
+  getNextConfig
+} from "./index-m63czgq5.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 };