vinext 1.0.1 → 1.1.0

package/dist/server/response-compression.d.ts

@@ -0,0 +1,43 @@
+import { NegotiatedEncoding } from "./accept-encoding.js";
+import { IncomingMessage } from "node:http";
+//#region src/server/response-compression.d.ts
+/**
+ * Whether a Content-Type is compressible, matching `compressible()`. This
+ * covers `text/x-component` (RSC payloads) through the `text/` rule.
+ */
+export declare function isCompressibleContentType(contentType: string | null | undefined): boolean;
+/** Whether a Cache-Control value forbids content codings (`no-transform`). */
+export declare function hasNoTransform(cacheControl: string | null | undefined): boolean;
+/** Responses whose known length is below this many bytes are sent uncompressed. */
+export declare const COMPRESS_THRESHOLD = 1024;
+export type ResponseCompressionHeaders = {
+  contentType: string | null | undefined;
+  cacheControl: string | null | undefined;
+  contentEncoding: string | null | undefined;
+  /**
+   * Body length in bytes when it is known before the headers are written (a
+   * Content-Length header, or a buffered or empty body). Undefined for
+   * streamed bodies, which are compressed regardless of size.
+   */
+  contentLength: number | undefined;
+};
+export type ResponseCompression = {
+  /** Whether the response must carry `Vary: Accept-Encoding`. */
+  varyAcceptEncoding: boolean;
+  /** The coding to apply. `identity` sends the body as is. */
+  encoding: NegotiatedEncoding;
+};
+/**
+ * Decide how to compress a response, in the middleware's order: the
+ * Content-Type filter and `Cache-Control: no-transform` skip compression
+ * without `Vary`; every other response gets `Vary: Accept-Encoding`, then is
+ * sent uncompressed when it is under the size threshold, already encoded, or
+ * a HEAD response, or when the client accepts no supported coding.
+ *
+ * Unlike the middleware, which offers only gzip and deflate, negotiation also
+ * offers zstd and br (see negotiateEncoding).
+ */
+export declare function resolveResponseCompression(req: IncomingMessage, compress: boolean, headers: ResponseCompressionHeaders): ResponseCompression;
+/** Parse a Content-Length header value the way the middleware compares it. */
+export declare function parseContentLengthHeader(value: string | null | undefined): number | undefined;
+//#endregion

package/dist/server/response-compression.js

@@ -0,0 +1,111 @@
+import { negotiateEncoding } from "./accept-encoding.js";
+//#region src/server/response-compression.ts
+/**
+* Response compression rules for the Node production server, ported from the
+* `compression` middleware that `next start` installs for every response
+* unless `compress: false` (next/dist/compiled/compression, see
+* packages/next/src/server/lib/router-server.ts).
+*/
+const EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
+const COMPRESSIBLE_TYPE_REGEXP = /^text\/|\+(?:json|text|xml)$/i;
+/**
+* mime-db entries marked `compressible: true` that COMPRESSIBLE_TYPE_REGEXP
+* does not match, taken from the mime-db bundled with Next.js's compression
+* middleware. That mime-db marks no type `compressible: false` that the
+* regexp matches, so this set plus the regexp reproduces `compressible()`.
+*/
+const MIME_DB_COMPRESSIBLE_TYPES = /* @__PURE__ */ new Set([
+	"application/dart",
+	"application/ecmascript",
+	"application/javascript",
+	"application/json",
+	"application/postscript",
+	"application/raml+yaml",
+	"application/rtf",
+	"application/tar",
+	"application/toml",
+	"application/vnd.dart",
+	"application/vnd.ms-fontobject",
+	"application/vnd.ms-opentype",
+	"application/wasm",
+	"application/x-httpd-php",
+	"application/x-javascript",
+	"application/x-ns-proxy-autoconfig",
+	"application/x-sh",
+	"application/x-tar",
+	"application/x-virtualbox-hdd",
+	"application/x-virtualbox-ova",
+	"application/x-virtualbox-ovf",
+	"application/x-virtualbox-vbox",
+	"application/x-virtualbox-vdi",
+	"application/x-virtualbox-vhd",
+	"application/x-virtualbox-vmdk",
+	"application/x-www-form-urlencoded",
+	"application/xml",
+	"application/xml-dtd",
+	"font/otf",
+	"font/ttf",
+	"image/bmp",
+	"image/vnd.adobe.photoshop",
+	"image/x-icon",
+	"image/x-ms-bmp",
+	"message/rfc822",
+	"model/gltf-binary",
+	"x-shader/x-fragment",
+	"x-shader/x-vertex"
+]);
+/**
+* Whether a Content-Type is compressible, matching `compressible()`. This
+* covers `text/x-component` (RSC payloads) through the `text/` rule.
+*/
+function isCompressibleContentType(contentType) {
+	if (!contentType) return false;
+	const match = EXTRACT_TYPE_REGEXP.exec(contentType);
+	const mime = match ? match[1].toLowerCase() : "";
+	return MIME_DB_COMPRESSIBLE_TYPES.has(mime) || COMPRESSIBLE_TYPE_REGEXP.test(mime);
+}
+const NO_TRANSFORM_REGEXP = /(?:^|,)\s*?no-transform\s*?(?:,|$)/;
+/** Whether a Cache-Control value forbids content codings (`no-transform`). */
+function hasNoTransform(cacheControl) {
+	return !!cacheControl && NO_TRANSFORM_REGEXP.test(cacheControl);
+}
+/** Responses whose known length is below this many bytes are sent uncompressed. */
+const COMPRESS_THRESHOLD = 1024;
+const NO_COMPRESSION = {
+	varyAcceptEncoding: false,
+	encoding: "identity"
+};
+/**
+* Decide how to compress a response, in the middleware's order: the
+* Content-Type filter and `Cache-Control: no-transform` skip compression
+* without `Vary`; every other response gets `Vary: Accept-Encoding`, then is
+* sent uncompressed when it is under the size threshold, already encoded, or
+* a HEAD response, or when the client accepts no supported coding.
+*
+* Unlike the middleware, which offers only gzip and deflate, negotiation also
+* offers zstd and br (see negotiateEncoding).
+*/
+function resolveResponseCompression(req, compress, headers) {
+	if (!compress) return NO_COMPRESSION;
+	if (!isCompressibleContentType(headers.contentType)) return NO_COMPRESSION;
+	if (hasNoTransform(headers.cacheControl)) return NO_COMPRESSION;
+	const identity = {
+		varyAcceptEncoding: true,
+		encoding: "identity"
+	};
+	if (headers.contentLength !== void 0 && headers.contentLength < 1024) return identity;
+	if ((headers.contentEncoding || "identity") !== "identity") return identity;
+	if (req.method === "HEAD") return identity;
+	return {
+		varyAcceptEncoding: true,
+		encoding: negotiateEncoding(req)
+	};
+}
+/** Parse a Content-Length header value the way the middleware compares it. */
+function parseContentLengthHeader(value) {
+	if (value === null || value === void 0) return void 0;
+	const length = Number(value);
+	return Number.isNaN(length) ? void 0 : length;
+}
+//#endregion
+export { COMPRESS_THRESHOLD, hasNoTransform, isCompressibleContentType, parseContentLengthHeader, resolveResponseCompression };

package/dist/server/seed-cache.js

@@ -70,8 +70,11 @@ async function seedMemoryCacheFromPrerender(serverDir, options) {
 		const expireSeconds = typeof route.expire === "number" ? route.expire : void 0;
 		const staleSeconds = typeof route.stale === "number" && route.stale >= 0 ? route.stale : void 0;
 		const tags = buildAppPageCacheTags(cachePathname, route.tags ?? []);
-		if (await seedHtml(writeAppPageEntry, prerenderDir, htmlKey, artifactPathname, trailingSlash, route.headers, revalidateSeconds, expireSeconds, staleSeconds, tags)) {
-			await seedRsc(writeAppPageEntry, prerenderDir, rscKey, artifactPathname, revalidateSeconds, expireSeconds, staleSeconds, tags);
+		const status = route.responseStatus;
+		const location = route.headers?.location;
+		const rscHeaders = status !== void 0 && location !== void 0 ? { location } : void 0;
+		if (await seedHtml(writeAppPageEntry, prerenderDir, htmlKey, artifactPathname, trailingSlash, route.headers, status, revalidateSeconds, expireSeconds, staleSeconds, tags)) {
+			await seedRsc(writeAppPageEntry, prerenderDir, rscKey, artifactPathname, rscHeaders, status, revalidateSeconds, expireSeconds, staleSeconds, tags);
 			seeded++;
 		}
 	}
@@ -107,7 +110,7 @@ function createDefaultAppPageEntryWriter() {
 * Seed the HTML cache entry for a single route.
 * Returns true if the file existed and was seeded.
 */
-async function seedHtml(writeAppPageEntry, prerenderDir, key, pathname, trailingSlash, headers, revalidateSeconds, expireSeconds, staleSeconds, tags) {
+async function seedHtml(writeAppPageEntry, prerenderDir, key, pathname, trailingSlash, headers, status, revalidateSeconds, expireSeconds, staleSeconds, tags) {
 	const relPath = getOutputPath(pathname, trailingSlash);
 	const fullPath = path.join(prerenderDir, relPath);
 	if (!fs.existsSync(fullPath)) return false;
@@ -117,7 +120,7 @@ async function seedHtml(writeAppPageEntry, prerenderDir, key, pathname, trailing
 		rscData: void 0,
 		headers,
 		postponed: void 0,
-		status: void 0
+		status
 	}, {
 		expireSeconds,
 		revalidateSeconds,
@@ -130,7 +133,7 @@ async function seedHtml(writeAppPageEntry, prerenderDir, key, pathname, trailing
 * Seed the RSC cache entry for a single route.
 * No-op if the .rsc file doesn't exist on disk.
 */
-async function seedRsc(writeAppPageEntry, prerenderDir, key, pathname, revalidateSeconds, expireSeconds, staleSeconds, tags) {
+async function seedRsc(writeAppPageEntry, prerenderDir, key, pathname, headers, status, revalidateSeconds, expireSeconds, staleSeconds, tags) {
 	const relPath = getRscOutputPath(pathname);
 	const fullPath = path.join(prerenderDir, relPath);
 	if (!fs.existsSync(fullPath)) return;
@@ -139,9 +142,9 @@ async function seedRsc(writeAppPageEntry, prerenderDir, key, pathname, revalidat
 		kind: "APP_PAGE",
 		html: "",
 		rscData: rscBuffer.buffer.slice(rscBuffer.byteOffset, rscBuffer.byteOffset + rscBuffer.byteLength),
-		headers: void 0,
+		headers,
 		postponed: void 0,
-		status: void 0
+		status
 	}, {
 		expireSeconds,
 		revalidateSeconds,

package/dist/server/socket-error-backstop.d.ts

@@ -23,6 +23,20 @@ export declare function peerDisconnectCode(err: unknown): string | undefined;
  * Exported for unit testing in isolation.
  */
 export declare function isBenignAssetImportError(err: unknown): boolean;
+/**
+ * Pure predicate: returns `true` when `err` is Node's
+ * `Readable.toWeb()` adapter enqueueing into a request body stream that was
+ * already cancelled. `pull()` calls `req.resume()`, which schedules `flow()`
+ * on `nextTick`; if the body is cancelled before that tick runs, `flow()`
+ * still emits the chunks already buffered in `req` and the adapter's
+ * `onData` throws inside the `nextTick` callback. srvx (used by
+ * `@vitejs/plugin-rsc` in dev) builds `request.body` this way, so any
+ * cancelled request body, e.g. an oversized Server Action, can crash the
+ * dev server. Node main drops that data instead (`if (wasCanceled) return;`
+ * in `onData`), so absorbing it matches upstream behaviour. Exported for
+ * unit testing in isolation.
+ */
+export declare function isCancelledRequestBodyEnqueueError(err: unknown): boolean;
 /**
  * Test-only: returns whether the backstop has been installed in this
  * process. Used by the unit test to assert idempotent install via the

package/dist/server/socket-error-backstop.js

@@ -15,9 +15,10 @@
 * `uncaughtException`, where this listener filters it.
 *
 * Filters strictly on peer-disconnect codes (ECONNRESET / EPIPE /
-* ECONNABORTED) plus benign static-asset `import()` rejections (see
-* `isBenignAssetImportError`), and synchronously re-throws everything
-* else, preserving Node's default crash semantics for genuine bugs.
+* ECONNABORTED), benign static-asset `import()` rejections (see
+* `isBenignAssetImportError`) and Node's cancelled-request-body enqueue
+* race (see `isCancelledRequestBodyEnqueueError`), and synchronously
+* re-throws everything else, preserving Node's default crash semantics for genuine bugs.
 * This is more conservative than Next.js's equivalent
 * (`router-server.ts`'s log-only handler), which silently swallows
 * every uncaught — vinext keeps real bugs surfacing.
@@ -153,6 +154,24 @@ function isBenignAssetImportError(err) {
 	return false;
 }
 /**
+* Pure predicate: returns `true` when `err` is Node's
+* `Readable.toWeb()` adapter enqueueing into a request body stream that was
+* already cancelled. `pull()` calls `req.resume()`, which schedules `flow()`
+* on `nextTick`; if the body is cancelled before that tick runs, `flow()`
+* still emits the chunks already buffered in `req` and the adapter's
+* `onData` throws inside the `nextTick` callback. srvx (used by
+* `@vitejs/plugin-rsc` in dev) builds `request.body` this way, so any
+* cancelled request body, e.g. an oversized Server Action, can crash the
+* dev server. Node main drops that data instead (`if (wasCanceled) return;`
+* in `onData`), so absorbing it matches upstream behaviour. Exported for
+* unit testing in isolation.
+*/
+function isCancelledRequestBodyEnqueueError(err) {
+	if (err === null || typeof err !== "object") return false;
+	const { code, message, stack } = err;
+	return code === "ERR_INVALID_STATE" && typeof message === "string" && message.includes("Controller is already closed") && typeof stack === "string" && /\.onData \(node:internal\/webstreams\/adapters:\d+/.test(stack);
+}
+/**
 * Test-only: returns whether the backstop has been installed in this
 * process. Used by the unit test to assert idempotent install via the
 * Symbol.for guard. Not part of the public API.
@@ -183,6 +202,10 @@ function installSocketErrorBackstop() {
 			if (debug) console.warn(`[vinext] absorbed uncaughtException ${code}`);
 			return;
 		}
+		if (isCancelledRequestBodyEnqueueError(err)) {
+			if (debug) console.warn("[vinext] absorbed uncaughtException ERR_INVALID_STATE (cancelled request body)");
+			return;
+		}
 		throw err;
 	});
 	process.on("unhandledRejection", (reason) => {
@@ -197,4 +220,4 @@ function installSocketErrorBackstop() {
 	});
 }
 //#endregion
-export { installSocketErrorBackstop, isBenignAssetImportError, isSocketErrorBackstopInstalled, peerDisconnectCode };
+export { installSocketErrorBackstop, isBenignAssetImportError, isCancelledRequestBodyEnqueueError, isSocketErrorBackstopInstalled, peerDisconnectCode };

package/dist/shims/cache-adapter-instantiate.d.ts

@@ -0,0 +1,50 @@
+//#region src/shims/cache-adapter-instantiate.d.ts
+/**
+ * Instantiate a declaratively configured cache adapter from its module's
+ * default export. The generated `virtual:vinext-cache-adapters` module calls
+ * this for both the `cache.data` and `cache.cdn` slots, so every router and
+ * runtime (Node.js dev/prod server and Cloudflare Workers) uses the same rule.
+ *
+ * Contract: the default export must be a function, and it receives one
+ * `{ env, options }` argument.
+ *
+ * - A `class` (class syntax, as Vite and every current toolchain emit it) is
+ *   invoked with `new`. It is recognised by the source text that
+ *   `Function.prototype.toString` must return for class syntax, which starts
+ *   with `class`, on a function that has [[Construct]].
+ * - Any other function is called as a factory, with plain-call semantics
+ *   (`this`, `new.target` and bound receivers are what a call gives them).
+ *   Existing factories therefore behave exactly as before, whatever their
+ *   `prototype` looks like (frozen, decorated, or inherited).
+ * - A constructor that is not class syntax (an ES5-compiled class, or a
+ *   bound or Proxy-wrapped class, whose source text is not observable) is
+ *   structurally indistinguishable from a factory without invoking it, so the
+ *   module states it explicitly by exporting a factory that constructs it:
+ *   `export default (args) => new Adapter(args)`.
+ *
+ * Classification never invokes the export, matches no error messages and
+ * never retries, so the export runs exactly once.
+ *
+ * The produced value must be an adapter (an object or a function, not a
+ * Promise) with the slot's required members; anything else throws an error
+ * naming what is wrong.
+ */
+export type CacheAdapterFactoryArgs = {
+  env: unknown;
+  options: unknown;
+};
+export type CacheAdapterSlot = "data" | "cdn";
+/**
+ * Whether `value` has a [[Construct]] internal method. A Proxy is
+ * constructible exactly when its target is; its no-op `construct` trap
+ * answers without running the export or reading any of its properties.
+ */
+export declare function isConstructor(value: unknown): boolean;
+/**
+ * Whether an export is class syntax and must be invoked with `new`. The
+ * [[Construct]] check excludes methods named `class`, whose source text
+ * also starts with that word.
+ */
+export declare function isClassExport(value: unknown): boolean;
+export declare function instantiateCacheAdapter<T>(exported: unknown, args: CacheAdapterFactoryArgs, slot: CacheAdapterSlot): T;
+//#endregion

package/dist/shims/cache-adapter-instantiate.js

@@ -0,0 +1,118 @@
+//#region src/shims/cache-adapter-instantiate.ts
+const REQUIREMENTS = {
+	data: {
+		methods: [
+			"get",
+			"set",
+			"revalidateTag"
+		],
+		booleans: [],
+		description: "A data cache adapter implements get, set and revalidateTag."
+	},
+	cdn: {
+		methods: [
+			"get",
+			"set",
+			"revalidateTag",
+			"buildResponseHeaders"
+		],
+		booleans: ["ownsBackgroundRevalidation"],
+		description: "A CDN cache adapter implements get, set, revalidateTag and buildResponseHeaders, and sets ownsBackgroundRevalidation to a boolean."
+	}
+};
+/**
+* Whether `value` has a [[Construct]] internal method. A Proxy is
+* constructible exactly when its target is; its no-op `construct` trap
+* answers without running the export or reading any of its properties.
+*/
+function isConstructor(value) {
+	if (typeof value !== "function") return false;
+	try {
+		new new Proxy(value, { construct: () => ({}) })();
+		return true;
+	} catch {
+		return false;
+	}
+}
+const CLASS_SOURCE = /^class\b/;
+/**
+* Whether an export is class syntax and must be invoked with `new`. The
+* [[Construct]] check excludes methods named `class`, whose source text
+* also starts with that word.
+*/
+function isClassExport(value) {
+	if (!isConstructor(value)) return false;
+	try {
+		return CLASS_SOURCE.test(Function.prototype.toString.call(value));
+	} catch {
+		return false;
+	}
+}
+function describeValue(value) {
+	if (value === null) return "null";
+	if (Array.isArray(value)) return "an array";
+	if (typeof value === "object") return "an object";
+	return typeof value === "undefined" ? "undefined" : `a ${typeof value}`;
+}
+const ignore = () => {};
+/**
+* Attach a no-op rejection handler with the intrinsic `Promise.prototype.then`,
+* which throws on a non-Promise before reading anything from it. Returns the
+* derived promise, which a Promise subclass's species constructor chooses.
+*/
+function handleRejection(promise) {
+	return Promise.prototype.then.call(promise, void 0, ignore);
+}
+/**
+* Whether `value` is a Promise, judged by its internal slot or this realm's
+* Promise prototype chain, never by a `then` member: adapter contracts are
+* structural and do not reserve `then`, so an adapter's own `then` method is
+* never read or invoked.
+*
+* A Promise from any realm passes the intrinsic `then`'s brand check, which
+* also attaches a no-op rejection handler, so the discarded result cannot
+* become an unhandled rejection. The derived promise that call returns is
+* handled too, since a subclass's species constructor may return a rejected
+* one.
+*
+* Known limitation: when a Promise subclass's `constructor` or
+* `Symbol.species` lookup throws, that call fails after the brand check, and
+* no handler can be attached (every way of observing a Promise goes through
+* that lookup or its `then`). Such a Promise is still rejected when it comes
+* from this realm, the one adapter modules are evaluated in; one from another
+* realm is judged by its members like any other value.
+*/
+function markHandledIfPromise(value) {
+	let derived;
+	try {
+		derived = handleRejection(value);
+	} catch {
+		try {
+			return value instanceof Promise;
+		} catch {
+			return false;
+		}
+	}
+	try {
+		handleRejection(derived);
+	} catch {}
+	return true;
+}
+function instantiateCacheAdapter(exported, args, slot) {
+	const label = `cache.${slot} adapter`;
+	const requirements = REQUIREMENTS[slot];
+	if (typeof exported !== "function") {
+		const hint = exported !== null && typeof exported === "object" ? " To use an adapter object directly, export a factory that returns it: `export default () => adapter`." : exported === void 0 ? " Check that the module has a default export." : "";
+		throw new TypeError(`${label}: the module's default export must be a factory function or a class that receives { env, options }, got ${describeValue(exported)}.${hint}`);
+	}
+	const adapter = isClassExport(exported) ? new exported(args) : exported(args);
+	const isObjectLike = adapter !== null && typeof adapter === "object" || typeof adapter === "function";
+	if (isObjectLike && markHandledIfPromise(adapter)) throw new TypeError(`${label}: the default export returned a Promise. Adapter factories must return the adapter synchronously; defer async setup to the adapter's methods.`);
+	if (!isObjectLike) throw new TypeError(`${label}: the default export must produce an adapter object, got ${describeValue(adapter)}. ${requirements.description}`);
+	const record = adapter;
+	const problems = [...requirements.methods.filter((method) => typeof record[method] !== "function").map((method) => `method ${method}`), ...requirements.booleans.filter((property) => typeof record[property] !== "boolean").map((property) => `boolean ${property}`)];
+	if (problems.length > 0) throw new TypeError(`${label}: the adapter produced by the default export is missing ${problems.join(", ")}. ${requirements.description}`);
+	return adapter;
+}
+//#endregion
+export { instantiateCacheAdapter, isClassExport, isConstructor };

package/dist/shims/cache-callable-runtime.d.ts

@@ -4,48 +4,10 @@ import { RegisterCachedFunctionOptions } from "./cache-runtime.js";
 declare const CACHE_CAPTURE_TYPE = "use-cache-captures";
 type CacheCaptureEnvelope = {
   type: typeof CACHE_CAPTURE_TYPE;
-  encrypted: string | PromiseLike<string>;
-};
-/**
- * Flight serializes a promise as its resolved value and drops its own fields.
- * Next.js params are promises that also expose their resolved fields, and the
- * cache key is built from those fields, so the payload carries each such
- * promise's fields next to the arguments and decoding assigns them back.
- */
-type EncodedCacheArguments = {
-  args: unknown[];
-  thenableObjects: EncodedThenableObject[];
-};
-/**
- * Flight writes each object once, so `promise` decodes to the same promise as
- * every other reference to it, including ones inside resolved values, and the
- * fields share references with the arguments. The fields build the cache key;
- * the resolved value can differ: the params proxy hides params named like
- * promise or React fields (`value`, `status`) from its own keys but still
- * resolves to them.
- */
-type EncodedThenableObject = {
-  fields: Record<string, unknown>;
-  promise: PromiseLike<unknown>;
+  encrypted: Promise<string>;
 };
 export declare function encryptCacheCaptures(captures: unknown[]): CacheCaptureEnvelope;
-/**
- * What to do when a read would run a getter: `reject` throws
- * `UnreplayableCacheArgumentsError`, `skip` leaves the getter unread.
- */
-type GetterHandling = "reject" | "skip";
-/**
- * Collect the own fields of every promise-augmented object in the arguments,
- * including ones inside resolved promise values. The arguments are passed to
- * Flight as they are, so Flight keeps their shared references and cycles.
- * With `getters: "reject"`, throws `UnreplayableCacheArgumentsError` when the
- * arguments hold a getter; with `"skip"`, promise fields behind a getter are
- * not recorded.
- */
-export declare function encodeCacheArguments(args: unknown[], getters?: GetterHandling): Promise<EncodedCacheArguments>;
-/** Restore the promise fields that `encodeCacheArguments` captured before Flight encoding. */
-export declare function decodeCacheArguments(value: unknown): unknown[];
 export declare function registerCachedFunction<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => Promise<TResult>, id: string, variant: string, options: RegisterCachedFunctionOptions): (...args: TArgs) => Promise<TResult>;
-/** Load and invoke one transformed cache function through its server-reference identity. */
+/** Replay the persisted payload without re-reading or re-encoding caller objects. */
 export declare function invokeCacheFunction(invocation: VinextCacheFunctionInvocation, loadServerAction: (id: string) => Promise<unknown>): Promise<void>;
 //#endregion