@thomas.f/prnext 0.1.0-alpha.1

package/compat/script-loader.cjs

@@ -0,0 +1,135 @@
+'use strict';
+
+const ReactDOM = require('react-dom');
+const registries = new WeakMap();
+const ignored = new Set(['onLoad', 'onReady', 'onError', 'children', 'dangerouslySetInnerHTML', 'strategy', 'stylesheets']);
+const attributeNames = { acceptCharset: 'accept-charset', className: 'class', htmlFor: 'for', httpEquiv: 'http-equiv', noModule: 'noModule' };
+
+function registry() {
+  let value = registries.get(document);
+  if (!value) registries.set(document, value = { scripts: new Map(), loaded: new Set(), before: null });
+  return value;
+}
+
+function setAttributes(element, props) {
+  for (const [name, value] of Object.entries(props)) {
+    if (ignored.has(name) || value === undefined) continue;
+    const attribute = attributeNames[name] || name.toLowerCase();
+    const boolean = element.tagName === 'SCRIPT' && ['async', 'defer', 'noModule'].includes(attribute);
+    if (boolean) element[attribute] = !!value;
+    else element.setAttribute(attribute, String(value));
+    // Setting then removing is significant: it overrides force-async for a
+    // dynamically created script even when async={false} is requested.
+    if (value === false || (boolean && (!value || value === 'false'))) {
+      element.setAttribute(attribute, '');
+      element.removeAttribute(attribute);
+    }
+  }
+}
+
+function insertStylesheets(stylesheets) {
+  if (ReactDOM.preinit) {
+    for (const href of stylesheets) ReactDOM.preinit(href, { as: 'style' });
+  } else {
+    for (const href of stylesheets) {
+      const link = document.createElement('link');
+      link.type = 'text/css'; link.rel = 'stylesheet'; link.href = href;
+      document.head.appendChild(link);
+    }
+  }
+}
+
+function isScriptLoaded(key) { return !!key && registry().loaded.has(key); }
+function markScriptLoaded(key) { registry().loaded.add(key); }
+
+function loadScript(props) {
+  const { src, id, onLoad = () => {}, onReady = null, onError, children = '', dangerouslySetInnerHTML,
+    strategy = 'afterInteractive', stylesheets } = props;
+  const { scripts, loaded } = registry();
+  const key = id || src;
+  if (key && loaded.has(key)) return;
+  if (scripts.has(src)) {
+    loaded.add(key);
+    scripts.get(src).then(onLoad, onError);
+    return;
+  }
+  const afterLoad = () => { if (onReady) onReady(); loaded.add(key); };
+  const element = document.createElement('script');
+  const promise = new Promise((resolve, reject) => {
+    element.addEventListener('load', function (event) {
+      resolve();
+      if (onLoad) onLoad.call(this, event);
+      afterLoad();
+    });
+    element.addEventListener('error', reject);
+  }).catch(error => { if (onError) onError(error); });
+  if (dangerouslySetInnerHTML) {
+    element.innerHTML = dangerouslySetInnerHTML.__html || '';
+    afterLoad();
+  } else if (children) {
+    element.textContent = typeof children === 'string' ? children : Array.isArray(children) ? children.join('') : '';
+    afterLoad();
+  } else if (src) {
+    element.src = src;
+    scripts.set(src, promise);
+  }
+  setAttributes(element, props);
+  if (strategy === 'worker') element.setAttribute('type', 'text/partytown');
+  element.setAttribute('data-nscript', strategy);
+  if (stylesheets) insertStylesheets(stylesheets);
+  document.body.appendChild(element);
+}
+
+function idle(callback) {
+  if (window.requestIdleCallback) window.requestIdleCallback(callback);
+  else window.setTimeout(callback, 1);
+}
+
+function loadLazyScript(props) {
+  if (document.readyState === 'complete') idle(() => loadScript(props));
+  else window.addEventListener('load', () => idle(() => loadScript(props)), { once: true });
+}
+
+function handleClientScriptLoad(props) {
+  if (props.strategy === 'lazyOnload') {
+    window.addEventListener('load', () => idle(() => loadScript(props)), { once: true });
+  } else loadScript(props);
+}
+
+function markBeforeInteractive() {
+  const { loaded } = registry();
+  for (const script of document.querySelectorAll('[data-nscript="beforeInteractive"], [data-nscript="beforePageRender"]')) {
+    loaded.add(script.id || script.getAttribute('src'));
+  }
+}
+
+function initScriptLoader(items = []) {
+  items.forEach(handleClientScriptLoad);
+  markBeforeInteractive();
+}
+
+function loadBeforeInteractive(queue = globalThis.__PRNEXT_SCRIPTS__) {
+  const state = registry();
+  if (state.before) return state.before;
+  state.before = (queue || []).reduce((previous, [src, props]) => previous.then(() => new Promise((resolve, reject) => {
+    const element = document.createElement('script');
+    if (props) setAttributes(element, props);
+    if (src) {
+      element.src = src;
+      element.onload = () => resolve();
+      element.onerror = reject;
+    } else if (props) {
+      element.innerHTML = props.children;
+      window.setTimeout(resolve, 0);
+    } else { resolve(); return; }
+    document.head.appendChild(element);
+  })), Promise.resolve()).catch(error => {
+    // As in Next, one failed blocking script stops the remaining queue but
+    // must not prevent the application itself from hydrating.
+    console.error(error);
+  });
+  return state.before;
+}
+
+module.exports = { loadScript, loadLazyScript, isScriptLoaded, markScriptLoaded, setAttributes, insertStylesheets,
+  handleClientScriptLoad, initScriptLoader, markBeforeInteractive, loadBeforeInteractive };

package/compat/script.cjs

@@ -0,0 +1,69 @@
+'use client';
+'use strict';
+
+const React = require('react');
+const ReactDOM = require('react-dom');
+const { ScriptContext } = require('./script-context.cjs');
+const { loadScript, loadLazyScript, isScriptLoaded, markScriptLoaded, handleClientScriptLoad, initScriptLoader } = require('./script-loader.cjs');
+
+function safeJSON(value) {
+  return JSON.stringify(value).replace(/[<>&\u2028\u2029]/g, character => ({
+    '<': '\\u003c', '>': '\\u003e', '&': '\\u0026', '\u2028': '\\u2028', '\u2029': '\\u2029',
+  })[character]);
+}
+
+function Script(props) {
+  const { id, src = '', onLoad = () => {}, onReady = null, onError, strategy = 'afterInteractive', stylesheets, ...attributes } = props;
+  const context = React.useContext(ScriptContext);
+  const nonce = attributes.nonce || context.nonce;
+  const readyCalled = React.useRef(false);
+  React.useEffect(() => {
+    if (!readyCalled.current) {
+      if (onReady && isScriptLoaded(id || src)) onReady();
+      readyCalled.current = true;
+    }
+  }, [onReady, id, src]);
+  const loadCalled = React.useRef(false);
+  React.useEffect(() => {
+    if (!loadCalled.current) {
+      if (strategy === 'afterInteractive') loadScript(props);
+      else if (strategy === 'lazyOnload') loadLazyScript(props);
+      loadCalled.current = true;
+    }
+  }, [props, strategy]);
+
+  if (!context.appDir && context.ssr) {
+    if (context.collect && (context.document || strategy === 'beforeInteractive' || strategy === 'worker')) {
+      context.collect({ ...props, nonce });
+    } else if (!context.collect && typeof window !== 'undefined' && (strategy === 'beforeInteractive' || strategy === 'worker')) {
+      markScriptLoaded(id || src);
+    }
+    return null;
+  }
+  if (!context.appDir && !context.ssr && typeof window !== 'undefined' && (strategy === 'beforeInteractive' || strategy === 'worker')) {
+    loadScript({ ...props, nonce });
+  }
+  if (context.appDir) {
+    if (stylesheets) for (const href of stylesheets) ReactDOM.preinit(href, { as: 'style' });
+    if (src && (strategy === 'beforeInteractive' || strategy === 'afterInteractive')) {
+      ReactDOM.preload(src, { as: 'script', nonce, crossOrigin: attributes.crossOrigin,
+        ...(attributes.integrity ? { integrity: attributes.integrity } : {}) });
+    }
+    if (strategy === 'beforeInteractive') {
+      if (!src && attributes.dangerouslySetInnerHTML) {
+        attributes.children = attributes.dangerouslySetInnerHTML.__html;
+        delete attributes.dangerouslySetInnerHTML;
+      }
+      return React.createElement('script', { nonce, dangerouslySetInnerHTML: {
+        __html: `(self.__PRNEXT_SCRIPTS__=self.__PRNEXT_SCRIPTS__||[]).push(${safeJSON([src || 0, { ...attributes, id }])})`,
+      } });
+    }
+  }
+  return null;
+}
+
+Object.defineProperty(Script, '__nextScript', { value: true });
+module.exports = Script;
+module.exports.default = Script;
+module.exports.handleClientScriptLoad = handleClientScriptLoad;
+module.exports.initScriptLoader = initScriptLoader;

package/compat/script.d.cts

@@ -0,0 +1,17 @@
+import type { JSX, ReactNode, ScriptHTMLAttributes } from 'react';
+
+export interface ScriptProps extends ScriptHTMLAttributes<HTMLScriptElement> {
+  strategy?: 'afterInteractive' | 'lazyOnload' | 'beforeInteractive' | 'worker';
+  id?: string;
+  onLoad?: (event: any) => void;
+  onReady?: () => void | null;
+  onError?: (event: any) => void;
+  children?: ReactNode;
+  stylesheets?: string[];
+}
+
+/** @deprecated Use ScriptProps instead. */
+export type Props = ScriptProps;
+export declare function handleClientScriptLoad(props: ScriptProps): void;
+export declare function initScriptLoader(scriptLoaderItems: ScriptProps[]): void;
+export default function Script(props: ScriptProps): JSX.Element | null;

package/compat/server-primitives.cjs

@@ -0,0 +1,109 @@
+'use strict';
+const { CookieStore, ResponseCookieStore } = require('./cookies.cjs');
+const { hasBasePath, addBasePath, removeBasePath } = require('./paths.cjs');
+const { localePath, withLocale } = require('./locale.cjs');
+
+function middlewareHeaders(init, headers) {
+  if (!init?.request?.headers) return;
+  if (!(init.request.headers instanceof Headers)) throw new TypeError('request.headers must be an instance of Headers');
+  const names = [];
+  for (const [name, value] of init.request.headers) {
+    headers.set(`x-middleware-request-${name}`, value);
+    names.push(name);
+  }
+  headers.set('x-middleware-override-headers', names.join(','));
+}
+
+class NextURL extends URL {
+  constructor(input, baseOrOptions, options) {
+    const base = typeof baseOrOptions === 'string' || baseOrOptions instanceof URL ? baseOrOptions : undefined;
+    const config = options || (base ? {} : baseOrOptions) || {};
+    super(input, base || config.base);
+    this._nextConfig = config.nextConfig || {};
+    this._trailingSlash = super.pathname === '/' ? !!this._nextConfig.trailingSlash : super.pathname.endsWith('/');
+    this._basePath = hasBasePath(super.pathname, this._nextConfig.basePath) ? this._nextConfig.basePath || '' : '';
+    this._locale = this._nextConfig.i18n ? localePath(removeBasePath(super.pathname, this._basePath), {...this._nextConfig.i18n,defaultLocale:this.defaultLocale}).locale : '';
+  }
+  get pathname() { return localePath(removeBasePath(super.pathname, this._basePath), this._nextConfig.i18n).pathname; }
+  set pathname(value) { super.pathname = addBasePath(withLocale(String(value).startsWith('/') ? value : `/${value}`, this._locale, this.defaultLocale), this._basePath); }
+  get defaultLocale() { return this.domainLocale?.defaultLocale || this._nextConfig.i18n?.defaultLocale; }
+  get domainLocale() { return this._nextConfig.i18n?.domains?.find(value=>value.domain.toLowerCase()===this.host.toLowerCase()); }
+  get locale() { return this._locale; }
+  set locale(value) {
+    if (!this._nextConfig.i18n?.locales.includes(value)) throw new TypeError(`Unknown locale: ${value}`);
+    const pathname=this.pathname;this._locale=value;this.pathname=pathname;
+  }
+  get basePath() { return this._basePath; }
+  set basePath(value) {
+    const pathname = this.pathname;
+    this._basePath = value.startsWith('/') ? value : `/${value}`;
+    this.pathname = pathname;
+  }
+  get trailingSlash() { return this._trailingSlash; }
+  set trailingSlash(value) { this._trailingSlash = value; }
+  get href() {
+    const url = new URL(super.href);
+    if (this._nextConfig.i18n) url.pathname=addBasePath(withLocale(this.pathname,this._locale,this.defaultLocale),this._basePath);
+    if (this._trailingSlash) { if (!url.pathname.endsWith('/')) url.pathname += '/'; }
+    else if (url.pathname !== '/') url.pathname = url.pathname.replace(/\/$/, '');
+    return url.href;
+  }
+  toString() { return this.href; }
+  toJSON() { return this.href; }
+  set href(value) {
+    super.href = value;
+    this._trailingSlash = super.pathname === '/' ? !!this._nextConfig.trailingSlash : super.pathname.endsWith('/');
+    this._basePath = hasBasePath(super.pathname, this._nextConfig.basePath) ? this._nextConfig.basePath || '' : '';
+    this._locale = this._nextConfig.i18n ? localePath(removeBasePath(super.pathname, this._basePath), {...this._nextConfig.i18n,defaultLocale:this.defaultLocale}).locale : '';
+  }
+  clone() { return new NextURL(this.href, { nextConfig: this._nextConfig }); }
+}
+
+class NextRequest extends Request {
+  constructor(input, init) {
+    super(input, init);
+    this.nextUrl = new NextURL(this.url, { nextConfig: init?.nextConfig || input?.nextUrl?._nextConfig });
+    this.cookies = new CookieStore(this.headers.get('cookie') || '', {
+      mutable: true,
+      onChange: () => this.headers.set('cookie', this.cookies.toString()),
+    });
+  }
+}
+
+class NextResponse extends Response {
+  constructor(body, init) {
+    super(body, init);
+    this.cookies = new ResponseCookieStore(this.headers);
+    const update = this.cookies._onChange;
+    this.cookies._onChange = () => {
+      update();
+      this.headers.set('x-middleware-set-cookie', this.headers.getSetCookie().join(','));
+    };
+  }
+  static json(value, init) {
+    const response = Response.json(value, init);
+    return new NextResponse(response.body, { status: response.status, statusText: response.statusText, headers: response.headers });
+  }
+  static redirect(url, init = 307) {
+    const options = typeof init === 'number' ? { status: init } : { ...init };
+    const status = options.status ?? 307;
+    if (![301, 302, 303, 307, 308].includes(status)) throw new RangeError('Invalid redirect status');
+    const headers = new Headers(options.headers);
+    headers.set('location', new URL(url).href);
+    return new NextResponse(null, { ...options, status, headers });
+  }
+  static next(init) {
+    const headers = new Headers(init?.headers);
+    headers.set('x-middleware-next', '1');
+    middlewareHeaders(init, headers);
+    return new NextResponse(null, { ...init, headers });
+  }
+  static rewrite(destination, init) {
+    const headers = new Headers(init?.headers);
+    headers.set('x-middleware-rewrite', new URL(destination).href);
+    middlewareHeaders(init, headers);
+    return new NextResponse(null, { ...init, headers });
+  }
+}
+
+module.exports = { NextRequest, NextResponse, NextURL };

package/compat/server.cjs

@@ -0,0 +1,13 @@
+'use strict';
+const { NextRequest, NextResponse, NextURL } = require('./server-primitives.cjs');
+
+async function connection() {
+  const context = require('./headers.cjs').currentRequest();
+  const { forceStaticRender, dynamicUsage } = require('./static-generation.cjs');
+  if (forceStaticRender(context)) return;
+  if (require('./data-cache.cjs').inCacheScope()) throw new Error('connection() cannot be used inside unstable_cache');
+  if (context.operation === 'static-params') throw new Error('connection() cannot be used inside generateStaticParams');
+  dynamicUsage('connection()', context);
+}
+
+module.exports = { NextRequest, NextResponse, NextURL, connection };

package/compat/server.d.cts

@@ -0,0 +1,37 @@
+import type { CookieStore } from './headers.cjs';
+export interface NextURLConfig { i18n?: import('./index.js').NextConfig['i18n']; basePath?: string; trailingSlash?: boolean; skipMiddlewareUrlNormalize?: boolean; skipProxyUrlNormalize?: boolean }
+export class NextURL extends URL { constructor(input: string | URL, options?: { base?: string | URL; nextConfig?: NextURLConfig }); constructor(input: string | URL, base: string | URL, options?: { nextConfig?: NextURLConfig }); clone(): NextURL; locale: string; readonly defaultLocale?: string; readonly domainLocale?: NonNullable<NonNullable<import('./index.js').NextConfig['i18n']>['domains']>[number]; basePath: string; trailingSlash: boolean }
+export class NextRequest extends Request { constructor(input: RequestInfo | URL, init?: RequestInit & { nextConfig?: NextURLConfig }); nextUrl: NextURL; cookies: CookieStore }
+export interface MiddlewareResponseInit extends ResponseInit { request?: { headers?: Headers } }
+export class NextResponse<Body = unknown> extends Response {
+  cookies: CookieStore;
+  static json<T>(body: T, init?: ResponseInit): NextResponse<T>;
+  static redirect(url: string | URL, init?: number | ResponseInit): NextResponse;
+  static next(init?: MiddlewareResponseInit): NextResponse;
+  static rewrite(destination: string | URL, init?: MiddlewareResponseInit): NextResponse;
+}
+export interface NextFetchEvent {
+  readonly sourcePage: string;
+  waitUntil(promise: Promise<unknown>): void;
+  passThroughOnException(): void;
+  /** @deprecated Read the handler's first argument instead. */
+  readonly request: never;
+  /** @deprecated Return a Response from the handler instead. */
+  respondWith(): never;
+}
+export type NextMiddlewareResult = NextResponse | Response | null | undefined | void;
+export type NextMiddleware = (request: NextRequest, event: NextFetchEvent) => NextMiddlewareResult | Promise<NextMiddlewareResult>;
+export type NextProxy = NextMiddleware;
+export interface MiddlewareMatcher {
+  source: string;
+  locale?: false;
+  has?: import('./index.d.ts').RouteCondition[];
+  missing?: import('./index.d.ts').RouteCondition[];
+}
+export interface MiddlewareConfig {
+  matcher?: string | Array<string | MiddlewareMatcher>;
+  runtime?: 'nodejs' | 'edge' | 'experimental-edge';
+}
+export interface ProxyConfig { matcher?: MiddlewareConfig['matcher'] }
+/** Exclude the following render from prerendering until a request is available. */
+export function connection(): Promise<void>;

package/compat/static-generation.cjs

@@ -0,0 +1,108 @@
+'use strict';
+const {sampleObject} = require('./instant-samples.cjs');
+let requestReader;
+
+function context() {
+  // Resolve the circular dependency once. Repeated CJS resolution can stat
+  // package.json on every cookies()/params access. Retain the reader function,
+  // never the result belonging to a particular visitor.
+  try { requestReader ||= require('./headers.cjs').currentRequest; return requestReader?.(); } catch { return undefined; }
+}
+
+function createStaticState(options = {}, config = {}) {
+  return { mode: options.mode || config.dynamic || 'auto', partial: options.partial === true, revalidate: config.revalidate ?? false,
+    tags: new Set(), paths: new Set(), dynamicReasons: new Set(), error: null };
+}
+
+function forceStaticRender(request) {
+  return ['render', 'route'].includes(request?.phase) && (request.cacheConfig?.dynamic === 'force-static' || request.staticState?.mode === 'force-static');
+}
+
+function dynamicUsage(reason, request = context()) {
+  if (forceStaticRender(request)) return false;
+  return staticBailout(reason, request);
+}
+
+function staticBailout(reason, request = context()) {
+  const state = request?.staticState;
+  if (!state) return true;
+  if (state.partial && state.mode === 'auto') {
+    state.dynamicReasons.add(reason);
+    if (request.metadataRendering) {
+      // Unknown fallback params alone do not make an otherwise static metadata
+      // export request-dependent. They are postponed by framework resolution.
+      if (!reason.startsWith('params for a path')) state.metadataDynamic = true;
+    } else state.contentDynamic = true;
+    throw Object.assign(new Error(`Partial prerendering postponed ${reason}`), {
+      code: 'PRNEXT_PPR_DYNAMIC', digest: 'PRNEXT_PPR_DYNAMIC', dynamicReason: reason,
+    });
+  }
+  const error = Object.assign(new Error(`Static rendering used ${reason}`), {
+    code: 'PRNEXT_DYNAMIC_SERVER_USAGE', staticMode: state.mode, dynamicReason: reason,
+  });
+  // A caught bailout must not silently turn private request data into a shared
+  // route. The render checks this state even if application code swallows it.
+  state.error ||= error;
+  throw error;
+}
+
+function trackStaticDependency({ tags = [], paths = [], revalidate, externalCache } = {}, request = context()) {
+  const state = request?.staticState;
+  if (!state) return;
+  if (externalCache) state.externalCache = true;
+  if (typeof revalidate === 'number' && Number.isFinite(revalidate) && revalidate >= 0) {
+    const seconds = Math.floor(revalidate);
+    state.revalidate = state.revalidate === false ? seconds : Math.min(state.revalidate, seconds);
+  }
+  for (const tag of tags) state.tags.add(tag);
+  for (const path of paths) state.paths.add(path);
+  if (state.tags.size > 128 || state.paths.size > 128 ||
+      Buffer.byteLength(JSON.stringify([[...state.tags], [...state.paths]])) > 48 * 1024) {
+    state.error ||= new Error('Static route cache dependencies exceed the PRNext metadata limit');
+    throw state.error;
+  }
+}
+
+function staticMetadata(request = context()) {
+  const state = request?.staticState;
+  if (!state) return undefined;
+  if (state.error) throw state.error;
+  return { revalidate: state.revalidate, tags: [...state.tags], paths: [...state.paths], ...(state.externalCache ? { externalCache: true } : {}),
+    ...(state.partial ? { dynamicReasons: [...state.dynamicReasons], metadataDynamic: !!state.metadataDynamic, contentDynamic: !!state.contentDynamic } : {}) };
+}
+
+function staticParams(values, request = context()) {
+  if (request?.instantValidation && request.instantSample) return Promise.resolve(sampleObject(request, 'params', values));
+  const unknown = request?.partialParams;
+  if (!request?.staticState || !unknown?.some(name => Object.hasOwn(values, name) || Object.values(values).some(value => JSON.stringify(value) === JSON.stringify(request.params?.[name])))) return Promise.resolve(values);
+  // Do not assimilate this thenable while constructing the tree. React or the
+  // component which actually awaits params must encounter the dynamic access,
+  // inside that component's nearest Suspense boundary.
+  return { then(resolve, reject) {
+    try { dynamicUsage('params for a path not supplied by generateStaticParams', request); resolve(values); }
+    catch (error) { if (reject) reject(error); else throw error; }
+  } };
+}
+
+function staticSearchParams(values, request = context(), clientPage = false) {
+  if (request?.instantValidation && request.instantSample) return Promise.resolve(sampleObject(request, 'searchParams', values));
+  if (forceStaticRender(request)) return Promise.resolve({});
+  if (!request?.staticState || clientPage) return Promise.resolve(values);
+  let initializing = true;
+  const proxy = new Proxy(values, {
+    get(target, property, receiver) {
+      // Promise.resolve probes `then` once while constructing the wrapper.
+      // Afterwards it is an ordinary query key and reading it is dynamic too.
+      if (typeof property === 'string' && !(initializing && property === 'then')) dynamicUsage('searchParams', request);
+      return Reflect.get(target, property, receiver);
+    },
+    has(target, property) { dynamicUsage('searchParams', request); return Reflect.has(target, property); },
+    ownKeys(target) { dynamicUsage('searchParams', request); return Reflect.ownKeys(target); },
+    getOwnPropertyDescriptor(target, property) { dynamicUsage('searchParams', request); return Reflect.getOwnPropertyDescriptor(target, property); },
+  });
+  const promise = Promise.resolve(proxy);
+  initializing = false;
+  return promise;
+}
+
+module.exports = { createStaticState, forceStaticRender, dynamicUsage, staticBailout, trackStaticDependency, staticMetadata, staticSearchParams, staticParams };

package/compat/use-cache.cjs

@@ -0,0 +1,129 @@
+'use strict';
+const { createHash } = require('node:crypto');
+const { serialize, deserialize } = require('node:v8');
+const { cachedValue, currentCacheScope, runCacheScope, optionalRequestContext, getCachePaths, validateTags } = require('./data-cache.cjs');
+const { trackStaticDependency, dynamicUsage } = require('./static-generation.cjs');
+const { defaults, validateLife } = require('./cache-life.cjs');
+const { configured, customCachedValue } = require('./cache-handlers.cjs');
+const codecSymbol = Symbol.for('prnext.cache-components-codec');
+const MAX_BYTES = 2 * 1024 * 1024;
+
+function scopeFor(name) {
+  const scope = currentCacheScope();
+  if (!scope || scope === true) throw new Error(`${name}() can only be called inside a 'use cache' function`);
+  return scope;
+}
+function cacheTag(...tags) {
+  const scope = scopeFor('cacheTag');
+  scope.tags = new Set(validateTags([...new Set([...scope.tags, ...validateTags(tags)])]));
+}
+function cacheLife(profile) {
+  const scope = scopeFor('cacheLife');
+  const value = typeof profile === 'string' ? scope.profiles[profile] : profile;
+  if (value === undefined) throw new TypeError(`Unknown cache lifetime profile: ${profile}`);
+  const valid = validateLife(value);
+  for (const [name, value] of Object.entries(valid)) {
+    scope.life[name] = scope.explicit.has(name) ? Math.min(scope.life[name], value) : value;
+    scope.explicit.add(name);
+  }
+}
+function recordCacheDependency({ tags = [], revalidate } = {}) {
+  const scope = currentCacheScope();
+  if (!scope || scope === true) return;
+  scope.tags = new Set(validateTags([...new Set([...scope.tags, ...validateTags(tags)])]));
+  if (typeof revalidate === 'number' && Number.isFinite(revalidate) && revalidate >= 0 && !scope.explicit.has('revalidate')) scope.life.revalidate = Math.min(scope.life.revalidate, revalidate);
+}
+function metadata(scope, context) { return { ...scope.life, revalidate: Math.min(scope.life.revalidate, scope.life.expire), tags: [...scope.tags], paths: getCachePaths(context), ...(scope.externalCache ? { externalCache: true } : {}) }; }
+function propagate(info, parent, context) {
+  trackStaticDependency(info, context);
+  if (!parent || parent === true) return;
+  if (info.externalCache) parent.externalCache = true;
+  for (const tag of info.tags) parent.tags.add(tag);
+  validateTags([...parent.tags]);
+  for (const name of ['stale', 'revalidate', 'expire']) if (!parent.explicit.has(name)) parent.life[name] = Math.min(parent.life[name], info[name]);
+}
+function envelope(info, value) {
+  const header = Buffer.from(JSON.stringify(info));
+  const result = Buffer.allocUnsafe(4 + header.length + value.length);
+  result.writeUInt32BE(header.length); header.copy(result, 4); value.copy(result, 4 + header.length);
+  return result;
+}
+function unpack(bytes) {
+  if (bytes.length < 4 || bytes.readUInt32BE(0) > 64 * 1024 || 4 + bytes.readUInt32BE(0) > bytes.length) throw new Error('Invalid Cache Components entry');
+  const end = 4 + bytes.readUInt32BE(0);
+  return { metadata: JSON.parse(bytes.subarray(4, end).toString()), value: bytes.subarray(end) };
+}
+function serializeData(value) {
+  const seen = new Set();
+  function validate(value) {
+    if (!value || typeof value !== 'object' || seen.has(value)) return;
+    seen.add(value);
+    if (value instanceof Date || value instanceof ArrayBuffer || ArrayBuffer.isView(value)) return;
+    if (value instanceof Map) { for (const [key, item] of value) { validate(key); validate(item); } return; }
+    if (value instanceof Set) { for (const item of value) validate(item); return; }
+    const prototype = Object.getPrototypeOf(value);
+    if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) throw new TypeError("'use cache' only supports serializable data; class instances are not supported");
+    for (const key of Object.keys(value)) validate(value[key]);
+  }
+  validate(value);
+  return serialize(value);
+}
+const plainCodec = {
+  async arguments(values) { const bytes = serializeData(values); return { key: bytes, values: deserialize(bytes) }; },
+  async render(callback) { return serializeData(await callback()); },
+  async decode(bytes) { return deserialize(bytes); },
+};
+
+async function invokeCache(id, kind, captures, args, callback, segment = '') {
+  const context = optionalRequestContext();
+  if (!context) throw new Error("'use cache' requires an active PRNext request or build render");
+  const parent = currentCacheScope();
+  if (kind === 'private' && parent && parent.kind !== 'private') throw new Error("'use cache: private' cannot be nested inside a shared cache");
+  if (kind === 'private') dynamicUsage("'use cache: private'", context);
+  const codec = globalThis[codecSymbol] || plainCodec;
+  if (segment === 'page' && kind !== 'private' && args[0]) {
+    const { searchParams: ignored, ...props } = args[0];
+    args = [props, ...args.slice(1)];
+  }
+  const encoded = await codec.arguments([captures, args], context);
+  if (segment === 'page' && kind !== 'private' && encoded.values[1][0]) encoded.values[1][0].searchParams = {
+    then(_resolve, reject) { reject(new Error("searchParams cannot be read inside 'use cache'; read them outside and pass their values as arguments")); },
+  };
+  if (encoded.key.length > MAX_BYTES) throw new Error("'use cache' arguments exceed 2 MiB");
+  const key = createHash('sha256').update(id).update(kind).update(codec === plainCodec ? ':v8:' : ':flight:').update(encoded.key).digest('hex');
+  const profiles = context.cacheLife || context.manifest?.config?.cacheLife || defaults;
+  const scope = { kind, profiles, life: { ...profiles.default }, explicit: new Set(), tags: new Set() };
+  let producedMetadata;
+  const producer = async () => runCacheScope(async () => {
+    const value = await codec.render(() => callback(...encoded.values), encoded, context);
+    producedMetadata = metadata(scope, context);
+    return envelope(producedMetadata, Buffer.from(value));
+  }, scope);
+  let bytes, handlerMetadata;
+  const custom = kind !== 'private' && !context.draftMode && Object.hasOwn(configured(context), kind);
+  if (custom) {
+    scope.externalCache = true;
+    if (context.staticState) context.staticState.externalCache = true;
+    bytes = await customCachedValue(key, kind, producer, { context, resolveMetadata: () => producedMetadata, onReadMetadata: value => { handlerMetadata = value; } });
+  } else if (kind === 'private' || context.draftMode || !process.env.PRNEXT_CACHE_URL) {
+    // Private entries are confined to this request, never persisted or shared.
+    const entries = context.privateCache ||= new Map();
+    if (!entries.has(key)) {
+      const pending = producer();
+      if (entries.size < 128) {
+        entries.set(key, pending);
+        void pending.then(bytes => {
+          const total = (context.privateCacheBytes || 0) + bytes.length;
+          if (total > 8 * 1024 * 1024) entries.delete(key); else context.privateCacheBytes = total;
+        }, () => entries.delete(key));
+      }
+      bytes = await pending;
+    } else bytes = await entries.get(key);
+  } else bytes = await cachedValue(key, producer, { context, tags: [], paths: getCachePaths(context),
+    signal: context.signal, resolveMetadata: () => producedMetadata, forceFresh: Boolean(context.staticState) });
+  const result = unpack(bytes);
+  if (handlerMetadata) Object.assign(result.metadata, handlerMetadata, { externalCache: true });
+  propagate(result.metadata, parent, context);
+  return codec.decode(result.value, encoded, context);
+}
+module.exports = { invokeCache, cacheTag, cacheLife, recordCacheDependency, codecSymbol };

package/index.mjs

@@ -0,0 +1 @@
+export { build } from './build/index.mjs';

package/native/platforms.json

@@ -0,0 +1,6 @@
+[
+  { "id": "darwin-arm64", "package": "prnext-darwin-arm64", "os": "darwin", "cpu": "arm64", "target": "aarch64-apple-darwin" },
+  { "id": "darwin-x64", "package": "prnext-darwin-x64", "os": "darwin", "cpu": "x64", "target": "x86_64-apple-darwin" },
+  { "id": "linux-arm64-gnu", "package": "prnext-linux-arm64-gnu", "os": "linux", "cpu": "arm64", "libc": "glibc", "target": "aarch64-unknown-linux-gnu" },
+  { "id": "linux-x64-gnu", "package": "prnext-linux-x64-gnu", "os": "linux", "cpu": "x64", "libc": "glibc", "target": "x86_64-unknown-linux-gnu" }
+]