lambder 6.0.2 → 7.0.1

package/dist/core/LambderFiles.d.ts

@@ -1,27 +1,5 @@
 import { LambderTemplatingEngine } from "./LambderTemplatingEngine.js";
-/** A file a source serves: its bytes, and its mime type when the source knows it (otherwise resolved from the extension). */
-export type LambderFile = {
-    body: Buffer;
-    mimeType?: string;
-};
-/**
- * Where an app's files come from: the `files` option at creation, read by
- * servePublicFiles, serveIndexHtml, res.file and res.templateFile alike,
- * through the instance's one reader (LambderFiles). Implement `read` over
- * any backing store: LambderLocalFileSource (a folder), LambderS3FileSource
- * (S3, or R2 and other S3-compatible stores), LambderHttpFileSource (any
- * origin serving files by path), or your own. The reader does the rest for
- * every source: traversal check, memory cache, mime fallback from the
- * extension.
- */
-export interface LambderFileSource {
-    /**
-     * The file at a relative path (no leading slash, no ".." segments: the
-     * reader rejects those before calling), or null when there is no such
-     * file, which lets a request fall through to the route fallback.
-     */
-    read(relativePath: string): Promise<LambderFile | null>;
-}
+import type { LambderFileSource } from "../shared/contracts/LambderFileSource.js";
 /** In-memory cache of files for warm invocations. Default: { maxBytes: 32MB, maxFileBytes: 2MB }. false disables it. */
 export type LambderFileMemoryCacheOption = false | {
     maxBytes?: number;
@@ -38,28 +16,6 @@ export type LambderReadFile = {
     mimeType: string;
     relativePath: string;
 };
-/**
- * Files from a folder on the Lambda's filesystem, typically the build output
- * bundled into the deployment package. Reads stay under root.
- */
-export declare class LambderLocalFileSource implements LambderFileSource {
-    private root;
-    constructor({ root }: {
-        root: string;
-    });
-    read(relativePath: string): Promise<LambderFile | null>;
-}
-/**
- * A file a remote store returned: the store's Content-Type unless it is a
- * generic octet-stream, in which case the extension decides, as for local
- * files.
- */
-export declare const remoteStoreFile: (body: Buffer, contentType: string | null | undefined) => LambderFile;
-/**
- * The path a source is asked for: leading slash stripped, traversal
- * rejected; null for a path that names no file (empty, or a directory).
- */
-export declare const toRelativePath: (target: string) => string | null;
 /**
  * The app's file reader, owned by the Lambder instance: one source, one
  * path rule, one memory cache and one compiled-template cache, shared by

package/dist/core/LambderFiles.js

@@ -1,48 +1,28 @@
 import mimeTypeResolver from "mime-types";
-import { getFS, getPath } from "../shared/node-polyfills.js";
 import { LambderTemplatingEngine } from "./LambderTemplatingEngine.js";
 const DEFAULT_MEMORY_CACHE_MAX_BYTES = 32 * 1024 * 1024;
 const DEFAULT_MEMORY_CACHE_MAX_FILE_BYTES = 2 * 1024 * 1024;
 /**
- * Files from a folder on the Lambda's filesystem, typically the build output
- * bundled into the deployment package. Reads stay under root.
+ * The path a source is asked for, or null for one that names no file.
+ *
+ * This is the whole path rule, and it belongs to the reader: every source is
+ * handed the result, and a source that resolves it against a base (a URL, a
+ * filesystem root) is safe only if the value really is the plain relative
+ * path the interface promises. Stripping only ONE leading slash would hand a
+ * source "//attacker.example/evil.html" as "/attacker.example/evil.html",
+ * which the HTTP source resolves as a protocol-relative reference: the app's
+ * origin credentials would go to a host the caller chose and its bytes would
+ * come back under the app's own domain. So every leading slash goes, and every segment is
+ * checked rather than only the ".." ones: an empty inner segment is how a
+ * host or a root gets back into the value, and a backslash is a separator to
+ * Windows paths and to every browser reading a Location.
  */
-export class LambderLocalFileSource {
-    root;
-    constructor({ root }) {
-        this.root = root;
-    }
-    async read(relativePath) {
-        const fs = await getFS();
-        const path = await getPath();
-        if (!fs || !path)
-            throw new Error("LambderLocalFileSource requires a Node.js environment.");
-        const base = path.resolve(this.root);
-        const absolute = path.resolve(base, relativePath);
-        if (absolute !== base && !absolute.startsWith(base + path.sep))
-            return null;
-        const stat = await fs.promises.stat(absolute).catch(() => null);
-        if (!stat?.isFile())
-            return null;
-        return { body: await fs.promises.readFile(absolute) };
-    }
-}
-/**
- * A file a remote store returned: the store's Content-Type unless it is a
- * generic octet-stream, in which case the extension decides, as for local
- * files.
- */
-export const remoteStoreFile = (body, contentType) => contentType && !contentType.endsWith("octet-stream") ? { body, mimeType: contentType } : { body };
-/**
- * The path a source is asked for: leading slash stripped, traversal
- * rejected; null for a path that names no file (empty, or a directory).
- */
-export const toRelativePath = (target) => {
-    if (target.split("/").some((segment) => segment === ".."))
-        return null;
-    const relative = target.startsWith("/") ? target.slice(1) : target;
+const toRelativePath = (target) => {
+    const relative = target.replace(/^\/+/, "");
     if (relative === "" || relative.endsWith("/"))
         return null;
+    if (relative.split("/").some((segment) => segment === "" || segment === "." || segment === ".." || segment.includes("\\")))
+        return null;
     return relative;
 };
 /**
@@ -99,7 +79,7 @@ export class LambderFiles {
             return cached;
         const file = await this.read(path);
         if (!file)
-            throw new Error(`templateFile: file not found in the files source: ${path}`);
+            throw new Error(`Lambder: res.templateFile found no such file in the files source: ${path}`);
         const template = new LambderTemplatingEngine(file.body.toString("utf8"), { htmlVirtualSlots: options.htmlVirtualSlots });
         this.templates.set(key, template);
         return template;

package/dist/core/LambderIndexHtml.d.ts

@@ -0,0 +1,37 @@
+import { type LambderRenderContext } from "./LambderContext.js";
+import type LambderResolver from "./LambderResolver.js";
+import type { LambderResponse } from "./LambderResponse.js";
+import type { LambderFallbackHandler } from "./LambderCreateOptions.js";
+export type LambderIndexHtmlOptions = {
+    /** Methods that reach the index handler. Default: ["GET", "HEAD"]; a list that names GET and not HEAD accepts HEAD too, as a route matcher's `method` does. */
+    methods?: string[];
+    /**
+     * Skip paths whose last segment contains a dot, treating them as missing
+     * assets rather than app routes. Default: false, because real files have already
+     * been served by servePublicFiles at this point, and plenty of app routes
+     * carry dots (JWTs, coordinates, domain names, version numbers). Turn it
+     * on to get 404s instead of a 200 shell for missing-asset requests.
+     */
+    skipFilePaths?: boolean;
+    /** 301-redirect trailing-slash paths to the canonical no-slash URL. Default: false. */
+    redirectTrailingSlash?: boolean;
+    /** Shell served by the default handler. Default: "index.html". */
+    indexFile?: string | ((ctx: LambderRenderContext) => string);
+    /** Compression override, like servePublicFiles: "auto" (default), true/false, or (ctx) => boolean | "auto". */
+    compress?: boolean | "auto" | ((ctx: LambderRenderContext) => boolean | "auto");
+};
+/**
+ * Serves the app shell for page requests that nothing else handled,
+ * registered via lambder.serveIndexHtml(). Runs after servePublicFiles in the
+ * fallback chain, so real files are already gone and everything left is an
+ * app route. A request the gates exclude (a method that is not configured, a
+ * dotted path under skipFilePaths) falls through to the route fallback.
+ */
+export declare class LambderIndexHtmlHandler {
+    private handler;
+    private options;
+    private methods;
+    constructor(handler: LambderFallbackHandler | null, options: LambderIndexHtmlOptions);
+    /** Serve the shell, or return null to fall through. */
+    handle(ctx: LambderRenderContext, resolver: LambderResolver): Promise<LambderResponse | null>;
+}

package/dist/core/LambderIndexHtml.js

@@ -0,0 +1,87 @@
+import { isV2HttpEvent } from "./LambderContext.js";
+import { allowsRequestMethod } from "./LambderRouting.js";
+/**
+ * Serves the app shell for page requests that nothing else handled,
+ * registered via lambder.serveIndexHtml(). Runs after servePublicFiles in the
+ * fallback chain, so real files are already gone and everything left is an
+ * app route. A request the gates exclude (a method that is not configured, a
+ * dotted path under skipFilePaths) falls through to the route fallback.
+ */
+export class LambderIndexHtmlHandler {
+    handler;
+    options;
+    methods;
+    constructor(handler, options) {
+        this.handler = handler;
+        this.options = options;
+        this.methods = new Set((options.methods ?? ["GET", "HEAD"]).map((method) => method.toUpperCase()));
+    }
+    /** Serve the shell, or return null to fall through. */
+    async handle(ctx, resolver) {
+        const { handler, options } = this;
+        if (!allowsRequestMethod(this.methods, ctx.method))
+            return null;
+        if ((options.skipFilePaths ?? false) && (ctx.path.split("/").pop() ?? "").includes("."))
+            return null;
+        if (options.redirectTrailingSlash && ctx.path.length > 1 && ctx.path.endsWith("/")) {
+            const target = sameOriginRedirectTarget(ctx.path);
+            if (target !== null)
+                return resolver.redirect(target + buildQueryString(ctx), 301);
+        }
+        const response = handler
+            ? await handler(ctx, resolver)
+            : await resolver.templateFile(typeof options.indexFile === "function" ? options.indexFile(ctx) : (options.indexFile ?? "index.html"), {}, { cacheControl: "no-cache" });
+        if (options.compress !== undefined) {
+            response.compress = typeof options.compress === "function" ? options.compress(ctx) : options.compress;
+        }
+        return response;
+    }
+}
+/**
+ * The canonical no-trailing-slash form of a request path, as a Location that
+ * cannot leave this origin, or null when no such form exists.
+ *
+ * `Location: //evil.example` is a protocol-relative URL, so a browser
+ * navigates to that host; every browser normalizes backslashes into slashes
+ * first, so `/\evil.example` is the same thing. This header is built from the
+ * request path, which the caller writes, so redirectTrailingSlash was an open
+ * redirect for anyone who asked for `GET //evil.example/`. The leading run of
+ * slashes and backslashes collapses to the single slash a path may have, and
+ * the result is then checked rather than assumed: the check is what the
+ * header's safety rests on, and it costs one comparison.
+ */
+const sameOriginRedirectTarget = (path) => {
+    const target = path.replace(/^[/\\]+/, "/").replace(/[/\\]+$/, "") || "/";
+    if (target.startsWith("//") || target.startsWith("/\\"))
+        return null;
+    return target;
+};
+/**
+ * Rebuild the query string from the API Gateway event for redirects.
+ *
+ * From the raw event rather than from ctx.get, which has flattened repeated
+ * keys to one value each and lost the order they arrived in; a redirect has
+ * to hand back the query it was given.
+ */
+const buildQueryString = (ctx) => {
+    if (isV2HttpEvent(ctx.event)) {
+        return ctx.event.rawQueryString ? `?${ctx.event.rawQueryString}` : "";
+    }
+    const multi = ctx.event.multiValueQueryStringParameters;
+    const single = ctx.event.queryStringParameters;
+    const params = new URLSearchParams();
+    if (multi) {
+        for (const [key, values] of Object.entries(multi)) {
+            for (const value of values ?? [])
+                params.append(key, value);
+        }
+    }
+    else if (single) {
+        for (const [key, value] of Object.entries(single)) {
+            if (value !== undefined)
+                params.append(key, value);
+        }
+    }
+    const queryString = params.toString();
+    return queryString ? `?${queryString}` : "";
+};

package/dist/core/LambderPolicyBuilders.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The server's policy builders: the generic builders from `api/`, bound to
+ * the render contexts a Lambda handler runs on.
+ *
+ * They live in `core/` rather than beside the engines because binding them is
+ * the one thing about a guard or a rate-limit key that is the SERVER's, and
+ * having them in `api/` was the last reason that layer imported from `core/`
+ * at all. The mock runtime binds the same builders to its own call contexts,
+ * in its own layer, which is why the builders themselves are generic.
+ */
+import type { LambderRenderContext, LambderSessionRenderContext } from "./LambderContext.js";
+import { type LambderGuardBuilder } from "../api/LambderApiGuards.js";
+import { type LambderRateLimitKeyBuilder } from "../api/LambderApiRateLimits.js";
+/** Builder for the server's guards: the handler sees the render context (session-typed when `session: true`). */
+export declare const lambderGuard: LambderGuardBuilder<LambderRenderContext, LambderSessionRenderContext<any, any>>;
+/** Builder for the server's rate-limit keys: the handler sees the render context. */
+export declare const lambderRateLimitKey: LambderRateLimitKeyBuilder<LambderRenderContext>;

package/dist/core/LambderPolicyBuilders.js

@@ -0,0 +1,16 @@
+/**
+ * The server's policy builders: the generic builders from `api/`, bound to
+ * the render contexts a Lambda handler runs on.
+ *
+ * They live in `core/` rather than beside the engines because binding them is
+ * the one thing about a guard or a rate-limit key that is the SERVER's, and
+ * having them in `api/` was the last reason that layer imported from `core/`
+ * at all. The mock runtime binds the same builders to its own call contexts,
+ * in its own layer, which is why the builders themselves are generic.
+ */
+import { lambderGuardBuilder } from "../api/LambderApiGuards.js";
+import { lambderRateLimitKeyBuilder } from "../api/LambderApiRateLimits.js";
+/** Builder for the server's guards: the handler sees the render context (session-typed when `session: true`). */
+export const lambderGuard = lambderGuardBuilder();
+/** Builder for the server's rate-limit keys: the handler sees the render context. */
+export const lambderRateLimitKey = lambderRateLimitKeyBuilder();

package/dist/core/LambderPublicFiles.d.ts

@@ -3,6 +3,8 @@ import type { LambderFiles } from "./LambderFiles.js";
 import { LambderResponse } from "./LambderResponse.js";
 /** Per-registration policy of servePublicFiles: how a request maps to a file and how the response is cached. */
 export type LambderPublicFilesOptions = {
+    /** Methods that reach the public-file layer. Default: ["GET", "HEAD"], the same gate and the same default its serveIndexHtml sibling has. */
+    methods?: string[];
     /**
      * Map the request to a file path (app-owned logic, e.g. per-tenant
      * roots: (ctx) => `${brand(ctx.host)}${ctx.path}`). Return
@@ -24,14 +26,15 @@ export type LambderPublicFilesOptions = {
 /**
  * Terminal public-file handler registered via lambder.servePublicFiles().
  * Runs only when no route matched, so it can never shadow routes registered
- * after it. Serves files through the instance's reader (traversal-safe,
+ * after it. Serves files through the instance's reader (one path rule,
  * mime-typed, memory-cached) with the immutable-cache heuristic for
  * content-hashed assets, and falls through to the route fallback when the
- * source has no such file.
+ * method is not configured or the source has no such file.
  */
 export declare class LambderPublicFilesHandler {
     private files;
     private options;
+    private methods;
     constructor(files: LambderFiles, options: LambderPublicFilesOptions);
     /** Serve the mapped file, or return null to fall through. */
     handle(ctx: LambderRenderContext): Promise<LambderResponse | null>;

package/dist/core/LambderPublicFiles.js

@@ -1,4 +1,5 @@
 import { LambderResponse } from "./LambderResponse.js";
+import { allowsRequestMethod } from "./LambderRouting.js";
 // Content-hashed build outputs (Vite/webpack/Rollup): a [-.] separated run of
 // 8+ hash chars containing at least one digit, before the extension.
 const DEFAULT_IMMUTABLE_PATTERN = /[-.](?=[A-Za-z0-9_-]*\d)[A-Za-z0-9_-]{8,}\.[A-Za-z0-9]+$/;
@@ -7,20 +8,24 @@ const DEFAULT_CACHE_CONTROL = "public, max-age=3600";
 /**
  * Terminal public-file handler registered via lambder.servePublicFiles().
  * Runs only when no route matched, so it can never shadow routes registered
- * after it. Serves files through the instance's reader (traversal-safe,
+ * after it. Serves files through the instance's reader (one path rule,
  * mime-typed, memory-cached) with the immutable-cache heuristic for
  * content-hashed assets, and falls through to the route fallback when the
- * source has no such file.
+ * method is not configured or the source has no such file.
  */
 export class LambderPublicFilesHandler {
     files;
     options;
+    methods;
     constructor(files, options) {
         this.files = files;
         this.options = options;
+        this.methods = new Set((options.methods ?? ["GET", "HEAD"]).map((method) => method.toUpperCase()));
     }
     /** Serve the mapped file, or return null to fall through. */
     async handle(ctx) {
+        if (!allowsRequestMethod(this.methods, ctx.method))
+            return null;
         const mappedPath = this.options.path ? this.options.path(ctx) : ctx.path;
         if (!mappedPath)
             return null;

package/dist/core/LambderResolver.d.ts

@@ -1,8 +1,10 @@
-import LambderResponseBuilder, { type LambderApiAnswer, type LambderApiResponseConfig, type LambderResponseOptions } from "./LambderResponseBuilder.js";
+import type { LambderApiNullAnswerConfig } from "../shared/wire/LambderApiContract.js";
+import LambderResponseBuilder, { type LambderResolverApiMethod, type LambderApiResponseConfig, type LambderResponseOptions } from "./LambderResponseBuilder.js";
 import type { LambderResponse } from "./LambderResponse.js";
 type SyncDie<T extends (...args: any[]) => LambderResponse> = (...args: Parameters<T>) => never;
 type AsyncDie<T extends (...args: any[]) => Promise<LambderResponse>> = (...args: Parameters<T>) => Promise<never>;
-export interface DieResolverMethods<TOutput> {
+/** The `res.die.*` surface: every builder method, throwing what it built. Internal to the resolver, which is the only thing that has one. */
+interface DieResolverMethods<TOutput> {
     raw: SyncDie<LambderResponseBuilder["raw"]>;
     json: SyncDie<LambderResponseBuilder["json"]>;
     text: SyncDie<LambderResponseBuilder["text"]>;
@@ -13,8 +15,8 @@ export interface DieResolverMethods<TOutput> {
     redirect: SyncDie<LambderResponseBuilder["redirect"]>;
     versionExpired: SyncDie<LambderResponseBuilder["versionExpired"]>;
     fileBase64: SyncDie<LambderResponseBuilder["fileBase64"]>;
-    api: LambderApiAnswer<TOutput, never>;
-    apiBinary: LambderApiAnswer<TOutput, never>;
+    api: LambderResolverApiMethod<TOutput, never>;
+    apiBinary: LambderResolverApiMethod<TOutput, never>;
     file: AsyncDie<LambderResponseBuilder["file"]>;
     templateFile: AsyncDie<LambderResponseBuilder["templateFile"]>;
 }
@@ -30,8 +32,8 @@ export default class LambderResolver<TOutput = any> extends LambderResponseBuild
     die: DieResolverMethods<TOutput>;
     constructor(...args: ConstructorParameters<typeof LambderResponseBuilder>);
     api(payload: TOutput, config?: LambderApiResponseConfig, options?: LambderResponseOptions): LambderResponse;
-    api(payload: null, config: LambderApiResponseConfig, options?: LambderResponseOptions): LambderResponse;
+    api(payload: null, config: LambderApiNullAnswerConfig, options?: LambderResponseOptions): LambderResponse;
     apiBinary(payload: TOutput, config?: LambderApiResponseConfig, options?: LambderResponseOptions): LambderResponse;
-    apiBinary(payload: null, config: LambderApiResponseConfig, options?: LambderResponseOptions): LambderResponse;
+    apiBinary(payload: null, config: LambderApiNullAnswerConfig, options?: LambderResponseOptions): LambderResponse;
 }
 export {};

package/dist/core/LambderResponse.d.ts

@@ -1,6 +1,8 @@
-import type { LambderCompressionOption, LambderCompressionSettingsBase, LambderEncoding } from "../shared/LambderCompressionOption.js";
-import type { LambderRenderContext } from "./LambderContext.js";
-export type HttpStatusCode = 100 | 101 | 200 | 201 | 202 | 203 | 204 | 206 | 300 | 301 | 302 | 303 | 304 | 307 | 308 | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 408 | 409 | 410 | 412 | 413 | 415 | 416 | 418 | 422 | 428 | 429 | 431 | 451 | 500 | 501 | 502 | 503 | 504;
+import { LAMBDER_RESPONSE_BRAND } from "../shared/util/LambderResponseBrand.js";
+import type { LambderCompressionOption, LambderCompressionSettingsBase, LambderEncoding } from "../shared/wire/LambderCompressionOption.js";
+import type { LambderRenderContext, LambderHttpEventFormat } from "./LambderContext.js";
+import type { LambderApiAnswer } from "../api/LambderApiAnswer.js";
+import type { LambderHttpStatusCode } from "../shared/wire/LambderHttpStatus.js";
 export type LambderHeadersInput = Record<string, string | string[]>;
 /**
  * Final Lambda response: v1 (REST API) uses multiValueHeaders, v2 (HTTP API /
@@ -18,10 +20,9 @@ export type LambderHttpResponse = {
     headers?: Record<string, string>;
     cookies?: string[];
 };
-export type LambderHttpEventFormat = "v1" | "v2";
-export declare const normalizeHeaders: (headers?: LambderHeadersInput) => Record<string, string[]>;
-export type LambderResponseInit = {
-    statusCode: HttpStatusCode;
+/** The constructor argument of LambderResponse; built through the resolver rather than by hand, so it is internal to this module. */
+type LambderResponseInit = {
+    statusCode: LambderHttpStatusCode;
     headers?: LambderHeadersInput;
     body?: string | Buffer | null;
     /** True when body is already a base64-encoded string (pre-encoded binary content). */
@@ -41,7 +42,8 @@ export type LambderResponseInit = {
  * the request: the thrown response becomes the response.
  */
 export declare class LambderResponse {
-    statusCode: HttpStatusCode;
+    readonly [LAMBDER_RESPONSE_BRAND]: true;
+    statusCode: LambderHttpStatusCode;
     headers: Record<string, string[]>;
     body: string | Buffer | null;
     isBodyBase64: boolean;
@@ -52,8 +54,16 @@ export declare class LambderResponse {
     setHeader(key: string, value: string | string[]): this;
     addHeader(key: string, value: string): this;
 }
-export declare const isCompressibleContentType: (contentType: string | undefined) => boolean;
-export declare const acceptsEncoding: (acceptEncoding: string | undefined | null, encoding: string) => boolean;
+/**
+ * A handler's response as a core answer: what the API pipeline stores,
+ * replays and hands back. A Buffer body travels base64-encoded and marked
+ * as such, so the idempotency engine never caches it and finalization
+ * passes it through untouched; the compress and etag flags ride along so
+ * nothing a handler asked for is lost on the way through the core.
+ */
+export declare const answerFromResponse: (response: LambderResponse) => LambderApiAnswer;
+/** A core answer as the response hooks, CORS and finalization work on. */
+export declare const responseFromAnswer: (answer: LambderApiAnswer) => LambderResponse;
 /** Response-side settings: the threshold plus what the wire can negotiate. */
 export type LambderResponseCompressionSettings = LambderCompressionSettingsBase & {
     /** Preference order; the first the client accepts wins. */
@@ -80,10 +90,18 @@ export type LambderFinalizeOptions = {
  */
 export declare const DEFAULT_RESPONSE_COMPRESSION_SETTINGS: LambderResponseCompressionSettings;
 export declare const DEFAULT_FINALIZE_OPTIONS: LambderFinalizeOptions;
+/**
+ * Emit the format-specific Lambda response shape. Exported because the
+ * last-resort crash path has to emit without finalizing (finalization may be
+ * what failed) and must still get the shape right; hand-writing it there left
+ * the v1/v2 split in four places.
+ */
+export declare const emitResponse: (format: LambderHttpEventFormat, statusCode: number, headers: Record<string, string[]>, body: string, isBase64Encoded: boolean) => LambderHttpResponse;
 /**
  * Convert an intermediate LambderResponse into the final Lambda response:
  * gzip negotiation (Accept-Encoding), ETag + If-None-Match 304, base64
  * encoding, HEAD body stripping, and Lambda payload size guard. Emits the v1
  * (REST API) or v2 (HTTP API / Function URL) response shape.
  */
-export declare const finalizeResponse: (ctx: Pick<LambderRenderContext, "method" | "headers"> | null, response: LambderResponse, options: LambderFinalizeOptions, format?: LambderHttpEventFormat) => Promise<LambderHttpResponse>;
+export declare const finalizeResponse: (ctx: Pick<LambderRenderContext, "method" | "header"> | null, response: LambderResponse, options: LambderFinalizeOptions, format?: LambderHttpEventFormat) => Promise<LambderHttpResponse>;
+export {};