lambda-deadline-middleware 0.0.0 → 1.1.0

package/src/index.ts

@@ -1,18 +1,11 @@
-// SPDX-FileCopyrightText: 2024 lambda-deadline-middleware contributors
+// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors
 // SPDX-License-Identifier: MIT
 
 export { withLambdaDeadline } from "./handler-wrapper.js";
-export { deadlineMiddleware, withDeadline } from "./registration.js";
+export { deadlineMiddleware } from "./middleware.js";
 export { DeadlineExceededError, isDeadlineExceeded } from "./error.js";
 export { getRemainingTimeInMillis } from "./context-store.js";
 
-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,109 +1,96 @@
-// 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 type { DeadlineComputation, DeadlineMiddlewareConfig, RequestDeadlineMs } from "./types.js";
-import { milliseconds } from "./types.js";
-
 import type {
   FinalizeHandler,
   FinalizeHandlerArguments,
   FinalizeHandlerOutput,
-  FinalizeRequestMiddleware,
   HandlerExecutionContext,
+  Pluggable,
 } from "@smithy/types";
 
-export function computeDeadline(config: DeadlineMiddlewareConfig): DeadlineComputation {
-  const remaining = getRemainingTimeInMillis();
+import { getRemainingTimeInMillis } from "./context-store.js";
+import { DeadlineExceededError } from "./error.js";
+import { milliseconds } from "./types.js";
 
-  if (remaining === undefined) {
-    return { kind: "no-context" };
-  }
+import type { DeadlineOptions } from "./types.js";
 
-  const deadline = remaining - config.flushBufferMs;
+export const composeSignals = (
+  existing: AbortSignal | undefined,
+  deadline: AbortSignal,
+): AbortSignal => {
+  if (existing === undefined) return deadline;
+  return AbortSignal.any([existing, deadline]);
+};
 
-  if (deadline <= 0) {
-    return {
-      kind: "insufficient-time",
-      remaining: milliseconds(remaining),
-      buffer: config.flushBufferMs,
-    };
+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);
 
-  // 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;
-}
-
-export function 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);
-    },
-  };
-}
+    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);
 
-export function composeSignals(
-  existing: AbortSignal | undefined,
-  deadline: AbortSignal,
-): AbortSignal {
-  if (existing === undefined) return deadline;
-  return AbortSignal.any([existing, deadline]);
-}
+            const deadline = remaining - flushBufferMs;
 
-export function deadlineMiddlewareHandler(
-  config: DeadlineMiddlewareConfig,
-): FinalizeRequestMiddleware<object, object> {
-  return (
-    next: FinalizeHandler<object, object>,
-    _context: HandlerExecutionContext,
-  ): FinalizeHandler<object, object> =>
-    // oxlint-disable-next-line typescript/consistent-return -- switch is exhaustive over DeadlineComputation discriminated union
-    async (args: FinalizeHandlerArguments<object>): Promise<FinalizeHandlerOutput<object>> => {
-      const computation = computeDeadline(config);
+            if (deadline <= 0) {
+              throw new DeadlineExceededError({
+                deadlineMs: milliseconds(0),
+                flushBufferMs,
+                remainingMs: milliseconds(remaining),
+              });
+            }
 
-      switch (computation.kind) {
-        case "no-context":
-          return next(args);
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => {
+              controller.abort(
+                new DeadlineExceededError({
+                  deadlineMs: milliseconds(deadline),
+                  flushBufferMs,
+                  remainingMs: milliseconds(remaining),
+                }),
+              );
+            }, deadline);
 
-        case "insufficient-time":
-          throw new DeadlineExceededError({
-            deadlineMs: milliseconds(0),
-            flushBufferMs: computation.buffer,
-            remainingMs: computation.remaining,
-          });
+            // `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);
+              },
+            };
 
-        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 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;
-        }
-      }
-    };
-}
+            // 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,50 +1,22 @@
-// SPDX-FileCopyrightText: 2024 lambda-deadline-middleware contributors
+// SPDX-FileCopyrightText: 2026 lambda-deadline-middleware contributors
 // SPDX-License-Identifier: MIT
 
+// 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 function milliseconds(value: number): Milliseconds {
+export const milliseconds = (value: number): Milliseconds => {
   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 as Milliseconds;
-}
-
-export function 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 function parseConfig(raw: DeadlineOptions | undefined): DeadlineMiddlewareConfig;
-
-//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -1 +0,0 @@
-{"mappings":"AAIA,cAAc,0BAA0B,uBAAuB;AAE/D,OAAO,iBAAS,YAAY,KAAK,8BAA8B","names":[],"sources":["src/config.ts"],"version":3,"sourcesContent":["// SPDX-FileCopyrightText: 2024 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nimport { flushBufferMs } from \"./types.js\";\nimport type { DeadlineMiddlewareConfig, DeadlineOptions } from \"./types.js\";\n\nexport function 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,15 +0,0 @@
-// SPDX-FileCopyrightText: 2024 lambda-deadline-middleware contributors
-// SPDX-License-Identifier: MIT
-import { flushBufferMs } from "./types.js";
-export function 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;AAG9B,OAAO,SAAS,YAAY,KAA4D;CACtF,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: 2024 lambda-deadline-middleware contributors\n// SPDX-License-Identifier: MIT\n\nimport { flushBufferMs } from \"./types.js\";\nimport type { DeadlineMiddlewareConfig, DeadlineOptions } from \"./types.js\";\n\nexport function 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,10 +0,0 @@
-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;
-
-//# sourceMappingURL=registration.d.ts.map

package/dist/registration.d.ts.map

@@ -1 +0,0 @@
-{"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"]}

package/dist/registration.js

@@ -1,23 +0,0 @@
-import { parseConfig } from "./config.js";
-import { deadlineMiddlewareHandler } from "./middleware.js";
-export function deadlineMiddleware(options) {
-	const config = parseConfig(options);
-	return { applyToStack(stack) {
-		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 +0,0 @@
-{"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"]}

package/dist/telemetry.d.ts

@@ -1,5 +0,0 @@
-import type { DeadlineExceededError } from "./error.js";
-import type { DeadlineMiddlewareConfig } from "./types.js";
-export declare function 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;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"]}

package/dist/telemetry.js

@@ -1,82 +0,0 @@
-let emitter;
-let detected = false;
-async function detectEmitter() {
-	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 async function emitDeadlineAbort(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":"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"]}

package/src/config.ts

@@ -1,16 +0,0 @@
-// SPDX-FileCopyrightText: 2024 lambda-deadline-middleware contributors
-// SPDX-License-Identifier: MIT
-
-import { flushBufferMs } from "./types.js";
-import type { DeadlineMiddlewareConfig, DeadlineOptions } from "./types.js";
-
-export function 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,36 +0,0 @@
-// SPDX-FileCopyrightText: 2024 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 function deadlineMiddleware(options?: DeadlineOptions): Pluggable<object, object> {
-  const config = parseConfig(options);
-
-  return {
-    applyToStack(stack) {
-      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<object>();
-
-export function withDeadline<
-  // oxlint-disable-next-line typescript/no-explicit-any -- AWS SDK clients use varying ServiceInput/OutputTypes generics, making `any` the only correct constraint here
-  T extends { middlewareStack: { use: (pluggable: Pluggable<any, any>) => void } },
->(client: T, options?: DeadlineOptions): T {
-  if (registeredClients.has(client)) return client;
-  registeredClients.add(client);
-  client.middlewareStack.use(deadlineMiddleware(options));
-  return client;
-}

package/src/telemetry.ts

@@ -1,129 +0,0 @@
-// SPDX-FileCopyrightText: 2024 lambda-deadline-middleware contributors
-// SPDX-License-Identifier: MIT
-
-import type { DeadlineExceededError } from "./error.js";
-import type { DeadlineMiddlewareConfig } from "./types.js";
-
-interface AbortDetails {
-  readonly deadlineMs: number;
-  readonly flushBufferMs: number;
-  readonly remainingMs: number;
-}
-
-interface TelemetryEmitter {
-  recordDeadlineAbort: (details: AbortDetails) => void;
-  setDeadlineErrorStatus: (error: DeadlineExceededError) => void;
-}
-
-let emitter: TelemetryEmitter | undefined;
-let detected = false;
-
-async function detectEmitter(): Promise<TelemetryEmitter | undefined> {
-  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: Record<string, unknown> = await import(/* webpackIgnore: true */ moduleName);
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing optional OTel API surface
-    const trace = otelApi["trace"] as { getActiveSpan: () => unknown } | undefined;
-
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing optional OTel API surface
-    const SpanStatusCode = otelApi["SpanStatusCode"] as
-      | {
-          ERROR: number;
-        }
-      | undefined;
-
-    if (!trace || !SpanStatusCode) {
-      emitter = undefined;
-      return emitter;
-    }
-
-    emitter = {
-      recordDeadlineAbort(details: AbortDetails): void {
-        try {
-          // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span from untyped getActiveSpan()
-          const span = trace.getActiveSpan() as Record<string, unknown> | undefined;
-          if (!span) return;
-
-          // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span.addEvent method
-          const addEvent = span["addEvent"] as
-            | ((name: string, attributes: Record<string, unknown>) => void)
-            | undefined;
-          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 {
-          // Telemetry must never disrupt request processing
-        }
-      },
-
-      setDeadlineErrorStatus(error: DeadlineExceededError): void {
-        try {
-          // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span from untyped getActiveSpan()
-          const span = trace.getActiveSpan() as Record<string, unknown> | undefined;
-          if (!span) return;
-
-          // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span.setStatus method
-          const setStatus = span["setStatus"] as
-            | ((status: { code: number; message: string }) => void)
-            | undefined;
-          // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- duck-typing OTel span.setAttribute method
-          const setAttribute = span["setAttribute"] as
-            | ((key: string, value: unknown) => void)
-            | undefined;
-
-          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 {
-          // Telemetry must never disrupt request processing
-        }
-      },
-    };
-  } catch {
-    emitter = undefined;
-  }
-
-  return emitter;
-}
-
-export async function emitDeadlineAbort(
-  error: DeadlineExceededError,
-  config: DeadlineMiddlewareConfig,
-): Promise<void> {
-  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 {
-    // Telemetry must never disrupt request processing
-  }
-}