lambda-deadline-middleware 0.0.0 → 1.1.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 lambda-deadline-middleware contributors
+Copyright (c) 2026 lambda-deadline-middleware contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/LICENSES/MIT.txt

@@ -0,0 +1,18 @@
+MIT License
+
+Copyright (c) <year> <copyright holders>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,21 +1,23 @@
-<!-- SPDX-FileCopyrightText: 2024 lambda-deadline-middleware contributors -->
+<!-- SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors -->
 <!-- SPDX-License-Identifier: MIT -->
 
 # lambda-deadline-middleware
 
-Zero-dependency AWS SDK v3 middleware that automatically propagates Lambda execution deadlines to outgoing SDK calls via `AbortController`-based timeouts.
+Zero-dependency AWS SDK v3 middleware that automatically propagates Lambda execution deadlines to outgoing SDK calls via
+`AbortController`-based timeouts.
 
-When an AWS SDK call hangs inside a Lambda function, the runtime terminates the process at the configured timeout — destroying in-flight OpenTelemetry/X-Ray spans without export. This library prevents that by computing per-request deadlines from the Lambda's remaining execution time and aborting requests before the hard timeout fires.
+When an AWS SDK call hangs inside a Lambda function, the runtime terminates the process at the configured timeout
+without throwing an error or giving your code a chance to react. This library prevents that by computing per-request
+deadlines from the Lambda's remaining execution time and aborting requests before the hard timeout fires.
 
 ## Features
 
-- **Automatic deadline propagation** — no manual timeout configuration per call
-- **Fresh deadline per retry** — each SDK retry attempt gets a deadline based on _current_ remaining time
-- **Signal composition** — preserves caller-provided `AbortSignal` via `AbortSignal.any()`
-- **Zero runtime dependencies** — uses `@smithy/types` for compile-time types only
-- **Safe outside Lambda** — complete no-op when no Lambda context is available
-- **OpenTelemetry integration** — optional span events on deadline aborts (detected dynamically)
-- **Type-safe** — branded types prevent millisecond/buffer interchange at compile time
+- Automatic deadline propagation, no manual timeout configuration per call
+- Fresh deadline per retry: each SDK retry attempt uses _current_ remaining time
+- Signal composition: preserves caller-provided `AbortSignal` via `AbortSignal.any()`
+- Zero runtime dependencies (`@smithy/types` is compile-time only)
+- Complete no-op when no Lambda context is available
+- Branded types prevent millisecond/buffer interchange at compile time
 
 ## Requirements
 
@@ -28,13 +30,23 @@ When an AWS SDK call hangs inside a Lambda function, the runtime terminates the
 pnpm add lambda-deadline-middleware
 ```
 
-## Quick Start
+## Usage
+
+Setup requires two pieces:
+
+1. **Wrap your handler** with `withLambdaDeadline`. This stores the Lambda `context` (specifically
+   `getRemainingTimeInMillis()`) in `AsyncLocalStorage` so the SDK middleware can read it. The SDK middleware stack has
+   no access to the Lambda context on its own.
+
+2. **Register the middleware** on each SDK client via the standard `middlewareStack.use()` pattern.
 
 ```typescript
-import { withLambdaDeadline, withDeadline } from "lambda-deadline-middleware";
-import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { withLambdaDeadline, deadlineMiddleware } from "lambda-deadline-middleware";
+import { DynamoDBClient, GetItemCommand } from "@aws-sdk/client-dynamodb";
+
+const dynamodb = new DynamoDBClient({});
+dynamodb.middlewareStack.use(deadlineMiddleware());
 
-// 1. Wrap your Lambda handler
 export const handler = withLambdaDeadline(async (event, context) => {
   const result = await dynamodb.send(
     new GetItemCommand({
@@ -43,112 +55,107 @@ export const handler = withLambdaDeadline(async (event, context) => {
   );
   return { statusCode: 200, body: JSON.stringify(result) };
 });
-
-// 2. Register middleware on SDK clients
-const dynamodb = withDeadline(new DynamoDBClient({}));
 ```
 
-That's it. Every SDK call through `dynamodb` will automatically receive a timeout derived from the Lambda's remaining execution time minus a 1000ms flush buffer.
+Every SDK call through `dynamodb` now receives a timeout derived from the Lambda's remaining execution time minus a
+configurable flush buffer (default: 1000ms).
 
-## Architecture
+## How It Works
 
 ```mermaid
-graph TB
-    subgraph "Lambda Runtime"
-        LR[Lambda Runtime] -->|invokes| HW[Handler Wrapper<br/>withLambdaDeadline]
-        HW -->|stores context| ALS[AsyncLocalStorage<br/>Lambda Context Store]
-        HW -->|delegates to| UH[User Handler]
-        UH -->|sends command| SDK[AWS SDK v3 Client]
-
-        subgraph "SDK Middleware Stack"
-            direction TB
-            INIT[Initialize Step]
-            FIN[Finalize Step]
-            RETRY[Retry Middleware]
-            DM[Deadline Middleware<br/>← attempt level]
-            HTTP[HTTP Handler]
-
-            INIT --> FIN --> RETRY
-            RETRY -->|per attempt| DM --> HTTP
-        end
-
-        DM -->|reads remaining time| ALS
-        DM -->|creates| AC[AbortController<br/>+ setTimeout]
-        AC -->|signal attached to| HTTP
+flowchart LR
+    subgraph Lambda Invocation
+        direction LR
+        A[Lambda Runtime] --> B[withLambdaDeadline]
+        B --> C[Your Handler]
+        C --> D[SDK .send]
     end
 
-    SDK -->|middleware stack| INIT
+    subgraph Per Attempt
+        direction LR
+        D --> E[Deadline Middleware]
+        E -->|getRemainingTimeInMillis\nminus flush buffer| F[AbortController\n+ setTimeout]
+        F --> G[HTTP Request]
+    end
 
-    style DM fill:#f9a825,stroke:#f57f17
-    style ALS fill:#42a5f5,stroke:#1565c0
-    style HW fill:#66bb6a,stroke:#2e7d32
+    style E fill:#f9a825,stroke:#f57f17
+    style B fill:#66bb6a,stroke:#2e7d32
 ```
 
-The middleware registers at the **attempt level** of the SDK stack — it executes once per HTTP request dispatch including retries, computing a fresh deadline each time.
+`withLambdaDeadline` stores the Lambda context in `AsyncLocalStorage`. The deadline middleware reads it on every attempt
+(including retries), computes a fresh timeout, and attaches an `AbortSignal` to the outgoing HTTP request.
 
 ## Configuration
 
 ### Flush Buffer
 
-The flush buffer is subtracted from the remaining Lambda time to leave room for telemetry export and error handling:
+The flush buffer is subtracted from the remaining Lambda time to leave room for graceful shutdown and error handling:
 
 ```typescript
-// Default: 1000ms flush buffer
-const client = withDeadline(new DynamoDBClient({}));
-
-// Custom: 500ms flush buffer
-const client = withDeadline(new DynamoDBClient({}), { flushBufferMs: 500 });
+// Default: 1000ms
+dynamodb.middlewareStack.use(deadlineMiddleware());
 
-// No buffer: use full remaining time
-const client = withDeadline(new DynamoDBClient({}), { flushBufferMs: 0 });
+// Custom: 500ms
+dynamodb.middlewareStack.use(deadlineMiddleware({ flushBufferMs: 500 }));
 ```
 
-### Handler-Level Defaults
+## Error Handling
+
+When remaining time is less than or equal to the flush buffer, the middleware throws `DeadlineExceededError` immediately
+without dispatching an HTTP request.
 
 ```typescript
-export const handler = withLambdaDeadline(
-  async (event, context) => {
-    /* ... */
-  },
-  { flushBufferMs: 2000, telemetryEnabled: false },
-);
+import { isDeadlineExceeded } from "lambda-deadline-middleware";
+
+try {
+  await dynamodb.send(
+    new GetItemCommand({
+      /* ... */
+    }),
+  );
+} catch (error) {
+  if (isDeadlineExceeded(error)) {
+    console.log(`Deadline exceeded: ${error.deadlineMs}ms`);
+    console.log(`Remaining time was: ${error.remainingMs}ms`);
+  }
+  throw error;
+}
 ```
 
-### Telemetry
+## Signal Composition
 
-OpenTelemetry integration is detected dynamically. If `@opentelemetry/api` is installed, span events are emitted on deadline aborts. Disable with:
+If you pass an `AbortSignal` to a request, the middleware composes both signals:
 
 ```typescript
-const client = withDeadline(new DynamoDBClient({}), { telemetryEnabled: false });
+const controller = new AbortController();
+setTimeout(() => controller.abort(), 5000);
+
+await dynamodb.send(
+  new GetItemCommand({
+    /* ... */
+  }),
+  {
+    abortSignal: controller.signal,
+  },
+);
 ```
 
 ## API Reference
 
-### `withLambdaDeadline(handler, options?)`
+### `withLambdaDeadline(handler)`
 
-Wraps a Lambda handler to initialize the context store.
+Wraps a Lambda handler to store the Lambda context in `AsyncLocalStorage`. Required for the middleware to access
+`getRemainingTimeInMillis()`.
 
 ```typescript
 function withLambdaDeadline<TEvent, TResult>(
   handler: (event: TEvent, context: LambdaContextLike) => Promise<TResult>,
-  options?: DeadlineOptions,
 ): (event: TEvent, context: LambdaContextLike) => Promise<TResult>;
 ```
 
-### `withDeadline(client, options?)`
-
-Registers the deadline middleware on an SDK client. Returns the same client instance. Idempotent — subsequent calls on the same client are no-ops.
-
-```typescript
-function withDeadline<T extends { middlewareStack: { use: Function } }>(
-  client: T,
-  options?: DeadlineOptions,
-): T;
-```
-
 ### `deadlineMiddleware(options?)`
 
-Factory returning a `Pluggable` object for `client.middlewareStack.use()`.
+Returns a `Pluggable` for `client.middlewareStack.use()`.
 
 ```typescript
 function deadlineMiddleware(options?: DeadlineOptions): Pluggable<object, object>;
@@ -162,106 +169,39 @@ Accessor for the current Lambda's remaining execution time. Returns `undefined`
 function getRemainingTimeInMillis(): number | undefined;
 ```
 
-### `DeadlineExceededError`
+### `isDeadlineExceeded(error)`
+
+Type guard for deadline-triggered abort errors.
+
+```typescript
+function isDeadlineExceeded(error: unknown): error is DeadlineExceededError;
+```
 
-Error thrown when a request is aborted due to deadline expiration.
+### `DeadlineExceededError`
 
 ```typescript
 class DeadlineExceededError extends Error {
   readonly name: "DeadlineExceededError";
   readonly deadlineMs: Milliseconds;
-  readonly flushBufferMs: FlushBufferMs;
+  readonly flushBufferMs: Milliseconds;
   readonly remainingMs: Milliseconds;
 }
 ```
 
-### `isDeadlineExceeded(error)`
-
-Type guard for deadline-triggered abort errors.
-
-```typescript
-function isDeadlineExceeded(error: unknown): error is DeadlineExceededError;
-```
-
 ### `DeadlineOptions`
 
 ```typescript
 interface DeadlineOptions {
   readonly flushBufferMs?: number; // Default: 1000
-  readonly telemetryEnabled?: boolean; // Default: true
 }
 ```
 
 ### Types
 
-| Type                       | Description                                                                  |
-| -------------------------- | ---------------------------------------------------------------------------- |
-| `Milliseconds`             | Branded number representing a duration in ms                                 |
-| `FlushBufferMs`            | Branded number for the flush buffer                                          |
-| `RequestDeadlineMs`        | Branded number for a computed deadline                                       |
-| `DeadlineComputation`      | Discriminated union: `"deadline"` \| `"insufficient-time"` \| `"no-context"` |
-| `DeadlineMiddlewareConfig` | Validated configuration (internal)                                           |
-| `LambdaContextLike`        | Minimal interface: `{ getRemainingTimeInMillis?(): number }`                 |
-
-## Error Handling
-
-```typescript
-import { isDeadlineExceeded } from "lambda-deadline-middleware";
-
-try {
-  await client.send(
-    new GetItemCommand({
-      /* ... */
-    }),
-  );
-} catch (error) {
-  if (isDeadlineExceeded(error)) {
-    console.log(`Deadline exceeded: ${error.deadlineMs}ms`);
-    console.log(`Remaining time was: ${error.remainingMs}ms`);
-    // Handle graceful degradation
-  }
-  throw error;
-}
-```
-
-When remaining time is less than or equal to the flush buffer, the middleware throws `DeadlineExceededError` immediately without dispatching an HTTP request.
-
-## Advanced Usage
-
-### Direct Pluggable Registration
-
-```typescript
-import { deadlineMiddleware } from "lambda-deadline-middleware";
-
-const client = new S3Client({});
-client.middlewareStack.use(deadlineMiddleware({ flushBufferMs: 750 }));
-```
-
-### Combining with Existing Abort Signals
-
-The middleware composes signals — your existing signal is preserved:
-
-```typescript
-const controller = new AbortController();
-setTimeout(() => controller.abort(), 5000); // your own timeout
-
-await client.send(
-  new GetItemCommand({
-    /* ... */
-  }),
-  {
-    abortSignal: controller.signal, // both signals are respected
-  },
-);
-```
-
-### Multiple Clients
-
-```typescript
-const dynamodb = withDeadline(new DynamoDBClient({}));
-const sqs = withDeadline(new SQSClient({}), { flushBufferMs: 2000 });
-const s3 = withDeadline(new S3Client({}), { flushBufferMs: 500 });
-```
+| Type                | Description                                                  |
+| ------------------- | ------------------------------------------------------------ |
+| `Milliseconds`      | Branded number representing a duration in ms                 |
+| `LambdaContextLike` | Minimal interface: `{ getRemainingTimeInMillis?(): number }` |
 
 ## Reporting Bugs
 

package/REUSE.toml

@@ -0,0 +1,9 @@
+version = 1
+SPDX-PackageName = "lambda-deadline-middleware"
+SPDX-PackageSupplier = "https://github.com/mikkopiu/lambda-deadline-middleware/issues"
+
+[[annotations]]
+path = ["**/*"]
+precedence = "aggregate"
+SPDX-FileCopyrightText = "2026 lambda-deadline-middleware contributors"
+SPDX-License-Identifier = "MIT"

package/SECURITY.md

@@ -1,14 +1,15 @@
-<!-- SPDX-FileCopyrightText: 2024 lambda-deadline-middleware contributors -->
+<!-- SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors -->
 <!-- SPDX-License-Identifier: MIT -->
 
 # Security
 
-This document describes the supply chain security practices for `lambda-deadline-middleware`.
+Supply chain security practices for `lambda-deadline-middleware`.
 
 ## Provenance Verification
 
-Every published release includes SLSA Level 3 provenance attestation, generated
-automatically by GitHub Actions using the `--provenance` flag during `npm publish`.
+Every published release includes SLSA Level 3 provenance attestation, generated by GitHub Actions via npm trusted
+publishing (OIDC). No long-lived tokens are used. Authentication and provenance signing use short-lived OIDC
+credentials.
 
 ### Verifying provenance
 
@@ -16,10 +17,10 @@ automatically by GitHub Actions using the `--provenance` flag during `npm publis
 npm audit signatures
 ```
 
-This command verifies that the package was:
+This verifies that the package was:
 
 - Built from the source repository (not a compromised local machine)
-- Published by the expected GitHub Actions workflow
+- Published by the expected GitHub Actions workflow via OIDC
 - Signed with a valid sigstore certificate tied to the workflow identity
 
 You can also inspect the provenance bundle directly:
@@ -30,9 +31,8 @@ npm provenance --package-name lambda-deadline-middleware
 
 ## SBOM (Software Bill of Materials)
 
-Each release includes a CycloneDX SBOM (`sbom.cdx.json`) attached as a GitHub
-Release asset. The SBOM lists all runtime and development dependencies with their
-versions, providing full transparency into the package's dependency tree.
+Each release includes a CycloneDX SBOM (`sbom.cdx.json`) attached as a GitHub Release asset. The SBOM lists all runtime
+and development dependencies with their versions.
 
 ### Generating the SBOM locally
 
@@ -40,7 +40,7 @@ versions, providing full transparency into the package's dependency tree.
 pnpm run sbom
 ```
 
-This produces `sbom.cdx.json` in the project root using pnpm's native CycloneDX SBOM generation.
+This produces `sbom.cdx.json` in the project root using pnpm's native CycloneDX generation.
 
 ### SBOM format
 
@@ -49,30 +49,32 @@ This produces `sbom.cdx.json` in the project root using pnpm's native CycloneDX
 - **Tool**: `pnpm sbom` (native, since pnpm 11)
 - **Contents**: Component inventory including direct and transitive dependencies
 
-## Sigstore Signing
+## Trusted Publishing (OIDC)
 
-All published artifacts are signed using **keyless sigstore signing** via OIDC
-identity federation. This means:
+This project uses npm trusted publishing via OpenID Connect (OIDC) identity federation. No long-lived npm tokens
+(`NPM_TOKEN`) are stored as secrets. Authentication to the npm registry uses short-lived OIDC tokens issued by GitHub
+Actions.
 
-- **No long-lived signing keys**: Signing happens via short-lived certificates
-  issued by Fulcio, tied to the GitHub Actions OIDC identity.
-- **Transparency log**: All signatures are recorded in the Rekor transparency log,
-  providing a tamper-evident audit trail.
-- **Verification without publisher keys**: Consumers verify signatures using the
-  sigstore root of trust, not a publisher-managed key.
+### How it works
 
-### How it works in CI
+1. The release workflow requests an OIDC token from GitHub (via `id-token: write` permission).
+2. semantic-release exchanges the OIDC token with the npm registry for a short-lived publish credential.
+3. The package is published with provenance (`publishConfig.provenance: true`).
+4. Fulcio issues a signing certificate tied to the workflow identity.
+5. The signature is recorded in the Rekor transparency log.
+6. npm stores the provenance bundle alongside the package tarball.
 
-1. The GitHub Actions release workflow requests an OIDC token from GitHub.
-2. The OIDC token is exchanged with Fulcio for a short-lived signing certificate.
-3. The npm package is signed with the certificate during `npm publish --provenance`.
-4. The signature and certificate are recorded in the Rekor transparency log.
-5. npm stores the provenance bundle alongside the package tarball.
+### Security benefits
+
+- **No long-lived secrets**: No `NPM_TOKEN` to leak, rotate, or compromise.
+- **Scoped trust**: Only the specific workflow in this repository can publish.
+- **Automatic provenance**: SLSA Level 3 provenance without extra configuration.
+- **Transparency log**: All signatures are recorded in Rekor for tamper-evident auditing.
+- **No publisher keys needed**: Consumers verify using the sigstore root of trust.
 
 ### Verifying signatures
 
-Signature verification is automatic when running `npm audit signatures`. The npm
-CLI checks:
+Signature verification is automatic when running `npm audit signatures`. The npm CLI checks:
 
 - The certificate was issued by Fulcio
 - The OIDC identity matches the expected repository and workflow
@@ -81,15 +83,9 @@ CLI checks:
 
 ## Reporting Vulnerabilities
 
-If you discover a security vulnerability in this package, please report it
-responsibly by opening a [GitHub Security Advisory](https://github.com/mikkopiu/lambda-deadline-middleware/security/advisories/new) on this repository. Do not
-file a public issue for security vulnerabilities.
-
-### Response Timeline
-
-We aim to acknowledge vulnerability reports within 72 hours. For critical
-issues, we target a fix or mitigation plan within 14 days. Lower-severity
-issues are addressed as part of normal maintenance cycles.
+If you discover a security vulnerability, report it by opening a
+[GitHub Security Advisory](https://github.com/mikkopiu/lambda-deadline-middleware/security/advisories/new) on this
+repository. Do not file a public issue for security vulnerabilities.
 
-Resolved vulnerabilities are disclosed publicly via GitHub Security Advisories
-once a fix is released.
+Reports are handled on a best-effort basis. Resolved vulnerabilities are disclosed via GitHub Security Advisories once a
+fix is released.

package/dist/context-store.d.ts

@@ -1,7 +1,7 @@
 export interface LambdaContextLike {
 	getRemainingTimeInMillis?: () => number;
 }
-export declare function run<T>(context: LambdaContextLike | null | undefined, fn: () => T): T;
-export declare function getRemainingTimeInMillis(): number | undefined;
+export declare const run: <T>(context: LambdaContextLike | null | undefined, fn: () => T) => T;
+export declare const getRemainingTimeInMillis: () => number | undefined;
 
 //# sourceMappingURL=context-store.d.ts.map

package/dist/context-store.d.ts.map

@@ -1 +1 @@
-{"mappings":"AAKA,iBAAiB,kBAAkB;CACjC;AACF;AAWA,OAAO,iBAAS,IAAI,GAAG,SAAS,sCAAsC,UAAU,IAAI;AAKpF,OAAO,iBAAS","names":[],"sources":["src/context-store.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2024 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nimport { AsyncLocalStorage } from \"node:async_hooks\";\n\nexport interface LambdaContextLike {\n  getRemainingTimeInMillis?: () => number;\n}\n\n// Sentinel allows AsyncLocalStorage.run() to accept null/undefined context\n// without throwing, while the accessor can distinguish \"no context stored\"\n// from \"context present but missing the method\".\nconst NO_CONTEXT: unique symbol = Symbol(\"no-context\");\n\ntype StoreValue = LambdaContextLike | typeof NO_CONTEXT;\n\nconst contextStorage = new AsyncLocalStorage<StoreValue>();\n\nexport function run<T>(context: LambdaContextLike | null | undefined, fn: () => T): T {\n  const value: StoreValue = context ?? NO_CONTEXT;\n  return contextStorage.run(value, fn);\n}\n\nexport function getRemainingTimeInMillis(): number | undefined {\n  const store = contextStorage.getStore();\n\n  if (store === undefined || store === NO_CONTEXT) {\n    return undefined;\n  }\n\n  if (typeof store.getRemainingTimeInMillis !== \"function\") {\n    return undefined;\n  }\n\n  return store.getRemainingTimeInMillis();\n}\n"]}
+{"mappings":"AAOA,iBAAiB,kBAAkB;CACjC;AACF;AAIA,OAAO,cAAM,MAAO,GAAG,SAAS,sCAAsC,UAAU,MAAI;AAKpF,OAAO,cAAM","names":[],"sources":["src/context-store.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nimport { AsyncLocalStorage } from \"node:async_hooks\";\n\n// AsyncLocalStorage propagates the Lambda context through the entire async call chain without parameter threading.\n// SDK middleware executes deep in the Smithy stack where we can't pass the context through function signatures.\nexport interface LambdaContextLike {\n  getRemainingTimeInMillis?: () => number;\n}\n\nconst contextStorage = new AsyncLocalStorage<LambdaContextLike>();\n\nexport const run = <T>(context: LambdaContextLike | null | undefined, fn: () => T): T => {\n  if (context === null || context === undefined) return fn();\n  return contextStorage.run(context, fn);\n};\n\nexport const getRemainingTimeInMillis = (): number | undefined => {\n  const store = contextStorage.getStore();\n  if (store === undefined) return undefined;\n  if (typeof store.getRemainingTimeInMillis !== \"function\") return undefined;\n  return store.getRemainingTimeInMillis();\n};\n"]}

package/dist/context-store.js

@@ -1,24 +1,16 @@
-// SPDX-FileCopyrightText: 2024 lambda-deadline-middleware contributors
+// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors
 // SPDX-License-Identifier: MIT
 import { AsyncLocalStorage } from "node:async_hooks";
-// Sentinel allows AsyncLocalStorage.run() to accept null/undefined context
-// without throwing, while the accessor can distinguish "no context stored"
-// from "context present but missing the method".
-const NO_CONTEXT = Symbol("no-context");
 const contextStorage = new AsyncLocalStorage();
-export function run(context, fn) {
-	const value = context ?? NO_CONTEXT;
-	return contextStorage.run(value, fn);
-}
-export function getRemainingTimeInMillis() {
+export const run = (context, fn) => {
+	if (context === null || context === undefined) return fn();
+	return contextStorage.run(context, fn);
+};
+export const getRemainingTimeInMillis = () => {
 	const store = contextStorage.getStore();
-	if (store === undefined || store === NO_CONTEXT) {
-		return undefined;
-	}
-	if (typeof store.getRemainingTimeInMillis !== "function") {
-		return undefined;
-	}
+	if (store === undefined) return undefined;
+	if (typeof store.getRemainingTimeInMillis !== "function") return undefined;
 	return store.getRemainingTimeInMillis();
-}
+};
 
 //# sourceMappingURL=context-store.js.map

package/dist/context-store.js.map

@@ -1 +1 @@
-{"mappings":";;AAGA,SAAS,yBAAyB;;;;AASlC,MAAM,aAA4B,OAAO,YAAY;AAIrD,MAAM,iBAAiB,IAAI,kBAA8B;AAEzD,OAAO,SAAS,IAAO,SAA+C,IAAgB;CACpF,MAAM,QAAoB,WAAW;CACrC,OAAO,eAAe,IAAI,OAAO,EAAE;AACrC;AAEA,OAAO,SAAS,2BAA+C;CAC7D,MAAM,QAAQ,eAAe,SAAS;CAEtC,IAAI,UAAU,aAAa,UAAU,YAAY;EAC/C,OAAO;CACT;CAEA,IAAI,OAAO,MAAM,6BAA6B,YAAY;EACxD,OAAO;CACT;CAEA,OAAO,MAAM,yBAAyB;AACxC","names":[],"sources":["src/context-store.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2024 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nimport { AsyncLocalStorage } from \"node:async_hooks\";\n\nexport interface LambdaContextLike {\n  getRemainingTimeInMillis?: () => number;\n}\n\n// Sentinel allows AsyncLocalStorage.run() to accept null/undefined context\n// without throwing, while the accessor can distinguish \"no context stored\"\n// from \"context present but missing the method\".\nconst NO_CONTEXT: unique symbol = Symbol(\"no-context\");\n\ntype StoreValue = LambdaContextLike | typeof NO_CONTEXT;\n\nconst contextStorage = new AsyncLocalStorage<StoreValue>();\n\nexport function run<T>(context: LambdaContextLike | null | undefined, fn: () => T): T {\n  const value: StoreValue = context ?? NO_CONTEXT;\n  return contextStorage.run(value, fn);\n}\n\nexport function getRemainingTimeInMillis(): number | undefined {\n  const store = contextStorage.getStore();\n\n  if (store === undefined || store === NO_CONTEXT) {\n    return undefined;\n  }\n\n  if (typeof store.getRemainingTimeInMillis !== \"function\") {\n    return undefined;\n  }\n\n  return store.getRemainingTimeInMillis();\n}\n"]}
+{"mappings":";;AAGA,SAAS,yBAAyB;AAQlC,MAAM,iBAAiB,IAAI,kBAAqC;AAEhE,OAAO,MAAM,OAAU,SAA+C,OAAmB;CACvF,IAAI,YAAY,QAAQ,YAAY,WAAW,OAAO,GAAG;CACzD,OAAO,eAAe,IAAI,SAAS,EAAE;AACvC;AAEA,OAAO,MAAM,iCAAqD;CAChE,MAAM,QAAQ,eAAe,SAAS;CACtC,IAAI,UAAU,WAAW,OAAO;CAChC,IAAI,OAAO,MAAM,6BAA6B,YAAY,OAAO;CACjE,OAAO,MAAM,yBAAyB;AACxC","names":[],"sources":["src/context-store.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nimport { AsyncLocalStorage } from \"node:async_hooks\";\n\n// AsyncLocalStorage propagates the Lambda context through the entire async call chain without parameter threading.\n// SDK middleware executes deep in the Smithy stack where we can't pass the context through function signatures.\nexport interface LambdaContextLike {\n  getRemainingTimeInMillis?: () => number;\n}\n\nconst contextStorage = new AsyncLocalStorage<LambdaContextLike>();\n\nexport const run = <T>(context: LambdaContextLike | null | undefined, fn: () => T): T => {\n  if (context === null || context === undefined) return fn();\n  return contextStorage.run(context, fn);\n};\n\nexport const getRemainingTimeInMillis = (): number | undefined => {\n  const store = contextStorage.getStore();\n  if (store === undefined) return undefined;\n  if (typeof store.getRemainingTimeInMillis !== \"function\") return undefined;\n  return store.getRemainingTimeInMillis();\n};\n"]}

package/dist/error.d.ts

@@ -1,17 +1,17 @@
-import type { FlushBufferMs, Milliseconds } from "./types.js";
+import type { Milliseconds } from "./types.js";
 interface DeadlineExceededInit {
 	readonly deadlineMs: Milliseconds;
-	readonly flushBufferMs: FlushBufferMs;
+	readonly flushBufferMs: Milliseconds;
 	readonly remainingMs: Milliseconds;
 }
 export declare class DeadlineExceededError extends Error {
 	override readonly name = "DeadlineExceededError";
 	readonly deadlineMs: Milliseconds;
-	readonly flushBufferMs: FlushBufferMs;
+	readonly flushBufferMs: Milliseconds;
 	readonly remainingMs: Milliseconds;
 	constructor(init: DeadlineExceededInit);
 }
-export declare function isDeadlineExceeded(error: unknown): error is DeadlineExceededError;
+export declare const isDeadlineExceeded: (error: unknown) => error is DeadlineExceededError;
 export {};
 
 //# sourceMappingURL=error.d.ts.map

package/dist/error.d.ts.map

@@ -1 +1 @@
-{"mappings":"AAGA,cAAc,eAAe,oBAAoB;UAEvC,qBAAqB;UACpB,YAAY;UACZ,eAAe;UACf,aAAa;AACxB;AAEA,OAAO,cAAM,8BAA8B,MAAM;CAC/C,kBAAkB,OAAO;CACzB,SAAS,YAAY;CACrB,SAAS,eAAe;CACxB,SAAS,aAAa;CAEtB,YAAY,MAAM;AAQpB;AAIA,OAAO,iBAAS,mBAAmB,iBAAiB,SAAS","names":[],"sources":["src/error.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2024 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nimport type { FlushBufferMs, Milliseconds } from \"./types.js\";\n\ninterface DeadlineExceededInit {\n  readonly deadlineMs: Milliseconds;\n  readonly flushBufferMs: FlushBufferMs;\n  readonly remainingMs: Milliseconds;\n}\n\nexport class DeadlineExceededError extends Error {\n  override readonly name = \"DeadlineExceededError\" as const;\n  readonly deadlineMs: Milliseconds;\n  readonly flushBufferMs: FlushBufferMs;\n  readonly remainingMs: Milliseconds;\n\n  constructor(init: DeadlineExceededInit) {\n    super(\n      `Request deadline exceeded: ${init.deadlineMs}ms deadline (${init.flushBufferMs}ms flush buffer)`,\n    );\n    this.deadlineMs = init.deadlineMs;\n    this.flushBufferMs = init.flushBufferMs;\n    this.remainingMs = init.remainingMs;\n  }\n}\n\n// Structural check rather than instanceof — works across module boundaries\n// and serialization boundaries where prototype chain may be broken.\nexport function isDeadlineExceeded(error: unknown): error is DeadlineExceededError {\n  if (error === null || error === undefined) return false;\n  if (typeof error !== \"object\") return false;\n  return (error as { name?: unknown }).name === \"DeadlineExceededError\";\n}\n"]}
+{"mappings":"AAGA,cAAc,oBAAoB;UAExB,qBAAqB;UACpB,YAAY;UACZ,eAAe;UACf,aAAa;AACxB;AAEA,OAAO,cAAM,8BAA8B,MAAM;CAC/C,kBAAkB,OAAO;CACzB,SAAS,YAAY;CACrB,SAAS,eAAe;CACxB,SAAS,aAAa;CAEtB,YAAY,MAAM;AAQpB;AAIA,OAAO,cAAM,qBAAsB,mBAAiB,SAAS","names":[],"sources":["src/error.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nimport type { Milliseconds } from \"./types.js\";\n\ninterface DeadlineExceededInit {\n  readonly deadlineMs: Milliseconds;\n  readonly flushBufferMs: Milliseconds;\n  readonly remainingMs: Milliseconds;\n}\n\nexport class DeadlineExceededError extends Error {\n  override readonly name = \"DeadlineExceededError\" as const;\n  readonly deadlineMs: Milliseconds;\n  readonly flushBufferMs: Milliseconds;\n  readonly remainingMs: Milliseconds;\n\n  constructor(init: DeadlineExceededInit) {\n    super(\n      `Request deadline exceeded: ${init.deadlineMs}ms deadline (${init.flushBufferMs}ms flush buffer)`,\n    );\n    this.deadlineMs = init.deadlineMs;\n    this.flushBufferMs = init.flushBufferMs;\n    this.remainingMs = init.remainingMs;\n  }\n}\n\n// Structural check rather than instanceof — works across module boundaries\n// and serialization boundaries where prototype chain may be broken.\nexport const isDeadlineExceeded = (error: unknown): error is DeadlineExceededError => {\n  if (error === null || error === undefined) return false;\n  if (typeof error !== \"object\") return false;\n  return (error as { name?: unknown }).name === \"DeadlineExceededError\";\n};\n"]}

package/dist/error.js

@@ -12,10 +12,10 @@ export class DeadlineExceededError extends Error {
 }
 // Structural check rather than instanceof — works across module boundaries
 // and serialization boundaries where prototype chain may be broken.
-export function isDeadlineExceeded(error) {
+export const isDeadlineExceeded = (error) => {
 	if (error === null || error === undefined) return false;
 	if (typeof error !== "object") return false;
 	return error.name === "DeadlineExceededError";
-}
+};
 
 //# sourceMappingURL=error.js.map

package/dist/error.js.map

@@ -1 +1 @@
-{"mappings":"AAWA,OAAO,MAAM,8BAA8B,MAAM;CAC/C,AAAkB,OAAO;CACzB,AAAS;CACT,AAAS;CACT,AAAS;CAET,YAAY,MAA4B;EACtC,MACE,8BAA8B,KAAK,WAAW,eAAe,KAAK,cAAc,iBAClF;EACA,KAAK,aAAa,KAAK;EACvB,KAAK,gBAAgB,KAAK;EAC1B,KAAK,cAAc,KAAK;CAC1B;AACF;;;AAIA,OAAO,SAAS,mBAAmB,OAAgD;CACjF,IAAI,UAAU,QAAQ,UAAU,WAAW,OAAO;CAClD,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,OAAQ,MAA6B,SAAS;AAChD","names":[],"sources":["src/error.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2024 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nimport type { FlushBufferMs, Milliseconds } from \"./types.js\";\n\ninterface DeadlineExceededInit {\n  readonly deadlineMs: Milliseconds;\n  readonly flushBufferMs: FlushBufferMs;\n  readonly remainingMs: Milliseconds;\n}\n\nexport class DeadlineExceededError extends Error {\n  override readonly name = \"DeadlineExceededError\" as const;\n  readonly deadlineMs: Milliseconds;\n  readonly flushBufferMs: FlushBufferMs;\n  readonly remainingMs: Milliseconds;\n\n  constructor(init: DeadlineExceededInit) {\n    super(\n      `Request deadline exceeded: ${init.deadlineMs}ms deadline (${init.flushBufferMs}ms flush buffer)`,\n    );\n    this.deadlineMs = init.deadlineMs;\n    this.flushBufferMs = init.flushBufferMs;\n    this.remainingMs = init.remainingMs;\n  }\n}\n\n// Structural check rather than instanceof — works across module boundaries\n// and serialization boundaries where prototype chain may be broken.\nexport function isDeadlineExceeded(error: unknown): error is DeadlineExceededError {\n  if (error === null || error === undefined) return false;\n  if (typeof error !== \"object\") return false;\n  return (error as { name?: unknown }).name === \"DeadlineExceededError\";\n}\n"]}
+{"mappings":"AAWA,OAAO,MAAM,8BAA8B,MAAM;CAC/C,AAAkB,OAAO;CACzB,AAAS;CACT,AAAS;CACT,AAAS;CAET,YAAY,MAA4B;EACtC,MACE,8BAA8B,KAAK,WAAW,eAAe,KAAK,cAAc,iBAClF;EACA,KAAK,aAAa,KAAK;EACvB,KAAK,gBAAgB,KAAK;EAC1B,KAAK,cAAc,KAAK;CAC1B;AACF;;;AAIA,OAAO,MAAM,sBAAsB,UAAmD;CACpF,IAAI,UAAU,QAAQ,UAAU,WAAW,OAAO;CAClD,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,OAAQ,MAA6B,SAAS;AAChD","names":[],"sources":["src/error.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nimport type { Milliseconds } from \"./types.js\";\n\ninterface DeadlineExceededInit {\n  readonly deadlineMs: Milliseconds;\n  readonly flushBufferMs: Milliseconds;\n  readonly remainingMs: Milliseconds;\n}\n\nexport class DeadlineExceededError extends Error {\n  override readonly name = \"DeadlineExceededError\" as const;\n  readonly deadlineMs: Milliseconds;\n  readonly flushBufferMs: Milliseconds;\n  readonly remainingMs: Milliseconds;\n\n  constructor(init: DeadlineExceededInit) {\n    super(\n      `Request deadline exceeded: ${init.deadlineMs}ms deadline (${init.flushBufferMs}ms flush buffer)`,\n    );\n    this.deadlineMs = init.deadlineMs;\n    this.flushBufferMs = init.flushBufferMs;\n    this.remainingMs = init.remainingMs;\n  }\n}\n\n// Structural check rather than instanceof — works across module boundaries\n// and serialization boundaries where prototype chain may be broken.\nexport const isDeadlineExceeded = (error: unknown): error is DeadlineExceededError => {\n  if (error === null || error === undefined) return false;\n  if (typeof error !== \"object\") return false;\n  return (error as { name?: unknown }).name === \"DeadlineExceededError\";\n};\n"]}