lambda-deadline-middleware 0.0.0 → 1.0.1

package/dist/error.js

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

package/dist/error.js.map

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

package/dist/handler-wrapper.d.ts

@@ -4,10 +4,10 @@ type AsyncHandler<
 	TEvent,
 	TResult
 > = (event: TEvent, context: LambdaContextLike) => Promise<TResult>;
-export declare function withLambdaDeadline<
+export declare const withLambdaDeadline: <
 	TEvent,
 	TResult
->(handler: AsyncHandler<TEvent, TResult>, _options?: DeadlineOptions): AsyncHandler<TEvent, TResult>;
+>(handler: AsyncHandler<TEvent, TResult>, _options?: DeadlineOptions) => AsyncHandler<TEvent, 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":"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"]}

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, _options) => 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,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"]}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { withLambdaDeadline } from "./handler-wrapper.js";
-export { deadlineMiddleware, withDeadline } from "./registration.js";
+export { deadlineMiddleware } from "./registration.js";
 export { DeadlineExceededError, isDeadlineExceeded } from "./error.js";
 export { getRemainingTimeInMillis } from "./context-store.js";
 export type { Milliseconds, FlushBufferMs, RequestDeadlineMs, DeadlineComputation, DeadlineMiddlewareConfig, DeadlineOptions } from "./types.js";

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

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 "./registration.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 \"./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"]}

package/dist/middleware.d.ts

@@ -1,12 +1,15 @@
 import type { DeadlineComputation, DeadlineMiddlewareConfig, RequestDeadlineMs } from "./types.js";
 import type { FinalizeRequestMiddleware } from "@smithy/types";
-export declare function computeDeadline(config: DeadlineMiddlewareConfig): DeadlineComputation;
+export declare const 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>;
+export declare const createDeadlineTimer: (deadlineMs: RequestDeadlineMs, config: DeadlineMiddlewareConfig) => DeadlineTimer;
+export declare const composeSignals: (existing: AbortSignal | undefined, deadline: AbortSignal) => AbortSignal;
+export declare const deadlineMiddlewareHandler: <
+	Input extends object,
+	Output extends object
+>(config: DeadlineMiddlewareConfig) => FinalizeRequestMiddleware<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":"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"]}

package/dist/middleware.js

@@ -1,9 +1,9 @@
-// SPDX-FileCopyrightText: 2024 lambda-deadline-middleware contributors
+// 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 function computeDeadline(config) {
+export const computeDeadline = (config) => {
 	const remaining = getRemainingTimeInMillis();
 	if (remaining === undefined) {
 		return { kind: "no-context" };
@@ -21,8 +21,8 @@ export function computeDeadline(config) {
 		kind: "deadline",
 		value: deadline
 	};
-}
-export function createDeadlineTimer(deadlineMs, config) {
+};
+export const createDeadlineTimer = (deadlineMs, config) => {
 	const controller = new AbortController();
 	const remaining = milliseconds(deadlineMs + config.flushBufferMs);
 	const error = new DeadlineExceededError({
@@ -39,38 +39,38 @@ export function createDeadlineTimer(deadlineMs, config) {
 			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
+};
+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": {
+			// `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);
+			// 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
+				}
 			});
-			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
-					}
-				});
-				return result;
-			}
+			return result;
 		}
-	};
-}
+	}
+};
 
 //# 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":";;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"]}

package/dist/registration.d.ts

@@ -1,10 +1,8 @@
 import type { Pluggable } from "@smithy/types";
 import type { DeadlineOptions } from "./types.js";
-export declare function deadlineMiddleware(options?: DeadlineOptions): Pluggable<object, object>;
-export declare function withDeadline<T extends {
-	middlewareStack: {
-		use: (pluggable: Pluggable<any, any>) => void;
-	};
-}>(client: T, options?: DeadlineOptions): T;
+export declare const deadlineMiddleware: <
+	Input extends object,
+	Output extends object
+>(options?: DeadlineOptions) => Pluggable<Input, Output>;
 
 //# sourceMappingURL=registration.d.ts.map

package/dist/registration.d.ts.map

@@ -1 +1 @@
-{"mappings":"AAGA,cAAc,iBAAiB;AAI/B,cAAc,uBAAuB;AAErC,OAAO,iBAAS,mBAAmB,UAAU,kBAAkB;AAkB/D,OAAO,iBAAS,aAEd,UAAU;CAAE,iBAAiB;EAAE,MAAM,WAAW;CAA6B;AAAE,GAC/E,QAAQ,GAAG,UAAU,kBAAkB","names":[],"sources":["src/registration.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2024 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nimport type { Pluggable } from \"@smithy/types\";\n\nimport { parseConfig } from \"./config.js\";\nimport { deadlineMiddlewareHandler } from \"./middleware.js\";\nimport type { DeadlineOptions } from \"./types.js\";\n\nexport function deadlineMiddleware(options?: DeadlineOptions): Pluggable<object, object> {\n  const config = parseConfig(options);\n\n  return {\n    applyToStack(stack) {\n      stack.add(deadlineMiddlewareHandler(config), {\n        step: \"finalizeRequest\",\n        name: \"deadlineMiddleware\",\n        override: true,\n      });\n    },\n  };\n}\n\n// WeakSet allows GC of discarded clients in long-running processes\n// while still preventing duplicate middleware registration.\nconst registeredClients = new WeakSet<object>();\n\nexport function withDeadline<\n  // oxlint-disable-next-line typescript/no-explicit-any -- AWS SDK clients use varying ServiceInput/OutputTypes generics, making `any` the only correct constraint here\n  T extends { middlewareStack: { use: (pluggable: Pluggable<any, any>) => void } },\n>(client: T, options?: DeadlineOptions): T {\n  if (registeredClients.has(client)) return client;\n  registeredClients.add(client);\n  client.middlewareStack.use(deadlineMiddleware(options));\n  return client;\n}\n"]}
+{"mappings":"AAGA,cAAc,iBAAiB;AAI/B,cAAc,uBAAuB;AAErC,OAAO,cAAM;CAAsB;CAAsB;EACvD,UAAU,oBACT,UAAU,OAAO","names":[],"sources":["src/registration.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nimport type { Pluggable } from \"@smithy/types\";\n\nimport { parseConfig } from \"./config.js\";\nimport { deadlineMiddlewareHandler } from \"./middleware.js\";\nimport type { DeadlineOptions } from \"./types.js\";\n\nexport const deadlineMiddleware = <Input extends object, Output extends object>(\n  options?: DeadlineOptions,\n): Pluggable<Input, Output> => {\n  const config = parseConfig(options);\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(deadlineMiddlewareHandler<Input, Output>(config), {\n        step: \"finalizeRequest\",\n        name: \"deadlineMiddleware\",\n        override: true,\n      });\n    },\n  };\n};\n"]}

package/dist/registration.js

@@ -1,23 +1,17 @@
 import { parseConfig } from "./config.js";
 import { deadlineMiddlewareHandler } from "./middleware.js";
-export function deadlineMiddleware(options) {
+export const deadlineMiddleware = (options) => {
 	const config = parseConfig(options);
 	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(deadlineMiddlewareHandler(config), {
 			step: "finalizeRequest",
 			name: "deadlineMiddleware",
 			override: true
 		});
 	} };
-}
-// WeakSet allows GC of discarded clients in long-running processes
-// while still preventing duplicate middleware registration.
-const registeredClients = new WeakSet();
-export function withDeadline(client, options) {
-	if (registeredClients.has(client)) return client;
-	registeredClients.add(client);
-	client.middlewareStack.use(deadlineMiddleware(options));
-	return client;
-}
+};
 
 //# sourceMappingURL=registration.js.map

package/dist/registration.js.map

@@ -1 +1 @@
-{"mappings":"AAKA,SAAS,mBAAmB;AAC5B,SAAS,iCAAiC;AAG1C,OAAO,SAAS,mBAAmB,SAAsD;CACvF,MAAM,SAAS,YAAY,OAAO;CAElC,OAAO,EACL,aAAa,OAAO;EAClB,MAAM,IAAI,0BAA0B,MAAM,GAAG;GAC3C,MAAM;GACN,MAAM;GACN,UAAU;EACZ,CAAC;CACH,EACF;AACF;;;AAIA,MAAM,oBAAoB,IAAI,QAAgB;AAE9C,OAAO,SAAS,aAGd,QAAW,SAA8B;CACzC,IAAI,kBAAkB,IAAI,MAAM,GAAG,OAAO;CAC1C,kBAAkB,IAAI,MAAM;CAC5B,OAAO,gBAAgB,IAAI,mBAAmB,OAAO,CAAC;CACtD,OAAO;AACT","names":[],"sources":["src/registration.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2024 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nimport type { Pluggable } from \"@smithy/types\";\n\nimport { parseConfig } from \"./config.js\";\nimport { deadlineMiddlewareHandler } from \"./middleware.js\";\nimport type { DeadlineOptions } from \"./types.js\";\n\nexport function deadlineMiddleware(options?: DeadlineOptions): Pluggable<object, object> {\n  const config = parseConfig(options);\n\n  return {\n    applyToStack(stack) {\n      stack.add(deadlineMiddlewareHandler(config), {\n        step: \"finalizeRequest\",\n        name: \"deadlineMiddleware\",\n        override: true,\n      });\n    },\n  };\n}\n\n// WeakSet allows GC of discarded clients in long-running processes\n// while still preventing duplicate middleware registration.\nconst registeredClients = new WeakSet<object>();\n\nexport function withDeadline<\n  // oxlint-disable-next-line typescript/no-explicit-any -- AWS SDK clients use varying ServiceInput/OutputTypes generics, making `any` the only correct constraint here\n  T extends { middlewareStack: { use: (pluggable: Pluggable<any, any>) => void } },\n>(client: T, options?: DeadlineOptions): T {\n  if (registeredClients.has(client)) return client;\n  registeredClients.add(client);\n  client.middlewareStack.use(deadlineMiddleware(options));\n  return client;\n}\n"]}
+{"mappings":"AAKA,SAAS,mBAAmB;AAC5B,SAAS,iCAAiC;AAG1C,OAAO,MAAM,sBACX,YAC6B;CAC7B,MAAM,SAAS,YAAY,OAAO;CAElC,OAAO,EACL,aAAa,OAAO;;;;EAIlB,MAAM,IAAI,0BAAyC,MAAM,GAAG;GAC1D,MAAM;GACN,MAAM;GACN,UAAU;EACZ,CAAC;CACH,EACF;AACF","names":[],"sources":["src/registration.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nimport type { Pluggable } from \"@smithy/types\";\n\nimport { parseConfig } from \"./config.js\";\nimport { deadlineMiddlewareHandler } from \"./middleware.js\";\nimport type { DeadlineOptions } from \"./types.js\";\n\nexport const deadlineMiddleware = <Input extends object, Output extends object>(\n  options?: DeadlineOptions,\n): Pluggable<Input, Output> => {\n  const config = parseConfig(options);\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(deadlineMiddlewareHandler<Input, Output>(config), {\n        step: \"finalizeRequest\",\n        name: \"deadlineMiddleware\",\n        override: true,\n      });\n    },\n  };\n};\n"]}

package/dist/telemetry.d.ts

@@ -1,5 +1,5 @@
 import type { DeadlineExceededError } from "./error.js";
 import type { DeadlineMiddlewareConfig } from "./types.js";
-export declare function emitDeadlineAbort(error: DeadlineExceededError, config: DeadlineMiddlewareConfig): Promise<void>;
+export declare const emitDeadlineAbort: (error: DeadlineExceededError, config: DeadlineMiddlewareConfig) => Promise<void>;
 
 //# sourceMappingURL=telemetry.d.ts.map

package/dist/telemetry.d.ts.map

@@ -1 +1 @@
-{"mappings":"AAGA,cAAc,6BAA6B;AAC3C,cAAc,gCAAgC;AAwG9C,OAAO,iBAAe,kBACpB,OAAO,uBACP,QAAQ,2BACP","names":[],"sources":["src/telemetry.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2024 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nimport type { DeadlineExceededError } from \"./error.js\";\nimport type { DeadlineMiddlewareConfig } from \"./types.js\";\n\ninterface AbortDetails {\n  readonly deadlineMs: number;\n  readonly flushBufferMs: number;\n  readonly remainingMs: number;\n}\n\ninterface TelemetryEmitter {\n  recordDeadlineAbort: (details: AbortDetails) => void;\n  setDeadlineErrorStatus: (error: DeadlineExceededError) => void;\n}\n\nlet emitter: TelemetryEmitter | undefined;\nlet detected = false;\n\nasync function detectEmitter(): Promise<TelemetryEmitter | undefined> {\n  if (detected) return emitter;\n  detected = true;\n\n  try {\n    // Variable indirection prevents TypeScript from resolving the module\n    // at compile time — keeps @opentelemetry/api as a purely optional runtime dep.\n    const moduleName = \"@opentelemetry/api\";\n    // oxlint-disable-next-line typescript/no-unsafe-assignment -- dynamic import of optional runtime dependency\n    const otelApi: Record<string, unknown> = await import(/* webpackIgnore: true */ moduleName);\n    // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing optional OTel API surface\n    const trace = otelApi[\"trace\"] as { getActiveSpan: () => unknown } | undefined;\n\n    // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing optional OTel API surface\n    const SpanStatusCode = otelApi[\"SpanStatusCode\"] as\n      | {\n          ERROR: number;\n        }\n      | undefined;\n\n    if (!trace || !SpanStatusCode) {\n      emitter = undefined;\n      return emitter;\n    }\n\n    emitter = {\n      recordDeadlineAbort(details: AbortDetails): void {\n        try {\n          // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span from untyped getActiveSpan()\n          const span = trace.getActiveSpan() as Record<string, unknown> | undefined;\n          if (!span) return;\n\n          // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span.addEvent method\n          const addEvent = span[\"addEvent\"] as\n            | ((name: string, attributes: Record<string, unknown>) => void)\n            | undefined;\n          if (typeof addEvent !== \"function\") return;\n\n          addEvent.call(span, \"lambda-deadline-middleware.abort\", {\n            \"deadline.duration_ms\": details.deadlineMs,\n            \"deadline.flush_buffer_ms\": details.flushBufferMs,\n            \"deadline.remaining_ms\": details.remainingMs,\n          });\n        } catch {\n          // Telemetry must never disrupt request processing\n        }\n      },\n\n      setDeadlineErrorStatus(error: DeadlineExceededError): void {\n        try {\n          // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span from untyped getActiveSpan()\n          const span = trace.getActiveSpan() as Record<string, unknown> | undefined;\n          if (!span) return;\n\n          // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span.setStatus method\n          const setStatus = span[\"setStatus\"] as\n            | ((status: { code: number; message: string }) => void)\n            | undefined;\n          // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span.setAttribute method\n          const setAttribute = span[\"setAttribute\"] as\n            | ((key: string, value: unknown) => void)\n            | undefined;\n\n          if (typeof setStatus === \"function\") {\n            setStatus.call(span, {\n              code: SpanStatusCode.ERROR,\n              message: error.message,\n            });\n          }\n\n          if (typeof setAttribute === \"function\") {\n            setAttribute.call(span, \"error.type\", \"DeadlineExceededError\");\n            setAttribute.call(span, \"deadline.duration_ms\", error.deadlineMs);\n            setAttribute.call(span, \"deadline.flush_buffer_ms\", error.flushBufferMs);\n            setAttribute.call(span, \"deadline.remaining_ms\", error.remainingMs);\n          }\n        } catch {\n          // Telemetry must never disrupt request processing\n        }\n      },\n    };\n  } catch {\n    emitter = undefined;\n  }\n\n  return emitter;\n}\n\nexport async function emitDeadlineAbort(\n  error: DeadlineExceededError,\n  config: DeadlineMiddlewareConfig,\n): Promise<void> {\n  try {\n    if (!config.telemetryEnabled) return;\n\n    const em = await detectEmitter();\n    if (!em) return;\n\n    em.recordDeadlineAbort({\n      deadlineMs: error.deadlineMs,\n      flushBufferMs: error.flushBufferMs,\n      remainingMs: error.remainingMs,\n    });\n\n    em.setDeadlineErrorStatus(error);\n  } catch {\n    // Telemetry must never disrupt request processing\n  }\n}\n"]}
+{"mappings":"AAGA,cAAc,6BAA6B;AAC3C,cAAc,gCAAgC;AA2G9C,OAAO,cAAM,oBACX,OAAO,uBACP,QAAQ,6BACP","names":[],"sources":["src/telemetry.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nimport type { DeadlineExceededError } from \"./error.js\";\nimport type { DeadlineMiddlewareConfig } from \"./types.js\";\n\n// OpenTelemetry is detected dynamically rather than declared as a peerDependency.\n// This avoids forcing all consumers to install @opentelemetry/api or suppress peer warnings.\n// Detection happens once at first use and the result is cached for the process lifetime.\ninterface AbortDetails {\n  readonly deadlineMs: number;\n  readonly flushBufferMs: number;\n  readonly remainingMs: number;\n}\n\ninterface TelemetryEmitter {\n  recordDeadlineAbort: (details: AbortDetails) => void;\n  setDeadlineErrorStatus: (error: DeadlineExceededError) => void;\n}\n\nlet emitter: TelemetryEmitter | undefined;\nlet detected = false;\n\nconst detectEmitter = async (): Promise<TelemetryEmitter | undefined> => {\n  if (detected) return emitter;\n  detected = true;\n\n  try {\n    // Variable indirection prevents TypeScript from resolving the module\n    // at compile time — keeps @opentelemetry/api as a purely optional runtime dep.\n    const moduleName = \"@opentelemetry/api\";\n    // oxlint-disable-next-line typescript/no-unsafe-assignment -- dynamic import of optional runtime dependency\n    const otelApi: Record<string, unknown> = await import(/* webpackIgnore: true */ moduleName);\n    // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing optional OTel API surface\n    const trace = otelApi[\"trace\"] as { getActiveSpan: () => unknown } | undefined;\n\n    // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing optional OTel API surface\n    const SpanStatusCode = otelApi[\"SpanStatusCode\"] as\n      | {\n          ERROR: number;\n        }\n      | undefined;\n\n    if (!trace || !SpanStatusCode) {\n      emitter = undefined;\n      return emitter;\n    }\n\n    emitter = {\n      recordDeadlineAbort(details: AbortDetails): void {\n        try {\n          // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span from untyped getActiveSpan()\n          const span = trace.getActiveSpan() as Record<string, unknown> | undefined;\n          if (!span) return;\n\n          // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span.addEvent method\n          const addEvent = span[\"addEvent\"] as\n            | ((name: string, attributes: Record<string, unknown>) => void)\n            | undefined;\n          if (typeof addEvent !== \"function\") return;\n\n          addEvent.call(span, \"lambda-deadline-middleware.abort\", {\n            \"deadline.duration_ms\": details.deadlineMs,\n            \"deadline.flush_buffer_ms\": details.flushBufferMs,\n            \"deadline.remaining_ms\": details.remainingMs,\n          });\n        } catch {\n          // Telemetry must never disrupt request processing\n        }\n      },\n\n      setDeadlineErrorStatus(error: DeadlineExceededError): void {\n        try {\n          // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span from untyped getActiveSpan()\n          const span = trace.getActiveSpan() as Record<string, unknown> | undefined;\n          if (!span) return;\n\n          // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span.setStatus method\n          const setStatus = span[\"setStatus\"] as\n            | ((status: { code: number; message: string }) => void)\n            | undefined;\n          // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span.setAttribute method\n          const setAttribute = span[\"setAttribute\"] as\n            | ((key: string, value: unknown) => void)\n            | undefined;\n\n          if (typeof setStatus === \"function\") {\n            setStatus.call(span, {\n              code: SpanStatusCode.ERROR,\n              message: error.message,\n            });\n          }\n\n          if (typeof setAttribute === \"function\") {\n            setAttribute.call(span, \"error.type\", \"DeadlineExceededError\");\n            setAttribute.call(span, \"deadline.duration_ms\", error.deadlineMs);\n            setAttribute.call(span, \"deadline.flush_buffer_ms\", error.flushBufferMs);\n            setAttribute.call(span, \"deadline.remaining_ms\", error.remainingMs);\n          }\n        } catch {\n          // Telemetry must never disrupt request processing\n        }\n      },\n    };\n  } catch {\n    emitter = undefined;\n  }\n\n  return emitter;\n};\n\nexport const emitDeadlineAbort = async (\n  error: DeadlineExceededError,\n  config: DeadlineMiddlewareConfig,\n): Promise<void> => {\n  try {\n    if (!config.telemetryEnabled) return;\n\n    const em = await detectEmitter();\n    if (!em) return;\n\n    em.recordDeadlineAbort({\n      deadlineMs: error.deadlineMs,\n      flushBufferMs: error.flushBufferMs,\n      remainingMs: error.remainingMs,\n    });\n\n    em.setDeadlineErrorStatus(error);\n  } catch {\n    // Telemetry must never disrupt request processing\n  }\n};\n"]}

package/dist/telemetry.js

@@ -1,6 +1,6 @@
 let emitter;
 let detected = false;
-async function detectEmitter() {
+const detectEmitter = async () => {
 	if (detected) return emitter;
 	detected = true;
 	try {
@@ -64,8 +64,8 @@ async function detectEmitter() {
 		emitter = undefined;
 	}
 	return emitter;
-}
-export async function emitDeadlineAbort(error, config) {
+};
+export const emitDeadlineAbort = async (error, config) => {
 	try {
 		if (!config.telemetryEnabled) return;
 		const em = await detectEmitter();
@@ -77,6 +77,6 @@ export async function emitDeadlineAbort(error, config) {
 		});
 		em.setDeadlineErrorStatus(error);
 	} catch {}
-}
+};
 
 //# sourceMappingURL=telemetry.js.map

package/dist/telemetry.js.map

@@ -1 +1 @@
-{"mappings":"AAiBA,IAAI;AACJ,IAAI,WAAW;AAEf,eAAe,gBAAuD;CACpE,IAAI,UAAU,OAAO;CACrB,WAAW;CAEX,IAAI;;;EAGF,MAAM,aAAa;;EAEnB,MAAM,UAAmC,MAAM;;GAAiC;;;EAEhF,MAAM,QAAQ,QAAQ;;EAGtB,MAAM,iBAAiB,QAAQ;EAM/B,IAAI,CAAC,SAAS,CAAC,gBAAgB;GAC7B,UAAU;GACV,OAAO;EACT;EAEA,UAAU;GACR,oBAAoB,SAA6B;IAC/C,IAAI;;KAEF,MAAM,OAAO,MAAM,cAAc;KACjC,IAAI,CAAC,MAAM;;KAGX,MAAM,WAAW,KAAK;KAGtB,IAAI,OAAO,aAAa,YAAY;KAEpC,SAAS,KAAK,MAAM,oCAAoC;MACtD,wBAAwB,QAAQ;MAChC,4BAA4B,QAAQ;MACpC,yBAAyB,QAAQ;KACnC,CAAC;IACH,QAAQ,CAER;GACF;GAEA,uBAAuB,OAAoC;IACzD,IAAI;;KAEF,MAAM,OAAO,MAAM,cAAc;KACjC,IAAI,CAAC,MAAM;;KAGX,MAAM,YAAY,KAAK;;KAIvB,MAAM,eAAe,KAAK;KAI1B,IAAI,OAAO,cAAc,YAAY;MACnC,UAAU,KAAK,MAAM;OACnB,MAAM,eAAe;OACrB,SAAS,MAAM;MACjB,CAAC;KACH;KAEA,IAAI,OAAO,iBAAiB,YAAY;MACtC,aAAa,KAAK,MAAM,cAAc,uBAAuB;MAC7D,aAAa,KAAK,MAAM,wBAAwB,MAAM,UAAU;MAChE,aAAa,KAAK,MAAM,4BAA4B,MAAM,aAAa;MACvE,aAAa,KAAK,MAAM,yBAAyB,MAAM,WAAW;KACpE;IACF,QAAQ,CAER;GACF;EACF;CACF,QAAQ;EACN,UAAU;CACZ;CAEA,OAAO;AACT;AAEA,OAAO,eAAe,kBACpB,OACA,QACe;CACf,IAAI;EACF,IAAI,CAAC,OAAO,kBAAkB;EAE9B,MAAM,KAAK,MAAM,cAAc;EAC/B,IAAI,CAAC,IAAI;EAET,GAAG,oBAAoB;GACrB,YAAY,MAAM;GAClB,eAAe,MAAM;GACrB,aAAa,MAAM;EACrB,CAAC;EAED,GAAG,uBAAuB,KAAK;CACjC,QAAQ,CAER;AACF","names":[],"sources":["src/telemetry.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2024 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nimport type { DeadlineExceededError } from \"./error.js\";\nimport type { DeadlineMiddlewareConfig } from \"./types.js\";\n\ninterface AbortDetails {\n  readonly deadlineMs: number;\n  readonly flushBufferMs: number;\n  readonly remainingMs: number;\n}\n\ninterface TelemetryEmitter {\n  recordDeadlineAbort: (details: AbortDetails) => void;\n  setDeadlineErrorStatus: (error: DeadlineExceededError) => void;\n}\n\nlet emitter: TelemetryEmitter | undefined;\nlet detected = false;\n\nasync function detectEmitter(): Promise<TelemetryEmitter | undefined> {\n  if (detected) return emitter;\n  detected = true;\n\n  try {\n    // Variable indirection prevents TypeScript from resolving the module\n    // at compile time — keeps @opentelemetry/api as a purely optional runtime dep.\n    const moduleName = \"@opentelemetry/api\";\n    // oxlint-disable-next-line typescript/no-unsafe-assignment -- dynamic import of optional runtime dependency\n    const otelApi: Record<string, unknown> = await import(/* webpackIgnore: true */ moduleName);\n    // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing optional OTel API surface\n    const trace = otelApi[\"trace\"] as { getActiveSpan: () => unknown } | undefined;\n\n    // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing optional OTel API surface\n    const SpanStatusCode = otelApi[\"SpanStatusCode\"] as\n      | {\n          ERROR: number;\n        }\n      | undefined;\n\n    if (!trace || !SpanStatusCode) {\n      emitter = undefined;\n      return emitter;\n    }\n\n    emitter = {\n      recordDeadlineAbort(details: AbortDetails): void {\n        try {\n          // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span from untyped getActiveSpan()\n          const span = trace.getActiveSpan() as Record<string, unknown> | undefined;\n          if (!span) return;\n\n          // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span.addEvent method\n          const addEvent = span[\"addEvent\"] as\n            | ((name: string, attributes: Record<string, unknown>) => void)\n            | undefined;\n          if (typeof addEvent !== \"function\") return;\n\n          addEvent.call(span, \"lambda-deadline-middleware.abort\", {\n            \"deadline.duration_ms\": details.deadlineMs,\n            \"deadline.flush_buffer_ms\": details.flushBufferMs,\n            \"deadline.remaining_ms\": details.remainingMs,\n          });\n        } catch {\n          // Telemetry must never disrupt request processing\n        }\n      },\n\n      setDeadlineErrorStatus(error: DeadlineExceededError): void {\n        try {\n          // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span from untyped getActiveSpan()\n          const span = trace.getActiveSpan() as Record<string, unknown> | undefined;\n          if (!span) return;\n\n          // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span.setStatus method\n          const setStatus = span[\"setStatus\"] as\n            | ((status: { code: number; message: string }) => void)\n            | undefined;\n          // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span.setAttribute method\n          const setAttribute = span[\"setAttribute\"] as\n            | ((key: string, value: unknown) => void)\n            | undefined;\n\n          if (typeof setStatus === \"function\") {\n            setStatus.call(span, {\n              code: SpanStatusCode.ERROR,\n              message: error.message,\n            });\n          }\n\n          if (typeof setAttribute === \"function\") {\n            setAttribute.call(span, \"error.type\", \"DeadlineExceededError\");\n            setAttribute.call(span, \"deadline.duration_ms\", error.deadlineMs);\n            setAttribute.call(span, \"deadline.flush_buffer_ms\", error.flushBufferMs);\n            setAttribute.call(span, \"deadline.remaining_ms\", error.remainingMs);\n          }\n        } catch {\n          // Telemetry must never disrupt request processing\n        }\n      },\n    };\n  } catch {\n    emitter = undefined;\n  }\n\n  return emitter;\n}\n\nexport async function emitDeadlineAbort(\n  error: DeadlineExceededError,\n  config: DeadlineMiddlewareConfig,\n): Promise<void> {\n  try {\n    if (!config.telemetryEnabled) return;\n\n    const em = await detectEmitter();\n    if (!em) return;\n\n    em.recordDeadlineAbort({\n      deadlineMs: error.deadlineMs,\n      flushBufferMs: error.flushBufferMs,\n      remainingMs: error.remainingMs,\n    });\n\n    em.setDeadlineErrorStatus(error);\n  } catch {\n    // Telemetry must never disrupt request processing\n  }\n}\n"]}
+{"mappings":"AAoBA,IAAI;AACJ,IAAI,WAAW;AAEf,MAAM,gBAAgB,YAAmD;CACvE,IAAI,UAAU,OAAO;CACrB,WAAW;CAEX,IAAI;;;EAGF,MAAM,aAAa;;EAEnB,MAAM,UAAmC,MAAM;;GAAiC;;;EAEhF,MAAM,QAAQ,QAAQ;;EAGtB,MAAM,iBAAiB,QAAQ;EAM/B,IAAI,CAAC,SAAS,CAAC,gBAAgB;GAC7B,UAAU;GACV,OAAO;EACT;EAEA,UAAU;GACR,oBAAoB,SAA6B;IAC/C,IAAI;;KAEF,MAAM,OAAO,MAAM,cAAc;KACjC,IAAI,CAAC,MAAM;;KAGX,MAAM,WAAW,KAAK;KAGtB,IAAI,OAAO,aAAa,YAAY;KAEpC,SAAS,KAAK,MAAM,oCAAoC;MACtD,wBAAwB,QAAQ;MAChC,4BAA4B,QAAQ;MACpC,yBAAyB,QAAQ;KACnC,CAAC;IACH,QAAQ,CAER;GACF;GAEA,uBAAuB,OAAoC;IACzD,IAAI;;KAEF,MAAM,OAAO,MAAM,cAAc;KACjC,IAAI,CAAC,MAAM;;KAGX,MAAM,YAAY,KAAK;;KAIvB,MAAM,eAAe,KAAK;KAI1B,IAAI,OAAO,cAAc,YAAY;MACnC,UAAU,KAAK,MAAM;OACnB,MAAM,eAAe;OACrB,SAAS,MAAM;MACjB,CAAC;KACH;KAEA,IAAI,OAAO,iBAAiB,YAAY;MACtC,aAAa,KAAK,MAAM,cAAc,uBAAuB;MAC7D,aAAa,KAAK,MAAM,wBAAwB,MAAM,UAAU;MAChE,aAAa,KAAK,MAAM,4BAA4B,MAAM,aAAa;MACvE,aAAa,KAAK,MAAM,yBAAyB,MAAM,WAAW;KACpE;IACF,QAAQ,CAER;GACF;EACF;CACF,QAAQ;EACN,UAAU;CACZ;CAEA,OAAO;AACT;AAEA,OAAO,MAAM,oBAAoB,OAC/B,OACA,WACkB;CAClB,IAAI;EACF,IAAI,CAAC,OAAO,kBAAkB;EAE9B,MAAM,KAAK,MAAM,cAAc;EAC/B,IAAI,CAAC,IAAI;EAET,GAAG,oBAAoB;GACrB,YAAY,MAAM;GAClB,eAAe,MAAM;GACrB,aAAa,MAAM;EACrB,CAAC;EAED,GAAG,uBAAuB,KAAK;CACjC,QAAQ,CAER;AACF","names":[],"sources":["src/telemetry.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nimport type { DeadlineExceededError } from \"./error.js\";\nimport type { DeadlineMiddlewareConfig } from \"./types.js\";\n\n// OpenTelemetry is detected dynamically rather than declared as a peerDependency.\n// This avoids forcing all consumers to install @opentelemetry/api or suppress peer warnings.\n// Detection happens once at first use and the result is cached for the process lifetime.\ninterface AbortDetails {\n  readonly deadlineMs: number;\n  readonly flushBufferMs: number;\n  readonly remainingMs: number;\n}\n\ninterface TelemetryEmitter {\n  recordDeadlineAbort: (details: AbortDetails) => void;\n  setDeadlineErrorStatus: (error: DeadlineExceededError) => void;\n}\n\nlet emitter: TelemetryEmitter | undefined;\nlet detected = false;\n\nconst detectEmitter = async (): Promise<TelemetryEmitter | undefined> => {\n  if (detected) return emitter;\n  detected = true;\n\n  try {\n    // Variable indirection prevents TypeScript from resolving the module\n    // at compile time — keeps @opentelemetry/api as a purely optional runtime dep.\n    const moduleName = \"@opentelemetry/api\";\n    // oxlint-disable-next-line typescript/no-unsafe-assignment -- dynamic import of optional runtime dependency\n    const otelApi: Record<string, unknown> = await import(/* webpackIgnore: true */ moduleName);\n    // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing optional OTel API surface\n    const trace = otelApi[\"trace\"] as { getActiveSpan: () => unknown } | undefined;\n\n    // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing optional OTel API surface\n    const SpanStatusCode = otelApi[\"SpanStatusCode\"] as\n      | {\n          ERROR: number;\n        }\n      | undefined;\n\n    if (!trace || !SpanStatusCode) {\n      emitter = undefined;\n      return emitter;\n    }\n\n    emitter = {\n      recordDeadlineAbort(details: AbortDetails): void {\n        try {\n          // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span from untyped getActiveSpan()\n          const span = trace.getActiveSpan() as Record<string, unknown> | undefined;\n          if (!span) return;\n\n          // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span.addEvent method\n          const addEvent = span[\"addEvent\"] as\n            | ((name: string, attributes: Record<string, unknown>) => void)\n            | undefined;\n          if (typeof addEvent !== \"function\") return;\n\n          addEvent.call(span, \"lambda-deadline-middleware.abort\", {\n            \"deadline.duration_ms\": details.deadlineMs,\n            \"deadline.flush_buffer_ms\": details.flushBufferMs,\n            \"deadline.remaining_ms\": details.remainingMs,\n          });\n        } catch {\n          // Telemetry must never disrupt request processing\n        }\n      },\n\n      setDeadlineErrorStatus(error: DeadlineExceededError): void {\n        try {\n          // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span from untyped getActiveSpan()\n          const span = trace.getActiveSpan() as Record<string, unknown> | undefined;\n          if (!span) return;\n\n          // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span.setStatus method\n          const setStatus = span[\"setStatus\"] as\n            | ((status: { code: number; message: string }) => void)\n            | undefined;\n          // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span.setAttribute method\n          const setAttribute = span[\"setAttribute\"] as\n            | ((key: string, value: unknown) => void)\n            | undefined;\n\n          if (typeof setStatus === \"function\") {\n            setStatus.call(span, {\n              code: SpanStatusCode.ERROR,\n              message: error.message,\n            });\n          }\n\n          if (typeof setAttribute === \"function\") {\n            setAttribute.call(span, \"error.type\", \"DeadlineExceededError\");\n            setAttribute.call(span, \"deadline.duration_ms\", error.deadlineMs);\n            setAttribute.call(span, \"deadline.flush_buffer_ms\", error.flushBufferMs);\n            setAttribute.call(span, \"deadline.remaining_ms\", error.remainingMs);\n          }\n        } catch {\n          // Telemetry must never disrupt request processing\n        }\n      },\n    };\n  } catch {\n    emitter = undefined;\n  }\n\n  return emitter;\n};\n\nexport const emitDeadlineAbort = async (\n  error: DeadlineExceededError,\n  config: DeadlineMiddlewareConfig,\n): Promise<void> => {\n  try {\n    if (!config.telemetryEnabled) return;\n\n    const em = await detectEmitter();\n    if (!em) return;\n\n    em.recordDeadlineAbort({\n      deadlineMs: error.deadlineMs,\n      flushBufferMs: error.flushBufferMs,\n      remainingMs: error.remainingMs,\n    });\n\n    em.setDeadlineErrorStatus(error);\n  } catch {\n    // Telemetry must never disrupt request processing\n  }\n};\n"]}

package/dist/types.d.ts

@@ -8,8 +8,8 @@ type Brand<
 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 declare const milliseconds: (value: number) => Milliseconds;
+export declare const flushBufferMs: (value: number) => FlushBufferMs;
 export type DeadlineComputation = {
 	readonly kind: "deadline";
 	readonly value: RequestDeadlineMs;

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

package/dist/types.js

@@ -1,11 +1,11 @@
-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) {
+};
+export const flushBufferMs = (value) => {
 	if (!Number.isFinite(value)) {
 		throw new TypeError(`flushBufferMs value must be finite, received: ${value}`);
 	}
@@ -14,6 +14,6 @@ export function flushBufferMs(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":"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"]}