lambda-deadline-middleware 1.0.1 → 1.1.0

package/README.md

@@ -6,8 +6,8 @@
 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
+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
@@ -17,7 +17,6 @@ deadlines from the Lambda's remaining execution time and aborting requests befor
 - 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
-- Optional OpenTelemetry span events on deadline aborts (detected dynamically)
 - Branded types prevent millisecond/buffer interchange at compile time
 
 ## Requirements
@@ -90,7 +89,7 @@ flowchart LR
 
 ### 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
@@ -100,14 +99,6 @@ dynamodb.middlewareStack.use(deadlineMiddleware());
 dynamodb.middlewareStack.use(deadlineMiddleware({ flushBufferMs: 500 }));
 ```
 
-### Telemetry
-
-If `@opentelemetry/api` is installed, span events are emitted on deadline aborts. Disable with:
-
-```typescript
-dynamodb.middlewareStack.use(deadlineMiddleware({ telemetryEnabled: false }));
-```
-
 ## Error Handling
 
 When remaining time is less than or equal to the flush buffer, the middleware throws `DeadlineExceededError` immediately
@@ -151,7 +142,7 @@ await dynamodb.send(
 
 ## API Reference
 
-### `withLambdaDeadline(handler, options?)`
+### `withLambdaDeadline(handler)`
 
 Wraps a Lambda handler to store the Lambda context in `AsyncLocalStorage`. Required for the middleware to access
 `getRemainingTimeInMillis()`.
@@ -159,7 +150,6 @@ Wraps a Lambda handler to store the Lambda context in `AsyncLocalStorage`. Requi
 ```typescript
 function withLambdaDeadline<TEvent, TResult>(
   handler: (event: TEvent, context: LambdaContextLike) => Promise<TResult>,
-  options?: DeadlineOptions,
 ): (event: TEvent, context: LambdaContextLike) => Promise<TResult>;
 ```
 
@@ -193,7 +183,7 @@ function isDeadlineExceeded(error: unknown): error is DeadlineExceededError;
 class DeadlineExceededError extends Error {
   readonly name: "DeadlineExceededError";
   readonly deadlineMs: Milliseconds;
-  readonly flushBufferMs: FlushBufferMs;
+  readonly flushBufferMs: Milliseconds;
   readonly remainingMs: Milliseconds;
 }
 ```
@@ -203,19 +193,15 @@ class DeadlineExceededError extends Error {
 ```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"` |
-| `LambdaContextLike`   | Minimal interface: `{ getRemainingTimeInMillis?(): number }`                 |
+| Type                | Description                                                  |
+| ------------------- | ------------------------------------------------------------ |
+| `Milliseconds`      | Branded number representing a duration in ms                 |
+| `LambdaContextLike` | Minimal interface: `{ getRemainingTimeInMillis?(): number }` |
 
 ## Reporting Bugs
 

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

@@ -1 +1 @@
-{"mappings":"AAOA,iBAAiB,kBAAkB;CACjC;AACF;AAWA,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\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 const 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 const 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,23 +1,15 @@
 // 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 const run = (context, fn) => {
-	const value = context ?? NO_CONTEXT;
-	return contextStorage.run(value, 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();
 };
 

package/dist/context-store.js.map

@@ -1 +1 @@
-{"mappings":";;AAGA,SAAS,yBAAyB;;;;AAWlC,MAAM,aAA4B,OAAO,YAAY;AAIrD,MAAM,iBAAiB,IAAI,kBAA8B;AAEzD,OAAO,MAAM,OAAU,SAA+C,OAAmB;CACvF,MAAM,QAAoB,WAAW;CACrC,OAAO,eAAe,IAAI,OAAO,EAAE;AACrC;AAEA,OAAO,MAAM,iCAAqD;CAChE,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: 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\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 const 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 const 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,13 +1,13 @@
-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);
 }

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,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 { 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 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"]}
+{"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.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,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 { 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 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"]}
+{"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"]}

package/dist/handler-wrapper.d.ts

@@ -1,13 +1,14 @@
 import type { LambdaContextLike } from "./context-store.js";
-import type { DeadlineOptions } from "./types.js";
 type AsyncHandler<
 	TEvent,
+	TContext extends LambdaContextLike,
 	TResult
-> = (event: TEvent, context: LambdaContextLike) => Promise<TResult>;
+> = (event: TEvent, context: TContext) => Promise<TResult>;
 export declare const withLambdaDeadline: <
 	TEvent,
+	TContext extends LambdaContextLike,
 	TResult
->(handler: AsyncHandler<TEvent, TResult>, _options?: DeadlineOptions) => AsyncHandler<TEvent, TResult>;
+>(handler: AsyncHandler<TEvent, TContext, TResult>) => AsyncHandler<TEvent, TContext, TResult>;
 export {};
 
 //# sourceMappingURL=handler-wrapper.d.ts.map

package/dist/handler-wrapper.d.ts.map

@@ -1 +1 @@
-{"mappings":"AAIA,cAAc,yBAAyB;AACvC,cAAc,uBAAuB;KAEhC;CAAa;CAAQ;KACxB,OAAO,QACP,SAAS,sBACN,QAAQ;AAEb,OAAO,cAAM;CACV;CAAQ;EACP,SAAS,aAAa,QAAQ,UAC9B,WAAW,oBACV,aAAa,QAAQ","names":[],"sources":["src/handler-wrapper.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nimport { run } from \"./context-store.js\";\nimport type { LambdaContextLike } from \"./context-store.js\";\nimport type { DeadlineOptions } from \"./types.js\";\n\ntype AsyncHandler<TEvent, TResult> = (\n  event: TEvent,\n  context: LambdaContextLike,\n) => Promise<TResult>;\n\nexport const withLambdaDeadline =\n  <TEvent, TResult>(\n    handler: AsyncHandler<TEvent, TResult>,\n    _options?: DeadlineOptions,\n  ): AsyncHandler<TEvent, TResult> =>\n  async (event: TEvent, context: LambdaContextLike): Promise<TResult> =>\n    run(context, async () => handler(event, context));\n"]}
+{"mappings":"AAKA,cAAc,yBAAyB;KAElC;CAAa;CAAQ,iBAAiB;CAAmB;KAC5D,OAAO,QACP,SAAS,aACN,QAAQ;AAEb,OAAO,cAAM;CACV;CAAQ,iBAAiB;CAAmB;EAC3C,SAAS,aAAa,QAAQ,UAAU,aACvC,aAAa,QAAQ,UAAU","names":[],"sources":["src/handler-wrapper.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nimport { run } from \"./context-store.js\";\n\nimport type { LambdaContextLike } from \"./context-store.js\";\n\ntype AsyncHandler<TEvent, TContext extends LambdaContextLike, TResult> = (\n  event: TEvent,\n  context: TContext,\n) => Promise<TResult>;\n\nexport const withLambdaDeadline =\n  <TEvent, TContext extends LambdaContextLike, TResult>(\n    handler: AsyncHandler<TEvent, TContext, TResult>,\n  ): AsyncHandler<TEvent, TContext, TResult> =>\n  async (event: TEvent, context: TContext): Promise<TResult> =>\n    run(context, async () => handler(event, context));\n"]}

package/dist/handler-wrapper.js

@@ -1,6 +1,6 @@
 // SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors
 // SPDX-License-Identifier: MIT
 import { run } from "./context-store.js";
-export const withLambdaDeadline = (handler, _options) => async (event, context) => run(context, async () => handler(event, context));
+export const withLambdaDeadline = (handler) => async (event, context) => run(context, async () => handler(event, context));
 
 //# sourceMappingURL=handler-wrapper.js.map

package/dist/handler-wrapper.js.map

@@ -1 +1 @@
-{"mappings":";;AAGA,SAAS,WAAW;AASpB,OAAO,MAAM,sBAET,SACA,aAEF,OAAO,OAAe,YACpB,IAAI,SAAS,YAAY,QAAQ,OAAO,OAAO,CAAC","names":[],"sources":["src/handler-wrapper.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nimport { run } from \"./context-store.js\";\nimport type { LambdaContextLike } from \"./context-store.js\";\nimport type { DeadlineOptions } from \"./types.js\";\n\ntype AsyncHandler<TEvent, TResult> = (\n  event: TEvent,\n  context: LambdaContextLike,\n) => Promise<TResult>;\n\nexport const withLambdaDeadline =\n  <TEvent, TResult>(\n    handler: AsyncHandler<TEvent, TResult>,\n    _options?: DeadlineOptions,\n  ): AsyncHandler<TEvent, TResult> =>\n  async (event: TEvent, context: LambdaContextLike): Promise<TResult> =>\n    run(context, async () => handler(event, context));\n"]}
+{"mappings":";;AAGA,SAAS,WAAW;AASpB,OAAO,MAAM,sBAET,YAEF,OAAO,OAAe,YACpB,IAAI,SAAS,YAAY,QAAQ,OAAO,OAAO,CAAC","names":[],"sources":["src/handler-wrapper.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nimport { run } from \"./context-store.js\";\n\nimport type { LambdaContextLike } from \"./context-store.js\";\n\ntype AsyncHandler<TEvent, TContext extends LambdaContextLike, TResult> = (\n  event: TEvent,\n  context: TContext,\n) => Promise<TResult>;\n\nexport const withLambdaDeadline =\n  <TEvent, TContext extends LambdaContextLike, TResult>(\n    handler: AsyncHandler<TEvent, TContext, TResult>,\n  ): AsyncHandler<TEvent, TContext, TResult> =>\n  async (event: TEvent, context: TContext): Promise<TResult> =>\n    run(context, async () => handler(event, context));\n"]}

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 export { withLambdaDeadline } from "./handler-wrapper.js";
-export { deadlineMiddleware } from "./registration.js";
+export { deadlineMiddleware } from "./middleware.js";
 export { DeadlineExceededError, isDeadlineExceeded } from "./error.js";
 export { getRemainingTimeInMillis } from "./context-store.js";
-export type { Milliseconds, FlushBufferMs, RequestDeadlineMs, DeadlineComputation, DeadlineMiddlewareConfig, DeadlineOptions } from "./types.js";
+export type { Milliseconds, DeadlineOptions } from "./types.js";
 export type { LambdaContextLike } from "./context-store.js";
 
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"mappings":"AAGA,SAAS,0BAA0B;AACnC,SAAS,0BAA0B;AACnC,SAAS,uBAAuB,0BAA0B;AAC1D,SAAS,gCAAgC;AAEzC,cACE,cACA,eACA,mBACA,qBACA,0BACA,uBACK;AAEP,cAAc,yBAAyB","names":[],"sources":["src/index.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nexport { withLambdaDeadline } from \"./handler-wrapper.js\";\nexport { deadlineMiddleware } from \"./registration.js\";\nexport { DeadlineExceededError, isDeadlineExceeded } from \"./error.js\";\nexport { getRemainingTimeInMillis } from \"./context-store.js\";\n\nexport type {\n  Milliseconds,\n  FlushBufferMs,\n  RequestDeadlineMs,\n  DeadlineComputation,\n  DeadlineMiddlewareConfig,\n  DeadlineOptions,\n} from \"./types.js\";\n\nexport type { LambdaContextLike } from \"./context-store.js\";\n"]}
+{"mappings":"AAGA,SAAS,0BAA0B;AACnC,SAAS,0BAA0B;AACnC,SAAS,uBAAuB,0BAA0B;AAC1D,SAAS,gCAAgC;AAEzC,cAAc,cAAc,uBAAuB;AAEnD,cAAc,yBAAyB","names":[],"sources":["src/index.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nexport { withLambdaDeadline } from \"./handler-wrapper.js\";\nexport { deadlineMiddleware } from \"./middleware.js\";\nexport { DeadlineExceededError, isDeadlineExceeded } from \"./error.js\";\nexport { getRemainingTimeInMillis } from \"./context-store.js\";\n\nexport type { Milliseconds, DeadlineOptions } from \"./types.js\";\n\nexport type { LambdaContextLike } from \"./context-store.js\";\n"]}

package/dist/index.js

@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors
 // SPDX-License-Identifier: MIT
 export { withLambdaDeadline } from "./handler-wrapper.js";
-export { deadlineMiddleware } from "./registration.js";
+export { deadlineMiddleware } from "./middleware.js";
 export { DeadlineExceededError, isDeadlineExceeded } from "./error.js";
 export { getRemainingTimeInMillis } from "./context-store.js";
 

package/dist/index.js.map

@@ -1 +1 @@
-{"mappings":";;AAGA,SAAS,0BAA0B;AACnC,SAAS,0BAA0B;AACnC,SAAS,uBAAuB,0BAA0B;AAC1D,SAAS,gCAAgC","names":[],"sources":["src/index.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nexport { withLambdaDeadline } from \"./handler-wrapper.js\";\nexport { deadlineMiddleware } from \"./registration.js\";\nexport { DeadlineExceededError, isDeadlineExceeded } from \"./error.js\";\nexport { getRemainingTimeInMillis } from \"./context-store.js\";\n\nexport type {\n  Milliseconds,\n  FlushBufferMs,\n  RequestDeadlineMs,\n  DeadlineComputation,\n  DeadlineMiddlewareConfig,\n  DeadlineOptions,\n} from \"./types.js\";\n\nexport type { LambdaContextLike } from \"./context-store.js\";\n"]}
+{"mappings":";;AAGA,SAAS,0BAA0B;AACnC,SAAS,0BAA0B;AACnC,SAAS,uBAAuB,0BAA0B;AAC1D,SAAS,gCAAgC","names":[],"sources":["src/index.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nexport { withLambdaDeadline } from \"./handler-wrapper.js\";\nexport { deadlineMiddleware } from \"./middleware.js\";\nexport { DeadlineExceededError, isDeadlineExceeded } from \"./error.js\";\nexport { getRemainingTimeInMillis } from \"./context-store.js\";\n\nexport type { Milliseconds, DeadlineOptions } from \"./types.js\";\n\nexport type { LambdaContextLike } from \"./context-store.js\";\n"]}

package/dist/middleware.d.ts

@@ -1,15 +1,9 @@
-import type { DeadlineComputation, DeadlineMiddlewareConfig, RequestDeadlineMs } from "./types.js";
-import type { FinalizeRequestMiddleware } from "@smithy/types";
-export declare const computeDeadline: (config: DeadlineMiddlewareConfig) => DeadlineComputation;
-export interface DeadlineTimer {
-	readonly controller: AbortController;
-	[Symbol.dispose]: () => void;
-}
-export declare const createDeadlineTimer: (deadlineMs: RequestDeadlineMs, config: DeadlineMiddlewareConfig) => DeadlineTimer;
+import type { Pluggable } from "@smithy/types";
+import type { DeadlineOptions } from "./types.js";
 export declare const composeSignals: (existing: AbortSignal | undefined, deadline: AbortSignal) => AbortSignal;
-export declare const deadlineMiddlewareHandler: <
+export declare const deadlineMiddleware: <
 	Input extends object,
 	Output extends object
->(config: DeadlineMiddlewareConfig) => FinalizeRequestMiddleware<Input, Output>;
+>(options?: DeadlineOptions) => Pluggable<Input, Output>;
 
 //# sourceMappingURL=middleware.d.ts.map

package/dist/middleware.d.ts.map

@@ -1 +1 @@
-{"mappings":"AAKA,cAAc,qBAAqB,0BAA0B,yBAAyB;AAGtF,cAIE,iCAEK;AAEP,OAAO,cAAM,kBAAmB,QAAQ,6BAA2B;AAqBnE,iBAAiB,cAAc;UACpB,YAAY;EACpB,OAAO;AACV;AAEA,OAAO,cAAM,sBACX,YAAY,mBACZ,QAAQ,6BACP;AAmBH,OAAO,cAAM,iBACX,UAAU,yBACV,UAAU,gBACT;AAKH,OAAO,cAAM;CACV;CAAsB;EACrB,QAAQ,6BACP,0BAA0B,OAAO","names":[],"sources":["src/middleware.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nimport { getRemainingTimeInMillis } from \"./context-store.js\";\nimport { DeadlineExceededError } from \"./error.js\";\nimport type { DeadlineComputation, DeadlineMiddlewareConfig, RequestDeadlineMs } from \"./types.js\";\nimport { milliseconds } from \"./types.js\";\n\nimport type {\n  FinalizeHandler,\n  FinalizeHandlerArguments,\n  FinalizeHandlerOutput,\n  FinalizeRequestMiddleware,\n  HandlerExecutionContext,\n} from \"@smithy/types\";\n\nexport const computeDeadline = (config: DeadlineMiddlewareConfig): DeadlineComputation => {\n  const remaining = getRemainingTimeInMillis();\n\n  if (remaining === undefined) {\n    return { kind: \"no-context\" };\n  }\n\n  const deadline = remaining - config.flushBufferMs;\n\n  if (deadline <= 0) {\n    return {\n      kind: \"insufficient-time\",\n      remaining: milliseconds(remaining),\n      buffer: config.flushBufferMs,\n    };\n  }\n\n  // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- branded narrowing: deadline is validated > 0 above\n  return { kind: \"deadline\", value: deadline as RequestDeadlineMs };\n};\n\nexport interface DeadlineTimer {\n  readonly controller: AbortController;\n  [Symbol.dispose]: () => void;\n}\n\nexport const createDeadlineTimer = (\n  deadlineMs: RequestDeadlineMs,\n  config: DeadlineMiddlewareConfig,\n): DeadlineTimer => {\n  const controller = new AbortController();\n  const remaining = milliseconds(deadlineMs + config.flushBufferMs);\n  const error = new DeadlineExceededError({\n    deadlineMs: milliseconds(deadlineMs),\n    flushBufferMs: config.flushBufferMs,\n    remainingMs: remaining,\n  });\n  const timeoutId = setTimeout(() => {\n    controller.abort(error);\n  }, deadlineMs);\n  return {\n    controller,\n    [Symbol.dispose]() {\n      clearTimeout(timeoutId);\n    },\n  };\n};\n\nexport const composeSignals = (\n  existing: AbortSignal | undefined,\n  deadline: AbortSignal,\n): AbortSignal => {\n  if (existing === undefined) return deadline;\n  return AbortSignal.any([existing, deadline]);\n};\n\nexport const deadlineMiddlewareHandler =\n  <Input extends object, Output extends object>(\n    config: DeadlineMiddlewareConfig,\n  ): FinalizeRequestMiddleware<Input, Output> =>\n  (\n    next: FinalizeHandler<Input, Output>,\n    _context: HandlerExecutionContext,\n  ): FinalizeHandler<Input, Output> =>\n  // oxlint-disable-next-line typescript/consistent-return -- switch is exhaustive over DeadlineComputation discriminated union\n  async (args: FinalizeHandlerArguments<Input>): Promise<FinalizeHandlerOutput<Output>> => {\n    const computation = computeDeadline(config);\n\n    switch (computation.kind) {\n      case \"no-context\":\n        return next(args);\n\n      case \"insufficient-time\":\n        throw new DeadlineExceededError({\n          deadlineMs: milliseconds(0),\n          flushBufferMs: computation.buffer,\n          remainingMs: computation.remaining,\n        });\n\n      case \"deadline\": {\n        // `using` guarantees cleanup (clearTimeout) even if next() throws, the promise rejects,\n        // or an external abort signal fires — strictly more reliable than try/finally.\n        using timer = createDeadlineTimer(computation.value, config);\n        // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- Smithy request is an opaque object; we access optional signal property\n        const request = args.request as { signal?: AbortSignal } | undefined;\n        const signal = composeSignals(request?.signal, timer.controller.signal);\n        const result = await next({\n          ...args,\n          // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- spreading opaque Smithy request to add signal\n          request: { ...(args.request as object), signal },\n        });\n        return result;\n      }\n    }\n  };\n"]}
+{"mappings":"AAGA,cAKE,iBACK;AAMP,cAAc,uBAAuB;AAErC,OAAO,cAAM,iBACX,UAAU,yBACV,UAAU,gBACT;AAKH,OAAO,cAAM;CAAsB;CAAsB;EACvD,UAAU,oBACT,UAAU,OAAO","names":[],"sources":["src/middleware.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nimport type {\n  FinalizeHandler,\n  FinalizeHandlerArguments,\n  FinalizeHandlerOutput,\n  HandlerExecutionContext,\n  Pluggable,\n} from \"@smithy/types\";\n\nimport { getRemainingTimeInMillis } from \"./context-store.js\";\nimport { DeadlineExceededError } from \"./error.js\";\nimport { milliseconds } from \"./types.js\";\n\nimport type { DeadlineOptions } from \"./types.js\";\n\nexport const composeSignals = (\n  existing: AbortSignal | undefined,\n  deadline: AbortSignal,\n): AbortSignal => {\n  if (existing === undefined) return deadline;\n  return AbortSignal.any([existing, deadline]);\n};\n\nexport const deadlineMiddleware = <Input extends object, Output extends object>(\n  options?: DeadlineOptions,\n): Pluggable<Input, Output> => {\n  const raw = options?.flushBufferMs ?? 1000;\n  if (raw < 0) {\n    throw new TypeError(`flushBufferMs option must be non-negative, received: ${raw}`);\n  }\n  const flushBufferMs = milliseconds(raw);\n\n  return {\n    applyToStack(stack) {\n      // Registered at \"finalizeRequest\" (attempt level) rather than API-call level so each retry gets a deadline\n      // computed from the actual remaining time at that moment. API-call level would cache a stale deadline\n      // across retries, which grow more dangerous after backoff delays eat into remaining time.\n      stack.add(\n        (\n          next: FinalizeHandler<Input, Output>,\n          _context: HandlerExecutionContext,\n        ): FinalizeHandler<Input, Output> =>\n          async (args: FinalizeHandlerArguments<Input>): Promise<FinalizeHandlerOutput<Output>> => {\n            const remaining = getRemainingTimeInMillis();\n            if (remaining === undefined) return next(args);\n\n            const deadline = remaining - flushBufferMs;\n\n            if (deadline <= 0) {\n              throw new DeadlineExceededError({\n                deadlineMs: milliseconds(0),\n                flushBufferMs,\n                remainingMs: milliseconds(remaining),\n              });\n            }\n\n            const controller = new AbortController();\n            const timeoutId = setTimeout(() => {\n              controller.abort(\n                new DeadlineExceededError({\n                  deadlineMs: milliseconds(deadline),\n                  flushBufferMs,\n                  remainingMs: milliseconds(remaining),\n                }),\n              );\n            }, deadline);\n\n            // `using` guarantees cleanup (clearTimeout) even if next() throws, the promise rejects,\n            // or an external abort signal fires — strictly more reliable than try/finally.\n            using _timer = {\n              [Symbol.dispose]() {\n                clearTimeout(timeoutId);\n              },\n            };\n\n            // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- Smithy request is an opaque object; we access optional signal property\n            const request = args.request as { signal?: AbortSignal } | undefined;\n            const signal = composeSignals(request?.signal, controller.signal);\n            const result = await next({\n              ...args,\n              // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- spreading opaque Smithy request to add signal\n              request: { ...(args.request as object), signal },\n            });\n            return result;\n          },\n        {\n          step: \"finalizeRequest\",\n          name: \"deadlineMiddleware\",\n          override: true,\n        },\n      );\n    },\n  };\n};\n"]}

package/dist/middleware.js

@@ -1,65 +1,47 @@
-// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors
-// SPDX-License-Identifier: MIT
 import { getRemainingTimeInMillis } from "./context-store.js";
 import { DeadlineExceededError } from "./error.js";
 import { milliseconds } from "./types.js";
-export const computeDeadline = (config) => {
-	const remaining = getRemainingTimeInMillis();
-	if (remaining === undefined) {
-		return { kind: "no-context" };
-	}
-	const deadline = remaining - config.flushBufferMs;
-	if (deadline <= 0) {
-		return {
-			kind: "insufficient-time",
-			remaining: milliseconds(remaining),
-			buffer: config.flushBufferMs
-		};
-	}
-	// oxlint-disable-next-line typescript/no-unsafe-type-assertion -- branded narrowing: deadline is validated > 0 above
-	return {
-		kind: "deadline",
-		value: deadline
-	};
-};
-export const createDeadlineTimer = (deadlineMs, config) => {
-	const controller = new AbortController();
-	const remaining = milliseconds(deadlineMs + config.flushBufferMs);
-	const error = new DeadlineExceededError({
-		deadlineMs: milliseconds(deadlineMs),
-		flushBufferMs: config.flushBufferMs,
-		remainingMs: remaining
-	});
-	const timeoutId = setTimeout(() => {
-		controller.abort(error);
-	}, deadlineMs);
-	return {
-		controller,
-		[Symbol.dispose]() {
-			clearTimeout(timeoutId);
-		}
-	};
-};
 export const composeSignals = (existing, deadline) => {
 	if (existing === undefined) return deadline;
 	return AbortSignal.any([existing, deadline]);
 };
-export const deadlineMiddlewareHandler = (config) => (next, _context) => async (args) => {
-	const computation = computeDeadline(config);
-	switch (computation.kind) {
-		case "no-context": return next(args);
-		case "insufficient-time": throw new DeadlineExceededError({
-			deadlineMs: milliseconds(0),
-			flushBufferMs: computation.buffer,
-			remainingMs: computation.remaining
-		});
-		case "deadline": {
+export const deadlineMiddleware = (options) => {
+	const raw = options?.flushBufferMs ?? 1e3;
+	if (raw < 0) {
+		throw new TypeError(`flushBufferMs option must be non-negative, received: ${raw}`);
+	}
+	const flushBufferMs = milliseconds(raw);
+	return { applyToStack(stack) {
+		// Registered at "finalizeRequest" (attempt level) rather than API-call level so each retry gets a deadline
+		// computed from the actual remaining time at that moment. API-call level would cache a stale deadline
+		// across retries, which grow more dangerous after backoff delays eat into remaining time.
+		stack.add((next, _context) => async (args) => {
+			const remaining = getRemainingTimeInMillis();
+			if (remaining === undefined) return next(args);
+			const deadline = remaining - flushBufferMs;
+			if (deadline <= 0) {
+				throw new DeadlineExceededError({
+					deadlineMs: milliseconds(0),
+					flushBufferMs,
+					remainingMs: milliseconds(remaining)
+				});
+			}
+			const controller = new AbortController();
+			const timeoutId = setTimeout(() => {
+				controller.abort(new DeadlineExceededError({
+					deadlineMs: milliseconds(deadline),
+					flushBufferMs,
+					remainingMs: milliseconds(remaining)
+				}));
+			}, deadline);
 			// `using` guarantees cleanup (clearTimeout) even if next() throws, the promise rejects,
 			// or an external abort signal fires — strictly more reliable than try/finally.
-			using timer = createDeadlineTimer(computation.value, config);
+			using _timer = { [Symbol.dispose]() {
+				clearTimeout(timeoutId);
+			} };
 			// oxlint-disable-next-line typescript/no-unsafe-type-assertion -- Smithy request is an opaque object; we access optional signal property
 			const request = args.request;
-			const signal = composeSignals(request?.signal, timer.controller.signal);
+			const signal = composeSignals(request?.signal, controller.signal);
 			const result = await next({
 				...args,
 				// oxlint-disable-next-line typescript/no-unsafe-type-assertion -- spreading opaque Smithy request to add signal
@@ -69,8 +51,12 @@ export const deadlineMiddlewareHandler = (config) => (next, _context) => async (
 				}
 			});
 			return result;
-		}
-	}
+		}, {
+			step: "finalizeRequest",
+			name: "deadlineMiddleware",
+			override: true
+		});
+	} };
 };
 
 //# sourceMappingURL=middleware.js.map

package/dist/middleware.js.map

@@ -1 +1 @@
-{"mappings":";;AAGA,SAAS,gCAAgC;AACzC,SAAS,6BAA6B;AAEtC,SAAS,oBAAoB;AAU7B,OAAO,MAAM,mBAAmB,WAA0D;CACxF,MAAM,YAAY,yBAAyB;CAE3C,IAAI,cAAc,WAAW;EAC3B,OAAO,EAAE,MAAM,aAAa;CAC9B;CAEA,MAAM,WAAW,YAAY,OAAO;CAEpC,IAAI,YAAY,GAAG;EACjB,OAAO;GACL,MAAM;GACN,WAAW,aAAa,SAAS;GACjC,QAAQ,OAAO;EACjB;CACF;;CAGA,OAAO;EAAE,MAAM;EAAY,OAAO;CAA8B;AAClE;AAOA,OAAO,MAAM,uBACX,YACA,WACkB;CAClB,MAAM,aAAa,IAAI,gBAAgB;CACvC,MAAM,YAAY,aAAa,aAAa,OAAO,aAAa;CAChE,MAAM,QAAQ,IAAI,sBAAsB;EACtC,YAAY,aAAa,UAAU;EACnC,eAAe,OAAO;EACtB,aAAa;CACf,CAAC;CACD,MAAM,YAAY,iBAAiB;EACjC,WAAW,MAAM,KAAK;CACxB,GAAG,UAAU;CACb,OAAO;EACL;EACA,CAAC,OAAO,WAAW;GACjB,aAAa,SAAS;EACxB;CACF;AACF;AAEA,OAAO,MAAM,kBACX,UACA,aACgB;CAChB,IAAI,aAAa,WAAW,OAAO;CACnC,OAAO,YAAY,IAAI,CAAC,UAAU,QAAQ,CAAC;AAC7C;AAEA,OAAO,MAAM,6BAET,YAGA,MACA,aAGF,OAAO,SAAkF;CACvF,MAAM,cAAc,gBAAgB,MAAM;CAE1C,QAAQ,YAAY,MAApB;EACE,KAAK,cACH,OAAO,KAAK,IAAI;EAElB,KAAK,qBACH,MAAM,IAAI,sBAAsB;GAC9B,YAAY,aAAa,CAAC;GAC1B,eAAe,YAAY;GAC3B,aAAa,YAAY;EAC3B,CAAC;EAEH,KAAK,YAAY;;;GAGf,MAAM,QAAQ,oBAAoB,YAAY,OAAO,MAAM;;GAE3D,MAAM,UAAU,KAAK;GACrB,MAAM,SAAS,eAAe,SAAS,QAAQ,MAAM,WAAW,MAAM;GACtE,MAAM,SAAS,MAAM,KAAK;IACxB,GAAG;;IAEH,SAAS;KAAE,GAAI,KAAK;KAAoB;IAAO;GACjD,CAAC;GACD,OAAO;EACT;CACF;AACF","names":[],"sources":["src/middleware.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nimport { getRemainingTimeInMillis } from \"./context-store.js\";\nimport { DeadlineExceededError } from \"./error.js\";\nimport type { DeadlineComputation, DeadlineMiddlewareConfig, RequestDeadlineMs } from \"./types.js\";\nimport { milliseconds } from \"./types.js\";\n\nimport type {\n  FinalizeHandler,\n  FinalizeHandlerArguments,\n  FinalizeHandlerOutput,\n  FinalizeRequestMiddleware,\n  HandlerExecutionContext,\n} from \"@smithy/types\";\n\nexport const computeDeadline = (config: DeadlineMiddlewareConfig): DeadlineComputation => {\n  const remaining = getRemainingTimeInMillis();\n\n  if (remaining === undefined) {\n    return { kind: \"no-context\" };\n  }\n\n  const deadline = remaining - config.flushBufferMs;\n\n  if (deadline <= 0) {\n    return {\n      kind: \"insufficient-time\",\n      remaining: milliseconds(remaining),\n      buffer: config.flushBufferMs,\n    };\n  }\n\n  // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- branded narrowing: deadline is validated > 0 above\n  return { kind: \"deadline\", value: deadline as RequestDeadlineMs };\n};\n\nexport interface DeadlineTimer {\n  readonly controller: AbortController;\n  [Symbol.dispose]: () => void;\n}\n\nexport const createDeadlineTimer = (\n  deadlineMs: RequestDeadlineMs,\n  config: DeadlineMiddlewareConfig,\n): DeadlineTimer => {\n  const controller = new AbortController();\n  const remaining = milliseconds(deadlineMs + config.flushBufferMs);\n  const error = new DeadlineExceededError({\n    deadlineMs: milliseconds(deadlineMs),\n    flushBufferMs: config.flushBufferMs,\n    remainingMs: remaining,\n  });\n  const timeoutId = setTimeout(() => {\n    controller.abort(error);\n  }, deadlineMs);\n  return {\n    controller,\n    [Symbol.dispose]() {\n      clearTimeout(timeoutId);\n    },\n  };\n};\n\nexport const composeSignals = (\n  existing: AbortSignal | undefined,\n  deadline: AbortSignal,\n): AbortSignal => {\n  if (existing === undefined) return deadline;\n  return AbortSignal.any([existing, deadline]);\n};\n\nexport const deadlineMiddlewareHandler =\n  <Input extends object, Output extends object>(\n    config: DeadlineMiddlewareConfig,\n  ): FinalizeRequestMiddleware<Input, Output> =>\n  (\n    next: FinalizeHandler<Input, Output>,\n    _context: HandlerExecutionContext,\n  ): FinalizeHandler<Input, Output> =>\n  // oxlint-disable-next-line typescript/consistent-return -- switch is exhaustive over DeadlineComputation discriminated union\n  async (args: FinalizeHandlerArguments<Input>): Promise<FinalizeHandlerOutput<Output>> => {\n    const computation = computeDeadline(config);\n\n    switch (computation.kind) {\n      case \"no-context\":\n        return next(args);\n\n      case \"insufficient-time\":\n        throw new DeadlineExceededError({\n          deadlineMs: milliseconds(0),\n          flushBufferMs: computation.buffer,\n          remainingMs: computation.remaining,\n        });\n\n      case \"deadline\": {\n        // `using` guarantees cleanup (clearTimeout) even if next() throws, the promise rejects,\n        // or an external abort signal fires — strictly more reliable than try/finally.\n        using timer = createDeadlineTimer(computation.value, config);\n        // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- Smithy request is an opaque object; we access optional signal property\n        const request = args.request as { signal?: AbortSignal } | undefined;\n        const signal = composeSignals(request?.signal, timer.controller.signal);\n        const result = await next({\n          ...args,\n          // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- spreading opaque Smithy request to add signal\n          request: { ...(args.request as object), signal },\n        });\n        return result;\n      }\n    }\n  };\n"]}
+{"mappings":"AAWA,SAAS,gCAAgC;AACzC,SAAS,6BAA6B;AACtC,SAAS,oBAAoB;AAI7B,OAAO,MAAM,kBACX,UACA,aACgB;CAChB,IAAI,aAAa,WAAW,OAAO;CACnC,OAAO,YAAY,IAAI,CAAC,UAAU,QAAQ,CAAC;AAC7C;AAEA,OAAO,MAAM,sBACX,YAC6B;CAC7B,MAAM,MAAM,SAAS,iBAAiB;CACtC,IAAI,MAAM,GAAG;EACX,MAAM,IAAI,UAAU,wDAAwD,KAAK;CACnF;CACA,MAAM,gBAAgB,aAAa,GAAG;CAEtC,OAAO,EACL,aAAa,OAAO;;;;EAIlB,MAAM,KAEF,MACA,aAEA,OAAO,SAAkF;GACvF,MAAM,YAAY,yBAAyB;GAC3C,IAAI,cAAc,WAAW,OAAO,KAAK,IAAI;GAE7C,MAAM,WAAW,YAAY;GAE7B,IAAI,YAAY,GAAG;IACjB,MAAM,IAAI,sBAAsB;KAC9B,YAAY,aAAa,CAAC;KAC1B;KACA,aAAa,aAAa,SAAS;IACrC,CAAC;GACH;GAEA,MAAM,aAAa,IAAI,gBAAgB;GACvC,MAAM,YAAY,iBAAiB;IACjC,WAAW,MACT,IAAI,sBAAsB;KACxB,YAAY,aAAa,QAAQ;KACjC;KACA,aAAa,aAAa,SAAS;IACrC,CAAC,CACH;GACF,GAAG,QAAQ;;;GAIX,MAAM,SAAS,EACb,CAAC,OAAO,WAAW;IACjB,aAAa,SAAS;GACxB,EACF;;GAGA,MAAM,UAAU,KAAK;GACrB,MAAM,SAAS,eAAe,SAAS,QAAQ,WAAW,MAAM;GAChE,MAAM,SAAS,MAAM,KAAK;IACxB,GAAG;;IAEH,SAAS;KAAE,GAAI,KAAK;KAAoB;IAAO;GACjD,CAAC;GACD,OAAO;EACT,GACF;GACE,MAAM;GACN,MAAM;GACN,UAAU;EACZ,CACF;CACF,EACF;AACF","names":[],"sources":["src/middleware.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nimport type {\n  FinalizeHandler,\n  FinalizeHandlerArguments,\n  FinalizeHandlerOutput,\n  HandlerExecutionContext,\n  Pluggable,\n} from \"@smithy/types\";\n\nimport { getRemainingTimeInMillis } from \"./context-store.js\";\nimport { DeadlineExceededError } from \"./error.js\";\nimport { milliseconds } from \"./types.js\";\n\nimport type { DeadlineOptions } from \"./types.js\";\n\nexport const composeSignals = (\n  existing: AbortSignal | undefined,\n  deadline: AbortSignal,\n): AbortSignal => {\n  if (existing === undefined) return deadline;\n  return AbortSignal.any([existing, deadline]);\n};\n\nexport const deadlineMiddleware = <Input extends object, Output extends object>(\n  options?: DeadlineOptions,\n): Pluggable<Input, Output> => {\n  const raw = options?.flushBufferMs ?? 1000;\n  if (raw < 0) {\n    throw new TypeError(`flushBufferMs option must be non-negative, received: ${raw}`);\n  }\n  const flushBufferMs = milliseconds(raw);\n\n  return {\n    applyToStack(stack) {\n      // Registered at \"finalizeRequest\" (attempt level) rather than API-call level so each retry gets a deadline\n      // computed from the actual remaining time at that moment. API-call level would cache a stale deadline\n      // across retries, which grow more dangerous after backoff delays eat into remaining time.\n      stack.add(\n        (\n          next: FinalizeHandler<Input, Output>,\n          _context: HandlerExecutionContext,\n        ): FinalizeHandler<Input, Output> =>\n          async (args: FinalizeHandlerArguments<Input>): Promise<FinalizeHandlerOutput<Output>> => {\n            const remaining = getRemainingTimeInMillis();\n            if (remaining === undefined) return next(args);\n\n            const deadline = remaining - flushBufferMs;\n\n            if (deadline <= 0) {\n              throw new DeadlineExceededError({\n                deadlineMs: milliseconds(0),\n                flushBufferMs,\n                remainingMs: milliseconds(remaining),\n              });\n            }\n\n            const controller = new AbortController();\n            const timeoutId = setTimeout(() => {\n              controller.abort(\n                new DeadlineExceededError({\n                  deadlineMs: milliseconds(deadline),\n                  flushBufferMs,\n                  remainingMs: milliseconds(remaining),\n                }),\n              );\n            }, deadline);\n\n            // `using` guarantees cleanup (clearTimeout) even if next() throws, the promise rejects,\n            // or an external abort signal fires — strictly more reliable than try/finally.\n            using _timer = {\n              [Symbol.dispose]() {\n                clearTimeout(timeoutId);\n              },\n            };\n\n            // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- Smithy request is an opaque object; we access optional signal property\n            const request = args.request as { signal?: AbortSignal } | undefined;\n            const signal = composeSignals(request?.signal, controller.signal);\n            const result = await next({\n              ...args,\n              // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- spreading opaque Smithy request to add signal\n              request: { ...(args.request as object), signal },\n            });\n            return result;\n          },\n        {\n          step: \"finalizeRequest\",\n          name: \"deadlineMiddleware\",\n          override: true,\n        },\n      );\n    },\n  };\n};\n"]}

package/dist/types.d.ts

@@ -6,27 +6,9 @@ type Brand<
 	readonly [BrandSymbol]: B;
 };
 export type Milliseconds = Brand<number, "Milliseconds">;
-export type FlushBufferMs = Brand<number, "FlushBufferMs">;
-export type RequestDeadlineMs = Brand<number, "RequestDeadlineMs">;
 export declare const milliseconds: (value: number) => Milliseconds;
-export declare const flushBufferMs: (value: number) => FlushBufferMs;
-export type DeadlineComputation = {
-	readonly kind: "deadline";
-	readonly value: RequestDeadlineMs;
-} | {
-	readonly kind: "insufficient-time";
-	readonly remaining: Milliseconds;
-	readonly buffer: FlushBufferMs;
-} | {
-	readonly kind: "no-context";
-};
-export interface DeadlineMiddlewareConfig {
-	readonly flushBufferMs: FlushBufferMs;
-	readonly telemetryEnabled: boolean;
-}
 export interface DeadlineOptions {
 	readonly flushBufferMs?: number;
-	readonly telemetryEnabled?: boolean;
 }
 export {};
 

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"mappings":"AAKA,cAAc;KAET;CAAM;CAAG;IAAoB,IAAI;WAAY,cAAc;AAAE;AAElE,YAAY,eAAe,cAAc;AAEzC,YAAY,gBAAgB,cAAc;AAE1C,YAAY,oBAAoB,cAAc;AAE9C,OAAO,cAAM,eAAgB,kBAAgB;AAQ7C,OAAO,cAAM,gBAAiB,kBAAgB;AAW9C,YAAY,sBACR;UAAW,MAAM;UAAqB,OAAO;AAAkB,IAC/D;UACW,MAAM;UACN,WAAW;UACX,QAAQ;AACnB,IACA;UAAW,MAAM;AAAa;AAElC,iBAAiB,yBAAyB;UAC/B,eAAe;UACf;AACX;AAEA,iBAAiB,gBAAgB;UACtB;UACA;AACX","names":[],"sources":["src/types.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\n// Branded types prevent interchange errors at compile time (e.g. passing seconds where milliseconds are expected).\n// Zero runtime cost. Smart constructors below validate at the boundary and brand the value.\ndeclare const BrandSymbol: unique symbol;\n\ntype Brand<T, B extends string> = T & { readonly [BrandSymbol]: B };\n\nexport type Milliseconds = Brand<number, \"Milliseconds\">;\n\nexport type FlushBufferMs = Brand<number, \"FlushBufferMs\">;\n\nexport type RequestDeadlineMs = Brand<number, \"RequestDeadlineMs\">;\n\nexport const milliseconds = (value: number): Milliseconds => {\n  if (!Number.isFinite(value)) {\n    throw new TypeError(`milliseconds value must be finite, received: ${value}`);\n  }\n  // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- branded type constructor: value is validated above\n  return value as Milliseconds;\n};\n\nexport const flushBufferMs = (value: number): FlushBufferMs => {\n  if (!Number.isFinite(value)) {\n    throw new TypeError(`flushBufferMs value must be finite, received: ${value}`);\n  }\n  if (value < 0) {\n    throw new TypeError(`flushBufferMs must be non-negative, received: ${value}`);\n  }\n  // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- branded type constructor: value is validated above\n  return value as FlushBufferMs;\n};\n\nexport type DeadlineComputation =\n  | { readonly kind: \"deadline\"; readonly value: RequestDeadlineMs }\n  | {\n      readonly kind: \"insufficient-time\";\n      readonly remaining: Milliseconds;\n      readonly buffer: FlushBufferMs;\n    }\n  | { readonly kind: \"no-context\" };\n\nexport interface DeadlineMiddlewareConfig {\n  readonly flushBufferMs: FlushBufferMs;\n  readonly telemetryEnabled: boolean;\n}\n\nexport interface DeadlineOptions {\n  readonly flushBufferMs?: number;\n  readonly telemetryEnabled?: boolean;\n}\n"]}
+{"mappings":"AAKA,cAAc;KAET;CAAM;CAAG;IAAoB,IAAI;WAAY,cAAc;AAAE;AAElE,YAAY,eAAe,cAAc;AAEzC,OAAO,cAAM,eAAgB,kBAAgB;AAQ7C,iBAAiB,gBAAgB;UACtB;AACX","names":[],"sources":["src/types.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\n// Branded type prevents interchange errors at compile time (e.g. passing seconds where milliseconds are expected).\n// Zero runtime cost. Smart constructor below validates at the boundary and brands the value.\ndeclare const BrandSymbol: unique symbol;\n\ntype Brand<T, B extends string> = T & { readonly [BrandSymbol]: B };\n\nexport type Milliseconds = Brand<number, \"Milliseconds\">;\n\nexport const milliseconds = (value: number): Milliseconds => {\n  if (!Number.isFinite(value)) {\n    throw new TypeError(`milliseconds value must be finite, received: ${value}`);\n  }\n  // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- branded type constructor: value is validated above\n  return value as Milliseconds;\n};\n\nexport interface DeadlineOptions {\n  readonly flushBufferMs?: number;\n}\n"]}

package/dist/types.js

@@ -5,15 +5,5 @@ export const milliseconds = (value) => {
 	// oxlint-disable-next-line typescript/no-unsafe-type-assertion -- branded type constructor: value is validated above
 	return value;
 };
-export const flushBufferMs = (value) => {
-	if (!Number.isFinite(value)) {
-		throw new TypeError(`flushBufferMs value must be finite, received: ${value}`);
-	}
-	if (value < 0) {
-		throw new TypeError(`flushBufferMs must be non-negative, received: ${value}`);
-	}
-	// oxlint-disable-next-line typescript/no-unsafe-type-assertion -- branded type constructor: value is validated above
-	return value;
-};
 
 //# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -1 +1 @@
-{"mappings":"AAeA,OAAO,MAAM,gBAAgB,UAAgC;CAC3D,IAAI,CAAC,OAAO,SAAS,KAAK,GAAG;EAC3B,MAAM,IAAI,UAAU,gDAAgD,OAAO;CAC7E;;CAEA,OAAO;AACT;AAEA,OAAO,MAAM,iBAAiB,UAAiC;CAC7D,IAAI,CAAC,OAAO,SAAS,KAAK,GAAG;EAC3B,MAAM,IAAI,UAAU,iDAAiD,OAAO;CAC9E;CACA,IAAI,QAAQ,GAAG;EACb,MAAM,IAAI,UAAU,iDAAiD,OAAO;CAC9E;;CAEA,OAAO;AACT","names":[],"sources":["src/types.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\n// Branded types prevent interchange errors at compile time (e.g. passing seconds where milliseconds are expected).\n// Zero runtime cost. Smart constructors below validate at the boundary and brand the value.\ndeclare const BrandSymbol: unique symbol;\n\ntype Brand<T, B extends string> = T & { readonly [BrandSymbol]: B };\n\nexport type Milliseconds = Brand<number, \"Milliseconds\">;\n\nexport type FlushBufferMs = Brand<number, \"FlushBufferMs\">;\n\nexport type RequestDeadlineMs = Brand<number, \"RequestDeadlineMs\">;\n\nexport const milliseconds = (value: number): Milliseconds => {\n  if (!Number.isFinite(value)) {\n    throw new TypeError(`milliseconds value must be finite, received: ${value}`);\n  }\n  // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- branded type constructor: value is validated above\n  return value as Milliseconds;\n};\n\nexport const flushBufferMs = (value: number): FlushBufferMs => {\n  if (!Number.isFinite(value)) {\n    throw new TypeError(`flushBufferMs value must be finite, received: ${value}`);\n  }\n  if (value < 0) {\n    throw new TypeError(`flushBufferMs must be non-negative, received: ${value}`);\n  }\n  // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- branded type constructor: value is validated above\n  return value as FlushBufferMs;\n};\n\nexport type DeadlineComputation =\n  | { readonly kind: \"deadline\"; readonly value: RequestDeadlineMs }\n  | {\n      readonly kind: \"insufficient-time\";\n      readonly remaining: Milliseconds;\n      readonly buffer: FlushBufferMs;\n    }\n  | { readonly kind: \"no-context\" };\n\nexport interface DeadlineMiddlewareConfig {\n  readonly flushBufferMs: FlushBufferMs;\n  readonly telemetryEnabled: boolean;\n}\n\nexport interface DeadlineOptions {\n  readonly flushBufferMs?: number;\n  readonly telemetryEnabled?: boolean;\n}\n"]}
+{"mappings":"AAWA,OAAO,MAAM,gBAAgB,UAAgC;CAC3D,IAAI,CAAC,OAAO,SAAS,KAAK,GAAG;EAC3B,MAAM,IAAI,UAAU,gDAAgD,OAAO;CAC7E;;CAEA,OAAO;AACT","names":[],"sources":["src/types.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\n// Branded type prevents interchange errors at compile time (e.g. passing seconds where milliseconds are expected).\n// Zero runtime cost. Smart constructor below validates at the boundary and brands the value.\ndeclare const BrandSymbol: unique symbol;\n\ntype Brand<T, B extends string> = T & { readonly [BrandSymbol]: B };\n\nexport type Milliseconds = Brand<number, \"Milliseconds\">;\n\nexport const milliseconds = (value: number): Milliseconds => {\n  if (!Number.isFinite(value)) {\n    throw new TypeError(`milliseconds value must be finite, received: ${value}`);\n  }\n  // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- branded type constructor: value is validated above\n  return value as Milliseconds;\n};\n\nexport interface DeadlineOptions {\n  readonly flushBufferMs?: number;\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lambda-deadline-middleware",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "AWS SDK v3 middleware for automatic Lambda deadline propagation via AbortController-based timeouts",
   "license": "MIT",
   "repository": {
@@ -64,11 +64,11 @@
     "conventional-changelog-conventionalcommits": "^9.3.1",
     "knip": "^6.16.1",
     "lefthook": "^2.1.9",
-    "oxc-transform": "^0.134.0",
-    "oxfmt": "^0.53.0",
+    "oxc-transform": "^0.135.0",
+    "oxfmt": "^0.54.0",
     "oxlint": "^1.69.0",
     "oxlint-tsgolint": "^0.23.0",
-    "semantic-release": "25.0.3",
+    "semantic-release": "25.0.5",
     "typescript": "^6.0.3",
     "vitest": "^4.1.8"
   },

package/src/context-store.ts

@@ -9,30 +9,16 @@ export interface LambdaContextLike {
   getRemainingTimeInMillis?: () => number;
 }
 
-// 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: unique symbol = Symbol("no-context");
-
-type StoreValue = LambdaContextLike | typeof NO_CONTEXT;
-
-const contextStorage = new AsyncLocalStorage<StoreValue>();
+const contextStorage = new AsyncLocalStorage<LambdaContextLike>();
 
 export const run = <T>(context: LambdaContextLike | null | undefined, fn: () => T): T => {
-  const value: StoreValue = context ?? NO_CONTEXT;
-  return contextStorage.run(value, fn);
+  if (context === null || context === undefined) return fn();
+  return contextStorage.run(context, fn);
 };
 
 export const getRemainingTimeInMillis = (): number | undefined => {
   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();
 };