lambda-deadline-middleware 1.0.1 → 1.1.0

package/src/error.ts

@@ -1,18 +1,18 @@
 // 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) {

package/src/handler-wrapper.ts

@@ -2,18 +2,17 @@
 // 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 const withLambdaDeadline =
-  <TEvent, TResult>(
-    handler: AsyncHandler<TEvent, TResult>,
-    _options?: DeadlineOptions,
-  ): AsyncHandler<TEvent, TResult> =>
-  async (event: TEvent, context: LambdaContextLike): Promise<TResult> =>
+  <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));

package/src/index.ts

@@ -2,17 +2,10 @@
 // SPDX-License-Identifier: MIT
 
 export { withLambdaDeadline } from "./handler-wrapper.js";
-export { deadlineMiddleware } from "./registration.js";
+export { deadlineMiddleware } from "./middleware.js";
 export { DeadlineExceededError, isDeadlineExceeded } from "./error.js";
 export { getRemainingTimeInMillis } from "./context-store.js";
 
-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";

package/src/middleware.ts

@@ -1,66 +1,19 @@
 // SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors
 // SPDX-License-Identifier: MIT
 
-import { getRemainingTimeInMillis } from "./context-store.js";
-import { DeadlineExceededError } from "./error.js";
-import type { DeadlineComputation, DeadlineMiddlewareConfig, RequestDeadlineMs } from "./types.js";
-import { milliseconds } from "./types.js";
-
 import type {
   FinalizeHandler,
   FinalizeHandlerArguments,
   FinalizeHandlerOutput,
-  FinalizeRequestMiddleware,
   HandlerExecutionContext,
+  Pluggable,
 } from "@smithy/types";
 
-export const computeDeadline = (config: DeadlineMiddlewareConfig): DeadlineComputation => {
-  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 as RequestDeadlineMs };
-};
-
-export interface DeadlineTimer {
-  readonly controller: AbortController;
-  [Symbol.dispose]: () => void;
-}
+import { getRemainingTimeInMillis } from "./context-store.js";
+import { DeadlineExceededError } from "./error.js";
+import { milliseconds } from "./types.js";
 
-export const createDeadlineTimer = (
-  deadlineMs: RequestDeadlineMs,
-  config: DeadlineMiddlewareConfig,
-): DeadlineTimer => {
-  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);
-    },
-  };
-};
+import type { DeadlineOptions } from "./types.js";
 
 export const composeSignals = (
   existing: AbortSignal | undefined,
@@ -70,42 +23,74 @@ export const composeSignals = (
   return AbortSignal.any([existing, deadline]);
 };
 
-export const deadlineMiddlewareHandler =
-  <Input extends object, Output extends object>(
-    config: DeadlineMiddlewareConfig,
-  ): FinalizeRequestMiddleware<Input, Output> =>
-  (
-    next: FinalizeHandler<Input, Output>,
-    _context: HandlerExecutionContext,
-  ): FinalizeHandler<Input, Output> =>
-  // oxlint-disable-next-line typescript/consistent-return -- switch is exhaustive over DeadlineComputation discriminated union
-  async (args: FinalizeHandlerArguments<Input>): Promise<FinalizeHandlerOutput<Output>> => {
-    const computation = computeDeadline(config);
+export const deadlineMiddleware = <Input extends object, Output extends object>(
+  options?: DeadlineOptions,
+): Pluggable<Input, Output> => {
+  const raw = options?.flushBufferMs ?? 1000;
+  if (raw < 0) {
+    throw new TypeError(`flushBufferMs option must be non-negative, received: ${raw}`);
+  }
+  const flushBufferMs = milliseconds(raw);
 
-    switch (computation.kind) {
-      case "no-context":
-        return next(args);
+  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: FinalizeHandler<Input, Output>,
+          _context: HandlerExecutionContext,
+        ): FinalizeHandler<Input, Output> =>
+          async (args: FinalizeHandlerArguments<Input>): Promise<FinalizeHandlerOutput<Output>> => {
+            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),
+              });
+            }
 
-      case "insufficient-time":
-        throw new DeadlineExceededError({
-          deadlineMs: milliseconds(0),
-          flushBufferMs: computation.buffer,
-          remainingMs: computation.remaining,
-        });
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => {
+              controller.abort(
+                new DeadlineExceededError({
+                  deadlineMs: milliseconds(deadline),
+                  flushBufferMs,
+                  remainingMs: milliseconds(remaining),
+                }),
+              );
+            }, deadline);
 
-      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 as { signal?: AbortSignal } | undefined;
-        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 as object), signal },
-        });
-        return result;
-      }
-    }
+            // `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 as { signal?: AbortSignal } | undefined;
+            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 as object), signal },
+            });
+            return result;
+          },
+        {
+          step: "finalizeRequest",
+          name: "deadlineMiddleware",
+          override: true,
+        },
+      );
+    },
   };
+};

package/src/types.ts

@@ -1,18 +1,14 @@
 // SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors
 // SPDX-License-Identifier: MIT
 
-// Branded types prevent interchange errors at compile time (e.g. passing seconds where milliseconds are expected).
-// Zero runtime cost. Smart constructors below validate at the boundary and brand the value.
+// Branded type prevents interchange errors at compile time (e.g. passing seconds where milliseconds are expected).
+// Zero runtime cost. Smart constructor below validates at the boundary and brands the value.
 declare const BrandSymbol: unique symbol;
 
 type Brand<T, B extends string> = T & { readonly [BrandSymbol]: B };
 
 export type Milliseconds = Brand<number, "Milliseconds">;
 
-export type FlushBufferMs = Brand<number, "FlushBufferMs">;
-
-export type RequestDeadlineMs = Brand<number, "RequestDeadlineMs">;
-
 export const milliseconds = (value: number): Milliseconds => {
   if (!Number.isFinite(value)) {
     throw new TypeError(`milliseconds value must be finite, received: ${value}`);
@@ -21,32 +17,6 @@ export const milliseconds = (value: number): Milliseconds => {
   return value as Milliseconds;
 };
 
-export const flushBufferMs = (value: number): FlushBufferMs => {
-  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 as FlushBufferMs;
-};
-
-export type DeadlineComputation =
-  | { readonly kind: "deadline"; readonly value: RequestDeadlineMs }
-  | {
-      readonly kind: "insufficient-time";
-      readonly remaining: Milliseconds;
-      readonly buffer: FlushBufferMs;
-    }
-  | { readonly kind: "no-context" };
-
-export interface DeadlineMiddlewareConfig {
-  readonly flushBufferMs: FlushBufferMs;
-  readonly telemetryEnabled: boolean;
-}
-
 export interface DeadlineOptions {
   readonly flushBufferMs?: number;
-  readonly telemetryEnabled?: boolean;
 }

package/dist/config.d.ts

@@ -1,4 +0,0 @@
-import type { DeadlineMiddlewareConfig, DeadlineOptions } from "./types.js";
-export declare const parseConfig: (raw: DeadlineOptions | undefined) => DeadlineMiddlewareConfig;
-
-//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -1 +0,0 @@
-{"mappings":"AAIA,cAAc,0BAA0B,uBAAuB;AAI/D,OAAO,cAAM,cAAe,KAAK,gCAA8B","names":[],"sources":["src/config.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nimport { flushBufferMs } from \"./types.js\";\nimport type { DeadlineMiddlewareConfig, DeadlineOptions } from \"./types.js\";\n\n// \"Parse, don't validate\": config is validated once here and returned as branded types.\n// Internal code can't receive unvalidated values. Invalid config throws TypeError at startup, not during requests.\nexport const parseConfig = (raw: DeadlineOptions | undefined): DeadlineMiddlewareConfig => {\n  const buffer = raw?.flushBufferMs ?? 1000;\n  if (buffer < 0) {\n    throw new TypeError(`flushBufferMs option must be non-negative, received: ${buffer}`);\n  }\n  return {\n    flushBufferMs: flushBufferMs(buffer),\n    telemetryEnabled: raw?.telemetryEnabled ?? true,\n  };\n};\n"]}

package/dist/config.js

@@ -1,17 +0,0 @@
-// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors
-// SPDX-License-Identifier: MIT
-import { flushBufferMs } from "./types.js";
-// "Parse, don't validate": config is validated once here and returned as branded types.
-// Internal code can't receive unvalidated values. Invalid config throws TypeError at startup, not during requests.
-export const parseConfig = (raw) => {
-	const buffer = raw?.flushBufferMs ?? 1e3;
-	if (buffer < 0) {
-		throw new TypeError(`flushBufferMs option must be non-negative, received: ${buffer}`);
-	}
-	return {
-		flushBufferMs: flushBufferMs(buffer),
-		telemetryEnabled: raw?.telemetryEnabled ?? true
-	};
-};
-
-//# sourceMappingURL=config.js.map

package/dist/config.js.map

@@ -1 +0,0 @@
-{"mappings":";;AAGA,SAAS,qBAAqB;;;AAK9B,OAAO,MAAM,eAAe,QAA+D;CACzF,MAAM,SAAS,KAAK,iBAAiB;CACrC,IAAI,SAAS,GAAG;EACd,MAAM,IAAI,UAAU,wDAAwD,QAAQ;CACtF;CACA,OAAO;EACL,eAAe,cAAc,MAAM;EACnC,kBAAkB,KAAK,oBAAoB;CAC7C;AACF","names":[],"sources":["src/config.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nimport { flushBufferMs } from \"./types.js\";\nimport type { DeadlineMiddlewareConfig, DeadlineOptions } from \"./types.js\";\n\n// \"Parse, don't validate\": config is validated once here and returned as branded types.\n// Internal code can't receive unvalidated values. Invalid config throws TypeError at startup, not during requests.\nexport const parseConfig = (raw: DeadlineOptions | undefined): DeadlineMiddlewareConfig => {\n  const buffer = raw?.flushBufferMs ?? 1000;\n  if (buffer < 0) {\n    throw new TypeError(`flushBufferMs option must be non-negative, received: ${buffer}`);\n  }\n  return {\n    flushBufferMs: flushBufferMs(buffer),\n    telemetryEnabled: raw?.telemetryEnabled ?? true,\n  };\n};\n"]}

package/dist/registration.d.ts

@@ -1,8 +0,0 @@
-import type { Pluggable } from "@smithy/types";
-import type { DeadlineOptions } from "./types.js";
-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 +0,0 @@
-{"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,17 +0,0 @@
-import { parseConfig } from "./config.js";
-import { deadlineMiddlewareHandler } from "./middleware.js";
-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
-		});
-	} };
-};
-
-//# sourceMappingURL=registration.js.map

package/dist/registration.js.map

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

package/dist/telemetry.d.ts.map

@@ -1 +0,0 @@
-{"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,82 +0,0 @@
-let emitter;
-let detected = false;
-const detectEmitter = async () => {
-	if (detected) return emitter;
-	detected = true;
-	try {
-		// Variable indirection prevents TypeScript from resolving the module
-		// at compile time — keeps @opentelemetry/api as a purely optional runtime dep.
-		const moduleName = "@opentelemetry/api";
-		// oxlint-disable-next-line typescript/no-unsafe-assignment -- dynamic import of optional runtime dependency
-		const otelApi = await import(
-			/* webpackIgnore: true */
-			moduleName
-);
-		// oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing optional OTel API surface
-		const trace = otelApi["trace"];
-		// oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing optional OTel API surface
-		const SpanStatusCode = otelApi["SpanStatusCode"];
-		if (!trace || !SpanStatusCode) {
-			emitter = undefined;
-			return emitter;
-		}
-		emitter = {
-			recordDeadlineAbort(details) {
-				try {
-					// oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span from untyped getActiveSpan()
-					const span = trace.getActiveSpan();
-					if (!span) return;
-					// oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span.addEvent method
-					const addEvent = span["addEvent"];
-					if (typeof addEvent !== "function") return;
-					addEvent.call(span, "lambda-deadline-middleware.abort", {
-						"deadline.duration_ms": details.deadlineMs,
-						"deadline.flush_buffer_ms": details.flushBufferMs,
-						"deadline.remaining_ms": details.remainingMs
-					});
-				} catch {}
-			},
-			setDeadlineErrorStatus(error) {
-				try {
-					// oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span from untyped getActiveSpan()
-					const span = trace.getActiveSpan();
-					if (!span) return;
-					// oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span.setStatus method
-					const setStatus = span["setStatus"];
-					// oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span.setAttribute method
-					const setAttribute = span["setAttribute"];
-					if (typeof setStatus === "function") {
-						setStatus.call(span, {
-							code: SpanStatusCode.ERROR,
-							message: error.message
-						});
-					}
-					if (typeof setAttribute === "function") {
-						setAttribute.call(span, "error.type", "DeadlineExceededError");
-						setAttribute.call(span, "deadline.duration_ms", error.deadlineMs);
-						setAttribute.call(span, "deadline.flush_buffer_ms", error.flushBufferMs);
-						setAttribute.call(span, "deadline.remaining_ms", error.remainingMs);
-					}
-				} catch {}
-			}
-		};
-	} catch {
-		emitter = undefined;
-	}
-	return emitter;
-};
-export const emitDeadlineAbort = async (error, config) => {
-	try {
-		if (!config.telemetryEnabled) return;
-		const em = await detectEmitter();
-		if (!em) return;
-		em.recordDeadlineAbort({
-			deadlineMs: error.deadlineMs,
-			flushBufferMs: error.flushBufferMs,
-			remainingMs: error.remainingMs
-		});
-		em.setDeadlineErrorStatus(error);
-	} catch {}
-};
-
-//# sourceMappingURL=telemetry.js.map

package/dist/telemetry.js.map

@@ -1 +0,0 @@
-{"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/src/config.ts

@@ -1,18 +0,0 @@
-// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors
-// SPDX-License-Identifier: MIT
-
-import { flushBufferMs } from "./types.js";
-import type { DeadlineMiddlewareConfig, DeadlineOptions } from "./types.js";
-
-// "Parse, don't validate": config is validated once here and returned as branded types.
-// Internal code can't receive unvalidated values. Invalid config throws TypeError at startup, not during requests.
-export const parseConfig = (raw: DeadlineOptions | undefined): DeadlineMiddlewareConfig => {
-  const buffer = raw?.flushBufferMs ?? 1000;
-  if (buffer < 0) {
-    throw new TypeError(`flushBufferMs option must be non-negative, received: ${buffer}`);
-  }
-  return {
-    flushBufferMs: flushBufferMs(buffer),
-    telemetryEnabled: raw?.telemetryEnabled ?? true,
-  };
-};

package/src/registration.ts

@@ -1,27 +0,0 @@
-// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors
-// SPDX-License-Identifier: MIT
-
-import type { Pluggable } from "@smithy/types";
-
-import { parseConfig } from "./config.js";
-import { deadlineMiddlewareHandler } from "./middleware.js";
-import type { DeadlineOptions } from "./types.js";
-
-export const deadlineMiddleware = <Input extends object, Output extends object>(
-  options?: DeadlineOptions,
-): Pluggable<Input, Output> => {
-  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<Input, Output>(config), {
-        step: "finalizeRequest",
-        name: "deadlineMiddleware",
-        override: true,
-      });
-    },
-  };
-};