lambder 5.1.2 → 6.0.1

package/dist/shared/LambderCrashDetail.d.ts

@@ -0,0 +1,48 @@
+/**
+ * A crash, described for a caller that is allowed to see it.
+ *
+ * A global error handler decides what a failed request learns about the
+ * failure. A browser gets a generic message; a trusted caller (another
+ * lambda invoking this one, a developer holding a debug cookie) can be
+ * handed the whole thing: the error's name, message and stack, its cause
+ * chain, and where it happened, so the caller can store it in its own
+ * error log and point at the right CloudWatch stream. The envelope carries
+ * it in the `crash` field beside errorMessage; LambderInvokeCaller reads it
+ * back and rebuilds an Error from it as the `cause` of the error it throws,
+ * so an error reporter that walks causes sees the callee's stack without
+ * being taught anything.
+ *
+ * Dependency-free and isomorphic: the type is part of the envelope both
+ * entries export, and describeCrash needs nothing from Node.
+ */
+export type LambderCrashCause = {
+    name: string;
+    message: string;
+    stack?: string | null;
+};
+export type LambderCrashDetail = LambderCrashCause & {
+    /** The Error `cause` chain, outermost first, a few levels deep. */
+    causeList?: LambderCrashCause[];
+    /** The failed invocation's own awsRequestId, from the render context's lambdaContext. */
+    requestId?: string | null;
+    /** The function it happened in, from the same place. */
+    functionName?: string | null;
+};
+/**
+ * Describes whatever was thrown. Pass the render context (the global error
+ * handler's second argument) so the detail names the invocation it came
+ * from; it is optional because the handler receives null when the context
+ * itself could not be built.
+ */
+export declare const describeCrash: (error: unknown, ctx?: {
+    lambdaContext?: {
+        awsRequestId?: string;
+        functionName?: string;
+    } | null;
+} | null) => LambderCrashDetail;
+/**
+ * Rebuilds an Error (with its cause chain) from a crash detail, so a caller
+ * can chain it as the `cause` of its own error and reporters that walk
+ * causes see the callee's stack as it was.
+ */
+export declare const errorFromCrashDetail: (crash: LambderCrashDetail) => Error;

package/dist/shared/LambderCrashDetail.js

@@ -0,0 +1,78 @@
+/**
+ * A crash, described for a caller that is allowed to see it.
+ *
+ * A global error handler decides what a failed request learns about the
+ * failure. A browser gets a generic message; a trusted caller (another
+ * lambda invoking this one, a developer holding a debug cookie) can be
+ * handed the whole thing: the error's name, message and stack, its cause
+ * chain, and where it happened, so the caller can store it in its own
+ * error log and point at the right CloudWatch stream. The envelope carries
+ * it in the `crash` field beside errorMessage; LambderInvokeCaller reads it
+ * back and rebuilds an Error from it as the `cause` of the error it throws,
+ * so an error reporter that walks causes sees the callee's stack without
+ * being taught anything.
+ *
+ * Dependency-free and isomorphic: the type is part of the envelope both
+ * entries export, and describeCrash needs nothing from Node.
+ */
+const MAX_NAME_CHARS = 200;
+const MAX_MESSAGE_CHARS = 2000;
+const MAX_STACK_CHARS = 8000;
+const MAX_CAUSE_DEPTH = 3;
+const clamp = (value, max) => (value.length > max ? value.slice(0, max) : value);
+const describeCause = (error) => ({
+    name: clamp(error.name || "Error", MAX_NAME_CHARS),
+    message: clamp(error.message || String(error), MAX_MESSAGE_CHARS),
+    stack: error.stack ? clamp(error.stack, MAX_STACK_CHARS) : null,
+});
+/**
+ * Describes whatever was thrown. Pass the render context (the global error
+ * handler's second argument) so the detail names the invocation it came
+ * from; it is optional because the handler receives null when the context
+ * itself could not be built.
+ */
+export const describeCrash = (error, ctx) => {
+    const where = {
+        requestId: ctx?.lambdaContext?.awsRequestId ?? null,
+        functionName: ctx?.lambdaContext?.functionName ?? null,
+    };
+    if (error instanceof Error) {
+        const causeList = [];
+        let cause = error.cause;
+        let depth = 0;
+        while (cause instanceof Error && depth < MAX_CAUSE_DEPTH) {
+            causeList.push(describeCause(cause));
+            cause = cause.cause;
+            depth += 1;
+        }
+        return { ...describeCause(error), ...(causeList.length ? { causeList } : {}), ...where };
+    }
+    if (typeof error === "string") {
+        return { name: "Error", message: clamp(error, MAX_MESSAGE_CHARS), stack: null, ...where };
+    }
+    let message;
+    try {
+        message = JSON.stringify(error) ?? String(error);
+    }
+    catch {
+        message = String(error);
+    }
+    return { name: "UnknownError", message: clamp(message, MAX_MESSAGE_CHARS), stack: null, ...where };
+};
+/**
+ * Rebuilds an Error (with its cause chain) from a crash detail, so a caller
+ * can chain it as the `cause` of its own error and reporters that walk
+ * causes see the callee's stack as it was.
+ */
+export const errorFromCrashDetail = (crash) => {
+    const build = (entry, cause) => {
+        const error = new Error(entry.message, cause ? { cause } : undefined);
+        error.name = entry.name;
+        error.stack = entry.stack ?? `${entry.name}: ${entry.message}`;
+        return error;
+    };
+    let cause;
+    for (const entry of [...(crash.causeList ?? [])].reverse())
+        cause = build(entry, cause);
+    return build(crash, cause);
+};

package/dist/shared/LambderRequestPayload.d.ts

@@ -4,10 +4,11 @@
  * When a LambderCaller call's payload clears the configured size, the caller
  * sends the payload's JSON as `payloadGz` (gzip bytes, base64) beside
  * `payloadBytes` (its UTF-8 byte length) in place of `payload`, and the
- * server restores it before anything reads the payload. Everything else in
- * the envelope (apiName, version, token, siteHost, guardInputs,
- * idempotencyKey) stays plain text, so routing, logging and request mocking
- * are unaffected.
+ * server restores it before anything reads the payload. A Node caller
+ * (LambderInvokeCaller) sends `payloadBr` instead, Brotli under the same
+ * rules; the server accepts either. Everything else in the envelope
+ * (apiName, version, token, siteHost, guardInputs, idempotencyKey) stays
+ * plain text, so routing, logging and request mocking are unaffected.
  *
  * Base64 inside the JSON envelope, rather than a binary body with
  * Content-Encoding: API Gateway hands a binary request body to Lambda
@@ -26,12 +27,23 @@
  */
 import type { LambderCompressionOption } from "./LambderCompressionOption.js";
 /** Envelope field carrying the base64 gzip of the payload's JSON. */
-export declare const COMPRESSED_PAYLOAD_FIELD = "payloadGz";
+export declare const COMPRESSED_PAYLOAD_GZ_FIELD = "payloadGz";
+/**
+ * Envelope field carrying the base64 Brotli of the payload's JSON: the same
+ * pair as payloadGz for a caller that can produce Brotli (a Node caller,
+ * LambderInvokeCaller). A request carries one of the two, never both.
+ */
+export declare const COMPRESSED_PAYLOAD_BR_FIELD = "payloadBr";
 /** Envelope field carrying the UTF-8 byte length of that JSON before compression. */
 export declare const COMPRESSED_PAYLOAD_BYTES_FIELD = "payloadBytes";
-/** The pair a compressed call sends in place of `payload`. */
-export type LambderCompressedPayload = {
-    [COMPRESSED_PAYLOAD_FIELD]: string;
+/** The pair a gzip-compressing call sends in place of `payload`. */
+export type LambderCompressedGzipPayload = {
+    [COMPRESSED_PAYLOAD_GZ_FIELD]: string;
+    [COMPRESSED_PAYLOAD_BYTES_FIELD]: number;
+};
+/** The pair a Brotli-compressing call sends in place of `payload`. */
+export type LambderCompressedBrotliPayload = {
+    [COMPRESSED_PAYLOAD_BR_FIELD]: string;
     [COMPRESSED_PAYLOAD_BYTES_FIELD]: number;
 };
 /**
@@ -51,30 +63,41 @@ export type LambderRequestCompressionOption = LambderCompressionOption<LambderRe
  */
 export declare const DEFAULT_REQUEST_COMPRESSION_SETTINGS: LambderRequestCompressionSettings;
 /**
- * Default ceiling for a restored payload. Lambda's ~6MB invoke cap already
- * bounds the compressed bytes; this bounds what they may expand to, so a
- * highly compressible body cannot exhaust the function's memory.
+ * Default ceiling for a restored payload, a request's on the server
+ * (maxRequestPayloadBytes) or an answer's on the invoke caller
+ * (maxResponsePayloadBytes). Lambda's ~6MB invoke cap already bounds the
+ * compressed bytes; this bounds what they may expand to, so a highly
+ * compressible body cannot exhaust the function's memory.
  */
-export declare const DEFAULT_MAX_REQUEST_PAYLOAD_BYTES = 20000000;
+export declare const DEFAULT_MAX_RESTORED_PAYLOAD_BYTES = 20000000;
+/**
+ * The two rules every compressed payload follows, whichever algorithm made
+ * the bytes: nothing below the threshold is compressed, and the compressed
+ * form is only ever sent when its base64 is smaller than the JSON it
+ * replaces. The threshold is measured on real UTF-8 bytes, not string
+ * length, so a payload of multi-byte text is judged by what actually goes on
+ * the wire. `compress` is the algorithm: the browser's CompressionStream for
+ * gzip, zlib for Brotli (LambderInvokeCaller); both go through here so the
+ * rules cannot drift between them.
+ */
+export declare const compressPayloadWith: <TField extends string>(json: string, minBytes: number, field: TField, compress: (bytes: Uint8Array<ArrayBuffer>) => Promise<Uint8Array>) => Promise<({ [K in TField]: string; } & {
+    [COMPRESSED_PAYLOAD_BYTES_FIELD]: number;
+}) | null>;
 /** True when this runtime can compress request payloads (browsers, and Node 18+). */
 export declare const isRequestCompressionAvailable: () => boolean;
 /**
  * Gzip one payload's JSON for sending, or null when the plain JSON should go
- * instead: below the threshold, or when compressing did not make it smaller.
- * The threshold is measured on real UTF-8 bytes, not string length, so a
- * payload of multi-byte text is judged by what actually goes on the wire.
- *
- * The second null matters for the payloads most likely to be large: a
- * base64 image gzips to nearly its own size, and base64 then inflates the
- * result past the original. Sending that would cost CPU on both ends for a
- * request that got bigger, so the compressed form is only ever sent when it
- * is smaller than the JSON it replaces.
+ * instead (see compressPayloadWith for the two rules). The second null
+ * matters for the payloads most likely to be large: a base64 image gzips to
+ * nearly its own size, and base64 then inflates the result past the
+ * original. Sending that would cost CPU on both ends for a request that got
+ * bigger, so the compressed form is only ever sent when it is smaller.
  */
-export declare const compressPayloadJson: (json: string, minBytes: number) => Promise<LambderCompressedPayload | null>;
+export declare const compressPayloadGzip: (json: string, minBytes: number) => Promise<LambderCompressedGzipPayload | null>;
 /**
  * Restores a payload the caller compressed, for request mocking
  * (LambderMSW), so a mock handler receives the same payload the server
  * would. The server does NOT use this: it decompresses through zlib, whose
  * bounded output is what makes an untrusted body safe to expand.
  */
-export declare const decompressPayloadJson: (payloadGz: string) => Promise<unknown>;
+export declare const decompressPayloadGzip: (payloadGz: string) => Promise<unknown>;

package/dist/shared/LambderRequestPayload.js

@@ -4,10 +4,11 @@
  * When a LambderCaller call's payload clears the configured size, the caller
  * sends the payload's JSON as `payloadGz` (gzip bytes, base64) beside
  * `payloadBytes` (its UTF-8 byte length) in place of `payload`, and the
- * server restores it before anything reads the payload. Everything else in
- * the envelope (apiName, version, token, siteHost, guardInputs,
- * idempotencyKey) stays plain text, so routing, logging and request mocking
- * are unaffected.
+ * server restores it before anything reads the payload. A Node caller
+ * (LambderInvokeCaller) sends `payloadBr` instead, Brotli under the same
+ * rules; the server accepts either. Everything else in the envelope
+ * (apiName, version, token, siteHost, guardInputs, idempotencyKey) stays
+ * plain text, so routing, logging and request mocking are unaffected.
  *
  * Base64 inside the JSON envelope, rather than a binary body with
  * Content-Encoding: API Gateway hands a binary request body to Lambda
@@ -25,7 +26,13 @@
  * body fails instead of expanding without limit.
  */
 /** Envelope field carrying the base64 gzip of the payload's JSON. */
-export const COMPRESSED_PAYLOAD_FIELD = "payloadGz";
+export const COMPRESSED_PAYLOAD_GZ_FIELD = "payloadGz";
+/**
+ * Envelope field carrying the base64 Brotli of the payload's JSON: the same
+ * pair as payloadGz for a caller that can produce Brotli (a Node caller,
+ * LambderInvokeCaller). A request carries one of the two, never both.
+ */
+export const COMPRESSED_PAYLOAD_BR_FIELD = "payloadBr";
 /** Envelope field carrying the UTF-8 byte length of that JSON before compression. */
 export const COMPRESSED_PAYLOAD_BYTES_FIELD = "payloadBytes";
 /**
@@ -37,13 +44,17 @@ export const COMPRESSED_PAYLOAD_BYTES_FIELD = "payloadBytes";
  */
 export const DEFAULT_REQUEST_COMPRESSION_SETTINGS = { minBytes: 4096 };
 /**
- * Default ceiling for a restored payload. Lambda's ~6MB invoke cap already
- * bounds the compressed bytes; this bounds what they may expand to, so a
- * highly compressible body cannot exhaust the function's memory.
+ * Default ceiling for a restored payload, a request's on the server
+ * (maxRequestPayloadBytes) or an answer's on the invoke caller
+ * (maxResponsePayloadBytes). Lambda's ~6MB invoke cap already bounds the
+ * compressed bytes; this bounds what they may expand to, so a highly
+ * compressible body cannot exhaust the function's memory.
  */
-export const DEFAULT_MAX_REQUEST_PAYLOAD_BYTES = 20_000_000;
-/** Chunked so a large payload cannot overflow the argument list of String.fromCharCode. */
+export const DEFAULT_MAX_RESTORED_PAYLOAD_BYTES = 20_000_000;
+/** Buffer where there is one (Node); otherwise chunked so a large payload cannot overflow the argument list of String.fromCharCode. */
 const bytesToBase64 = (bytes) => {
+    if (typeof Buffer !== "undefined")
+        return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64");
     const chunkSize = 0x8000;
     let binary = "";
     for (let i = 0; i < bytes.length; i += chunkSize) {
@@ -51,41 +62,46 @@ const bytesToBase64 = (bytes) => {
     }
     return btoa(binary);
 };
-/** True when this runtime can compress request payloads (browsers, and Node 18+). */
-export const isRequestCompressionAvailable = () => typeof CompressionStream !== "undefined" && typeof btoa !== "undefined";
 /**
- * Gzip one payload's JSON for sending, or null when the plain JSON should go
- * instead: below the threshold, or when compressing did not make it smaller.
- * The threshold is measured on real UTF-8 bytes, not string length, so a
- * payload of multi-byte text is judged by what actually goes on the wire.
- *
- * The second null matters for the payloads most likely to be large: a
- * base64 image gzips to nearly its own size, and base64 then inflates the
- * result past the original. Sending that would cost CPU on both ends for a
- * request that got bigger, so the compressed form is only ever sent when it
- * is smaller than the JSON it replaces.
+ * The two rules every compressed payload follows, whichever algorithm made
+ * the bytes: nothing below the threshold is compressed, and the compressed
+ * form is only ever sent when its base64 is smaller than the JSON it
+ * replaces. The threshold is measured on real UTF-8 bytes, not string
+ * length, so a payload of multi-byte text is judged by what actually goes on
+ * the wire. `compress` is the algorithm: the browser's CompressionStream for
+ * gzip, zlib for Brotli (LambderInvokeCaller); both go through here so the
+ * rules cannot drift between them.
  */
-export const compressPayloadJson = async (json, minBytes) => {
+export const compressPayloadWith = async (json, minBytes, field, compress) => {
     const encoded = new TextEncoder().encode(json);
     if (encoded.length < minBytes)
         return null;
-    const stream = new Blob([encoded]).stream().pipeThrough(new CompressionStream("gzip"));
-    const compressed = new Uint8Array(await new Response(stream).arrayBuffer());
-    const base64 = bytesToBase64(compressed);
+    const base64 = bytesToBase64(await compress(encoded));
     if (base64.length >= encoded.length)
         return null;
-    return {
-        [COMPRESSED_PAYLOAD_FIELD]: base64,
-        [COMPRESSED_PAYLOAD_BYTES_FIELD]: encoded.length,
-    };
+    return { [field]: base64, [COMPRESSED_PAYLOAD_BYTES_FIELD]: encoded.length };
 };
+/** True when this runtime can compress request payloads (browsers, and Node 18+). */
+export const isRequestCompressionAvailable = () => typeof CompressionStream !== "undefined" && typeof btoa !== "undefined";
+/**
+ * Gzip one payload's JSON for sending, or null when the plain JSON should go
+ * instead (see compressPayloadWith for the two rules). The second null
+ * matters for the payloads most likely to be large: a base64 image gzips to
+ * nearly its own size, and base64 then inflates the result past the
+ * original. Sending that would cost CPU on both ends for a request that got
+ * bigger, so the compressed form is only ever sent when it is smaller.
+ */
+export const compressPayloadGzip = (json, minBytes) => compressPayloadWith(json, minBytes, COMPRESSED_PAYLOAD_GZ_FIELD, async (bytes) => {
+    const stream = new Blob([bytes]).stream().pipeThrough(new CompressionStream("gzip"));
+    return new Uint8Array(await new Response(stream).arrayBuffer());
+});
 /**
  * Restores a payload the caller compressed, for request mocking
  * (LambderMSW), so a mock handler receives the same payload the server
  * would. The server does NOT use this: it decompresses through zlib, whose
  * bounded output is what makes an untrusted body safe to expand.
  */
-export const decompressPayloadJson = async (payloadGz) => {
+export const decompressPayloadGzip = async (payloadGz) => {
     const binary = atob(payloadGz);
     const bytes = new Uint8Array(binary.length);
     for (let i = 0; i < binary.length; i += 1) {

package/dist/stores/LambderDdbCache.d.ts

@@ -1,4 +1,4 @@
-import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import type { DynamoDBClient } from "@aws-sdk/client-dynamodb";
 import { type LambderCompressionOption } from "../shared/LambderCompressionOption.js";
 export interface LambderDdbCacheOptions {
     tableName: string;
@@ -72,7 +72,10 @@ export declare class LambderDdbCache {
     readonly tableName: string;
     readonly keyPrefix: string;
     readonly namespace: string;
-    private readonly client;
+    /** The client given at creation, or one created from `region` on first use; the SDK arrives with it. */
+    private readonly providedClient;
+    private readonly region;
+    private readyPromise;
     private readonly defaultTtlSeconds;
     private readonly chunkBytes;
     private readonly compression;
@@ -80,6 +83,8 @@ export declare class LambderDdbCache {
     private readonly memory;
     private readonly inFlight;
     constructor(options: LambderDdbCacheOptions);
+    /** The SDK and the client, loaded and created the first time the table is touched (see LambderDdbSdk). */
+    private ready;
     get<T>(key: LambderCacheKey): Promise<T | undefined>;
     private getByAddress;
     has(key: LambderCacheKey): Promise<boolean>;

package/dist/stores/LambderDdbCache.js

@@ -1,6 +1,6 @@
-import { BatchWriteItemCommand, DeleteItemCommand, DynamoDBClient, GetItemCommand, PutItemCommand, QueryCommand, } from "@aws-sdk/client-dynamodb";
+import { loadDynamoClientSdk } from "./LambderDdbSdk.js";
 import { getCrypto } from "../shared/node-polyfills.js";
-import { compressText, restoreBoundedText } from "../shared/LambderCompressionCodec.js";
+import { compressText, restoreText } from "../shared/LambderCompressionCodec.js";
 import { resolveCompressionOption, } from "../shared/LambderCompressionOption.js";
 import { LRUCache } from "lru-cache";
 const DEFAULT_TTL_SECONDS = 365 * 24 * 60 * 60;
@@ -84,7 +84,10 @@ export class LambderDdbCache {
     tableName;
     keyPrefix;
     namespace;
-    client;
+    /** The client given at creation, or one created from `region` on first use; the SDK arrives with it. */
+    providedClient;
+    region;
+    readyPromise;
     defaultTtlSeconds;
     chunkBytes;
     compression;
@@ -114,7 +117,15 @@ export class LambderDdbCache {
                 maxSize: positiveInteger(memoryMaxBytes, "memoryMaxBytes"),
                 sizeCalculation: (entry) => entry.stored.length,
             });
-        this.client = options.client ?? new DynamoDBClient({ region: options.region ?? "us-east-1" });
+        this.providedClient = options.client;
+        this.region = options.region ?? "us-east-1";
+    }
+    /** The SDK and the client, loaded and created the first time the table is touched (see LambderDdbSdk). */
+    ready() {
+        this.readyPromise ??= loadDynamoClientSdk("LambderDdbCache")
+            .then((sdk) => ({ sdk, client: this.providedClient ?? new sdk.DynamoDBClient({ region: this.region }) }))
+            .catch((error) => { this.readyPromise = undefined; throw error; });
+        return this.readyPromise;
     }
     async get(key) {
         return await this.getByAddress(this.normalizeKey(key));
@@ -205,7 +216,8 @@ export class LambderDdbCache {
             },
         }));
         await this.batchWrite(writes);
-        await this.client.send(new PutItemCommand({
+        const { client, sdk } = await this.ready();
+        await client.send(new sdk.PutItemCommand({
             TableName: this.tableName,
             Item: {
                 pk: { S: pk },
@@ -356,7 +368,8 @@ export class LambderDdbCache {
     async acquireLease(pk, address, owner, leaseSeconds) {
         const now = this.nowSeconds();
         try {
-            await this.client.send(new PutItemCommand({
+            const { client, sdk } = await this.ready();
+            await client.send(new sdk.PutItemCommand({
                 TableName: this.tableName,
                 Item: {
                     pk: { S: pk },
@@ -378,7 +391,8 @@ export class LambderDdbCache {
     }
     async releaseLease(pk, address, owner) {
         try {
-            await this.client.send(new DeleteItemCommand({
+            const { client, sdk } = await this.ready();
+            await client.send(new sdk.DeleteItemCommand({
                 TableName: this.tableName,
                 Key: { pk: { S: pk }, sk: { S: this.itemSortKey(address, LOCK_SORT_KEY) } },
                 ConditionExpression: "#owner = :owner",
@@ -393,7 +407,8 @@ export class LambderDdbCache {
         }
     }
     async readManifest(pk, address) {
-        const response = await this.client.send(new GetItemCommand({
+        const { client, sdk } = await this.ready();
+        const response = await client.send(new sdk.GetItemCommand({
             TableName: this.tableName,
             Key: { pk: { S: pk }, sk: { S: this.itemSortKey(address, META_SORT_KEY) } },
             ConsistentRead: false,
@@ -469,7 +484,8 @@ export class LambderDdbCache {
         const items = [];
         let cursor;
         do {
-            const response = await this.client.send(new QueryCommand({
+            const { client, sdk } = await this.ready();
+            const response = await client.send(new sdk.QueryCommand({
                 TableName: this.tableName,
                 KeyConditionExpression: options.prefix
                     ? "#pk = :pk AND begins_with(#sk, :prefix)"
@@ -494,7 +510,8 @@ export class LambderDdbCache {
     }
     async invalidateManifest(pk, address, version) {
         try {
-            await this.client.send(new DeleteItemCommand({
+            const { client, sdk } = await this.ready();
+            await client.send(new sdk.DeleteItemCommand({
                 TableName: this.tableName,
                 Key: { pk: { S: pk }, sk: { S: this.itemSortKey(address, META_SORT_KEY) } },
                 ConditionExpression: "#version = :version",
@@ -515,7 +532,8 @@ export class LambderDdbCache {
                 if (attempt >= MAX_BATCH_RETRIES) {
                     throw new Error(`DynamoDB cache batch write remained throttled after ${MAX_BATCH_RETRIES} attempts`);
                 }
-                const response = await this.client.send(new BatchWriteItemCommand({ RequestItems: { [this.tableName]: pending } }));
+                const { client, sdk } = await this.ready();
+                const response = await client.send(new sdk.BatchWriteItemCommand({ RequestItems: { [this.tableName]: pending } }));
                 pending = response.UnprocessedItems?.[this.tableName] ?? [];
                 if (pending.length > 0) {
                     const backoff = Math.min(25 * 2 ** attempt, 1_000) + Math.floor(Math.random() * 50);
@@ -526,7 +544,7 @@ export class LambderDdbCache {
     }
     /** The JSON text of a stored payload. */
     async decode(stored, encoding, uncompressedBytes) {
-        return encoding === "br" ? await restoreBoundedText(stored, uncompressedBytes, "br") : stored.toString("utf8");
+        return encoding === "br" ? await restoreText(stored, "br", { declaredBytes: uncompressedBytes }) : stored.toString("utf8");
     }
     remember(key, stored, encoding, uncompressedBytes, expiresAt) {
         if (!this.memory)

package/dist/stores/LambderDdbIdempotency.d.ts

@@ -1,4 +1,4 @@
-import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import type { DynamoDBClient } from "@aws-sdk/client-dynamodb";
 import { type LambderCompressionOption } from "../shared/LambderCompressionOption.js";
 export interface LambderDdbIdempotencyOptions {
     tableName: string;
@@ -56,8 +56,13 @@ export declare class LambderDdbIdempotency {
     readonly tableName: string;
     readonly keyPrefix: string;
     private readonly compression;
-    private readonly client;
+    /** The client given at creation, or one created from `region` on first use; the SDK arrives with it. */
+    private readonly providedClient;
+    private readonly region;
+    private readyPromise;
     constructor(options: LambderDdbIdempotencyOptions);
+    /** The SDK and the client, loaded and created the first time the table is touched (see LambderDdbSdk). */
+    private ready;
     private itemKey;
     /** Parse a stored item's response headers. */
     private static readItemHeaders;

package/dist/stores/LambderDdbIdempotency.js

@@ -1,6 +1,6 @@
 import crypto from "crypto";
-import { DynamoDBClient, PutItemCommand, GetItemCommand, DeleteItemCommand, } from "@aws-sdk/client-dynamodb";
-import { compressText, restoreBoundedText } from "../shared/LambderCompressionCodec.js";
+import { loadDynamoClientSdk } from "./LambderDdbSdk.js";
+import { compressText, restoreText } from "../shared/LambderCompressionCodec.js";
 import { resolveCompressionOption, } from "../shared/LambderCompressionOption.js";
 /** Bodies of 1KB or more are stored Brotli-compressed by default; smaller ones stay plain. */
 const COMPRESSION_DEFAULTS = { minBytes: 1024, quality: 5 };
@@ -38,14 +38,25 @@ export class LambderDdbIdempotency {
     tableName;
     keyPrefix;
     compression;
-    client;
+    /** The client given at creation, or one created from `region` on first use; the SDK arrives with it. */
+    providedClient;
+    region;
+    readyPromise;
     constructor(options) {
         if (!options.tableName.trim())
             throw new Error("tableName is required");
         this.tableName = options.tableName;
         this.keyPrefix = options.keyPrefix ?? "IDEM";
         this.compression = resolveCompressionOption(options.compression, COMPRESSION_DEFAULTS);
-        this.client = options.client ?? new DynamoDBClient(options.region ? { region: options.region } : {});
+        this.providedClient = options.client;
+        this.region = options.region;
+    }
+    /** The SDK and the client, loaded and created the first time the table is touched (see LambderDdbSdk). */
+    ready() {
+        this.readyPromise ??= loadDynamoClientSdk("LambderDdbIdempotency")
+            .then((sdk) => ({ sdk, client: this.providedClient ?? new sdk.DynamoDBClient(this.region ? { region: this.region } : {}) }))
+            .catch((error) => { this.readyPromise = undefined; throw error; });
+        return this.readyPromise;
     }
     itemKey(scopeKey) {
         return { pk: { S: `${this.keyPrefix}#${scopeKey}` }, sk: { S: "idem" } };
@@ -67,7 +78,7 @@ export class LambderDdbIdempotency {
     static async readItemBody(item) {
         const compressed = item.bodyBr?.B;
         if (compressed)
-            return await restoreBoundedText(compressed, Number(item.bodyBytes?.N ?? 0), "br");
+            return await restoreText(compressed, "br", { declaredBytes: Number(item.bodyBytes?.N ?? 0) });
         return item.body?.S ?? "";
     }
     /**
@@ -77,7 +88,8 @@ export class LambderDdbIdempotency {
      * proceeds to begin(), whose read is authoritative.
      */
     async peek(scopeKey) {
-        const existing = await this.client.send(new GetItemCommand({
+        const { client, sdk } = await this.ready();
+        const existing = await client.send(new sdk.GetItemCommand({
             TableName: this.tableName,
             Key: this.itemKey(scopeKey),
         }));
@@ -103,7 +115,8 @@ export class LambderDdbIdempotency {
         const nowSeconds = Math.floor(Date.now() / 1000);
         const ownerToken = crypto.randomBytes(16).toString("hex");
         try {
-            await this.client.send(new PutItemCommand({
+            const { client, sdk } = await this.ready();
+            await client.send(new sdk.PutItemCommand({
                 TableName: this.tableName,
                 Item: {
                     ...this.itemKey(scopeKey),
@@ -120,7 +133,8 @@ export class LambderDdbIdempotency {
             if (error.name !== "ConditionalCheckFailedException")
                 throw error;
         }
-        const existing = await this.client.send(new GetItemCommand({
+        const { client, sdk } = await this.ready();
+        const existing = await client.send(new sdk.GetItemCommand({
             TableName: this.tableName,
             Key: this.itemKey(scopeKey),
             ConsistentRead: true,
@@ -168,7 +182,8 @@ export class LambderDdbIdempotency {
             bodyAttributes = { body: { S: body } };
         }
         try {
-            await this.client.send(new PutItemCommand({
+            const { client, sdk } = await this.ready();
+            await client.send(new sdk.PutItemCommand({
                 TableName: this.tableName,
                 Item: {
                     ...this.itemKey(scopeKey),
@@ -197,7 +212,8 @@ export class LambderDdbIdempotency {
      */
     async abandon(scopeKey, ownerToken) {
         try {
-            await this.client.send(new DeleteItemCommand({
+            const { client, sdk } = await this.ready();
+            await client.send(new sdk.DeleteItemCommand({
                 TableName: this.tableName,
                 Key: this.itemKey(scopeKey),
                 ConditionExpression: "ownerToken = :owner",

package/dist/stores/LambderDdbRateLimiter.d.ts

@@ -1,4 +1,4 @@
-import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import type { DynamoDBClient } from "@aws-sdk/client-dynamodb";
 /**
  * The fixed windows a policy may cap, smallest first (the evaluation order),
  * with their length. The policy type derives from this table, so the two can
@@ -68,10 +68,15 @@ export interface LambderDdbRateLimiterOptions {
 export declare class LambderDdbRateLimiter {
     readonly tableName: string;
     readonly keyPrefix: string;
-    private readonly client;
+    /** The client given at creation, or one created from `region` on first use; the SDK arrives with it. */
+    private readonly providedClient;
+    private readonly region;
+    private readyPromise;
     private readonly ttlWindowMultiplier;
     private readonly failOpen;
     constructor(options: LambderDdbRateLimiterOptions);
+    /** The SDK and the client, loaded and created the first time the table is touched (see LambderDdbSdk). */
+    private ready;
     /**
      * Increment every configured window for `trackerKey` (IP, session, user id, ...)
      * and report whether any of them is over its limit, with the window's