lambder 2.0.16 → 3.0.0

package/dist/LambderContext.d.ts

@@ -1,22 +1,33 @@
-import type { APIGatewayProxyEvent, APIGatewayProxyEventHeaders, Context } from "aws-lambda";
+import type { APIGatewayProxyEvent, APIGatewayProxyEventV2, APIGatewayProxyEventHeaders, Context } from "aws-lambda";
 import type { LambderSessionContext } from "./LambderSessionManager.js";
-export type LambderRenderContext<TApiPayload = any> = {
+import type { LambderHttpEventFormat } from "./LambderResponse.js";
+export type LambderHttpEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2;
+/** True for API Gateway HTTP API / Lambda Function URL (payload v2) events. */
+export declare const isV2HttpEvent: (event: unknown) => event is APIGatewayProxyEventV2;
+export type LambderRenderContext<TApiPayload = any, TPathParams extends Record<string, string> = Record<string, string>> = {
     host: string;
     path: string;
-    pathParams: Record<string, any> | null;
+    pathParams: TPathParams;
     method: string;
-    get: Record<string, any>;
+    get: Record<string, string | undefined>;
     post: Record<string, any>;
-    cookie: Record<string, any>;
+    cookie: Record<string, string>;
     session: null;
-    apiName: string;
+    apiName: string | null;
     apiPayload: TApiPayload;
     headers: APIGatewayProxyEventHeaders;
-    event: APIGatewayProxyEvent;
+    /** Decoded request body, exactly as received (e.g. for webhook signature verification). */
+    rawBody: string;
+    /** Client IP: CF-Connecting-IP, then X-Forwarded-For, then the API Gateway source IP. */
+    ip: string;
+    /** Case-insensitive request header lookup. */
+    header: (name: string) => string | undefined;
+    event: LambderHttpEvent;
     lambdaContext: Context;
     _otherInternal: {
         isApiCall: boolean;
         requestVersion: string | null;
+        eventFormat: LambderHttpEventFormat;
         setHeaderFnAccumulator: {
             key: string;
             value: string | string[];
@@ -28,7 +39,7 @@ export type LambderRenderContext<TApiPayload = any> = {
         logToApiResponseAccumulator: any[];
     };
 };
-export type LambderSessionRenderContext<TApiPayload = any, SessionData = any> = Omit<LambderRenderContext<TApiPayload>, 'session'> & {
+export type LambderSessionRenderContext<TApiPayload = any, SessionData = any, TPathParams extends Record<string, string> = Record<string, string>> = Omit<LambderRenderContext<TApiPayload, TPathParams>, 'session'> & {
     session: LambderSessionContext<SessionData>;
 };
-export declare const createContext: (event: APIGatewayProxyEvent, lambdaContext: Context, apiPath: string) => LambderRenderContext<any>;
+export declare const createContext: (event: LambderHttpEvent, lambdaContext: Context, apiPath: string) => LambderRenderContext;

package/dist/LambderContext.js

@@ -1,21 +1,61 @@
 import cookieParser from "cookie";
+/** True for API Gateway HTTP API / Lambda Function URL (payload v2) events. */
+export const isV2HttpEvent = (event) => !!event && typeof event === "object"
+    && event.version === "2.0"
+    && !!event.requestContext?.http;
 export const createContext = (event, lambdaContext, apiPath) => {
-    const host = event.headers.Host || event.headers.host || "";
-    const path = event.path;
-    const pathParams = null;
-    const get = event.queryStringParameters || {};
-    const method = event.httpMethod;
-    const cookie = cookieParser.parse(event.headers.Cookie || event.headers.cookie || "");
-    const headers = event.headers;
-    // Decode body for the post
+    // Normalize the two API Gateway payload formats into one shape.
+    const eventFormat = isV2HttpEvent(event) ? "v2" : "v1";
+    let host;
+    let path;
+    let method;
+    let get;
+    let cookieHeader;
+    let sourceIp;
+    const headers = event.headers ?? {};
+    if (isV2HttpEvent(event)) {
+        host = headers.host || event.requestContext.domainName || "";
+        path = event.rawPath;
+        method = event.requestContext.http.method;
+        get = {};
+        for (const [key, value] of new URLSearchParams(event.rawQueryString ?? "").entries()) {
+            get[key] = value;
+        }
+        cookieHeader = (event.cookies ?? []).join("; ");
+        sourceIp = event.requestContext.http.sourceIp || "";
+    }
+    else {
+        host = headers.Host || headers.host || "";
+        path = event.path;
+        method = event.httpMethod;
+        get = event.queryStringParameters || {};
+        cookieHeader = headers.Cookie || headers.cookie || "";
+        sourceIp = event.requestContext?.identity?.sourceIp || "";
+    }
+    const cookie = cookieParser.parse(cookieHeader);
+    const lowercasedHeaders = {};
+    for (const [key, value] of Object.entries(headers)) {
+        if (value !== undefined)
+            lowercasedHeaders[key.toLowerCase()] = value;
+    }
+    const header = (name) => lowercasedHeaders[name.toLowerCase()];
+    const forwardedFor = lowercasedHeaders["x-forwarded-for"];
+    const ip = lowercasedHeaders["cf-connecting-ip"]
+        || (forwardedFor ? (forwardedFor.split(",")[0] ?? "").trim() : "")
+        || sourceIp
+        || "";
+    // Decode body: keep the raw string, then parse as JSON with urlencoded fallback.
+    let rawBody = "";
     let post = {};
     try {
-        const decodedBody = event.isBase64Encoded ? (event.body ? Buffer.from(event.body, "base64").toString() : "{}") : (event.body || "{}");
+        rawBody = event.isBase64Encoded
+            ? (event.body ? Buffer.from(event.body, "base64").toString() : "")
+            : (event.body || "");
         try {
-            post = JSON.parse(decodedBody) || {};
+            post = JSON.parse(rawBody || "{}") || {};
         }
         catch (e) {
-            const params = new URLSearchParams(decodedBody);
+            const params = new URLSearchParams(rawBody);
             post = {};
             for (const [key, value] of params.entries()) {
                 post[key] = value;
@@ -23,19 +63,19 @@ export const createContext = (event, lambdaContext, apiPath) => {
         }
     }
     catch (e) { }
-    // Parse api variables
-    const isApiCall = method === "POST" && apiPath && path === apiPath && post.apiName;
+    const isApiCall = !!(method === "POST" && apiPath && path === apiPath && post.apiName);
     const apiName = isApiCall ? post.apiName : null;
     const apiPayload = isApiCall ? post.payload : null;
-    const requestVersion = isApiCall ? post.version : null;
+    const requestVersion = isApiCall ? (post.version ?? null) : null;
     return {
-        host, path, pathParams, method,
+        host, path, pathParams: {}, method,
         get, post, cookie, event,
         session: null,
         apiName, apiPayload,
-        headers, lambdaContext,
+        headers, rawBody, ip, header,
+        lambdaContext,
         _otherInternal: {
-            isApiCall, requestVersion,
+            isApiCall, requestVersion, eventFormat,
             setHeaderFnAccumulator: [],
             addHeaderFnAccumulator: [],
             logToApiResponseAccumulator: [],

package/dist/LambderCors.d.ts

@@ -0,0 +1,12 @@
+import type { LambderRenderContext } from "./LambderContext.js";
+import type { LambderResponse } from "./LambderResponse.js";
+export type LambderCorsConfig = {
+    /** "*" (default), an allowlist, or a per-request predicate. With credentials, the origin is echoed (never "*"). */
+    origins?: "*" | string[] | ((origin: string, ctx: LambderRenderContext) => boolean);
+    credentials?: boolean;
+    methods?: string[];
+    allowHeaders?: string[];
+    maxAge?: number;
+};
+/** Mutate the response with the CORS headers the config allows for this request. */
+export declare const applyCorsHeaders: (config: LambderCorsConfig | null, ctx: LambderRenderContext, response: LambderResponse, isPreflight: boolean) => void;

package/dist/LambderCors.js

@@ -0,0 +1,30 @@
+/** Mutate the response with the CORS headers the config allows for this request. */
+export const applyCorsHeaders = (config, ctx, response, isPreflight) => {
+    if (!config)
+        return;
+    const origin = ctx.header("origin") ?? "";
+    const origins = config.origins ?? "*";
+    let allowOrigin = null;
+    if (origins === "*") {
+        allowOrigin = config.credentials ? (origin || null) : "*";
+    }
+    else if (Array.isArray(origins)) {
+        allowOrigin = origin && origins.includes(origin) ? origin : null;
+    }
+    else {
+        allowOrigin = origin && origins(origin, ctx) ? origin : null;
+    }
+    if (!allowOrigin)
+        return;
+    response.setHeader("Access-Control-Allow-Origin", allowOrigin);
+    if (allowOrigin !== "*")
+        response.addHeader("Vary", "Origin");
+    if (config.credentials)
+        response.setHeader("Access-Control-Allow-Credentials", "true");
+    if (isPreflight) {
+        response.setHeader("Access-Control-Allow-Methods", (config.methods ?? ["GET", "POST", "OPTIONS"]).join(","));
+        response.setHeader("Access-Control-Allow-Headers", (config.allowHeaders ?? ["Origin", "X-Requested-With", "Content-Type", "Accept"]).join(", "));
+        if (config.maxAge !== undefined)
+            response.setHeader("Access-Control-Max-Age", String(config.maxAge));
+    }
+};

package/dist/LambderHtml.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Type-safe templating via tagged template literals: interpolated values are
+ * HTML-escaped by default, so templates are XSS-safe and fully type-checked by
+ * TypeScript (no untyped template-locals bag like EJS).
+ *
+ * - strings/numbers are escaped
+ * - null/undefined/booleans render as "" (enables `${cond && html`...`}`)
+ * - arrays are flattened (`${items.map((i) => html`<li>${i}</li>`)}`)
+ * - nested html`...` fragments are inserted verbatim (no double escaping)
+ * - raw(value) marks a trusted string as safe; never pass user input to it
+ *
+ * The same escaping rules are valid XML, so `xml` is an alias for sitemaps etc.
+ */
+export declare class LambderSafeHtml {
+    readonly value: string;
+    constructor(value: string);
+    toString(): string;
+}
+export type LambderHtmlValue = string | number | boolean | null | undefined | LambderSafeHtml | LambderHtmlValue[];
+export declare const escapeHtml: (value: string) => string;
+/** Serialize any LambderHtmlValue to a string (escaped unless marked safe). */
+export declare const renderHtmlValue: (value: LambderHtmlValue) => string;
+export declare const html: (strings: TemplateStringsArray, ...values: LambderHtmlValue[]) => LambderSafeHtml;
+/** Alias of html for XML documents (identical, XML-valid escaping). */
+export declare const xml: (strings: TemplateStringsArray, ...values: LambderHtmlValue[]) => LambderSafeHtml;
+/** Mark a trusted string as safe (inserted without escaping). Never pass user input. */
+export declare const raw: (value: string) => LambderSafeHtml;
+/**
+ * Server-preloaded state as <script type="application/json" id="..."> so an SPA
+ * can hydrate without a first fetch. Escaped so the payload can't break out of
+ * the script element. Read with JSON.parse(document.getElementById(id).textContent).
+ */
+export declare const jsonScript: (id: string, data: unknown) => LambderSafeHtml;

package/dist/LambderHtml.js

@@ -0,0 +1,62 @@
+/**
+ * Type-safe templating via tagged template literals: interpolated values are
+ * HTML-escaped by default, so templates are XSS-safe and fully type-checked by
+ * TypeScript (no untyped template-locals bag like EJS).
+ *
+ * - strings/numbers are escaped
+ * - null/undefined/booleans render as "" (enables `${cond && html`...`}`)
+ * - arrays are flattened (`${items.map((i) => html`<li>${i}</li>`)}`)
+ * - nested html`...` fragments are inserted verbatim (no double escaping)
+ * - raw(value) marks a trusted string as safe; never pass user input to it
+ *
+ * The same escaping rules are valid XML, so `xml` is an alias for sitemaps etc.
+ */
+export class LambderSafeHtml {
+    value;
+    constructor(value) { this.value = value; }
+    toString() { return this.value; }
+}
+export const escapeHtml = (value) => value
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;")
+    .replace(/`/g, "&#96;");
+/** Serialize any LambderHtmlValue to a string (escaped unless marked safe). */
+export const renderHtmlValue = (value) => {
+    if (value === null || value === undefined || typeof value === "boolean")
+        return "";
+    if (value instanceof LambderSafeHtml)
+        return value.value;
+    if (Array.isArray(value))
+        return value.map(renderHtmlValue).join("");
+    if (typeof value === "number")
+        return String(value);
+    return escapeHtml(value);
+};
+export const html = (strings, ...values) => {
+    let out = "";
+    for (let i = 0; i < strings.length; i++) {
+        out += strings[i];
+        if (i < values.length)
+            out += renderHtmlValue(values[i]);
+    }
+    return new LambderSafeHtml(out);
+};
+/** Alias of html for XML documents (identical, XML-valid escaping). */
+export const xml = html;
+/** Mark a trusted string as safe (inserted without escaping). Never pass user input. */
+export const raw = (value) => new LambderSafeHtml(value);
+/**
+ * Server-preloaded state as <script type="application/json" id="..."> so an SPA
+ * can hydrate without a first fetch. Escaped so the payload can't break out of
+ * the script element. Read with JSON.parse(document.getElementById(id).textContent).
+ */
+export const jsonScript = (id, data) => {
+    const json = JSON.stringify(data)
+        .replace(/</g, "\\u003c")
+        .replace(/\u2028/g, "\\u2028")
+        .replace(/\u2029/g, "\\u2029");
+    return new LambderSafeHtml(`<script type="application/json" id="${escapeHtml(id)}">${json}</script>`);
+};

package/dist/LambderMSW.d.ts

@@ -1,5 +1,18 @@
 import type { ApiContractShape } from './LambderApiContract';
 type RequestHandler = any;
+/** The parts of the msw module LambderMSW uses: `import { http, HttpResponse } from "msw"`. */
+export type LambderMswModule = {
+    http: {
+        post: (path: string, resolver: (info: {
+            request: Request;
+        }) => any) => any;
+    };
+    HttpResponse: {
+        json: (body: any, init?: {
+            status?: number;
+        }) => any;
+    };
+};
 type MockApiOptions = {
     versionExpired?: boolean;
     sessionExpired?: boolean;
@@ -14,9 +27,11 @@ export default class LambderMSW<TContract extends ApiContractShape = any> {
     private apiVersion?;
     private http;
     private HttpResponse;
-    constructor({ apiPath, apiVersion, }: {
+    constructor({ apiPath, apiVersion, msw, }: {
         apiPath: string;
         apiVersion?: string;
+        /** Pass the msw module: `import * as msw from "msw"` (ESM-safe; no hidden require). */
+        msw: LambderMswModule;
     });
     /**
      * Mock an API endpoint with MSW

package/dist/LambderMSW.js

@@ -3,18 +3,14 @@ export default class LambderMSW {
     apiVersion;
     http;
     HttpResponse;
-    constructor({ apiPath, apiVersion, }) {
+    constructor({ apiPath, apiVersion, msw, }) {
         this.apiPath = apiPath;
         this.apiVersion = apiVersion;
-        // Dynamically import MSW - it needs to be installed by the user
-        try {
-            const msw = require('msw');
-            this.http = msw.http;
-            this.HttpResponse = msw.HttpResponse;
-        }
-        catch (err) {
-            throw new Error('MSW (Mock Service Worker) is required. Install it with: npm install msw --save-dev');
+        if (!msw?.http || !msw?.HttpResponse) {
+            throw new Error('LambderMSW requires the msw module: new LambderMSW({ apiPath, msw: await import("msw") }). Install it with: npm install msw --save-dev');
         }
+        this.http = msw.http;
+        this.HttpResponse = msw.HttpResponse;
     }
     /**
      * Mock an API endpoint with MSW

package/dist/LambderPublicFiles.d.ts

@@ -0,0 +1,47 @@
+import type { LambderRenderContext } from "./LambderContext.js";
+import { LambderResponse } from "./LambderResponse.js";
+export type LambderPublicFilesOptions = {
+    /**
+     * Map the request to a file path under publicPath (app-owned logic, e.g.
+     * per-tenant roots: (ctx) => `${brand(ctx.host)}${ctx.path}`). Return
+     * null/undefined to skip. Default: (ctx) => ctx.path.
+     */
+    path?: (ctx: LambderRenderContext) => string | null | undefined;
+    /** Cache-Control for served files. Default: "public, max-age=3600". */
+    cacheControl?: string | ((ctx: LambderRenderContext, filePath: string) => string);
+    /** Filenames matching this get immutableCacheControl. Default: content-hash heuristic. Set false to disable. */
+    immutablePattern?: RegExp | false;
+    /** Default: "public, max-age=31536000, immutable". */
+    immutableCacheControl?: string;
+    /** In-memory cache of files for warm invocations. Default: { maxBytes: 32MB, maxFileBytes: 2MB }. Set false to disable. */
+    memoryCache?: false | {
+        maxBytes?: number;
+        maxFileBytes?: number;
+    };
+    /**
+     * Compression per file: "auto" (default: compressible mime + size threshold),
+     * true/false, or a function, e.g. (ctx) => /\.(css|js|svg)$/.test(ctx.path).
+     */
+    compress?: boolean | "auto" | ((ctx: LambderRenderContext) => boolean | "auto");
+};
+/**
+ * Terminal public-file handler registered via lambder.servePublicFiles().
+ * Runs only when no route matched, so it can never shadow routes registered
+ * after it. Serves real files under publicPath (traversal-safe, mime-typed,
+ * memory-cached, immutable-cache heuristic for content-hashed assets) and
+ * falls through to the route fallback when the file does not exist.
+ */
+export declare class LambderPublicFilesHandler {
+    private publicPath;
+    private options;
+    private fileCache;
+    private fileCacheBytes;
+    constructor(publicPath: string, options: LambderPublicFilesOptions);
+    /** Serve the mapped file, or return null to fall through. */
+    handle(ctx: LambderRenderContext): Promise<LambderResponse | null>;
+    /** Join base+target and require the result to stay under base. */
+    private resolveSafe;
+    /** Read a file, caching small files in memory for warm invocations. */
+    private readFileCached;
+    private cacheControlFor;
+}

package/dist/LambderPublicFiles.js

@@ -0,0 +1,108 @@
+import mimeTypeResolver from "mime-types";
+import { getFS, getPath } from "./node-polyfills.js";
+import { LambderResponse } from "./LambderResponse.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]+$/;
+const DEFAULT_IMMUTABLE_CACHE_CONTROL = "public, max-age=31536000, immutable";
+const DEFAULT_CACHE_CONTROL = "public, max-age=3600";
+const DEFAULT_MEMORY_CACHE_MAX_BYTES = 32 * 1024 * 1024;
+const DEFAULT_MEMORY_CACHE_MAX_FILE_BYTES = 2 * 1024 * 1024;
+/**
+ * Terminal public-file handler registered via lambder.servePublicFiles().
+ * Runs only when no route matched, so it can never shadow routes registered
+ * after it. Serves real files under publicPath (traversal-safe, mime-typed,
+ * memory-cached, immutable-cache heuristic for content-hashed assets) and
+ * falls through to the route fallback when the file does not exist.
+ */
+export class LambderPublicFilesHandler {
+    publicPath;
+    options;
+    fileCache = new Map();
+    fileCacheBytes = 0;
+    constructor(publicPath, options) {
+        this.publicPath = publicPath;
+        this.options = options;
+    }
+    /** Serve the mapped file, or return null to fall through. */
+    async handle(ctx) {
+        const fs = await getFS();
+        const path = await getPath();
+        if (!fs || !path)
+            throw new Error("servePublicFiles requires a Node.js environment.");
+        const mappedPath = this.options.path ? this.options.path(ctx) : ctx.path;
+        if (!mappedPath)
+            return null;
+        const publicRoot = path.resolve(this.publicPath);
+        const filePath = this.resolveSafe(path, publicRoot, mappedPath);
+        if (!filePath)
+            return null;
+        const file = await this.readFileCached(fs, filePath);
+        if (!file)
+            return null;
+        const compressOption = this.options.compress;
+        const compress = typeof compressOption === "function" ? compressOption(ctx) : (compressOption ?? "auto");
+        return new LambderResponse({
+            statusCode: 200,
+            headers: {
+                "Content-Type": file.mimeType,
+                "Cache-Control": this.cacheControlFor(ctx, filePath),
+            },
+            body: file.body,
+            compress,
+        });
+    }
+    /** Join base+target and require the result to stay under base. */
+    resolveSafe(path, base, target) {
+        if (target.split("/").some((segment) => segment === ".."))
+            return null;
+        const normalizedTarget = target.startsWith("/") ? target.slice(1) : target;
+        const absolute = path.resolve(base, normalizedTarget);
+        if (absolute !== base && !absolute.startsWith(base + path.sep))
+            return null;
+        return absolute;
+    }
+    /** Read a file, caching small files in memory for warm invocations. */
+    async readFileCached(fs, filePath) {
+        const cached = this.fileCache.get(filePath);
+        if (cached)
+            return cached;
+        const stat = await fs.promises.stat(filePath).catch(() => null);
+        if (!stat?.isFile())
+            return null;
+        const body = await fs.promises.readFile(filePath);
+        const mimeType = mimeTypeResolver.lookup(filePath) || "application/octet-stream";
+        const entry = { body, mimeType };
+        const cacheConfig = this.options.memoryCache;
+        if (cacheConfig !== false) {
+            const maxBytes = cacheConfig?.maxBytes ?? DEFAULT_MEMORY_CACHE_MAX_BYTES;
+            const maxFileBytes = cacheConfig?.maxFileBytes ?? DEFAULT_MEMORY_CACHE_MAX_FILE_BYTES;
+            if (body.length <= maxFileBytes) {
+                // Evict oldest entries until the new file fits the budget.
+                for (const [key, value] of this.fileCache) {
+                    if (this.fileCacheBytes + body.length <= maxBytes)
+                        break;
+                    this.fileCache.delete(key);
+                    this.fileCacheBytes -= value.body.length;
+                }
+                if (this.fileCacheBytes + body.length <= maxBytes) {
+                    this.fileCache.set(filePath, entry);
+                    this.fileCacheBytes += body.length;
+                }
+            }
+        }
+        return entry;
+    }
+    cacheControlFor(ctx, filePath) {
+        const cacheOption = this.options.cacheControl;
+        if (typeof cacheOption === "function")
+            return cacheOption(ctx, filePath);
+        const immutablePattern = this.options.immutablePattern === false
+            ? null
+            : (this.options.immutablePattern ?? DEFAULT_IMMUTABLE_PATTERN);
+        if (immutablePattern && immutablePattern.test(filePath)) {
+            return this.options.immutableCacheControl ?? DEFAULT_IMMUTABLE_CACHE_CONTROL;
+        }
+        return cacheOption ?? DEFAULT_CACHE_CONTROL;
+    }
+}

package/dist/LambderResolver.d.ts

@@ -1,36 +1,35 @@
-import type { LambderRenderContext } from "./LambderContext.js";
-import LambderResponseBuilder, { LambderResolverResponse } from "./LambderResponseBuilder.js";
-import LambderUtils from "./LambderUtils.js";
-type MethodType<T, M extends keyof T> = T[M] extends (...args: any[]) => any ? T[M] : never;
-interface DieResolverMethods<TOutput> {
-    raw: MethodType<LambderResponseBuilder, 'raw'>;
-    json: MethodType<LambderResponseBuilder, 'json'>;
-    xml: MethodType<LambderResponseBuilder, 'xml'>;
-    html: MethodType<LambderResponseBuilder, 'html'>;
-    redirect: MethodType<LambderResponseBuilder, 'redirect'>;
-    status404: MethodType<LambderResponseBuilder, 'status404'>;
-    cors: MethodType<LambderResponseBuilder, 'cors'>;
-    fileBase64: MethodType<LambderResponseBuilder, 'fileBase64'>;
-    file: MethodType<LambderResponseBuilder, 'file'>;
-    ejsFile: MethodType<LambderResponseBuilder, 'ejsFile'>;
-    ejsTemplate: MethodType<LambderResponseBuilder, 'ejsTemplate'>;
-    api: (payload: TOutput | null, config?: Parameters<LambderResponseBuilder['api']>[1], headers?: Parameters<LambderResponseBuilder['api']>[2]) => LambderResolverResponse;
+import LambderResponseBuilder, { 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> {
+    raw: SyncDie<LambderResponseBuilder["raw"]>;
+    json: SyncDie<LambderResponseBuilder["json"]>;
+    text: SyncDie<LambderResponseBuilder["text"]>;
+    xml: SyncDie<LambderResponseBuilder["xml"]>;
+    html: SyncDie<LambderResponseBuilder["html"]>;
+    status: SyncDie<LambderResponseBuilder["status"]>;
+    status404: SyncDie<LambderResponseBuilder["status404"]>;
+    redirect: SyncDie<LambderResponseBuilder["redirect"]>;
+    versionExpired: SyncDie<LambderResponseBuilder["versionExpired"]>;
+    fileBase64: SyncDie<LambderResponseBuilder["fileBase64"]>;
+    api: (payload: TOutput | null, config?: LambderApiResponseConfig, options?: LambderResponseOptions) => never;
+    apiBinary: (payload: TOutput | null, config?: LambderApiResponseConfig, options?: LambderResponseOptions) => never;
+    file: AsyncDie<LambderResponseBuilder["file"]>;
+    templateFile: AsyncDie<LambderResponseBuilder["templateFile"]>;
 }
+/**
+ * Response builder passed to route/api handlers and hooks.
+ *
+ * `res.die.*` builds the response and THROWS it, immediately halting the
+ * request at any call depth (handlers, hooks, nested service functions).
+ * Lambder's render pipeline catches thrown LambderResponse instances and uses
+ * them as the response. Plain `throw res.html(...)` works the same way.
+ */
 export default class LambderResolver<TOutput = any> extends LambderResponseBuilder<TOutput> {
-    resolve: (response: LambderResolverResponse) => void;
-    reject: (err: Error) => void;
     die: DieResolverMethods<TOutput>;
-    constructor({ isCorsEnabled, publicPath, apiVersion, lambderUtils, ctx, resolve, reject }: {
-        isCorsEnabled: boolean;
-        publicPath: string;
-        apiVersion?: string | null;
-        lambderUtils: LambderUtils;
-        ctx: LambderRenderContext<any>;
-        resolve: (response: LambderResolverResponse) => void;
-        reject: (err: Error) => void;
-    });
-    api(payload: TOutput | null, config?: Parameters<LambderResponseBuilder['api']>[1], headers?: Parameters<LambderResponseBuilder['api']>[2]): LambderResolverResponse;
-    private autoResolve;
-    private autoResolvePromise;
+    constructor(...args: ConstructorParameters<typeof LambderResponseBuilder>);
+    api(payload: TOutput | null, config?: LambderApiResponseConfig, options?: LambderResponseOptions): LambderResponse;
+    apiBinary(payload: TOutput | null, config?: LambderApiResponseConfig, options?: LambderResponseOptions): LambderResponse;
 }
 export {};