@wular/pnext 0.0.1

package/src/compat/next/cache.ts

@@ -0,0 +1,211 @@
+import {
+  bumpRevalidationEvent,
+  cachedData,
+  currentRenderCacheMeta,
+  insideDataCacheProducer,
+  insideUnstableCacheProducer,
+  markPathRevalidated,
+  markTagRevalidated,
+  markTagStale,
+  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';
+
+export function refresh() {
+  const phase = getWorkUnit()?.phase;
+  if (phase !== 'action' || insideDataCacheProducer()) {
+    throw new Error('refresh can only be called from within a Server Action');
+  }
+  bumpRevalidationEvent();
+}
+
+export const unstable_refresh = refresh;
+
+/**
+ * Revalidation is a side effect and must never run during a render or inside a cached function. At
+ * request time a render-phase call throws Next's exact error (the page shows its error UI and the
+ * message reaches the server log); during a build prerender the route simply becomes dynamic
+ * (postpone). Actions, route handlers and after() are the supported call sites and pass through.
+ */
+function assertRevalidateOutsideRender(expression: string): void {
+  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}`,
+    );
+  }
+  // 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}`);
+}
+
+export function revalidatePath(path: string, type?: 'page' | 'layout') {
+  assertRevalidateOutsideRender(`revalidatePath ${path}`);
+  markPathRevalidated(path, type);
+}
+
+export function revalidateTag(tag: string, profile?: string | CacheLifeProfile) {
+  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;
+  }
+  // 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
+  // recompute inline and observe a fresh value. Softer profiles keep SWR semantics.
+  //
+  // 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;
+  if (!resolved || resolved.expire === 0 || resolved.revalidate === 0) {
+    markTagRevalidated(tag);
+    return;
+  }
+  markTagStale(tag);
+}
+
+/** updateTag is Server-Action-only in Next (read-your-writes expiry). */
+export function updateTag(tag: string) {
+  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);
+}
+
+// Newer names for the same operations.
+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;
+
+export interface UnstableCacheOptions {
+  revalidate?: number | false;
+  tags?: string[];
+}
+
+export function unstable_cache<Args extends unknown[], Result>(
+  fn: (...args: Args) => Promise<Result>,
+  keyParts?: string[],
+  options: UnstableCacheOptions = {},
+): (...args: Args) => Promise<Result> {
+  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: Args) => {
+    // Surrounding prerender/ISR writes inherit this entry's tags and TTL.
+    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>;
+  };
+}
+
+/** Opt the surrounding render out of prebuilt static output (Next semantics). */
+export function unstable_noStore() {
+  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);
+}
+
+// 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;
+}
+
+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 },
+  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 },
+};
+
+/** 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 };
+  return {
+    ...merged,
+    expire: merged.expire ?? expireTime,
+  };
+}
+
+export function cacheLife(
+  profile: string | { revalidate?: number; stale?: number; expire?: number },
+) {
+  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');
+}
+export const unstable_cacheTag = cacheTag;
+export const unstable_cacheLife = cacheLife;

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

@@ -0,0 +1,35 @@
+// Canonical (as-requested) URL tracking for next/navigation hooks (COMPAT).
+//
+// After a config or middleware rewrite, the downstream render sees the DESTINATION URL (the rewrite
+// mutates the forwarded request's URL). But Next's usePathname()/useSearchParams() must return the
+// CANONICAL URL the browser asked for. This module stashes that original URL on the per-request work
+// unit so the SSR hooks can return it.
+//
+// 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';
+
+const CANONICAL_URL_KEY = Symbol.for('pnext.compat.navigation.canonicalUrl');
+
+/**
+ * Record the canonical (original, as-requested) URL for the active request,
+ * before a rewrite replaces it with the destination. A no-op outside a request
+ * 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 ??= {});
+  // 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;
+}
+
+/** 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;
+}

package/src/compat/next/client-cache.ts

@@ -0,0 +1,57 @@
+/**
+ * Client-bundle variant of next/cache. These APIs are server-only in Next;
+ * client references exist mostly so modules shared with server code parse.
+ * Revalidation calls throw (as in Next), unstable_cache degrades to a
+ * pass-through, and the 'use cache' companions are no-ops.
+ */
+
+function serverOnly(name: string): never {
+  throw new Error(`${name} can only be called from a Server Component or server function.`);
+}
+
+export function revalidatePath(_path: string, _type?: 'page' | 'layout') {
+  serverOnly('revalidatePath');
+}
+
+export function revalidateTag(_tag: string) {
+  serverOnly('revalidateTag');
+}
+
+export const unstable_expirePath = revalidatePath;
+export const unstable_expireTag = revalidateTag;
+export const expirePath = revalidatePath;
+export const expireTag = revalidateTag;
+export const updateTag = revalidateTag;
+
+export function refresh() {
+  serverOnly('refresh');
+}
+export const unstable_refresh = refresh;
+
+export interface UnstableCacheOptions {
+  revalidate?: number | false;
+  tags?: string[];
+}
+
+export function unstable_cache<Args extends unknown[], Result>(
+  fn: (...args: Args) => Promise<Result>,
+  _keyParts?: string[],
+  _options: UnstableCacheOptions = {},
+): (...args: Args) => Promise<Result> {
+  return fn;
+}
+
+export function unstable_noStore() {
+  return undefined;
+}
+export function io(): Promise<void> {
+  return Promise.resolve();
+}
+export function cacheTag(..._tags: string[]) {
+  return undefined;
+}
+export function cacheLife(_profile: string | Record<string, unknown>) {
+  return undefined;
+}
+export const unstable_cacheTag = cacheTag;
+export const unstable_cacheLife = cacheLife;

package/src/compat/next/client-navigation.ts

@@ -0,0 +1,313 @@
+import { useContext } from 'preact/hooks';
+import {
+  ReadonlyURLSearchParams,
+  useParams as usePNextParams,
+  usePathname,
+  useRouter as usePNextRouter,
+  useSearchParams,
+} from '../../api/client-navigation';
+import {
+  LayoutSegmentContext,
+  type LayoutSegmentSnapshot,
+  RouteParamsContext,
+} from '../../render/island-context';
+import { blockJavascriptUrl } from '../../api/router';
+import { isUnrecognizedActionError } from '../actions/unrecognized-error';
+import {
+  forbidden,
+  notFound,
+  PNextForbiddenError,
+  PNextNotFoundError,
+  PNextRedirectError,
+  PNextUnauthorizedError,
+  unauthorized,
+  type RedirectStatus,
+} from '../../api/navigation';
+
+export {
+  forbidden,
+  notFound,
+  PNextForbiddenError,
+  PNextNotFoundError,
+  PNextRedirectError,
+  PNextUnauthorizedError,
+  unauthorized,
+  ReadonlyURLSearchParams,
+  usePathname,
+  useSearchParams,
+};
+export type { RedirectStatus };
+
+export const RedirectType = {
+  push: 'push',
+  replace: 'replace',
+} as const;
+
+export type RedirectType = (typeof RedirectType)[keyof typeof RedirectType];
+
+let pendingRedirectHref: string | undefined;
+
+export function redirect(location: string, type: RedirectType = RedirectType.replace): never {
+  redirectInBrowser(location, type);
+  return undefined as never;
+}
+
+export function permanentRedirect(
+  location: string,
+  type: RedirectType = RedirectType.replace,
+): never {
+  redirectInBrowser(location, type);
+  return undefined as never;
+}
+
+function redirectInBrowser(location: string, mode: RedirectType) {
+  if (!process.browser && typeof window === 'undefined') return;
+
+  const href = new URL(location, window.location.href).href;
+  if (pendingRedirectHref === href) return;
+  pendingRedirectHref = href;
+  if (mode === RedirectType.push) window.location.assign(href);
+  else window.location.replace(href);
+}
+
+export interface NavigateOptions {
+  scroll?: boolean;
+}
+
+export interface PrefetchOptions {
+  kind?: 'auto' | 'full';
+  onInvalidate?: () => void;
+}
+
+export interface AppRouterInstance {
+  push(href: string, options?: NavigateOptions): void;
+  replace(href: string, options?: NavigateOptions): void;
+  prefetch(href: string, options?: PrefetchOptions): void;
+  refresh(): void;
+  back(): void;
+  forward(): void;
+  /**
+   * React Gesture Transitions (`experimental.gestureTransition`): commit the target route OPTIMISTICALLY
+   * while a gesture is still in flight, ahead of the canonical `push` the gesture's completion issues.
+   * pnext has no partially-committed render state, so the optimistic commit is the same soft navigation
+   * - the canonical push that follows re-renders the already current URL.
+   */
+  experimental_gesturePush(href: string, options?: NavigateOptions): void;
+  bfcacheId: string;
+}
+
+// Next's useRouter returns a stable instance across renders. The wrapper is
+// stateless (it delegates to core's singleton router), so build it once and
+// reuse it — callers rely on referential identity (deps arrays, memoization).
+let cachedRouter: AppRouterInstance | undefined;
+let refreshSuppressed = false;
+
+function suppressSameTickRefresh() {
+  refreshSuppressed = true;
+  queueMicrotask(() => {
+    refreshSuppressed = false;
+  });
+}
+
+export function useRouter(): AppRouterInstance {
+  const router = usePNextRouter();
+  const pathname = usePathname();
+  const snapshot = useContext(LayoutSegmentContext);
+  const bfcacheId = scopedBfcacheId(pathname, snapshot, router.bfcacheId);
+  cachedRouter ??= {
+    push: (href, options) => {
+      if (blockJavascriptUrl(href)) return;
+      suppressSameTickRefresh();
+      router.push(href as never, options as never);
+    },
+    replace: (href, options) => {
+      if (blockJavascriptUrl(href)) return;
+      suppressSameTickRefresh();
+      router.replace(href as never, options as never);
+    },
+    prefetch: (href, options) => {
+      if (blockJavascriptUrl(href)) return;
+      router.prefetch(href as never, options as never);
+    },
+    refresh: () => {
+      if (refreshSuppressed) return;
+      router.refresh();
+    },
+    back: () => router.back(),
+    forward: () => router.forward(),
+    experimental_gesturePush: (href, options) => {
+      if (blockJavascriptUrl(href)) return;
+      suppressSameTickRefresh();
+      // A gesture commits the target route optimistically: the address bar moves as soon as the gesture
+      // starts, ahead of the render landing. Start the navigation FIRST (its synchronous prologue reads
+      // the current location to key the departing route), as a `replace` so the entry pushed just below
+      // is the one it commits into - one new history entry, showing the target URL immediately.
+      router.replace(href as never, options as never);
+      pushOptimisticEntry(href);
+    },
+    bfcacheId: '',
+  };
+  cachedRouter.bfcacheId = bfcacheId;
+  return cachedRouter;
+}
+
+// The optimistic history entry a gesture push commits before its render lands.
+// Same-origin only; the in-flight soft navigation replaces this entry with the
+// committed one (and the patched pushState broadcasts the location change, so
+// usePathname/useSearchParams see the target route right away).
+function pushOptimisticEntry(href: string) {
+  if (!process.browser && typeof window === 'undefined') return;
+  const target = new URL(href, window.location.href);
+  if (target.origin !== window.location.origin) return;
+  if (target.href === window.location.href) return;
+  window.history.pushState(window.history.state, '', target.href);
+}
+
+export function useParams<
+  T extends Record<string, string | string[]> = Record<string, string | string[]>,
+>() {
+  // An island rendered inside a parallel-route slot is stamped with the slot's
+  // own params (route params + the slot's dynamic/catch-all captures) via
+  // RouteParamsContext — window.__PNEXT_ROUTE__.params only carries the global
+  // route params. Prefer the island-scoped snapshot when present.
+  const scoped = useContext(RouteParamsContext);
+  const params = usePNextParams();
+  return (scoped ?? params) as T;
+}
+
+interface DocumentNavState {
+  children?: string;
+  slots?: Record<string, string>;
+  /** Children rendered `default.*` (Next's `__DEFAULT__`) — no selected segment. */
+  childrenDefault?: boolean;
+}
+
+export function useSelectedLayoutSegment(parallelRoutesKey?: string): string | null {
+  const segments = clientSelectedSegments(parallelRoutesKey);
+  return segments[parallelRoutesKey ? segments.length - 1 : 0] ?? null;
+}
+
+export function useSelectedLayoutSegments(parallelRoutesKey?: string): string[] {
+  return clientSelectedSegments(parallelRoutesKey);
+}
+
+/**
+ * Client implementation of useSelectedLayoutSegment(s). A `'use client'` layout
+ * hydrates as an island with no per-layout server scope; the renderer stamps it
+ * with a LayoutSegmentContext snapshot (render/island-context.ts) carrying the
+ * layout's `depth` plus the server-resolved segments.
+ *
+ * - Server render (SSR of the island): return the resolved `segments`/`slots`
+ *   from the snapshot so the emitted HTML is byte-exact.
+ * - Client render: recompute the suffix live from the layout `depth` and the
+ *   current path. `depth` is stable for a given layout, so a shared layout's
+ *   island stays correct across soft navigations even when it is preserved and
+ *   merely re-rendered (usePathname subscribes, driving the recompute).
+ *
+ * Without a snapshot (e.g. a client PAGE island, which has no layout scope) it
+ * falls back to deriving segments from the server-embedded nav state.
+ */
+function clientSelectedSegments(parallelRoutesKey?: string): string[] {
+  usePathname();
+  const snapshot = useContext(LayoutSegmentContext);
+
+  if (!process.browser && typeof window === 'undefined') {
+    if (snapshot) {
+      return parallelRoutesKey ? (snapshot.slots[parallelRoutesKey] ?? []) : snapshot.segments;
+    }
+    return [];
+  }
+
+  const navState = documentNavState();
+  // A defaulted children slot (Next's `__DEFAULT__`) selects nothing: the URL's
+  // segments were matched by a PARALLEL slot, not by children.
+  const childrenSegments = () =>
+    navState.childrenDefault
+      ? []
+      : routePatternSegments(navState.children ?? window.location.pathname);
+
+  if (snapshot) {
+    if (parallelRoutesKey) return pathSegments(slotPath(parallelRoutesKey) ?? '');
+    return childrenSegments().slice(snapshot.depth);
+  }
+
+  if (parallelRoutesKey) return pathSegments(slotPath(parallelRoutesKey) ?? '');
+  return childrenSegments();
+}
+
+function routePatternSegments(pathname: string): string[] {
+  const pattern = window.__PNEXT_ROUTE__?.route;
+  const segments = pathSegments(pathname);
+  if (!pattern) return segments;
+  const patternSegments = pattern.split('/').filter(Boolean);
+  // Colon form: a catch-all segment is `:slug*` (both `[...slug]` and
+  // `[[...slug]]` collapse the trailing group the same way here).
+  const catchAllIndex = patternSegments.findIndex(part => /^:[\w$]+\*$/.test(part));
+  if (catchAllIndex === -1) return segments;
+  const head = segments.slice(0, catchAllIndex);
+  const tail = segments.slice(catchAllIndex);
+  return tail.length > 0 ? [...head, tail.join('/')] : head;
+}
+
+function pathSegments(pathname: string): string[] {
+  return pathname.split('/').filter(Boolean).map(decodeSegment);
+}
+
+function slotPath(parallelRoutesKey: string): string | undefined {
+  const slotName = `@${parallelRoutesKey}`;
+  for (const [dir, pathname] of Object.entries(documentNavState().slots ?? {})) {
+    const parts = dir.split(/[\\/]/);
+    if (parts[parts.length - 1] === slotName) return pathname;
+  }
+  return undefined;
+}
+
+function documentNavState(): DocumentNavState {
+  const text = document.getElementById('__PNEXT_NAV_STATE__')?.textContent;
+  if (!text) return {};
+  try {
+    return JSON.parse(text) as DocumentNavState;
+  } catch {
+    return {};
+  }
+}
+
+function decodeSegment(segment: string): string {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return segment;
+  }
+}
+
+// A layout's bfcacheId must stay stable across a sibling leaf navigation: the shared layout is
+// preserved live, so its own form/DOM state must not reset just because the leaf below it navigated.
+// The per-history-entry `baseId` changes on every path-changing push, so it cannot be part of a
+// layout's key - concatenating it would make the layout's scoped id churn on every sibling nav,
+// defeating the whole point of the scope. Instead the layout's id is derived purely from its own scope
+// (the path segments it actually owns), stable across siblings and naturally different when the
+// scope's own segment changes.
+function scopedBfcacheId(
+  pathname: string,
+  snapshot: LayoutSegmentSnapshot | null,
+  baseId: string,
+) {
+  if (!baseId) return '';
+  if (!snapshot || snapshot.depth <= 0) return baseId;
+  const segments = pathname.split('/').filter(Boolean);
+  if (!segments.length) return baseId;
+  const scope = segments.slice(0, Math.min(snapshot.depth, segments.length)).join('/');
+  return scope ? `layout:${scope}` : baseId;
+}
+
+export { useLinkStatus } from './link';
+export { useServerInsertedHTML } from '../react/server-inserted-html';
+
+/**
+ * True for the error a server-action dispatch throws when the server no longer
+ * recognizes the action id (version skew). Matches the message the pnext
+ * action endpoint sends for an unknown id.
+ */
+export function unstable_isUnrecognizedActionError(error: unknown): boolean {
+  return isUnrecognizedActionError(error);
+}

package/src/compat/next/client-only.ts

@@ -0,0 +1,3 @@
+// client-only import marker: valid in client modules (browser bundle); the
+// server bundler keeps the real package error path. Mirror of server-only.ts.
+export {};