lambda-deadline-middleware 0.0.0 → 1.1.0

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>;
-export declare function withLambdaDeadline<
+> = (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,iBAAS;CAAmB;CAAQ;EACzC,SAAS,aAAa,QAAQ,UAC9B,WAAW,kBACV,aAAa,QAAQ","names":[],"sources":["src/handler-wrapper.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2024 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 function withLambdaDeadline<TEvent, TResult>(\n  handler: AsyncHandler<TEvent, TResult>,\n  _options?: DeadlineOptions,\n): AsyncHandler<TEvent, TResult> {\n  return async (event: TEvent, context: LambdaContextLike): Promise<TResult> =>\n    run(context, async () => handler(event, context));\n}\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,8 +1,6 @@
-// SPDX-FileCopyrightText: 2024 lambda-deadline-middleware contributors
+// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors
 // SPDX-License-Identifier: MIT
 import { run } from "./context-store.js";
-export function withLambdaDeadline(handler, _options) {
-	return 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,SAAS,mBACd,SACA,UAC+B;CAC/B,OAAO,OAAO,OAAe,YAC3B,IAAI,SAAS,YAAY,QAAQ,OAAO,OAAO,CAAC;AACpD","names":[],"sources":["src/handler-wrapper.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2024 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 function withLambdaDeadline<TEvent, TResult>(\n  handler: AsyncHandler<TEvent, TResult>,\n  _options?: DeadlineOptions,\n): AsyncHandler<TEvent, TResult> {\n  return async (event: TEvent, context: LambdaContextLike): Promise<TResult> =>\n    run(context, async () => handler(event, context));\n}\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, withDeadline } 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,oBAAoB,oBAAoB;AACjD,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: 2024 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nexport { withLambdaDeadline } from \"./handler-wrapper.js\";\nexport { deadlineMiddleware, withDeadline } 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: 2024 lambda-deadline-middleware contributors
+// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors
 // SPDX-License-Identifier: MIT
 export { withLambdaDeadline } from "./handler-wrapper.js";
-export { deadlineMiddleware, withDeadline } 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,oBAAoB,oBAAoB;AACjD,SAAS,uBAAuB,0BAA0B;AAC1D,SAAS,gCAAgC","names":[],"sources":["src/index.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2024 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nexport { withLambdaDeadline } from \"./handler-wrapper.js\";\nexport { deadlineMiddleware, withDeadline } 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,12 +1,9 @@
-import type { DeadlineComputation, DeadlineMiddlewareConfig, RequestDeadlineMs } from "./types.js";
-import type { FinalizeRequestMiddleware } from "@smithy/types";
-export declare function computeDeadline(config: DeadlineMiddlewareConfig): DeadlineComputation;
-export interface DeadlineTimer {
-	readonly controller: AbortController;
-	[Symbol.dispose]: () => void;
-}
-export declare function createDeadlineTimer(deadlineMs: RequestDeadlineMs, config: DeadlineMiddlewareConfig): DeadlineTimer;
-export declare function composeSignals(existing: AbortSignal | undefined, deadline: AbortSignal): AbortSignal;
-export declare function deadlineMiddlewareHandler(config: DeadlineMiddlewareConfig): FinalizeRequestMiddleware<object, object>;
+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 deadlineMiddleware: <
+	Input extends object,
+	Output extends object
+>(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,iBAAS,gBAAgB,QAAQ,2BAA2B;AAqBnE,iBAAiB,cAAc;UACpB,YAAY;EACpB,OAAO;AACV;AAEA,OAAO,iBAAS,oBACd,YAAY,mBACZ,QAAQ,2BACP;AAmBH,OAAO,iBAAS,eACd,UAAU,yBACV,UAAU,cACT;AAKH,OAAO,iBAAS,0BACd,QAAQ,2BACP","names":[],"sources":["src/middleware.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2024 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 function 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 function 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 function 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 function deadlineMiddlewareHandler(\n  config: DeadlineMiddlewareConfig,\n): FinalizeRequestMiddleware<object, object> {\n  return (\n    next: FinalizeHandler<object, object>,\n    _context: HandlerExecutionContext,\n  ): FinalizeHandler<object, object> =>\n    // oxlint-disable-next-line typescript/consistent-return -- switch is exhaustive over DeadlineComputation discriminated union\n    async (args: FinalizeHandlerArguments<object>): Promise<FinalizeHandlerOutput<object>> => {\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 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}\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,76 +1,62 @@
-// SPDX-FileCopyrightText: 2024 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 function 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 function 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 function composeSignals(existing, deadline) {
+export const composeSignals = (existing, deadline) => {
 	if (existing === undefined) return deadline;
 	return AbortSignal.any([existing, deadline]);
-}
-export function deadlineMiddlewareHandler(config) {
-	return (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": {
-				using timer = createDeadlineTimer(computation.value, config);
-				// 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 result = await next({
-					...args,
-					// oxlint-disable-next-line typescript/no-unsafe-type-assertion -- spreading opaque Smithy request to add signal
-					request: {
-						...args.request,
-						signal
-					}
+};
+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)
 				});
-				return result;
 			}
-		}
-	};
-}
+			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 = { [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, controller.signal);
+			const result = await next({
+				...args,
+				// oxlint-disable-next-line typescript/no-unsafe-type-assertion -- spreading opaque Smithy request to add signal
+				request: {
+					...args.request,
+					signal
+				}
+			});
+			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,SAAS,gBAAgB,QAAuD;CACrF,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,SAAS,oBACd,YACA,QACe;CACf,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,SAAS,eACd,UACA,UACa;CACb,IAAI,aAAa,WAAW,OAAO;CACnC,OAAO,YAAY,IAAI,CAAC,UAAU,QAAQ,CAAC;AAC7C;AAEA,OAAO,SAAS,0BACd,QAC2C;CAC3C,QACE,MACA,aAGA,OAAO,SAAmF;EACxF,MAAM,cAAc,gBAAgB,MAAM;EAE1C,QAAQ,YAAY,MAApB;GACE,KAAK,cACH,OAAO,KAAK,IAAI;GAElB,KAAK,qBACH,MAAM,IAAI,sBAAsB;IAC9B,YAAY,aAAa,CAAC;IAC1B,eAAe,YAAY;IAC3B,aAAa,YAAY;GAC3B,CAAC;GAEH,KAAK,YAAY;IACf,MAAM,QAAQ,oBAAoB,YAAY,OAAO,MAAM;;IAE3D,MAAM,UAAU,KAAK;IACrB,MAAM,SAAS,eAAe,SAAS,QAAQ,MAAM,WAAW,MAAM;IACtE,MAAM,SAAS,MAAM,KAAK;KACxB,GAAG;;KAEH,SAAS;MAAE,GAAI,KAAK;MAAoB;KAAO;IACjD,CAAC;IACD,OAAO;GACT;EACF;CACF;AACJ","names":[],"sources":["src/middleware.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2024 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 function 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 function 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 function 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 function deadlineMiddlewareHandler(\n  config: DeadlineMiddlewareConfig,\n): FinalizeRequestMiddleware<object, object> {\n  return (\n    next: FinalizeHandler<object, object>,\n    _context: HandlerExecutionContext,\n  ): FinalizeHandler<object, object> =>\n    // oxlint-disable-next-line typescript/consistent-return -- switch is exhaustive over DeadlineComputation discriminated union\n    async (args: FinalizeHandlerArguments<object>): Promise<FinalizeHandlerOutput<object>> => {\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 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}\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 function milliseconds(value: number): Milliseconds;
-export declare function 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 declare const milliseconds: (value: number) => Milliseconds;
 export interface DeadlineOptions {
 	readonly flushBufferMs?: number;
-	readonly telemetryEnabled?: boolean;
 }
 export {};
 

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"mappings":"AAGA,cAAc;KAET;CAAM;CAAG;IAAoB,IAAI;WAAY,cAAc;AAAE;AAElE,YAAY,eAAe,cAAc;AAEzC,YAAY,gBAAgB,cAAc;AAE1C,YAAY,oBAAoB,cAAc;AAE9C,OAAO,iBAAS,aAAa,gBAAgB;AAQ7C,OAAO,iBAAS,cAAc,gBAAgB;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: 2024 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\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 function 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 function 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

@@ -1,19 +1,9 @@
-export function milliseconds(value) {
+export const milliseconds = (value) => {
 	if (!Number.isFinite(value)) {
 		throw new TypeError(`milliseconds value must be finite, received: ${value}`);
 	}
 	// oxlint-disable-next-line typescript/no-unsafe-type-assertion -- branded type constructor: value is validated above
 	return value;
-}
-export function 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":"AAaA,OAAO,SAAS,aAAa,OAA6B;CACxD,IAAI,CAAC,OAAO,SAAS,KAAK,GAAG;EAC3B,MAAM,IAAI,UAAU,gDAAgD,OAAO;CAC7E;;CAEA,OAAO;AACT;AAEA,OAAO,SAAS,cAAc,OAA8B;CAC1D,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: 2024 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\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 function 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 function 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,12 +1,18 @@
 {
   "name": "lambda-deadline-middleware",
-  "version": "0.0.0",
+  "version": "1.1.0",
   "description": "AWS SDK v3 middleware for automatic Lambda deadline propagation via AbortController-based timeouts",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mikkopiu/lambda-deadline-middleware"
+  },
   "files": [
     "dist",
     "src",
     "LICENSE",
+    "LICENSES",
+    "REUSE.toml",
     "SECURITY.md"
   ],
   "type": "module",
@@ -20,54 +26,54 @@
     "access": "public",
     "provenance": true
   },
+  "scripts": {
+    "build": "node --experimental-strip-types scripts/build.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "bench": "vitest bench --run --outputJson=bench-results.json && node --experimental-strip-types scripts/validate-bench.ts",
+    "typecheck": "tsc",
+    "lint": "oxlint --type-aware --type-check --fix .",
+    "lint:check": "oxlint --type-aware --type-check .",
+    "fmt": "oxfmt .",
+    "fmt:check": "oxfmt --check .",
+    "lint:knip": "knip",
+    "sast": "scripts/ensure-opengrep.sh scan .",
+    "sast:check": "scripts/ensure-opengrep.sh scan --error .",
+    "sca": "podman run --rm -v \"$(pwd):/src:Z\" -v trivy-cache:/root/.cache/trivy:Z ghcr.io/aquasecurity/trivy:0.71.0@sha256:016eae51fdcf989332a5404af7e8f625cd5d95d7c0907a221d080a996f556500 fs --scanners vuln --include-dev-deps --exit-code 1 --severity HIGH,CRITICAL /src",
+    "sca:full": "podman run --rm -v \"$(pwd):/src:Z\" -v trivy-cache:/root/.cache/trivy:Z ghcr.io/aquasecurity/trivy:0.71.0@sha256:016eae51fdcf989332a5404af7e8f625cd5d95d7c0907a221d080a996f556500 fs --scanners vuln,secret,misconfig --include-dev-deps /src",
+    "actionlint": "podman run --rm -w /repo -v \"$(pwd):/repo:Z\" docker.io/rhysd/actionlint:1.7.12@sha256:9d36088643581e728c969f35141f88139fec77280b2be23c1f66f8e40e1025e7",
+    "security": "pnpm run sast:check && pnpm run sca && pnpm run actionlint",
+    "prepare": "lefthook install",
+    "sbom": "pnpm sbom --sbom-format cyclonedx --sbom-spec-version 1.5 --sbom-type library > sbom.cdx.json",
+    "release": "semantic-release"
+  },
   "devDependencies": {
-    "@aws-sdk/client-dynamodb": "^3.1062.0",
-    "@aws-sdk/client-s3": "^3.1062.0",
-    "@aws-sdk/client-sqs": "^3.1062.0",
+    "@aws-sdk/client-dynamodb": "^3.1064.0",
+    "@aws-sdk/client-s3": "^3.1064.0",
+    "@aws-sdk/client-sqs": "^3.1064.0",
     "@commitlint/cli": "^21.0.2",
     "@commitlint/config-conventional": "^21.0.2",
     "@fast-check/vitest": "^0.4.1",
-    "@semantic-release/changelog": "6.0.3",
     "@semantic-release/commit-analyzer": "13.0.1",
-    "@semantic-release/git": "10.0.1",
     "@semantic-release/github": "12.0.8",
     "@semantic-release/npm": "13.1.5",
     "@semantic-release/release-notes-generator": "14.1.1",
     "@smithy/types": "^4.14.3",
-    "@types/node": "^25.9.1",
+    "@types/node": "^25.9.2",
     "@vitest/coverage-v8": "^4.1.8",
     "conventional-changelog-conventionalcommits": "^9.3.1",
-    "knip": "^6.15.0",
+    "knip": "^6.16.1",
     "lefthook": "^2.1.9",
-    "oxc-transform": "^0.134.0",
-    "oxfmt": "^0.53.0",
-    "oxlint": "^1.68.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"
   },
   "engines": {
     "node": ">=24"
   },
-  "scripts": {
-    "build": "node --experimental-strip-types scripts/build.ts",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "bench": "vitest bench --run --outputJson=bench-results.json && node --experimental-strip-types scripts/validate-bench.ts",
-    "typecheck": "tsc",
-    "lint": "oxlint --type-aware --type-check --fix .",
-    "lint:check": "oxlint --type-aware --type-check .",
-    "fmt": "oxfmt .",
-    "fmt:check": "oxfmt --check .",
-    "lint:knip": "knip",
-    "sast": "scripts/ensure-opengrep.sh scan .",
-    "sast:check": "scripts/ensure-opengrep.sh scan --error .",
-    "sca": "podman run --rm -v \"$(pwd):/src:Z\" ghcr.io/aquasecurity/trivy:0.71.0@sha256:016eae51fdcf989332a5404af7e8f625cd5d95d7c0907a221d080a996f556500 fs --scanners vuln --include-dev-deps --exit-code 1 --severity HIGH,CRITICAL /src",
-    "sca:full": "podman run --rm -v \"$(pwd):/src:Z\" ghcr.io/aquasecurity/trivy:0.71.0@sha256:016eae51fdcf989332a5404af7e8f625cd5d95d7c0907a221d080a996f556500 fs --scanners vuln,secret,misconfig --include-dev-deps /src",
-    "actionlint": "podman run --rm -w /repo -v \"$(pwd):/repo:Z\" docker.io/rhysd/actionlint:1.7.12@sha256:9d36088643581e728c969f35141f88139fec77280b2be23c1f66f8e40e1025e7",
-    "security": "pnpm run sast:check && pnpm run sca && pnpm run actionlint",
-    "sbom": "pnpm sbom --sbom-format cyclonedx --sbom-spec-version 1.5 --sbom-type library > sbom.cdx.json",
-    "release": "semantic-release"
-  }
-}
+  "packageManager": "pnpm@11.5.2+sha512.71c631e382066efc25625d5cf029075de07b61b37f6e27350fbd84b1bda5864c8c1967adc280776b45c30a715c0359a3be08fef42d5bb09e2b99029979692916"
+}

package/src/context-store.ts

@@ -1,36 +1,24 @@
-// SPDX-FileCopyrightText: 2024 lambda-deadline-middleware contributors
+// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors
 // SPDX-License-Identifier: MIT
 
 import { AsyncLocalStorage } from "node:async_hooks";
 
+// AsyncLocalStorage propagates the Lambda context through the entire async call chain without parameter threading.
+// SDK middleware executes deep in the Smithy stack where we can't pass the context through function signatures.
 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");
+const contextStorage = new AsyncLocalStorage<LambdaContextLike>();
 
-type StoreValue = LambdaContextLike | typeof NO_CONTEXT;
+export const run = <T>(context: LambdaContextLike | null | undefined, fn: () => T): T => {
+  if (context === null || context === undefined) return fn();
+  return contextStorage.run(context, fn);
+};
 
-const contextStorage = new AsyncLocalStorage<StoreValue>();
-
-export function run<T>(context: LambdaContextLike | null | undefined, fn: () => T): T {
-  const value: StoreValue = context ?? NO_CONTEXT;
-  return contextStorage.run(value, fn);
-}
-
-export function getRemainingTimeInMillis(): number | undefined {
+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();
-}
+};

package/src/error.ts

@@ -1,18 +1,18 @@
-// SPDX-FileCopyrightText: 2024 lambda-deadline-middleware contributors
+// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors
 // SPDX-License-Identifier: MIT
 
-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 class DeadlineExceededError extends Error {
   override readonly name = "DeadlineExceededError" as const;
   readonly deadlineMs: Milliseconds;
-  readonly flushBufferMs: FlushBufferMs;
+  readonly flushBufferMs: Milliseconds;
   readonly remainingMs: Milliseconds;
 
   constructor(init: DeadlineExceededInit) {
@@ -27,8 +27,8 @@ 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: unknown): error is DeadlineExceededError {
+export const isDeadlineExceeded = (error: unknown): error is DeadlineExceededError => {
   if (error === null || error === undefined) return false;
   if (typeof error !== "object") return false;
   return (error as { name?: unknown }).name === "DeadlineExceededError";
-}
+};

package/src/handler-wrapper.ts

@@ -1,19 +1,18 @@
-// SPDX-FileCopyrightText: 2024 lambda-deadline-middleware contributors
+// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors
 // SPDX-License-Identifier: MIT
 
 import { run } from "./context-store.js";
+
 import type { LambdaContextLike } from "./context-store.js";
-import type { DeadlineOptions } from "./types.js";
 
-type AsyncHandler<TEvent, TResult> = (
+type AsyncHandler<TEvent, TContext extends LambdaContextLike, TResult> = (
   event: TEvent,
-  context: LambdaContextLike,
+  context: TContext,
 ) => Promise<TResult>;
 
-export function withLambdaDeadline<TEvent, TResult>(
-  handler: AsyncHandler<TEvent, TResult>,
-  _options?: DeadlineOptions,
-): AsyncHandler<TEvent, TResult> {
-  return async (event: TEvent, context: LambdaContextLike): Promise<TResult> =>
+export const withLambdaDeadline =
+  <TEvent, TContext extends LambdaContextLike, TResult>(
+    handler: AsyncHandler<TEvent, TContext, TResult>,
+  ): AsyncHandler<TEvent, TContext, TResult> =>
+  async (event: TEvent, context: TContext): Promise<TResult> =>
     run(context, async () => handler(event, context));
-}