@wular/pnext 0.0.4 → 0.0.6

package/src/compat/metadata.ts

@@ -1,31 +1,25 @@
-import type {
-  Metadata,
-  MetadataOpenGraph,
-  PageProps,
-  RouteManifestEntry,
-  Viewport,
-} from '../types';
-import { staticMetadataForPathFromFiles, type StaticMetadataFile } from '../routing/metadata';
-import { coerceString } from '../render/metadata';
-import { readSourceText } from '../resolve/source-text';
-import { SPAN_TYPE, withChildSpan } from './otel/tracer';
-import { settledPromise } from '../render/renderer';
+import type { Metadata, MetadataOpenGraph, PageProps, RouteManifestEntry, Viewport } from '../types'
+import { staticMetadataForPathFromFiles, type StaticMetadataFile } from '../routing/metadata-files'
+import { coerceString } from '../render/metadata'
+import { readSourceText } from '../resolve/source-text'
+import { SPAN_TYPE, withChildSpan } from './otel/tracer'
+import { settledPromise } from '../render/renderer'
 import {
   createVaryingParams,
   createVaryingSearchParams,
   getMetadataVaryParamsAccumulator,
   varyTrackingInfo,
   type VaryTrackingInfo,
-} from './segment/vary-params';
+} from './segment/vary-params'
 
 type NextGenerateMetadata = (
   props: Pick<PageProps, 'params' | 'searchParams'>,
   parent: Promise<Metadata>,
-) => Metadata | Promise<Metadata>;
+) => Metadata | Promise<Metadata>
 
 type NextGenerateViewport = (
   props: Pick<PageProps, 'params' | 'searchParams'>,
-) => Viewport | Promise<Viewport>;
+) => Viewport | Promise<Viewport>
 
 export async function readNextModuleMetadata(
   module: Record<string, unknown>,
@@ -34,17 +28,17 @@ export async function readNextModuleMetadata(
   modulePath?: string,
 ): Promise<Metadata | undefined> {
   if (typeof module.generateMetadata === 'function') {
-    const generate = module.generateMetadata as NextGenerateMetadata;
+    const generate = module.generateMetadata as NextGenerateMetadata
     // `generateMetadata <page>` OTel span (ResolveMetadata.generateMetadata),
     // named by the route-relative module path (e.g. `/app/[param]/layout`).
     // Inert when otel-api is unavailable or no root span is open.
-    const headProps = headVaryTrackedProps(props);
+    const headProps = headVaryTrackedProps(props)
     const run = () =>
       generate(
         { params: headProps.params, searchParams: headProps.searchParams },
         Promise.resolve(resolvedParentMetadata(parent)),
-      );
-    const name = metadataSpanName(modulePath);
+      )
+    const name = metadataSpanName(modulePath)
     return await (name
       ? withChildSpan(
           name,
@@ -52,9 +46,9 @@ export async function readNextModuleMetadata(
           { 'next.page': name.slice('generateMetadata '.length) },
           run,
         )
-      : run());
+      : run())
   }
-  return module.metadata as Metadata | undefined;
+  return module.metadata as Metadata | undefined
 }
 
 // Route-relative module path for a `generateMetadata` span name: an absolute `<root>/app/[param]/
@@ -62,12 +56,12 @@ export async function readNextModuleMetadata(
 // relative path prefixed by the `/app` segment. Returns undefined when the path cannot be derived, in
 // which case the span is skipped rather than failing.
 function metadataSpanName(modulePath: string | undefined): string | undefined {
-  if (!modulePath) return undefined;
-  const normalized = modulePath.replace(/\\/g, '/').replace(/\.[cm]?[jt]sx?$/, '');
+  if (!modulePath) return undefined
+  const normalized = modulePath.replace(/\\/g, '/').replace(/\.[cm]?[jt]sx?$/, '')
   // Keep everything from the LAST `/app/` segment onward (handles src/app too).
-  const idx = normalized.lastIndexOf('/app/');
-  const rel = idx >= 0 ? normalized.slice(idx) : `/${normalized.replace(/^\/+/, '')}`;
-  return `generateMetadata ${rel}`;
+  const idx = normalized.lastIndexOf('/app/')
+  const rel = idx >= 0 ? normalized.slice(idx) : `/${normalized.replace(/^\/+/, '')}`
+  return `generateMetadata ${rel}`
 }
 
 export async function readNextModuleViewport(
@@ -75,13 +69,13 @@ export async function readNextModuleViewport(
   props: PageProps,
 ): Promise<Viewport | undefined> {
   if (typeof module.generateViewport === 'function') {
-    const headProps = headVaryTrackedProps(props);
+    const headProps = headVaryTrackedProps(props)
     return (module.generateViewport as NextGenerateViewport)({
       params: headProps.params,
       searchParams: headProps.searchParams,
-    });
+    })
   }
-  return module.viewport as Viewport | undefined;
+  return module.viewport as Viewport | undefined
 }
 
 /**
@@ -95,14 +89,14 @@ export async function readNextModuleViewport(
  * postpone machinery still sees it.
  */
 function headVaryTrackedProps(props: PageProps): Pick<PageProps, 'params' | 'searchParams'> {
-  const head = getMetadataVaryParamsAccumulator();
-  if (!head) return { params: props.params, searchParams: props.searchParams };
+  const head = getMetadataVaryParamsAccumulator()
+  if (!head) return { params: props.params, searchParams: props.searchParams }
   return {
     params: retrackSettled(props.params, (raw, info) =>
       createVaryingParams(head, raw, info.optionalCatchAllParam),
     ),
     searchParams: retrackSettled(props.searchParams, raw => createVaryingSearchParams(head, raw)),
-  };
+  }
 }
 
 /**
@@ -114,29 +108,29 @@ function retrackSettled<T extends Record<string, unknown>>(
   promise: Promise<T>,
   wrap: (raw: T, info: VaryTrackingInfo) => T,
 ): Promise<T> {
-  const settled = promise as Promise<T> & { status?: string; value?: T };
-  if (settled.status !== 'fulfilled' || settled.value === undefined) return promise;
-  const info = varyTrackingInfo(settled.value);
-  if (!info) return promise;
-  return settledPromise(wrap(info.raw as T, info));
+  const settled = promise as Promise<T> & { status?: string; value?: T }
+  if (settled.status !== 'fulfilled' || settled.value === undefined) return promise
+  const info = varyTrackingInfo(settled.value)
+  if (!info) return promise
+  return settledPromise(wrap(info.raw as T, info))
 }
 
 export function hasRuntimeMetadata(module: Record<string, unknown>) {
-  return typeof module.generateMetadata === 'function';
+  return typeof module.generateMetadata === 'function'
 }
 
 export function shouldRenderMetadataInBody({
   config,
   request,
 }: {
-  config: { htmlLimitedBots?: RegExp };
-  request?: Request;
+  config: { htmlLimitedBots?: RegExp }
+  request?: Request
 }) {
-  const userAgent = request?.headers.get('user-agent') ?? '';
+  const userAgent = request?.headers.get('user-agent') ?? ''
   const limitedBot =
     config.htmlLimitedBots ??
-    /Twitterbot|Slackbot|Bingbot|Discordbot|LinkedInBot|Google-PageRenderer|Chrome-Lighthouse|Lighthouse/i;
-  return !limitedBot.test(userAgent);
+    /Twitterbot|Slackbot|Bingbot|Discordbot|LinkedInBot|Google-PageRenderer|Chrome-Lighthouse|Lighthouse/i
+  return !limitedBot.test(userAgent)
 }
 
 function resolvedParentMetadata(parent: Metadata): Metadata {
@@ -149,11 +143,11 @@ function resolvedParentMetadata(parent: Metadata): Metadata {
     robots: parent.robots ?? {},
     alternates: parent.alternates ?? {},
     icons: parent.icons ?? {},
-  };
+  }
 }
 
 function resolvedParentOpenGraph(openGraph: MetadataOpenGraph | undefined): MetadataOpenGraph {
-  if (!openGraph) return {};
+  if (!openGraph) return {}
   return {
     ...openGraph,
     title:
@@ -167,12 +161,12 @@ function resolvedParentOpenGraph(openGraph: MetadataOpenGraph | undefined): Meta
         : Array.isArray(openGraph.images)
           ? openGraph.images
           : [openGraph.images],
-  };
+  }
 }
 
 function normalizeKeywordList(value: Metadata['keywords']): (string | number)[] | undefined {
-  if (value === undefined) return undefined;
-  return Array.isArray(value) ? value : [value];
+  if (value === undefined) return undefined
+  return Array.isArray(value) ? value : [value]
 }
 
 export async function warnNextMetadataBuildIssues(
@@ -180,44 +174,44 @@ export async function warnNextMetadataBuildIssues(
   routes: RouteManifestEntry[],
   staticMetadataFiles: StaticMetadataFile[],
 ) {
-  const warned = new Set<string>();
+  const warned = new Set<string>()
   // A route's own file plus its layout chain: on a 23-route app with one shell
   // that is the same handful of layouts 23 times over. Each file's four verdicts
   // are derived once and reused, and the reads come from the build's shared
   // source cache (the route-fact walk has already read every one of them).
-  const facts = new Map<string, MetadataSourceFacts>();
+  const facts = new Map<string, MetadataSourceFacts>()
   const factsFor = async (file: string) => {
-    let cached = facts.get(file);
+    let cached = facts.get(file)
     if (!cached) {
-      cached = metadataSourceFacts(await readSourceTextOrEmpty(file));
-      facts.set(file, cached);
+      cached = metadataSourceFacts(await readSourceTextOrEmpty(file))
+      facts.set(file, cached)
     }
-    return cached;
-  };
+    return cached
+  }
   for (const route of routes) {
-    if (route.kind !== 'page') continue;
-    const routeFacts = await Promise.all(routeSourceFiles(appPath, route).map(factsFor));
-    const some = (pick: (fact: MetadataSourceFacts) => boolean) => routeFacts.some(pick);
+    if (route.kind !== 'page') continue
+    const routeFacts = await Promise.all(routeSourceFiles(appPath, route).map(factsFor))
+    const some = (pick: (fact: MetadataSourceFacts) => boolean) => routeFacts.some(pick)
     if (some(fact => fact.themeColor)) {
       warnOnce(
         warned,
         `themeColor:${route.route}`,
         `Unsupported metadata themeColor is configured in metadata export in ${route.route || '/'}. Please move it to viewport\nRead more: https://nextjs.org/docs/app/api-reference/functions/generate-viewport`,
-      );
+      )
     }
     if (some(fact => fact.appleTouchFullscreen)) {
       warnOnce(
         warned,
         'apple-touch-fullscreen',
         'Unsupported metadata other.apple-touch-fullscreen is configured in metadata export. Use appleWebApp instead.',
-      );
+      )
     }
     if (some(fact => fact.appleTouchIconPrecomposed)) {
       warnOnce(
         warned,
         'apple-touch-icon-precomposed',
         'Unsupported metadata other.apple-touch-icon-precomposed is configured in metadata export. Use icons.apple instead.',
-      );
+      )
     }
     if (
       !some(fact => fact.metadataBase) &&
@@ -227,22 +221,22 @@ export async function warnNextMetadataBuildIssues(
         warned,
         'metadataBase',
         'metadataBase property in metadata export is not set for resolving social open graph or twitter images, using "http://localhost:3000". See https://nextjs.org/docs/app/api-reference/functions/generate-metadata#metadatabase',
-      );
+      )
     }
   }
 }
 
 /** The app-dir files whose metadata exports apply to this route. */
 function routeSourceFiles(appPath: string, route: RouteManifestEntry) {
-  const root = `${appPath}/`;
-  return route.sourceFiles.filter(file => file === appPath || file.startsWith(root));
+  const root = `${appPath}/`
+  return route.sourceFiles.filter(file => file === appPath || file.startsWith(root))
 }
 
 async function readSourceTextOrEmpty(file: string) {
   try {
-    return await readSourceText(file);
+    return await readSourceText(file)
   } catch {
-    return '';
+    return ''
   }
 }
 
@@ -252,11 +246,11 @@ async function readSourceTextOrEmpty(file: string) {
  * nearly every file has none of these keys.
  */
 interface MetadataSourceFacts {
-  themeColor: boolean;
-  appleTouchFullscreen: boolean;
-  appleTouchIconPrecomposed: boolean;
-  metadataBase: boolean;
-  relativeSocialImage: boolean;
+  themeColor: boolean
+  appleTouchFullscreen: boolean
+  appleTouchIconPrecomposed: boolean
+  metadataBase: boolean
+  relativeSocialImage: boolean
 }
 
 function metadataSourceFacts(source: string): MetadataSourceFacts {
@@ -269,7 +263,7 @@ function metadataSourceFacts(source: string): MetadataSourceFacts {
       /['"]apple-touch-icon-precomposed['"]/.test(source),
     metadataBase: source.includes('metadataBase') && /\bmetadataBase\s*:/.test(source),
     relativeSocialImage: hasRelativeSocialImage(source),
-  };
+  }
 }
 
 function routeUsesRelativeSocialImage(
@@ -277,19 +271,19 @@ function routeUsesRelativeSocialImage(
   facts: MetadataSourceFacts[],
   staticMetadataFiles: StaticMetadataFile[],
 ) {
-  if (facts.some(fact => fact.relativeSocialImage)) return true;
-  if (route.params.length > 0) return false;
-  const staticMetadata = staticMetadataForPathFromFiles(staticMetadataFiles, route.route);
-  return Boolean(staticMetadata.openGraphImage || staticMetadata.twitterImage);
+  if (facts.some(fact => fact.relativeSocialImage)) return true
+  if (route.params.length > 0) return false
+  const staticMetadata = staticMetadataForPathFromFiles(staticMetadataFiles, route.route)
+  return Boolean(staticMetadata.openGraphImage || staticMetadata.twitterImage)
 }
 
 function hasRelativeSocialImage(source: string) {
-  if (!source.includes('images')) return false;
-  return /(?:openGraph|twitter)\s*:\s*\{[\s\S]*?\bimages\s*:\s*['"`](?:\/|\.\.?\/)/m.test(source);
+  if (!source.includes('images')) return false
+  return /(?:openGraph|twitter)\s*:\s*\{[\s\S]*?\bimages\s*:\s*['"`](?:\/|\.\.?\/)/m.test(source)
 }
 
 function warnOnce(warned: Set<string>, key: string, message: string) {
-  if (warned.has(key)) return;
-  warned.add(key);
-  console.warn(message);
+  if (warned.has(key)) return
+  warned.add(key)
+  console.warn(message)
 }

package/src/compat/next/cache.ts

@@ -10,22 +10,22 @@ import {
   recordCacheNoStore,
   recordCacheRevalidate,
   recordCacheTags,
-} from '../cache/revalidate';
-import { recordUseCacheLife, recordUseCacheTags } from '../cache/use-cache';
-import { currentRequest, getWorkUnit } from '../../request/context';
-import { getNextConfig } from './config-loader';
-import { isPrerendering, PostponeError } from '../../ppr';
-export { io } from '../ppr/io';
+} from '../cache/revalidate'
+import { recordUseCacheLife, recordUseCacheTags } from '../cache/use-cache'
+import { currentRequest, getWorkUnit } from '../../request/context'
+import { getNextConfig } from './config-loader'
+import { isPrerendering, PostponeError } from '../../render/ppr'
+export { io } from '../ppr/io'
 
 export function refresh() {
-  const phase = getWorkUnit()?.phase;
+  const phase = getWorkUnit()?.phase
   if (phase !== 'action' || insideDataCacheProducer()) {
-    throw new Error('refresh can only be called from within a Server Action');
+    throw new Error('refresh can only be called from within a Server Action')
   }
-  bumpRevalidationEvent();
+  bumpRevalidationEvent()
 }
 
-export const unstable_refresh = refresh;
+export const unstable_refresh = refresh
 
 /**
  * Revalidation is a side effect and must never run during a render or inside a cached function. At
@@ -34,38 +34,38 @@ export const unstable_refresh = refresh;
  * (postpone). Actions, route handlers and after() are the supported call sites and pass through.
  */
 function assertRevalidateOutsideRender(expression: string): void {
-  const route = currentRenderCacheMeta()?.route ?? '/';
+  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';
+    '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}`,
-    );
+    )
   }
   // Live request renders only: build prerenders (and their after() drains,
   // which run with the work-unit phase still 'render') keep their existing
   // skip-to-dynamic behavior rather than throwing here.
-  if (getWorkUnit()?.phase !== 'render' || isPrerendering()) return;
-  throw new Error(`Route ${route} used "${expression}" during render ${suffix}`);
+  if (getWorkUnit()?.phase !== 'render' || isPrerendering()) return
+  throw new Error(`Route ${route} used "${expression}" during render ${suffix}`)
 }
 
 export function revalidatePath(path: string, type?: 'page' | 'layout') {
-  assertRevalidateOutsideRender(`revalidatePath ${path}`);
-  markPathRevalidated(path, type);
+  assertRevalidateOutsideRender(`revalidatePath ${path}`)
+  markPathRevalidated(path, type)
 }
 
 export function revalidateTag(tag: string, profile?: string | CacheLifeProfile) {
-  assertRevalidateOutsideRender(`revalidateTag ${tag}`);
+  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;
+    )
+    markTagRevalidated(tag)
+    return
   }
   // A cache-life profile whose expiry has already elapsed (the built-in `expireNow`, or any profile with
   // expire/revalidate 0) is an immediate hard expiry, not stale-while-revalidate: the next read must
@@ -74,39 +74,39 @@ export function revalidateTag(tag: string, profile?: string | CacheLifeProfile)
   // The profile is either a cacheLife name or an inline `{ expire }` object. An unknown name is treated
   // as immediate expiry too - Next only softens the invalidation when the profile RESOLVES to a nonzero
   // expiry, so failing hard keeps revalidation observable.
-  const resolved = typeof profile === 'string' ? resolveCacheLifeProfile(profile) : profile;
+  const resolved = typeof profile === 'string' ? resolveCacheLifeProfile(profile) : profile
   if (!resolved || resolved.expire === 0 || resolved.revalidate === 0) {
-    markTagRevalidated(tag);
-    return;
+    markTagRevalidated(tag)
+    return
   }
-  markTagStale(tag);
+  markTagStale(tag)
 }
 
 /** updateTag is Server-Action-only in Next (read-your-writes expiry). */
 export function updateTag(tag: string) {
-  const request = currentRequest();
+  const request = currentRequest()
   const inServerAction =
-    request?.method?.toUpperCase?.() === 'POST' && Boolean(request.headers?.get?.('next-action'));
+    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);
+  markTagRevalidated(tag)
 }
 
 // Newer names for the same operations.
-export const unstable_expirePath = revalidatePath;
+export const unstable_expirePath = revalidatePath
 export const unstable_expireTag = (tag: string) => {
-  assertRevalidateOutsideRender(`expireTag ${tag}`);
-  markTagRevalidated(tag);
-};
-export const expirePath = revalidatePath;
-export const expireTag = unstable_expireTag;
+  assertRevalidateOutsideRender(`expireTag ${tag}`)
+  markTagRevalidated(tag)
+}
+export const expirePath = revalidatePath
+export const expireTag = unstable_expireTag
 
 export interface UnstableCacheOptions {
-  revalidate?: number | false;
-  tags?: string[];
+  revalidate?: number | false
+  tags?: string[]
 }
 
 export function unstable_cache<Args extends unknown[], Result>(
@@ -114,7 +114,7 @@ export function unstable_cache<Args extends unknown[], Result>(
   keyParts?: string[],
   options: UnstableCacheOptions = {},
 ): (...args: Args) => Promise<Result> {
-  const { revalidate } = options;
+  const { revalidate } = options
   if (
     revalidate !== undefined &&
     revalidate !== false &&
@@ -122,43 +122,43 @@ export function unstable_cache<Args extends unknown[], Result>(
   ) {
     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();
+  const baseKey = keyParts?.length ? keyParts.join(',') : fn.toString()
   return (...args: Args) => {
     // Surrounding prerender/ISR writes inherit this entry's tags and TTL.
-    recordCacheTags(options.tags ?? []);
-    if (typeof options.revalidate === 'number') recordCacheRevalidate(options.revalidate);
+    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,
-    }) as Promise<Result>;
-  };
+    }) as Promise<Result>
+  }
 }
 
 /** Opt the surrounding render out of prebuilt static output (Next semantics). */
 export function unstable_noStore() {
-  recordCacheNoStore();
+  recordCacheNoStore()
 }
 
 // 'use cache' directive companions: tag/bound the active use-cache entry
 // (see cache/use-cache.ts) and propagate to the surrounding render meta so
 // prerendered pages inherit tags/TTL.
 export function cacheTag(...tags: string[]) {
-  recordUseCacheTags(tags);
-  recordCacheTags(tags);
+  recordUseCacheTags(tags)
+  recordCacheTags(tags)
 }
 
 // Built-in cacheLife profiles (Next defaults). `expire` defaults to the
 // config's `expireTime` (one year) when a profile omits it; `stale` feeds the
 // `x-nextjs-stale-time` header.
 interface CacheLifeProfile {
-  revalidate?: number;
-  expire?: number;
-  stale?: number;
+  revalidate?: number
+  expire?: number
+  stale?: number
 }
 
-const DEFAULT_EXPIRE_TIME = 31536000; // one year, Next's default expireTime.
+const DEFAULT_EXPIRE_TIME = 31536000 // one year, Next's default expireTime.
 
 const builtInCacheLifeProfiles: Record<string, CacheLifeProfile> = {
   default: { revalidate: 900, expire: DEFAULT_EXPIRE_TIME, stale: 300 },
@@ -168,22 +168,21 @@ const builtInCacheLifeProfiles: Record<string, CacheLifeProfile> = {
   days: { revalidate: 86400, expire: 604800, stale: 300 },
   weeks: { revalidate: 604800, expire: 2592000, stale: 300 },
   max: { revalidate: 2592000, expire: DEFAULT_EXPIRE_TIME, stale: 300 },
-};
+}
 
 /** Resolve a cacheLife profile name against config `cacheLife` overrides. */
 function resolveCacheLifeProfile(name: string): CacheLifeProfile | undefined {
-  const config = getNextConfig();
-  const overrides = config.cacheLife as Record<string, CacheLifeProfile> | undefined;
-  const custom = overrides?.[name];
-  const builtIn = builtInCacheLifeProfiles[name];
-  if (!custom && !builtIn) return undefined;
-  const expireTime =
-    typeof config.expireTime === 'number' ? config.expireTime : DEFAULT_EXPIRE_TIME;
-  const merged = { ...builtIn, ...custom };
+  const config = getNextConfig()
+  const overrides = config.cacheLife as Record<string, CacheLifeProfile> | undefined
+  const custom = overrides?.[name]
+  const builtIn = builtInCacheLifeProfiles[name]
+  if (!custom && !builtIn) return undefined
+  const expireTime = typeof config.expireTime === 'number' ? config.expireTime : DEFAULT_EXPIRE_TIME
+  const merged = { ...builtIn, ...custom }
   return {
     ...merged,
     expire: merged.expire ?? expireTime,
-  };
+  }
 }
 
 export function cacheLife(
@@ -196,16 +195,16 @@ export function cacheLife(
           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;
+        }
+  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');
+  })
+  if (revalidate !== undefined) recordCacheRevalidate(revalidate)
+  if (isPrerendering() && stale === 0) throw new PostponeError('cacheLife')
 }
-export const unstable_cacheTag = cacheTag;
-export const unstable_cacheLife = cacheLife;
+export const unstable_cacheTag = cacheTag
+export const unstable_cacheLife = cacheLife

package/src/compat/next/canonical-url.ts

@@ -8,9 +8,9 @@
 // The setter is invoked from the rewrite observer: when a same-origin rewrite fires, the original URL is
 // remembered here. When nothing sets it, the hooks fall back to the request URL.
 
-import { getWorkUnit } from '../../request/context';
+import { getWorkUnit } from '../../request/context'
 
-const CANONICAL_URL_KEY = Symbol.for('pnext.compat.navigation.canonicalUrl');
+const CANONICAL_URL_KEY = Symbol.for('pnext.compat.navigation.canonicalUrl')
 
 /**
  * Record the canonical (original, as-requested) URL for the active request,
@@ -18,18 +18,18 @@ const CANONICAL_URL_KEY = Symbol.for('pnext.compat.navigation.canonicalUrl');
  * work unit. `from` is the URL the client asked for.
  */
 export function recordCanonicalUrl(from: URL): void {
-  const unit = getWorkUnit();
-  if (!unit) return;
-  const compat = (unit.compat ??= {});
+  const unit = getWorkUnit()
+  if (!unit) return
+  const compat = (unit.compat ??= {})
   // Chained rewrites (middleware → next.config) record in sequence; the
   // canonical URL is what the BROWSER asked for, so only the first wins — a
   // later record's `from` is itself a rewrite destination.
-  if (typeof compat[CANONICAL_URL_KEY] === 'string') return;
-  compat[CANONICAL_URL_KEY] = from.href;
+  if (typeof compat[CANONICAL_URL_KEY] === 'string') return
+  compat[CANONICAL_URL_KEY] = from.href
 }
 
 /** The canonical URL recorded for the active request, or undefined. */
 export function canonicalUrlHref(): string | undefined {
-  const value = getWorkUnit()?.compat?.[CANONICAL_URL_KEY];
-  return typeof value === 'string' ? value : undefined;
+  const value = getWorkUnit()?.compat?.[CANONICAL_URL_KEY]
+  return typeof value === 'string' ? value : undefined
 }