ec2-instance-running-scheduler 0.4.6 → 0.5.0

package/assets/funcs/running-scheduler.lambda/index.js

@@ -20300,13 +20300,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.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.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.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'`)
        */
@@ -20328,7 +20403,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
@@ -20343,7 +20418,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
@@ -20356,7 +20431,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
        */
@@ -20367,7 +20442,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'`)
        */
@@ -20378,150 +20453,278 @@ var require_lib = __commonJS({
       }
     };
     exports2.FetchRetrierUnreachableError = FetchRetrierUnreachableError;
+  }
+});
+
+// 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);
+      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 === "") {
+        return void 0;
+      }
+      if (/^\d+$/.test(trimmed)) {
+        return Number.parseInt(trimmed, 10) * 1e3;
+      }
+      if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+        return void 0;
+      }
+      const dateMs = Date.parse(trimmed);
+      if (Number.isNaN(dateMs)) {
+        return void 0;
+      }
+      return Math.max(0, dateMs - nowMs);
+    };
+    exports2.parseRetryAfterMs = parseRetryAfterMs;
+    var resolveRetryDelayMs = (response, baseBackoffMs, attempt, maxBackoffMs, nowMs = Date.now()) => {
+      const header = response.headers?.get("Retry-After");
+      if (header == null) {
+        return (0, jitter_1.fullJitter)(baseBackoffMs, attempt, maxBackoffMs);
+      }
+      const fromHeader = (0, exports2.parseRetryAfterMs)(header, nowMs);
+      if (fromHeader === void 0) {
+        return (0, jitter_1.fullJitter)(baseBackoffMs, attempt, maxBackoffMs);
+      }
+      return fromHeader;
+    };
+    exports2.resolveRetryDelayMs = resolveRetryDelayMs;
+  }
+});
+
+// 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.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 await fetch(url, {
+          ...init,
+          ...headers !== void 0 ? { headers } : {},
+          signal: controller.signal
+        });
+      } finally {
+        clearTimeout(timer);
+        externalSignal?.removeEventListener("abort", onExternalAbort);
+      }
+    };
+    exports2.timedFetch = timedFetch;
+  }
+});
+
+// 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.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);
     };
     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 } = options;
+      const { retries, timeoutMs, baseBackoffMs, maxBackoffMs } = options;
       if (retries < 1) {
-        throw new FetchRetrierInvalidOptionsError("retries must be >= 1");
+        throw new errors_1.FetchRetrierInvalidOptionsError("retries must be >= 1");
       }
       if (timeoutMs <= 0) {
-        throw new FetchRetrierInvalidOptionsError("timeoutMs must be > 0");
+        throw new errors_1.FetchRetrierInvalidOptionsError("timeoutMs must be > 0");
       }
       if (baseBackoffMs < 0) {
-        throw new FetchRetrierInvalidOptionsError("baseBackoffMs must be >= 0");
+        throw new errors_1.FetchRetrierInvalidOptionsError("baseBackoffMs must be >= 0");
       }
+      if (maxBackoffMs !== void 0 && maxBackoffMs < 0) {
+        throw new errors_1.FetchRetrierInvalidOptionsError("maxBackoffMs must be >= 0");
+      }
+    };
+    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.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/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.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, signal: externalSignal, shouldRetry = exports2.defaultShouldRetry } = options;
-      validateRequestOptions({ retries, timeoutMs, baseBackoffMs });
+      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 FetchRetrierAlreadyAbortedError();
-        }
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), timeoutMs);
-        const onExternalAbort = () => {
-          clearTimeout(timer);
-          controller.abort();
-        };
-        if (externalSignal) {
-          externalSignal.addEventListener("abort", onExternalAbort);
+          throw new errors_1.FetchRetrierAlreadyAbortedError();
         }
         try {
-          const res = await fetch(url, {
-            ...init,
-            ...headers !== void 0 ? { headers } : {},
-            signal: controller.signal
+          const res = await (0, timed_fetch_1.timedFetch)(url, {
+            timeoutMs,
+            init,
+            headers,
+            signal: externalSignal
           });
-          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);
+          if (!isContinue) {
+            throw new errors_1.FetchRetrierHttpError(`Non-retriable HTTP error: ${res.status}`, res.status, text);
+          }
+          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) {
-          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));
+            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 (attempt === retries)
-              throw new FetchRetrierNetworkError("Network error", err);
-            await wait(fullJitter(baseBackoffMs, attempt));
+            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 new FetchRetrierUnreachableError();
+      throw new errors_1.FetchRetrierUnreachableError();
     };
     exports2.fetchRetrier = fetchRetrier;
-    var wait = (ms) => {
-      return new Promise((resolve) => setTimeout(resolve, ms));
-    };
-    var fullJitter = (base, attempt) => {
-      const cap = base * Math.pow(2, attempt);
-      return Math.floor(Math.random() * cap);
-    };
-    var parseRetryAfterMs = (value, nowMs = Date.now()) => {
-      const trimmed = value.trim();
-      if (trimmed === "") {
-        return void 0;
-      }
-      if (/^\d+$/.test(trimmed)) {
-        return Number.parseInt(trimmed, 10) * 1e3;
-      }
-      if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
-        return void 0;
-      }
-      const dateMs = Date.parse(trimmed);
-      if (Number.isNaN(dateMs)) {
-        return void 0;
-      }
-      return Math.max(0, dateMs - nowMs);
-    };
-    exports2.parseRetryAfterMs = parseRetryAfterMs;
-    var resolveRetryDelayMs = (response, baseBackoffMs, attempt, nowMs = Date.now()) => {
-      const header = response.headers?.get("Retry-After");
-      if (header == null) {
-        return fullJitter(baseBackoffMs, attempt);
-      }
-      const fromHeader = (0, exports2.parseRetryAfterMs)(header, nowMs);
-      if (fromHeader === void 0) {
-        return fullJitter(baseBackoffMs, attempt);
-      }
-      return fromHeader;
-    };
   }
 });
 
-// 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/index.js
+var require_lib = __commonJS({
+  "node_modules/fetch-retrier/lib/index.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;
-      }
-      try {
-        return JSON.parse(jsonString, safeReviver);
-      } catch (error) {
-        onError?.(error);
-        return fallback;
-      }
-    };
-    exports2.quietParse = quietParse;
+    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/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/strict-env-resolver/lib/index.js
+var require_lib2 = __commonJS({
+  "node_modules/strict-env-resolver/lib/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.StrictEnvResolver = exports2.StrictEnvType = exports2.StrictEnvValidationError = exports2.StrictEnvError = void 0;
@@ -20571,13 +20774,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" }, {
+      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`, call as `StrictEnvType.Number({ min, max, exclusiveMin, exclusiveMax, integer })`,
+       * or use a nested preset such as `StrictEnvType.Number.Port`.
        */
-      Number: { type: "number" },
+      Number: NumberSpec,
       /** Spec for a boolean value (`1`/`true`/`yes`/`on` → `true`; other non-empty values → `false`). */
       Boolean: { type: "boolean" },
       /**
@@ -20598,6 +20826,44 @@ ${lines.join("\n")}`;
       }
       return raw.trim();
     };
+    var validateNumberConstraints = (key, raw, n, constraints) => {
+      if (constraints.integer === true && !Number.isInteger(n)) {
+        return { key, message: `Env ${key}: expected integer, got "${raw}"`, raw, kind: "invalid_number" };
+      }
+      if (constraints.min !== void 0 && n < constraints.min) {
+        return {
+          key,
+          message: `Env ${key}: must be >= ${constraints.min}, got ${n}`,
+          raw,
+          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,
+          message: `Env ${key}: must be <= ${constraints.max}, got ${n}`,
+          raw,
+          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) => ({
       spec: Array.isArray(entry) ? entry[0] : entry,
       options: Array.isArray(entry) ? entry[1] : void 0
@@ -20624,6 +20890,10 @@ ${lines.join("\n")}`;
               error: { key, message: `Env ${key}: expected number, got "${raw}"`, raw, kind: "invalid_number" }
             };
           }
+          const constraintError = validateNumberConstraints(key, raw, n, spec);
+          if (constraintError !== void 0) {
+            return { ok: false, error: constraintError };
+          }
           return { ok: true, value: n };
         }
         case "boolean":
@@ -20677,46 +20947,16 @@ ${lines.join("\n")}`;
   }
 });
 
-// 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/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.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;
-          }
-          if (res.status === 400 && /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();
-      if (!isSecretResponse(raw)) {
-        throw new Error("Invalid secret response format");
-      }
-      const data = raw;
-      return (0, quiet_json_parser_1.quietParse)(data.SecretString, data.SecretString);
-    };
+    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 = () => {
@@ -20724,240 +20964,333 @@ var require_lib4 = __commonJS({
         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);
+          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: 2773 }) : parseExtensionHttpPortOverride(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 Error("Invalid extension HTTP port: must be a number");
+        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 Error("Invalid extension HTTP port: must be between 1 and 65535");
+        throw new errors_1.SecretFetcherPortError("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
-    };
   }
 });
 
-// node_modules/strict-env-resolver/lib/index.js
-var require_lib5 = __commonJS({
-  "node_modules/strict-env-resolver/lib/index.js"(exports2) {
+// 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.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.
-       */
+    exports2.QuietJsonParserValidateError = exports2.QuietJsonParserError = void 0;
+    var QuietJsonParserError = class _QuietJsonParserError extends Error {
       constructor(message) {
         super(message);
-        this.name = "StrictEnvError";
+        this.name = "QuietJsonParserError";
+        Object.setPrototypeOf(this, _QuietJsonParserError.prototype);
       }
     };
-    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")}`;
+    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);
       }
-      /**
-       * 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.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);
     };
-    exports2.StrictEnvValidationError = StrictEnvValidationError;
-    var createNumberSpec = (constraints) => ({
-      type: "number",
-      ...constraints?.min !== void 0 ? { min: constraints.min } : {},
-      ...constraints?.max !== void 0 ? { max: constraints.max } : {},
-      ...constraints?.integer !== void 0 ? { integer: constraints.integer } : {}
-    });
-    var NumberSpec = Object.assign((constraints) => createNumberSpec(constraints), { type: "number" });
-    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 })`.
-       */
-      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" },
-      /**
-       * 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 })
+    var shouldOmitKey = (key, value) => {
+      if (key === PROTO_KEY || key === PROTOTYPE_KEY) {
+        return true;
+      }
+      if (key !== CONSTRUCTOR_KEY) {
+        return false;
+      }
+      return isUnsafeConstructorValue(value);
     };
-    var defaultTrimForSpec = (spec) => spec.type !== "string";
-    var normalizeEnvRaw = (raw, trim) => {
-      if (raw == null) {
+    var omitUnsafeKey = (key, value) => {
+      if (shouldOmitKey(key, value)) {
         return void 0;
       }
-      if (!trim) {
-        return raw;
-      }
-      return raw.trim();
+      return value;
     };
-    var validateNumberConstraints = (key, raw, n, constraints) => {
-      if (constraints.integer === true && !Number.isInteger(n)) {
-        return { key, message: `Env ${key}: expected integer, got "${raw}"`, raw, kind: "invalid_number" };
+    exports2.omitUnsafeKey = omitUnsafeKey;
+    var omitUnsafeDeep = (value) => {
+      if (Array.isArray(value)) {
+        return value.map(exports2.omitUnsafeDeep);
       }
-      if (constraints.min !== void 0 && n < constraints.min) {
-        return {
-          key,
-          message: `Env ${key}: must be >= ${constraints.min}, got ${n}`,
-          raw,
-          kind: "invalid_number"
-        };
+      if (!isPlainObject(value)) {
+        return value;
       }
-      if (constraints.max !== void 0 && n > constraints.max) {
-        return {
-          key,
-          message: `Env ${key}: must be <= ${constraints.max}, got ${n}`,
-          raw,
-          kind: "invalid_number"
-        };
+      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 void 0;
+      return result;
     };
-    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 };
+    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;
         }
-        return {
-          ok: false,
-          error: { key, message: `Missing required environment variable: ${key}`, raw, kind: "missing" }
-        };
+      } catch (error) {
+        onError?.(error);
+        return fallback;
       }
-      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" }
-            };
-          }
-          const constraintError = validateNumberConstraints(key, raw, n, spec);
-          if (constraintError !== void 0) {
-            return { ok: false, error: constraintError };
-          }
-          return { ok: true, value: n };
+      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;
         }
-        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 };
+        return json;
+      } catch (error) {
+        onError?.(error);
+        return fallback;
       }
     };
-    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]);
+    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);
       }
-      return result.value;
+      if ("SecretString" in raw) {
+        return (0, quiet_json_parser_1.quietParse)(raw.SecretString, raw.SecretString);
+      }
+      return decodeSecretBinary(raw.SecretBinary);
     };
-    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;
+    exports2.readSecretValue = readSecretValue;
+    var secretFieldKind = (record, key) => {
+      if (!Object.prototype.hasOwnProperty.call(record, key)) {
+        return "absent";
       }
-      if (errors.length > 0)
-        throw new StrictEnvValidationError(errors);
-      return envs;
+      const field = record[key];
+      if (typeof field !== "string" || field.length === 0) {
+        return "invalid";
+      }
+      return "string";
     };
-    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
+    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/running-scheduler.lambda.ts
 var running_scheduler_lambda_exports = {};
 __export(running_scheduler_lambda_exports, {
@@ -24484,7 +24817,7 @@ var import_client_ec2 = require("@aws-sdk/client-ec2");
 var import_client_resource_groups_tagging_api = require("@aws-sdk/client-resource-groups-tagging-api");
 var import_web_api = __toESM(require_dist5());
 var import_aws_lambda_secret_fetcher = __toESM(require_lib4());
-var import_strict_env_resolver2 = __toESM(require_lib5());
+var import_strict_env_resolver2 = __toESM(require_lib2());
 
 // src/funcs/running-scheduler-predicates.ts
 var DEFAULT_RESOURCE_WAIT_LIMITS = {
@@ -24517,7 +24850,7 @@ var formatResourceWaitFailure = (reason, context) => {
 };
 
 // src/funcs/running-scheduler-wait-env.ts
-var import_strict_env_resolver = __toESM(require_lib5());
+var import_strict_env_resolver = __toESM(require_lib2());
 
 // src/funcs/running-scheduler-wait-config.ts
 var PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV = "PROCESS_RESOURCE_MAX_LOOP_COUNT";
@@ -24529,15 +24862,15 @@ var PROCESS_RESOURCES_MAX_CONCURRENCY_ENV = "PROCESS_RESOURCES_MAX_CONCURRENCY";
 var parseResourceWaitLimitsFromEnv = () => {
   const parsed = import_strict_env_resolver.StrictEnvResolver.resolveAll({
     [PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV]: [
-      import_strict_env_resolver.StrictEnvType.PositiveInt,
+      import_strict_env_resolver.StrictEnvType.Number.PositiveInteger,
       { default: DEFAULT_RESOURCE_WAIT_LIMITS.maxLoopCount }
     ],
     [PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV]: [
-      import_strict_env_resolver.StrictEnvType.PositiveInt,
+      import_strict_env_resolver.StrictEnvType.Number.PositiveInteger,
       { default: DEFAULT_RESOURCE_WAIT_LIMITS.maxElapsedSeconds }
     ],
     [PROCESS_RESOURCE_STATUS_CHANGE_WAIT_SECONDS_ENV]: [
-      import_strict_env_resolver.StrictEnvType.PositiveInt,
+      import_strict_env_resolver.StrictEnvType.Number.PositiveInteger,
       { default: DEFAULT_RESOURCE_WAIT_LIMITS.statusChangeWaitSeconds }
     ]
   });
@@ -24550,7 +24883,7 @@ var parseResourceWaitLimitsFromEnv = () => {
 var parseMaxConcurrencyFromEnv = () => {
   const parsed = import_strict_env_resolver.StrictEnvResolver.resolveAll({
     [PROCESS_RESOURCES_MAX_CONCURRENCY_ENV]: [
-      import_strict_env_resolver.StrictEnvType.PositiveInt,
+      import_strict_env_resolver.StrictEnvType.Number.PositiveInteger,
       { default: DEFAULT_MAX_CONCURRENCY }
     ]
   });