rds-database-auto-start-preventer 0.3.5 → 0.4.0

package/assets/funcs/auto-start-prevent.lambda/index.js

@@ -20561,13 +20561,88 @@ var require_dist5 = __commonJS({
   }
 });
 
-// node_modules/fetch-retrier/lib/index.js
-var require_lib = __commonJS({
-  "node_modules/fetch-retrier/lib/index.js"(exports2) {
+// node_modules/aws-lambda-secret-fetcher/lib/core/errors.js
+var require_errors2 = __commonJS({
+  "node_modules/aws-lambda-secret-fetcher/lib/core/errors.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.parseRetryAfterMs = exports2.fetchRetrier = exports2.defaultShouldRetry = exports2.DEFAULT_RETRYABLE_HTTP_STATUSES = exports2.FetchRetrierUnreachableError = exports2.FetchRetrierInvalidOptionsError = exports2.FetchRetrierNetworkError = exports2.FetchRetrierHttpError = exports2.FetchRetrierAlreadyAbortedError = exports2.FetchRetrierAbortError = void 0;
-    var FetchRetrierAbortError = class _FetchRetrierAbortError extends Error {
+    exports2.SecretFetcherBinaryError = exports2.SecretFetcherResponseError = exports2.SecretFetcherPortError = exports2.SecretFetcherSessionTokenError = exports2.SecretFetcherError = void 0;
+    var SecretFetcherError = class _SecretFetcherError extends Error {
+      /**
+       * @param message - Error message shown to the caller
+       */
+      constructor(message) {
+        super(message);
+        this.name = "SecretFetcherError";
+        Object.setPrototypeOf(this, _SecretFetcherError.prototype);
+      }
+    };
+    exports2.SecretFetcherError = SecretFetcherError;
+    var SecretFetcherSessionTokenError = class _SecretFetcherSessionTokenError extends SecretFetcherError {
+      /**
+       * @param message - Error message shown to the caller
+       */
+      constructor(message) {
+        super(message);
+        this.name = "SecretFetcherSessionTokenError";
+        Object.setPrototypeOf(this, _SecretFetcherSessionTokenError.prototype);
+      }
+    };
+    exports2.SecretFetcherSessionTokenError = SecretFetcherSessionTokenError;
+    var SecretFetcherPortError = class _SecretFetcherPortError extends SecretFetcherError {
+      /**
+       * @param message - Error message shown to the caller
+       */
+      constructor(message) {
+        super(message);
+        this.name = "SecretFetcherPortError";
+        Object.setPrototypeOf(this, _SecretFetcherPortError.prototype);
+      }
+    };
+    exports2.SecretFetcherPortError = SecretFetcherPortError;
+    var SecretFetcherResponseError = class _SecretFetcherResponseError extends SecretFetcherError {
+      /**
+       * @param message - Error message shown to the caller
+       */
+      constructor(message) {
+        super(message);
+        this.name = "SecretFetcherResponseError";
+        Object.setPrototypeOf(this, _SecretFetcherResponseError.prototype);
+      }
+    };
+    exports2.SecretFetcherResponseError = SecretFetcherResponseError;
+    var SecretFetcherBinaryError = class _SecretFetcherBinaryError extends SecretFetcherError {
+      /**
+       * @param message - Error message shown to the caller
+       */
+      constructor(message) {
+        super(message);
+        this.name = "SecretFetcherBinaryError";
+        Object.setPrototypeOf(this, _SecretFetcherBinaryError.prototype);
+      }
+    };
+    exports2.SecretFetcherBinaryError = SecretFetcherBinaryError;
+  }
+});
+
+// node_modules/fetch-retrier/lib/core/errors.js
+var require_errors3 = __commonJS({
+  "node_modules/fetch-retrier/lib/core/errors.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.FetchRetrierUnreachableError = exports2.FetchRetrierInvalidOptionsError = exports2.FetchRetrierNetworkError = exports2.FetchRetrierHttpError = exports2.FetchRetrierAlreadyAbortedError = exports2.FetchRetrierAbortError = exports2.FetchRetrierError = void 0;
+    var FetchRetrierError = class _FetchRetrierError extends Error {
+      /**
+       * @param message - Human-readable reason
+       */
+      constructor(message) {
+        super(message);
+        this.name = "FetchRetrierError";
+        Object.setPrototypeOf(this, _FetchRetrierError.prototype);
+      }
+    };
+    exports2.FetchRetrierError = FetchRetrierError;
+    var FetchRetrierAbortError = class _FetchRetrierAbortError extends FetchRetrierError {
       /**
        * @param message - Human-readable reason (default: `'Aborted'`)
        */
@@ -20589,7 +20664,7 @@ var require_lib = __commonJS({
       }
     };
     exports2.FetchRetrierAlreadyAbortedError = FetchRetrierAlreadyAbortedError;
-    var FetchRetrierHttpError = class _FetchRetrierHttpError extends Error {
+    var FetchRetrierHttpError = class _FetchRetrierHttpError extends FetchRetrierError {
       /**
        * @param message - Error description
        * @param status - HTTP status code from the last non-OK response
@@ -20604,7 +20679,7 @@ var require_lib = __commonJS({
       }
     };
     exports2.FetchRetrierHttpError = FetchRetrierHttpError;
-    var FetchRetrierNetworkError = class _FetchRetrierNetworkError extends Error {
+    var FetchRetrierNetworkError = class _FetchRetrierNetworkError extends FetchRetrierError {
       /**
        * @param message - Human-readable reason (default: `'Network error'`)
        * @param cause - Original error from the underlying `fetch`, when available
@@ -20617,7 +20692,7 @@ var require_lib = __commonJS({
       }
     };
     exports2.FetchRetrierNetworkError = FetchRetrierNetworkError;
-    var FetchRetrierInvalidOptionsError = class _FetchRetrierInvalidOptionsError extends TypeError {
+    var FetchRetrierInvalidOptionsError = class _FetchRetrierInvalidOptionsError extends FetchRetrierError {
       /**
        * @param message - Human-readable reason describing the invalid option
        */
@@ -20628,7 +20703,7 @@ var require_lib = __commonJS({
       }
     };
     exports2.FetchRetrierInvalidOptionsError = FetchRetrierInvalidOptionsError;
-    var FetchRetrierUnreachableError = class _FetchRetrierUnreachableError extends Error {
+    var FetchRetrierUnreachableError = class _FetchRetrierUnreachableError extends FetchRetrierError {
       /**
        * @param message - Human-readable reason (default: `'Unreachable'`)
        */
@@ -20639,88 +20714,34 @@ var require_lib = __commonJS({
       }
     };
     exports2.FetchRetrierUnreachableError = FetchRetrierUnreachableError;
-    exports2.DEFAULT_RETRYABLE_HTTP_STATUSES = [408, 425, 429, 500, 502, 503, 504];
-    var defaultShouldRetry = (response, _body) => {
-      return exports2.DEFAULT_RETRYABLE_HTTP_STATUSES.includes(response.status);
-    };
-    exports2.defaultShouldRetry = defaultShouldRetry;
-    var validateRequestOptions = (options) => {
-      const { retries, timeoutMs, baseBackoffMs } = options;
-      if (retries < 1) {
-        throw new FetchRetrierInvalidOptionsError("retries must be >= 1");
-      }
-      if (timeoutMs <= 0) {
-        throw new FetchRetrierInvalidOptionsError("timeoutMs must be > 0");
-      }
-      if (baseBackoffMs < 0) {
-        throw new FetchRetrierInvalidOptionsError("baseBackoffMs must be >= 0");
-      }
-    };
-    var fetchRetrier = async (url, options) => {
-      const { headers, init, retries, timeoutMs, baseBackoffMs, signal: externalSignal, shouldRetry = exports2.defaultShouldRetry } = options;
-      validateRequestOptions({ retries, timeoutMs, baseBackoffMs });
-      for (let attempt = 1; attempt <= retries; attempt++) {
-        if (externalSignal?.aborted) {
-          throw new FetchRetrierAlreadyAbortedError();
-        }
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), timeoutMs);
-        const onExternalAbort = () => {
-          clearTimeout(timer);
-          controller.abort();
-        };
-        if (externalSignal) {
-          externalSignal.addEventListener("abort", onExternalAbort);
-        }
-        try {
-          const res = await fetch(url, {
-            ...init,
-            ...headers !== void 0 ? { headers } : {},
-            signal: controller.signal
-          });
-          clearTimeout(timer);
-          externalSignal?.removeEventListener("abort", onExternalAbort);
-          if (res.ok) {
-            return res;
-          }
-          const text = await res.text();
-          const isContinue = shouldRetry(res, text);
-          if (isContinue) {
-            if (attempt === retries) {
-              throw new FetchRetrierHttpError(`HTTP ${res.status}`, res.status, text);
-            }
-            await wait(resolveRetryDelayMs(res, baseBackoffMs, attempt));
-          } else {
-            throw new FetchRetrierHttpError(`Non-retriable HTTP error: ${res.status}`, res.status, text);
-          }
-        } catch (err) {
-          clearTimeout(timer);
-          externalSignal?.removeEventListener("abort", onExternalAbort);
-          if (err instanceof Error && err.name === "AbortError") {
-            if (attempt === retries)
-              throw err instanceof FetchRetrierAbortError ? err : new FetchRetrierAbortError();
-            await wait(fullJitter(baseBackoffMs, attempt));
-            continue;
-          }
-          if (err instanceof TypeError) {
-            if (attempt === retries)
-              throw new FetchRetrierNetworkError("Network error", err);
-            await wait(fullJitter(baseBackoffMs, attempt));
-            continue;
-          }
-          throw err;
-        }
-      }
-      throw new FetchRetrierUnreachableError();
-    };
-    exports2.fetchRetrier = fetchRetrier;
-    var wait = (ms) => {
-      return new Promise((resolve) => setTimeout(resolve, ms));
-    };
-    var fullJitter = (base, attempt) => {
+  }
+});
+
+// node_modules/fetch-retrier/lib/core/backoff/jitter.js
+var require_jitter = __commonJS({
+  "node_modules/fetch-retrier/lib/core/backoff/jitter.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.fullJitter = void 0;
+    var fullJitter = (base, attempt, maxBackoffMs) => {
       const cap = base * Math.pow(2, attempt);
-      return Math.floor(Math.random() * cap);
+      const delay = Math.floor(Math.random() * cap);
+      if (maxBackoffMs === void 0) {
+        return delay;
+      }
+      return Math.min(delay, maxBackoffMs);
     };
+    exports2.fullJitter = fullJitter;
+  }
+});
+
+// node_modules/fetch-retrier/lib/core/backoff/retry-after.js
+var require_retry_after = __commonJS({
+  "node_modules/fetch-retrier/lib/core/backoff/retry-after.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.resolveRetryDelayMs = exports2.parseRetryAfterMs = void 0;
+    var jitter_1 = require_jitter();
     var parseRetryAfterMs = (value, nowMs = Date.now()) => {
       const trimmed = value.trim();
       if (trimmed === "") {
@@ -20739,288 +20760,231 @@ var require_lib = __commonJS({
       return Math.max(0, dateMs - nowMs);
     };
     exports2.parseRetryAfterMs = parseRetryAfterMs;
-    var resolveRetryDelayMs = (response, baseBackoffMs, attempt, nowMs = Date.now()) => {
+    var resolveRetryDelayMs = (response, baseBackoffMs, attempt, maxBackoffMs, nowMs = Date.now()) => {
       const header = response.headers?.get("Retry-After");
       if (header == null) {
-        return fullJitter(baseBackoffMs, attempt);
+        return (0, jitter_1.fullJitter)(baseBackoffMs, attempt, maxBackoffMs);
       }
       const fromHeader = (0, exports2.parseRetryAfterMs)(header, nowMs);
       if (fromHeader === void 0) {
-        return fullJitter(baseBackoffMs, attempt);
+        return (0, jitter_1.fullJitter)(baseBackoffMs, attempt, maxBackoffMs);
       }
       return fromHeader;
     };
+    exports2.resolveRetryDelayMs = resolveRetryDelayMs;
   }
 });
 
-// node_modules/quiet-json-parser/lib/index.js
-var require_lib2 = __commonJS({
-  "node_modules/quiet-json-parser/lib/index.js"(exports2) {
+// node_modules/fetch-retrier/lib/core/http/timed-fetch.js
+var require_timed_fetch = __commonJS({
+  "node_modules/fetch-retrier/lib/core/http/timed-fetch.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.quietParse = void 0;
-    var safeReviver = (key, value) => {
-      if (key === "__proto__" || key === "constructor" || key === "prototype") {
-        return void 0;
-      }
-      return value;
-    };
-    var quietParse = (jsonString, fallback, onError) => {
-      if (!jsonString) {
-        return fallback;
+    exports2.timedFetch = void 0;
+    var timedFetch = async (url, options) => {
+      const { timeoutMs, init, headers, signal: externalSignal } = options;
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeoutMs);
+      const onExternalAbort = () => {
+        clearTimeout(timer);
+        controller.abort();
+      };
+      if (externalSignal) {
+        externalSignal.addEventListener("abort", onExternalAbort);
       }
       try {
-        return JSON.parse(jsonString, safeReviver);
-      } catch (error) {
-        onError?.(error);
-        return fallback;
+        return await fetch(url, {
+          ...init,
+          ...headers !== void 0 ? { headers } : {},
+          signal: controller.signal
+        });
+      } finally {
+        clearTimeout(timer);
+        externalSignal?.removeEventListener("abort", onExternalAbort);
       }
     };
-    exports2.quietParse = quietParse;
+    exports2.timedFetch = timedFetch;
   }
 });
 
-// node_modules/aws-lambda-secret-fetcher/node_modules/strict-env-resolver/lib/index.js
-var require_lib3 = __commonJS({
-  "node_modules/aws-lambda-secret-fetcher/node_modules/strict-env-resolver/lib/index.js"(exports2) {
+// node_modules/fetch-retrier/lib/core/policy/default-should-retry.js
+var require_default_should_retry = __commonJS({
+  "node_modules/fetch-retrier/lib/core/policy/default-should-retry.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.StrictEnvResolver = exports2.StrictEnvType = exports2.StrictEnvValidationError = exports2.StrictEnvError = void 0;
-    var TRUE_BOOLEAN_PATTERN = /^(1|true|yes|on)$/i;
-    var parseNumber = (raw) => {
-      const n = Number(raw);
-      if (!Number.isFinite(n)) {
-        return void 0;
-      }
-      return n;
-    };
-    var parseBooleanEnvValue = (normalizedRaw) => TRUE_BOOLEAN_PATTERN.test(normalizedRaw);
-    var StrictEnvError = class extends Error {
-      /**
-       * @param message - Error message.
-       */
-      constructor(message) {
-        super(message);
-        this.name = "StrictEnvError";
-      }
-    };
-    exports2.StrictEnvError = StrictEnvError;
-    var StrictEnvValidationError = class _StrictEnvValidationError extends StrictEnvError {
-      /**
-       * Formats validation errors into a human-readable error message.
-       *
-       * @template K - Environment variable key type.
-       * @param errors - Validation error entries to format.
-       * @returns Multi-line summary listing each key and message.
-       */
-      static format(errors) {
-        const lines = errors.map((e) => `- ${e.key}: ${e.message}${e.raw == null ? "" : ` (raw="${e.raw}")`}`);
-        return `Invalid environment variables (${errors.length}):
-${lines.join("\n")}`;
-      }
-      /**
-       * Creates a new validation error from one or more `StrictEnvValidationEntry` entries.
-       *
-       * @param errors - One or more structured validation errors.
-       */
-      constructor(errors) {
-        const msg = _StrictEnvValidationError.format(errors);
-        super(msg);
-        this.name = "StrictEnvValidationError";
-        this.errors = errors;
-        this.keys = errors.map((e) => e.key);
-      }
-    };
-    exports2.StrictEnvValidationError = StrictEnvValidationError;
-    exports2.StrictEnvType = {
-      /** Spec for a string value (returned as-is unless `trim: true` is set in options). */
-      String: { type: "string" },
-      /**
-       * Spec for a finite numeric value (`Number()` parsing; rejects `NaN` and `Infinity`).
-       */
-      Number: { type: "number" },
-      /** Spec for a boolean value (`1`/`true`/`yes`/`on` → `true`; other non-empty values → `false`). */
-      Boolean: { type: "boolean" },
-      /**
-       * Returns a spec that restricts the value to one of the given choices.
-       *
-       * @param choices - Allowed string literals.
-       * @returns Enum spec for use with `resolve` or `resolveAll`.
-       */
-      Enum: (choices) => ({ type: "enum", choices })
+    exports2.defaultShouldRetry = exports2.DEFAULT_RETRYABLE_HTTP_STATUSES = void 0;
+    exports2.DEFAULT_RETRYABLE_HTTP_STATUSES = [408, 425, 429, 500, 502, 503, 504];
+    var defaultShouldRetry = (response, _body) => {
+      return exports2.DEFAULT_RETRYABLE_HTTP_STATUSES.includes(response.status);
     };
-    var defaultTrimForSpec = (spec) => spec.type !== "string";
-    var normalizeEnvRaw = (raw, trim) => {
-      if (raw == null) {
-        return void 0;
-      }
-      if (!trim) {
-        return raw;
+    exports2.defaultShouldRetry = defaultShouldRetry;
+  }
+});
+
+// node_modules/fetch-retrier/lib/core/policy/validate-options.js
+var require_validate_options = __commonJS({
+  "node_modules/fetch-retrier/lib/core/policy/validate-options.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.validateRequestOptions = void 0;
+    var errors_1 = require_errors3();
+    var validateRequestOptions = (options) => {
+      const { retries, timeoutMs, baseBackoffMs, maxBackoffMs } = options;
+      if (retries < 1) {
+        throw new errors_1.FetchRetrierInvalidOptionsError("retries must be >= 1");
       }
-      return raw.trim();
-    };
-    var resolveSchemaEntry = (entry) => ({
-      spec: Array.isArray(entry) ? entry[0] : entry,
-      options: Array.isArray(entry) ? entry[1] : void 0
-    });
-    var parseEnvValue = (key, spec, raw, defaultValue, options) => {
-      const trim = options?.trim ?? defaultTrimForSpec(spec);
-      const normalizedRaw = normalizeEnvRaw(raw, trim);
-      const hasDefault = defaultValue !== void 0;
-      if (normalizedRaw == null || normalizedRaw === "") {
-        if (hasDefault) {
-          return { ok: true, value: defaultValue };
-        }
-        return {
-          ok: false,
-          error: { key, message: `Missing required environment variable: ${key}`, raw, kind: "missing" }
-        };
+      if (timeoutMs <= 0) {
+        throw new errors_1.FetchRetrierInvalidOptionsError("timeoutMs must be > 0");
       }
-      switch (spec.type) {
-        case "number": {
-          const n = parseNumber(normalizedRaw);
-          if (n === void 0) {
-            return {
-              ok: false,
-              error: { key, message: `Env ${key}: expected number, got "${raw}"`, raw, kind: "invalid_number" }
-            };
-          }
-          return { ok: true, value: n };
-        }
-        case "boolean":
-          return { ok: true, value: parseBooleanEnvValue(normalizedRaw) };
-        case "enum":
-          if (!spec.choices.includes(normalizedRaw)) {
-            return {
-              ok: false,
-              error: {
-                key,
-                message: `Env ${key}: must be one of [${spec.choices.join(", ")}]`,
-                raw,
-                kind: "invalid_enum"
-              }
-            };
-          }
-          return { ok: true, value: normalizedRaw };
-        default:
-          return { ok: true, value: normalizedRaw };
+      if (baseBackoffMs < 0) {
+        throw new errors_1.FetchRetrierInvalidOptionsError("baseBackoffMs must be >= 0");
       }
-    };
-    var resolve = (key, spec = exports2.StrictEnvType.String, options) => {
-      const result = parseEnvValue(key, spec, process.env[key], options?.default, options);
-      if (!result.ok) {
-        throw new StrictEnvValidationError([result.error]);
+      if (maxBackoffMs !== void 0 && maxBackoffMs < 0) {
+        throw new errors_1.FetchRetrierInvalidOptionsError("maxBackoffMs must be >= 0");
       }
-      return result.value;
     };
-    var resolveAll = (schema) => {
-      const envs = {};
-      const errors = [];
-      for (const key of Object.keys(schema)) {
-        const { spec, options } = resolveSchemaEntry(schema[key]);
-        const result = parseEnvValue(key, spec, process.env[key], options?.default, options);
-        if (!result.ok) {
-          errors.push(result.error);
-          continue;
-        }
-        envs[key] = result.value;
-      }
-      if (errors.length > 0)
-        throw new StrictEnvValidationError(errors);
-      return envs;
+    exports2.validateRequestOptions = validateRequestOptions;
+  }
+});
+
+// node_modules/fetch-retrier/lib/core/retry-predicates.js
+var require_retry_predicates = __commonJS({
+  "node_modules/fetch-retrier/lib/core/retry-predicates.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.isLastAttempt = void 0;
+    var isLastAttempt = (attempt, retries) => {
+      return attempt === retries;
     };
-    exports2.StrictEnvResolver = {
-      /** Reads and parses a single environment variable. See {@link resolve}. */
-      resolve,
-      /** Reads and parses multiple environment variables in one pass. See {@link resolveAll}. */
-      resolveAll
+    exports2.isLastAttempt = isLastAttempt;
+  }
+});
+
+// node_modules/fetch-retrier/lib/core/time/wait.js
+var require_wait = __commonJS({
+  "node_modules/fetch-retrier/lib/core/time/wait.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.wait = void 0;
+    var wait = (ms) => {
+      return new Promise((resolve) => setTimeout(resolve, ms));
     };
+    exports2.wait = wait;
   }
 });
 
-// node_modules/aws-lambda-secret-fetcher/lib/index.js
-var require_lib4 = __commonJS({
-  "node_modules/aws-lambda-secret-fetcher/lib/index.js"(exports2) {
+// node_modules/fetch-retrier/lib/core/fetch-retrier.js
+var require_fetch_retrier = __commonJS({
+  "node_modules/fetch-retrier/lib/core/fetch-retrier.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.secretFetcher = void 0;
-    var fetch_retrier_1 = require_lib();
-    var quiet_json_parser_1 = require_lib2();
-    var strict_env_resolver_1 = require_lib3();
-    var getSecretValue = async (name, options = {}) => {
-      const { extensionHttpPort, timeoutMs = 2e3, retries = 3, baseBackoffMs = 300 } = options;
-      const port = resolveExtensionHttpPort(extensionHttpPort);
-      const sessionToken = resolveAwsSessionToken();
-      const url = `http://localhost:${port}/secretsmanager/get?secretId=${encodeURIComponent(name)}`;
-      const requestOptions = {
-        headers: {
-          "X-Aws-Parameters-Secrets-Token": sessionToken
-        },
-        retries,
-        timeoutMs,
-        baseBackoffMs,
-        shouldRetry: (res, body) => {
-          if ((0, fetch_retrier_1.defaultShouldRetry)(res, body)) {
-            return true;
+    exports2.fetchRetrier = void 0;
+    var jitter_1 = require_jitter();
+    var retry_after_1 = require_retry_after();
+    var errors_1 = require_errors3();
+    var timed_fetch_1 = require_timed_fetch();
+    var default_should_retry_1 = require_default_should_retry();
+    var validate_options_1 = require_validate_options();
+    var retry_predicates_1 = require_retry_predicates();
+    var wait_1 = require_wait();
+    var fetchRetrier = async (url, options) => {
+      const { headers, init, retries, timeoutMs, baseBackoffMs, maxBackoffMs, signal: externalSignal, shouldRetry = default_should_retry_1.defaultShouldRetry } = options;
+      (0, validate_options_1.validateRequestOptions)({ retries, timeoutMs, baseBackoffMs, maxBackoffMs });
+      for (let attempt = 1; attempt <= retries; attempt++) {
+        if (externalSignal?.aborted) {
+          throw new errors_1.FetchRetrierAlreadyAbortedError();
+        }
+        try {
+          const res = await (0, timed_fetch_1.timedFetch)(url, {
+            timeoutMs,
+            init,
+            headers,
+            signal: externalSignal
+          });
+          if (res.ok) {
+            return res;
           }
-          if (res.status === 400 && /not\s+ready.*traffic/i.test(body)) {
-            return true;
+          const text = await res.text();
+          const isContinue = shouldRetry(res, text);
+          if (!isContinue) {
+            throw new errors_1.FetchRetrierHttpError(`Non-retriable HTTP error: ${res.status}`, res.status, text);
           }
-          return false;
-        }
-      };
-      const response = await (0, fetch_retrier_1.fetchRetrier)(url, requestOptions);
-      const raw = await response.json();
-      if (!isSecretResponse(raw)) {
-        throw new Error("Invalid secret response format");
-      }
-      const data = raw;
-      return (0, quiet_json_parser_1.quietParse)(data.SecretString, data.SecretString);
-    };
-    var AWS_SESSION_TOKEN_GUIDANCE = "AWS_SESSION_TOKEN is not set. This library only works inside an AWS Lambda execution environment where the runtime provides AWS_SESSION_TOKEN for the Parameters and Secrets Extension. Attach the extension layer and run your code as a Lambda function handler.";
-    var MIN_TCP_PORT = 1;
-    var MAX_TCP_PORT = 65535;
-    var resolveAwsSessionToken = () => {
-      try {
-        return strict_env_resolver_1.StrictEnvResolver.resolve("AWS_SESSION_TOKEN", strict_env_resolver_1.StrictEnvType.String, { trim: true });
-      } catch (e) {
-        if (e instanceof strict_env_resolver_1.StrictEnvValidationError && e.errors.length === 1 && e.errors[0]?.key === "AWS_SESSION_TOKEN" && e.errors[0]?.kind === "missing") {
-          throw new Error(AWS_SESSION_TOKEN_GUIDANCE);
+          if ((0, retry_predicates_1.isLastAttempt)(attempt, retries)) {
+            throw new errors_1.FetchRetrierHttpError(`HTTP ${res.status}`, res.status, text);
+          }
+          await (0, wait_1.wait)((0, retry_after_1.resolveRetryDelayMs)(res, baseBackoffMs, attempt, maxBackoffMs));
+        } catch (err) {
+          if (err instanceof Error && err.name === "AbortError") {
+            if ((0, retry_predicates_1.isLastAttempt)(attempt, retries)) {
+              throw err instanceof errors_1.FetchRetrierAbortError ? err : new errors_1.FetchRetrierAbortError();
+            }
+            await (0, wait_1.wait)((0, jitter_1.fullJitter)(baseBackoffMs, attempt, maxBackoffMs));
+            continue;
+          }
+          if (err instanceof TypeError) {
+            if ((0, retry_predicates_1.isLastAttempt)(attempt, retries)) {
+              throw new errors_1.FetchRetrierNetworkError("Network error", err);
+            }
+            await (0, wait_1.wait)((0, jitter_1.fullJitter)(baseBackoffMs, attempt, maxBackoffMs));
+            continue;
+          }
+          throw err;
         }
-        throw e;
-      }
-    };
-    var resolveExtensionHttpPort = (overridePort) => {
-      const port = overridePort === void 0 ? strict_env_resolver_1.StrictEnvResolver.resolve("PARAMETERS_SECRETS_EXTENSION_HTTP_PORT", strict_env_resolver_1.StrictEnvType.Number, { default: 2773 }) : parseExtensionHttpPortOverride(overridePort);
-      return assertValidTcpPort(port);
-    };
-    var parseExtensionHttpPortOverride = (overridePort) => {
-      const candidate = String(overridePort).trim();
-      if (!/^\d+$/.test(candidate)) {
-        throw new Error("Invalid extension HTTP port: must be a number");
-      }
-      return Number.parseInt(candidate, 10);
-    };
-    var assertValidTcpPort = (port) => {
-      if (port < MIN_TCP_PORT || port > MAX_TCP_PORT) {
-        throw new Error("Invalid extension HTTP port: must be between 1 and 65535");
       }
-      return String(port);
-    };
-    var isSecretResponse = (value) => {
-      if (typeof value !== "object" || value === null)
-        return false;
-      const v = value;
-      return typeof v.SecretString === "string" && typeof v.Name === "string" && typeof v.ARN === "string" && (v.VersionId === void 0 || typeof v.VersionId === "string");
-    };
-    exports2.secretFetcher = {
-      getSecretValue
+      throw new errors_1.FetchRetrierUnreachableError();
     };
+    exports2.fetchRetrier = fetchRetrier;
+  }
+});
+
+// node_modules/fetch-retrier/lib/index.js
+var require_lib = __commonJS({
+  "node_modules/fetch-retrier/lib/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.defaultShouldRetry = exports2.DEFAULT_RETRYABLE_HTTP_STATUSES = exports2.fetchRetrier = exports2.parseRetryAfterMs = exports2.FetchRetrierUnreachableError = exports2.FetchRetrierNetworkError = exports2.FetchRetrierInvalidOptionsError = exports2.FetchRetrierHttpError = exports2.FetchRetrierError = exports2.FetchRetrierAlreadyAbortedError = exports2.FetchRetrierAbortError = void 0;
+    var errors_1 = require_errors3();
+    Object.defineProperty(exports2, "FetchRetrierAbortError", { enumerable: true, get: function() {
+      return errors_1.FetchRetrierAbortError;
+    } });
+    Object.defineProperty(exports2, "FetchRetrierAlreadyAbortedError", { enumerable: true, get: function() {
+      return errors_1.FetchRetrierAlreadyAbortedError;
+    } });
+    Object.defineProperty(exports2, "FetchRetrierError", { enumerable: true, get: function() {
+      return errors_1.FetchRetrierError;
+    } });
+    Object.defineProperty(exports2, "FetchRetrierHttpError", { enumerable: true, get: function() {
+      return errors_1.FetchRetrierHttpError;
+    } });
+    Object.defineProperty(exports2, "FetchRetrierInvalidOptionsError", { enumerable: true, get: function() {
+      return errors_1.FetchRetrierInvalidOptionsError;
+    } });
+    Object.defineProperty(exports2, "FetchRetrierNetworkError", { enumerable: true, get: function() {
+      return errors_1.FetchRetrierNetworkError;
+    } });
+    Object.defineProperty(exports2, "FetchRetrierUnreachableError", { enumerable: true, get: function() {
+      return errors_1.FetchRetrierUnreachableError;
+    } });
+    var retry_after_1 = require_retry_after();
+    Object.defineProperty(exports2, "parseRetryAfterMs", { enumerable: true, get: function() {
+      return retry_after_1.parseRetryAfterMs;
+    } });
+    var fetch_retrier_1 = require_fetch_retrier();
+    Object.defineProperty(exports2, "fetchRetrier", { enumerable: true, get: function() {
+      return fetch_retrier_1.fetchRetrier;
+    } });
+    var default_should_retry_1 = require_default_should_retry();
+    Object.defineProperty(exports2, "DEFAULT_RETRYABLE_HTTP_STATUSES", { enumerable: true, get: function() {
+      return default_should_retry_1.DEFAULT_RETRYABLE_HTTP_STATUSES;
+    } });
+    Object.defineProperty(exports2, "defaultShouldRetry", { enumerable: true, get: function() {
+      return default_should_retry_1.defaultShouldRetry;
+    } });
   }
 });
 
 // node_modules/strict-env-resolver/lib/index.js
-var require_lib5 = __commonJS({
+var require_lib2 = __commonJS({
   "node_modules/strict-env-resolver/lib/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -21071,29 +21035,38 @@ ${lines.join("\n")}`;
       }
     };
     exports2.StrictEnvValidationError = StrictEnvValidationError;
+    var MIN_POSITIVE_INTEGER = 1;
+    var MAX_NEGATIVE_INTEGER = -1;
+    var ZERO = 0;
+    var MIN_PORT = MIN_POSITIVE_INTEGER;
+    var MAX_PORT = 65535;
     var createNumberSpec = (constraints) => ({
       type: "number",
       ...constraints?.min !== void 0 ? { min: constraints.min } : {},
       ...constraints?.max !== void 0 ? { max: constraints.max } : {},
+      ...constraints?.exclusiveMin !== void 0 ? { exclusiveMin: constraints.exclusiveMin } : {},
+      ...constraints?.exclusiveMax !== void 0 ? { exclusiveMax: constraints.exclusiveMax } : {},
       ...constraints?.integer !== void 0 ? { integer: constraints.integer } : {}
     });
-    var NumberSpec = Object.assign((constraints) => createNumberSpec(constraints), { type: "number" });
+    var NumberSpec = Object.assign((constraints) => createNumberSpec(constraints), { type: "number" }, {
+      Integer: createNumberSpec({ integer: true }),
+      PositiveInteger: createNumberSpec({ min: MIN_POSITIVE_INTEGER, integer: true }),
+      NegativeInteger: createNumberSpec({ max: MAX_NEGATIVE_INTEGER, integer: true }),
+      NonNegativeInteger: createNumberSpec({ min: ZERO, integer: true }),
+      Positive: createNumberSpec({ exclusiveMin: ZERO }),
+      Negative: createNumberSpec({ exclusiveMax: ZERO }),
+      NonNegative: createNumberSpec({ min: ZERO }),
+      Port: createNumberSpec({ min: MIN_PORT, max: MAX_PORT, integer: true })
+    });
     exports2.StrictEnvType = {
       /** Spec for a string value (returned as-is unless `trim: true` is set in options). */
       String: { type: "string" },
       /**
        * Spec for a finite numeric value (`Number()` parsing; rejects `NaN` and `Infinity`).
-       * Use as `StrictEnvType.Number`, or call as `StrictEnvType.Number({ min, max, integer })`.
+       * Use as `StrictEnvType.Number`, call as `StrictEnvType.Number({ min, max, exclusiveMin, exclusiveMax, integer })`,
+       * or use a nested preset such as `StrictEnvType.Number.Port`.
        */
       Number: NumberSpec,
-      /**
-       * Spec for a positive integer (`>= 1`). Sugar for `Number({ min: 1, integer: true })`.
-       */
-      PositiveInt: createNumberSpec({ min: 1, integer: true }),
-      /**
-       * Spec for a negative integer (`<= -1`). Sugar for `Number({ max: -1, integer: true })`.
-       */
-      NegativeInt: createNumberSpec({ max: -1, integer: true }),
       /** Spec for a boolean value (`1`/`true`/`yes`/`on` → `true`; other non-empty values → `false`). */
       Boolean: { type: "boolean" },
       /**
@@ -21126,6 +21099,14 @@ ${lines.join("\n")}`;
           kind: "invalid_number"
         };
       }
+      if (constraints.exclusiveMin !== void 0 && n <= constraints.exclusiveMin) {
+        return {
+          key,
+          message: `Env ${key}: must be > ${constraints.exclusiveMin}, got ${n}`,
+          raw,
+          kind: "invalid_number"
+        };
+      }
       if (constraints.max !== void 0 && n > constraints.max) {
         return {
           key,
@@ -21134,6 +21115,14 @@ ${lines.join("\n")}`;
           kind: "invalid_number"
         };
       }
+      if (constraints.exclusiveMax !== void 0 && n >= constraints.exclusiveMax) {
+        return {
+          key,
+          message: `Env ${key}: must be < ${constraints.exclusiveMax}, got ${n}`,
+          raw,
+          kind: "invalid_number"
+        };
+      }
       return void 0;
     };
     var resolveSchemaEntry = (entry) => ({
@@ -21219,6 +21208,350 @@ ${lines.join("\n")}`;
   }
 });
 
+// node_modules/aws-lambda-secret-fetcher/lib/core/extension-http.js
+var require_extension_http = __commonJS({
+  "node_modules/aws-lambda-secret-fetcher/lib/core/extension-http.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.resolveExtensionHttpPort = exports2.resolveAwsSessionToken = void 0;
+    var strict_env_resolver_1 = require_lib2();
+    var errors_1 = require_errors2();
+    var AWS_SESSION_TOKEN_GUIDANCE = "AWS_SESSION_TOKEN is not set. This library only works inside an AWS Lambda execution environment where the runtime provides AWS_SESSION_TOKEN for the Parameters and Secrets Extension. Attach the extension layer and run your code as a Lambda function handler.";
+    var DEFAULT_EXTENSION_HTTP_PORT = 2773;
+    var MIN_TCP_PORT = 1;
+    var MAX_TCP_PORT = 65535;
+    var resolveAwsSessionToken = () => {
+      try {
+        return strict_env_resolver_1.StrictEnvResolver.resolve("AWS_SESSION_TOKEN", strict_env_resolver_1.StrictEnvType.String, { trim: true });
+      } catch (e) {
+        if (e instanceof strict_env_resolver_1.StrictEnvValidationError && e.errors.length === 1 && e.errors[0]?.key === "AWS_SESSION_TOKEN" && e.errors[0]?.kind === "missing") {
+          throw new errors_1.SecretFetcherSessionTokenError(AWS_SESSION_TOKEN_GUIDANCE);
+        }
+        throw e;
+      }
+    };
+    exports2.resolveAwsSessionToken = resolveAwsSessionToken;
+    var resolveExtensionHttpPort = (overridePort) => {
+      const port = overridePort === void 0 ? strict_env_resolver_1.StrictEnvResolver.resolve("PARAMETERS_SECRETS_EXTENSION_HTTP_PORT", strict_env_resolver_1.StrictEnvType.Number, { default: DEFAULT_EXTENSION_HTTP_PORT }) : parseExtensionHttpPortOverride(overridePort);
+      return assertValidTcpPort(port);
+    };
+    exports2.resolveExtensionHttpPort = resolveExtensionHttpPort;
+    var parseExtensionHttpPortOverride = (overridePort) => {
+      const candidate = String(overridePort).trim();
+      if (!/^\d+$/.test(candidate)) {
+        throw new errors_1.SecretFetcherPortError("Invalid extension HTTP port: must be a number");
+      }
+      return Number.parseInt(candidate, 10);
+    };
+    var assertValidTcpPort = (port) => {
+      if (port < MIN_TCP_PORT || port > MAX_TCP_PORT) {
+        throw new errors_1.SecretFetcherPortError("Invalid extension HTTP port: must be between 1 and 65535");
+      }
+      return String(port);
+    };
+  }
+});
+
+// node_modules/quiet-json-parser/lib/core/errors.js
+var require_errors4 = __commonJS({
+  "node_modules/quiet-json-parser/lib/core/errors.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.QuietJsonParserValidateError = exports2.QuietJsonParserError = void 0;
+    var QuietJsonParserError = class _QuietJsonParserError extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "QuietJsonParserError";
+        Object.setPrototypeOf(this, _QuietJsonParserError.prototype);
+      }
+    };
+    exports2.QuietJsonParserError = QuietJsonParserError;
+    var VALIDATE_MISMATCH_MESSAGE = "Parsed JSON did not match the expected shape";
+    var QuietJsonParserValidateError = class _QuietJsonParserValidateError extends QuietJsonParserError {
+      constructor(message = VALIDATE_MISMATCH_MESSAGE) {
+        super(message);
+        this.name = "QuietJsonParserValidateError";
+        Object.setPrototypeOf(this, _QuietJsonParserValidateError.prototype);
+      }
+    };
+    exports2.QuietJsonParserValidateError = QuietJsonParserValidateError;
+  }
+});
+
+// node_modules/quiet-json-parser/lib/core/omit-unsafe.js
+var require_omit_unsafe = __commonJS({
+  "node_modules/quiet-json-parser/lib/core/omit-unsafe.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.omitUnsafeDeep = exports2.omitUnsafeKey = void 0;
+    var PROTO_KEY = "__proto__";
+    var PROTOTYPE_KEY = "prototype";
+    var CONSTRUCTOR_KEY = "constructor";
+    var isPlainObject = (value) => {
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    };
+    var isUnsafeConstructorValue = (value) => {
+      if (!isPlainObject(value)) {
+        return false;
+      }
+      return Object.prototype.hasOwnProperty.call(value, PROTOTYPE_KEY);
+    };
+    var shouldOmitKey = (key, value) => {
+      if (key === PROTO_KEY || key === PROTOTYPE_KEY) {
+        return true;
+      }
+      if (key !== CONSTRUCTOR_KEY) {
+        return false;
+      }
+      return isUnsafeConstructorValue(value);
+    };
+    var omitUnsafeKey = (key, value) => {
+      if (shouldOmitKey(key, value)) {
+        return void 0;
+      }
+      return value;
+    };
+    exports2.omitUnsafeKey = omitUnsafeKey;
+    var omitUnsafeDeep = (value) => {
+      if (Array.isArray(value)) {
+        return value.map(exports2.omitUnsafeDeep);
+      }
+      if (!isPlainObject(value)) {
+        return value;
+      }
+      const result = {};
+      for (const key of Object.keys(value)) {
+        const nested = value[key];
+        if (shouldOmitKey(key, nested)) {
+          continue;
+        }
+        result[key] = (0, exports2.omitUnsafeDeep)(nested);
+      }
+      return result;
+    };
+    exports2.omitUnsafeDeep = omitUnsafeDeep;
+  }
+});
+
+// node_modules/quiet-json-parser/lib/parse.js
+var require_parse = __commonJS({
+  "node_modules/quiet-json-parser/lib/parse.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.quietParse = void 0;
+    var errors_1 = require_errors4();
+    var omit_unsafe_1 = require_omit_unsafe();
+    var toParseOptions = (onErrorOrOptions) => {
+      if (typeof onErrorOrOptions === "function") {
+        return { onError: onErrorOrOptions };
+      }
+      return onErrorOrOptions ?? {};
+    };
+    var quietParse = (jsonString, fallback, onErrorOrOptions) => {
+      const { validate, onError } = toParseOptions(onErrorOrOptions);
+      if (!jsonString) {
+        return fallback;
+      }
+      let sanitized;
+      try {
+        const parsed = JSON.parse(jsonString);
+        sanitized = (0, omit_unsafe_1.omitUnsafeDeep)(parsed);
+      } catch (error) {
+        onError?.(error);
+        return fallback;
+      }
+      if (!validate) {
+        return sanitized;
+      }
+      try {
+        if (validate(sanitized)) {
+          return sanitized;
+        }
+      } catch (error) {
+        onError?.(error);
+        return fallback;
+      }
+      onError?.(new errors_1.QuietJsonParserValidateError());
+      return fallback;
+    };
+    exports2.quietParse = quietParse;
+  }
+});
+
+// node_modules/quiet-json-parser/lib/stringify.js
+var require_stringify = __commonJS({
+  "node_modules/quiet-json-parser/lib/stringify.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.quietStringify = void 0;
+    var omit_unsafe_1 = require_omit_unsafe();
+    var quietStringify = (value, fallback, onError) => {
+      try {
+        const json = JSON.stringify(value, omit_unsafe_1.omitUnsafeKey);
+        if (typeof json !== "string") {
+          return fallback;
+        }
+        return json;
+      } catch (error) {
+        onError?.(error);
+        return fallback;
+      }
+    };
+    exports2.quietStringify = quietStringify;
+  }
+});
+
+// node_modules/quiet-json-parser/lib/index.js
+var require_lib3 = __commonJS({
+  "node_modules/quiet-json-parser/lib/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.quietStringify = exports2.quietParse = exports2.QuietJsonParserValidateError = exports2.QuietJsonParserError = void 0;
+    var errors_1 = require_errors4();
+    Object.defineProperty(exports2, "QuietJsonParserError", { enumerable: true, get: function() {
+      return errors_1.QuietJsonParserError;
+    } });
+    Object.defineProperty(exports2, "QuietJsonParserValidateError", { enumerable: true, get: function() {
+      return errors_1.QuietJsonParserValidateError;
+    } });
+    var parse_1 = require_parse();
+    Object.defineProperty(exports2, "quietParse", { enumerable: true, get: function() {
+      return parse_1.quietParse;
+    } });
+    var stringify_1 = require_stringify();
+    Object.defineProperty(exports2, "quietStringify", { enumerable: true, get: function() {
+      return stringify_1.quietStringify;
+    } });
+  }
+});
+
+// node_modules/aws-lambda-secret-fetcher/lib/core/secret-response.js
+var require_secret_response = __commonJS({
+  "node_modules/aws-lambda-secret-fetcher/lib/core/secret-response.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.readSecretValue = void 0;
+    var quiet_json_parser_1 = require_lib3();
+    var errors_1 = require_errors2();
+    var STANDARD_BASE64 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+    var INVALID_SECRET_RESPONSE = "Invalid secret response format";
+    var readSecretValue = (raw) => {
+      if (!isSecretResponse(raw)) {
+        throw new errors_1.SecretFetcherResponseError(INVALID_SECRET_RESPONSE);
+      }
+      if ("SecretString" in raw) {
+        return (0, quiet_json_parser_1.quietParse)(raw.SecretString, raw.SecretString);
+      }
+      return decodeSecretBinary(raw.SecretBinary);
+    };
+    exports2.readSecretValue = readSecretValue;
+    var secretFieldKind = (record, key) => {
+      if (!Object.prototype.hasOwnProperty.call(record, key)) {
+        return "absent";
+      }
+      const field = record[key];
+      if (typeof field !== "string" || field.length === 0) {
+        return "invalid";
+      }
+      return "string";
+    };
+    var isSecretResponse = (value) => {
+      if (typeof value !== "object" || value === null)
+        return false;
+      const record = value;
+      if (typeof record.Name !== "string" || typeof record.ARN !== "string") {
+        return false;
+      }
+      if (record.VersionId !== void 0 && typeof record.VersionId !== "string") {
+        return false;
+      }
+      const secretString = secretFieldKind(record, "SecretString");
+      const secretBinary = secretFieldKind(record, "SecretBinary");
+      const hasString = secretString === "string" && secretBinary === "absent";
+      const hasBinary = secretBinary === "string" && secretString === "absent";
+      return hasString || hasBinary;
+    };
+    var isStandardBase64 = (encoded) => STANDARD_BASE64.test(encoded);
+    var decodeSecretBinary = (encoded) => {
+      if (!isStandardBase64(encoded)) {
+        throw new errors_1.SecretFetcherBinaryError("Invalid secret binary encoding");
+      }
+      return Uint8Array.from(Buffer.from(encoded, "base64"));
+    };
+  }
+});
+
+// node_modules/aws-lambda-secret-fetcher/lib/get-secret-value.js
+var require_get_secret_value = __commonJS({
+  "node_modules/aws-lambda-secret-fetcher/lib/get-secret-value.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.secretFetcher = void 0;
+    var fetch_retrier_1 = require_lib();
+    var extension_http_1 = require_extension_http();
+    var secret_response_1 = require_secret_response();
+    var EXTENSION_NOT_READY_STATUS = 400;
+    var getSecretValue = async (name, options = {}) => {
+      const { extensionHttpPort, timeoutMs = 2e3, retries = 3, baseBackoffMs = 300 } = options;
+      const port = (0, extension_http_1.resolveExtensionHttpPort)(extensionHttpPort);
+      const sessionToken = (0, extension_http_1.resolveAwsSessionToken)();
+      const url = `http://localhost:${port}/secretsmanager/get?secretId=${encodeURIComponent(name)}`;
+      const requestOptions = {
+        headers: {
+          "X-Aws-Parameters-Secrets-Token": sessionToken
+        },
+        retries,
+        timeoutMs,
+        baseBackoffMs,
+        shouldRetry: (res, body) => {
+          if ((0, fetch_retrier_1.defaultShouldRetry)(res, body)) {
+            return true;
+          }
+          if (res.status === EXTENSION_NOT_READY_STATUS && /not\s+ready.*traffic/i.test(body)) {
+            return true;
+          }
+          return false;
+        }
+      };
+      const response = await (0, fetch_retrier_1.fetchRetrier)(url, requestOptions);
+      const raw = await response.json();
+      return (0, secret_response_1.readSecretValue)(raw);
+    };
+    exports2.secretFetcher = {
+      getSecretValue
+    };
+  }
+});
+
+// node_modules/aws-lambda-secret-fetcher/lib/index.js
+var require_lib4 = __commonJS({
+  "node_modules/aws-lambda-secret-fetcher/lib/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.secretFetcher = exports2.SecretFetcherSessionTokenError = exports2.SecretFetcherResponseError = exports2.SecretFetcherPortError = exports2.SecretFetcherError = exports2.SecretFetcherBinaryError = void 0;
+    var errors_1 = require_errors2();
+    Object.defineProperty(exports2, "SecretFetcherBinaryError", { enumerable: true, get: function() {
+      return errors_1.SecretFetcherBinaryError;
+    } });
+    Object.defineProperty(exports2, "SecretFetcherError", { enumerable: true, get: function() {
+      return errors_1.SecretFetcherError;
+    } });
+    Object.defineProperty(exports2, "SecretFetcherPortError", { enumerable: true, get: function() {
+      return errors_1.SecretFetcherPortError;
+    } });
+    Object.defineProperty(exports2, "SecretFetcherResponseError", { enumerable: true, get: function() {
+      return errors_1.SecretFetcherResponseError;
+    } });
+    Object.defineProperty(exports2, "SecretFetcherSessionTokenError", { enumerable: true, get: function() {
+      return errors_1.SecretFetcherSessionTokenError;
+    } });
+    var get_secret_value_1 = require_get_secret_value();
+    Object.defineProperty(exports2, "secretFetcher", { enumerable: true, get: function() {
+      return get_secret_value_1.secretFetcher;
+    } });
+  }
+});
+
 // src/funcs/auto-start-prevent.lambda.ts
 var auto_start_prevent_lambda_exports = {};
 __export(auto_start_prevent_lambda_exports, {
@@ -24745,9 +25078,10 @@ var DEFAULT_CONFIG = {
 var import_client_rds = require("@aws-sdk/client-rds");
 var import_web_api = __toESM(require_dist5());
 var import_aws_lambda_secret_fetcher = __toESM(require_lib4());
-var import_strict_env_resolver = __toESM(require_lib5());
+var import_strict_env_resolver = __toESM(require_lib2());
 
 // src/funcs/auto-start-prevent.predicates.ts
+var WAIT_INTERVAL_MINUTES = 5;
 var TRANSITIONAL_STATUSES = /* @__PURE__ */ new Set([
   "starting",
   "configuring-enhanced-monitoring",
@@ -24794,7 +25128,7 @@ var isDbInstanceAutoStart = (detailType, detail) => detailType === "RDS DB Insta
 var isDbClusterAutoStart = (detailType, detail) => detailType === "RDS DB Cluster Event" && detail.SourceType === "CLUSTER" && detail.EventID === "RDS-EVENT-0153";
 var waitStrategyUntilStable = (state) => {
   if (isTransitionalStatus(state.status)) {
-    return { shouldContinue: true, delay: { minutes: 5 } };
+    return { shouldContinue: true, delay: { minutes: WAIT_INTERVAL_MINUTES } };
   }
   return { shouldContinue: false };
 };
@@ -24803,7 +25137,7 @@ var waitStrategyUntilStopped = (state) => {
     return { shouldContinue: false };
   }
   if (isTransitionalStatus(state.status)) {
-    return { shouldContinue: true, delay: { minutes: 5 } };
+    return { shouldContinue: true, delay: { minutes: WAIT_INTERVAL_MINUTES } };
   }
   throw new Error(`Unexpected status while waiting for stop: ${state.status}`);
 };
@@ -24883,13 +25217,18 @@ var processAutoStartPrevent = async (input, context) => {
   const { event, params } = normalizeInput(input);
   const { detail, "detail-type": detailType } = event;
   const slackSecretName = import_strict_env_resolver.StrictEnvResolver.resolve("SLACK_SECRET_NAME", import_strict_env_resolver.StrictEnvType.String, {
-    trim: true
-  });
-  const slackSecretValue = await context.step("fetch-slack-secret", async () => {
-    return import_aws_lambda_secret_fetcher.secretFetcher.getSecretValue(slackSecretName);
+    trim: true,
+    default: ""
   });
-  if (!isSlackSecret(slackSecretValue)) {
-    throw new Error("Slack secret must be JSON with non-empty token and channel.");
+  let slackSecret;
+  if (slackSecretName.length > 0) {
+    const slackSecretValue = await context.step("fetch-slack-secret", async () => {
+      return import_aws_lambda_secret_fetcher.secretFetcher.getSecretValue(slackSecretName);
+    });
+    if (!isSlackSecret(slackSecretValue)) {
+      throw new Error("Slack secret must be JSON with non-empty token and channel.");
+    }
+    slackSecret = slackSecretValue;
   }
   const isInstance = isDbInstanceAutoStart(detailType, detail);
   const isCluster = isDbClusterAutoStart(detailType, detail);
@@ -25006,18 +25345,21 @@ var processAutoStartPrevent = async (input, context) => {
     throw new Error(`DB status is not stopped after processing: ${finalStatus}`);
   }
   const { region, account } = parseRdsSourceArn(detail.SourceArn);
-  const client = new import_web_api.WebClient(slackSecretValue.token);
-  await context.step("post-slack-messages", async () => {
-    return client.chat.postMessage(
-      buildSlackStopNotification({
-        channel: slackSecretValue.channel,
-        sourceType: detail.SourceType,
-        sourceIdentifier: detail.SourceIdentifier,
-        account,
-        region
-      })
-    );
-  });
+  if (slackSecret !== void 0) {
+    const channel = slackSecret.channel;
+    const client = new import_web_api.WebClient(slackSecret.token);
+    await context.step("post-slack-messages", async () => {
+      return client.chat.postMessage(
+        buildSlackStopNotification({
+          channel,
+          sourceType: detail.SourceType,
+          sourceIdentifier: detail.SourceIdentifier,
+          account,
+          region
+        })
+      );
+    });
+  }
   return buildStoppedResult({
     finalStatus,
     account,