ec2-instance-running-scheduler 0.2.7 → 0.3.0

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

@@ -20305,21 +20305,92 @@ var require_lib = __commonJS({
   "node_modules/fetch-retrier/lib/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.fetchRetrier = void 0;
+    exports2.fetchRetrier = exports2.FetchRetrierUnreachableError = exports2.FetchRetrierNetworkError = exports2.FetchRetrierHttpError = exports2.FetchRetrierAlreadyAbortedError = exports2.FetchRetrierAbortError = void 0;
+    var FetchRetrierAbortError = class _FetchRetrierAbortError extends Error {
+      /**
+       * @param message - Human-readable reason (default: `'Aborted'`)
+       */
+      constructor(message = "Aborted") {
+        super(message);
+        this.name = "FetchRetrierAbortError";
+        Object.setPrototypeOf(this, _FetchRetrierAbortError.prototype);
+      }
+    };
+    exports2.FetchRetrierAbortError = FetchRetrierAbortError;
+    var FetchRetrierAlreadyAbortedError = class _FetchRetrierAlreadyAbortedError extends FetchRetrierAbortError {
+      /**
+       * @param message - Human-readable reason (default: `'Signal was already aborted'`)
+       */
+      constructor(message = "Signal was already aborted") {
+        super(message);
+        this.name = "FetchRetrierAlreadyAbortedError";
+        Object.setPrototypeOf(this, _FetchRetrierAlreadyAbortedError.prototype);
+      }
+    };
+    exports2.FetchRetrierAlreadyAbortedError = FetchRetrierAlreadyAbortedError;
+    var FetchRetrierHttpError = class _FetchRetrierHttpError extends Error {
+      /**
+       * @param message - Error description
+       * @param status - HTTP status code from the last non-OK response
+       */
+      constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = "FetchRetrierHttpError";
+        Object.setPrototypeOf(this, _FetchRetrierHttpError.prototype);
+      }
+    };
+    exports2.FetchRetrierHttpError = FetchRetrierHttpError;
+    var FetchRetrierNetworkError = class _FetchRetrierNetworkError extends Error {
+      /**
+       * @param message - Human-readable reason (default: `'Network error'`)
+       * @param cause - Original error from the underlying `fetch`, when available
+       */
+      constructor(message = "Network error", cause) {
+        super(message);
+        this.cause = cause;
+        this.name = "FetchRetrierNetworkError";
+        Object.setPrototypeOf(this, _FetchRetrierNetworkError.prototype);
+      }
+    };
+    exports2.FetchRetrierNetworkError = FetchRetrierNetworkError;
+    var FetchRetrierUnreachableError = class _FetchRetrierUnreachableError extends Error {
+      /**
+       * @param message - Human-readable reason (default: `'Unreachable'`)
+       */
+      constructor(message = "Unreachable") {
+        super(message);
+        this.name = "FetchRetrierUnreachableError";
+        Object.setPrototypeOf(this, _FetchRetrierUnreachableError.prototype);
+      }
+    };
+    exports2.FetchRetrierUnreachableError = FetchRetrierUnreachableError;
     var defaultShouldRetry = (res) => {
       return [429, 500, 502, 503, 504].includes(res.status);
     };
     var fetchRetrier = async (url, options) => {
-      const { headers, retries, timeoutMs, baseBackoffMs, shouldRetry = defaultShouldRetry } = options;
+      const { headers, init, retries, timeoutMs, baseBackoffMs, signal: externalSignal, shouldRetry = defaultShouldRetry } = options;
       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, {
-            headers,
+            ...init,
+            ...headers !== void 0 ? { headers } : {},
             signal: controller.signal
           });
           clearTimeout(timer);
+          externalSignal?.removeEventListener("abort", onExternalAbort);
           if (res.ok) {
             return res;
           }
@@ -20327,30 +20398,31 @@ var require_lib = __commonJS({
           const isContinue = shouldRetry(res, text);
           if (isContinue) {
             if (attempt === retries) {
-              throw new Error(`HTTP ${res.status}`);
+              throw new FetchRetrierHttpError(`HTTP ${res.status}`, res.status);
             }
             await wait(fullJitter(baseBackoffMs, attempt));
           } else {
-            throw new Error(`Non-retriable HTTP error: ${res.status}`);
+            throw new FetchRetrierHttpError(`Non-retriable HTTP error: ${res.status}`, res.status);
           }
         } catch (err) {
           clearTimeout(timer);
+          externalSignal?.removeEventListener("abort", onExternalAbort);
           if (err instanceof Error && err.name === "AbortError") {
             if (attempt === retries)
-              throw err;
+              throw err instanceof FetchRetrierAbortError ? err : new FetchRetrierAbortError();
             await wait(fullJitter(baseBackoffMs, attempt));
             continue;
           }
           if (err instanceof TypeError) {
             if (attempt === retries)
-              throw err;
+              throw new FetchRetrierNetworkError("Network error", err);
             await wait(fullJitter(baseBackoffMs, attempt));
             continue;
           }
           throw err;
         }
       }
-      throw new Error("Unreachable");
+      throw new FetchRetrierUnreachableError();
     };
     exports2.fetchRetrier = fetchRetrier;
     var wait = (ms) => {
@@ -20363,87 +20435,32 @@ var require_lib = __commonJS({
   }
 });
 
-// node_modules/aws-lambda-secret-fetcher/lib/index.js
+// node_modules/strict-env-resolver/lib/index.js
 var require_lib2 = __commonJS({
-  "node_modules/aws-lambda-secret-fetcher/lib/index.js"(exports2) {
+  "node_modules/strict-env-resolver/lib/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.secretFetcher = void 0;
-    var fetch_retrier_1 = require_lib();
-    var getSecretValue = async (name, options = {}) => {
-      const { timeoutMs = 2e3, retries = 3, baseBackoffMs = 300 } = options;
-      const url = `http://localhost:2773/secretsmanager/get?secretId=${encodeURIComponent(name)}`;
-      const requestOptions = {
-        headers: {
-          "X-Aws-Parameters-Secrets-Token": process.env.AWS_SESSION_TOKEN ?? ""
-        },
-        retries,
-        timeoutMs,
-        baseBackoffMs,
-        shouldRetry: (res, body) => {
-          if ([429, 500, 502, 503, 504].includes(res.status))
-            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;
-      const secretString = data.SecretString;
-      if (looksLikeJson(secretString)) {
-        return JSON.parse(secretString);
-      }
-      return secretString;
-    };
-    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");
-    };
-    var looksLikeJson = (str) => {
-      return typeof str === "string" && str.trim().startsWith("{");
-    };
-    exports2.secretFetcher = {
-      getSecretValue
-    };
-  }
-});
-
-// node_modules/safe-env-getter/lib/index.js
-var require_lib3 = __commonJS({
-  "node_modules/safe-env-getter/lib/index.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.SafeEnvGetter = exports2.SafeEnvType = exports2.SafeEnvGetterValidationError = exports2.SafeEnvGetterError = void 0;
-    var STRICT_INTEGER_PATTERN = /^-?\d+$/;
-    var parseStrictInteger = (raw) => {
-      const trimmed = raw.trim();
-      if (trimmed === "" || !STRICT_INTEGER_PATTERN.test(trimmed)) {
-        return void 0;
-      }
-      const n = Number(trimmed);
-      if (!Number.isFinite(n) || !Number.isInteger(n)) {
+    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 SafeEnvGetterError = class extends Error {
+    var parseBooleanEnvValue = (normalizedRaw) => TRUE_BOOLEAN_PATTERN.test(normalizedRaw);
+    var StrictEnvError = class extends Error {
       /**
        * @param message - Error message.
        */
       constructor(message) {
         super(message);
-        this.name = "SafeEnvGetterError";
+        this.name = "StrictEnvError";
       }
     };
-    exports2.SafeEnvGetterError = SafeEnvGetterError;
-    var SafeEnvGetterValidationError = class _SafeEnvGetterValidationError extends SafeEnvGetterError {
+    exports2.StrictEnvError = StrictEnvError;
+    var StrictEnvValidationError = class _StrictEnvValidationError extends StrictEnvError {
       /**
        * Formats validation errors into a human-readable error message.
        *
@@ -20457,126 +20474,206 @@ var require_lib3 = __commonJS({
 ${lines.join("\n")}`;
       }
       /**
-       * Creates a new validation error from one or more `SafeEnvError` entries.
+       * Creates a new validation error from one or more `StrictEnvValidationEntry` entries.
        *
        * @param errors - One or more structured validation errors.
        */
       constructor(errors) {
-        const msg = _SafeEnvGetterValidationError.format(errors);
+        const msg = _StrictEnvValidationError.format(errors);
         super(msg);
-        this.name = "SafeEnvGetterValidationError";
+        this.name = "StrictEnvValidationError";
         this.errors = errors;
         this.keys = errors.map((e) => e.key);
       }
     };
-    exports2.SafeEnvGetterValidationError = SafeEnvGetterValidationError;
-    exports2.SafeEnvType = {
-      /** Spec for a string value (returned as-is). */
+    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 strict decimal integer.
-       * Rejects whitespace-only, hex, `Infinity`, `NaN`, and non-integer forms.
+       * 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). */
+      /** 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 `getEnv`.
+       * @returns Enum spec for use with `resolve` or `resolveAll`.
        */
       Enum: (choices) => ({ type: "enum", choices })
     };
-    function getEnv(key, spec = exports2.SafeEnvType.String, options) {
-      const raw = process.env[key];
-      const defaultValue = options?.default;
+    var defaultTrimForSpec = (spec) => spec.type !== "string";
+    var normalizeEnvRaw = (raw, trim) => {
+      if (raw == null) {
+        return void 0;
+      }
+      if (!trim) {
+        return raw;
+      }
+      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 (raw == null || raw === "") {
-        if (!hasDefault) {
-          throw new SafeEnvGetterValidationError([
-            { key, message: `Missing required environment variable: ${key}`, raw, kind: "missing" }
-          ]);
+      if (normalizedRaw == null || normalizedRaw === "") {
+        if (hasDefault) {
+          return { ok: true, value: defaultValue };
         }
-        return defaultValue;
+        return {
+          ok: false,
+          error: { key, message: `Missing required environment variable: ${key}`, raw, kind: "missing" }
+        };
       }
       switch (spec.type) {
         case "number": {
-          const n = parseStrictInteger(raw);
+          const n = parseNumber(normalizedRaw);
           if (n === void 0) {
-            throw new SafeEnvGetterValidationError([
-              { key, message: `Env ${key}: expected number, got "${raw}"`, raw, kind: "invalid_number" }
-            ]);
+            return {
+              ok: false,
+              error: { key, message: `Env ${key}: expected number, got "${raw}"`, raw, kind: "invalid_number" }
+            };
           }
-          return n;
+          return { ok: true, value: n };
         }
         case "boolean":
-          return /^(1|true|yes|on)$/i.test(raw) ? true : false;
+          return { ok: true, value: parseBooleanEnvValue(normalizedRaw) };
         case "enum":
-          if (!spec.choices.includes(raw)) {
-            throw new SafeEnvGetterValidationError([
-              { key, message: `Env ${key}: must be one of [${spec.choices.join(", ")}]`, raw, kind: "invalid_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 raw;
+          return { ok: true, value: normalizedRaw };
         default:
-          return raw;
+          return { ok: true, value: normalizedRaw };
       }
-    }
-    var getEnvs = (schema) => {
+    };
+    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]);
+      }
+      return result.value;
+    };
+    var resolveAll = (schema) => {
       const envs = {};
       const errors = [];
       for (const key of Object.keys(schema)) {
-        const entry = schema[key];
-        const spec = Array.isArray(entry) ? entry[0] : entry;
-        const options = Array.isArray(entry) ? entry[1] : void 0;
-        const raw = process.env[key];
-        const defaultValue = options?.default;
-        const hasDefault = defaultValue !== void 0;
-        if (raw == null || raw === "") {
-          if (!hasDefault) {
-            errors.push({ key, message: `Missing required environment variable: ${key}`, raw, kind: "missing" });
-            continue;
-          }
-          envs[key] = defaultValue;
-          continue;
-        }
-        if (spec.type === "number") {
-          const n = parseStrictInteger(raw);
-          if (n === void 0) {
-            errors.push({ key, message: `Env ${key}: expected number, got "${raw}"`, raw, kind: "invalid_number" });
-            continue;
-          }
-          envs[key] = n;
-          continue;
-        }
-        if (spec.type === "boolean") {
-          envs[key] = /^(1|true|yes|on)$/i.test(raw) ? true : false;
-          continue;
-        }
-        if (spec.type === "enum") {
-          if (!spec.choices.includes(raw)) {
-            errors.push({
-              key,
-              message: `Env ${key}: must be one of [${spec.choices.join(", ")}]`,
-              raw,
-              kind: "invalid_enum"
-            });
-            continue;
-          }
-          envs[key] = raw;
+        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] = raw;
+        envs[key] = result.value;
       }
       if (errors.length > 0)
-        throw new SafeEnvGetterValidationError(errors);
+        throw new StrictEnvValidationError(errors);
       return envs;
     };
-    exports2.SafeEnvGetter = {
-      /** Reads and parses a single environment variable. See {@link getEnv}. */
-      getEnv,
-      /** Reads and parses multiple environment variables. See {@link getEnvs}. */
-      getEnvs
+    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
+    };
+  }
+});
+
+// node_modules/aws-lambda-secret-fetcher/lib/index.js
+var require_lib3 = __commonJS({
+  "node_modules/aws-lambda-secret-fetcher/lib/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.secretFetcher = void 0;
+    var fetch_retrier_1 = require_lib();
+    var strict_env_resolver_1 = require_lib2();
+    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 ([429, 500, 502, 503, 504].includes(res.status))
+            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;
+      const secretString = data.SecretString;
+      if (looksLikeJson(secretString)) {
+        return JSON.parse(secretString);
+      }
+      return 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);
+        }
+        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");
+    };
+    var looksLikeJson = (str) => {
+      return typeof str === "string" && str.trim().startsWith("{");
+    };
+    exports2.secretFetcher = {
+      getSecretValue
     };
   }
 });
@@ -24106,24 +24203,17 @@ var DEFAULT_CONFIG = {
 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_lib2());
-var import_safe_env_getter2 = __toESM(require_lib3());
-
-// src/funcs/running-scheduler-polling-env.ts
-var import_safe_env_getter = __toESM(require_lib3());
-
-// src/funcs/running-scheduler-polling-config.ts
-var PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV = "PROCESS_RESOURCE_MAX_LOOP_COUNT";
-var PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV = "PROCESS_RESOURCE_MAX_ELAPSED_SECONDS";
+var import_aws_lambda_secret_fetcher = __toESM(require_lib3());
+var import_strict_env_resolver2 = __toESM(require_lib2());
 
 // src/funcs/running-scheduler-predicates.ts
-var DEFAULT_RESOURCE_POLLING_LIMITS = {
+var DEFAULT_RESOURCE_WAIT_LIMITS = {
   maxLoopCount: 90,
   maxElapsedSeconds: 1800
 };
 var isDesiredStableState = (mode, currentState) => mode === "Start" && currentState === "running" || mode === "Stop" && currentState === "stopped";
 var isTransitioningState = (mode, currentState) => mode === "Start" && currentState === "pending" || mode === "Stop" && (currentState === "stopping" || currentState === "shutting-down");
-var getPollingAbortReason = (loopCount, startedAtMs, nowMs, limits) => {
+var getWaitAbortReason = (loopCount, startedAtMs, nowMs, limits) => {
   if (loopCount >= limits.maxLoopCount) {
     return "MaxLoopCountExceeded";
   }
@@ -24133,18 +24223,25 @@ var getPollingAbortReason = (loopCount, startedAtMs, nowMs, limits) => {
   }
   return void 0;
 };
-var formatResourcePollingFailure = (reason, context) => {
+var formatResourceWaitFailure = (reason, context) => {
   const common = `identifier=${context.identifier} mode=${context.mode} currentState=${context.currentState} loopCount=${context.loopCount}`;
   if (reason === "MaxLoopCountExceeded") {
-    return `ResourcePollingFailed:MaxLoopCountExceeded: ${common} maxLoopCount=${context.limits.maxLoopCount}`;
+    return `ResourceWaitFailed:MaxLoopCountExceeded: ${common} maxLoopCount=${context.limits.maxLoopCount}`;
   }
   if (reason === "MaxElapsedTimeExceeded") {
-    return `ResourcePollingFailed:MaxElapsedTimeExceeded: ${common} maxElapsedSeconds=${context.limits.maxElapsedSeconds}`;
+    return `ResourceWaitFailed:MaxElapsedTimeExceeded: ${common} maxElapsedSeconds=${context.limits.maxElapsedSeconds}`;
   }
-  return `ResourcePollingFailed:UnexpectedInstanceState: ${common}`;
+  return `ResourceWaitFailed:UnexpectedInstanceState: ${common}`;
 };
 
-// src/funcs/running-scheduler-polling-env.ts
+// src/funcs/running-scheduler-wait-env.ts
+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";
+var PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV = "PROCESS_RESOURCE_MAX_ELAPSED_SECONDS";
+
+// src/funcs/running-scheduler-wait-env.ts
 var assertPositiveEnvInt = (key, value) => {
   if (value <= 0) {
     const raw = process.env[key];
@@ -24152,15 +24249,15 @@ var assertPositiveEnvInt = (key, value) => {
   }
   return value;
 };
-var parseResourcePollingLimitsFromEnv = () => {
-  const parsed = import_safe_env_getter.SafeEnvGetter.getEnvs({
+var parseResourceWaitLimitsFromEnv = () => {
+  const parsed = import_strict_env_resolver.StrictEnvResolver.resolveAll({
     [PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV]: [
-      import_safe_env_getter.SafeEnvType.Number,
-      { default: DEFAULT_RESOURCE_POLLING_LIMITS.maxLoopCount }
+      import_strict_env_resolver.StrictEnvType.Number,
+      { default: DEFAULT_RESOURCE_WAIT_LIMITS.maxLoopCount }
     ],
     [PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV]: [
-      import_safe_env_getter.SafeEnvType.Number,
-      { default: DEFAULT_RESOURCE_POLLING_LIMITS.maxElapsedSeconds }
+      import_strict_env_resolver.StrictEnvType.Number,
+      { default: DEFAULT_RESOURCE_WAIT_LIMITS.maxElapsedSeconds }
     ]
   });
   return {
@@ -24181,11 +24278,16 @@ var STATE_LIST = [
   { name: "STOPPED", emoji: "\u{1F634}", state: "stopped" }
 ];
 var STATUS_CHANGE_WAIT_SECONDS = 20;
+var SLACK_SECRET_FETCH_OPTIONS = {
+  timeoutMs: 3e3,
+  retries: 5,
+  baseBackoffMs: 300
+};
 var getStateDisplay = (current) => {
   const found = STATE_LIST.find((s) => s.state === current);
   return found ? { emoji: found.emoji, name: found.name } : void 0;
 };
-var processOneResource = async (ctx, targetResource, params, resourceIndex, pollingLimits) => {
+var processOneResource = async (ctx, targetResource, params, resourceIndex, waitLimits) => {
   const parts = targetResource.split("/");
   const identifier = parts[parts.length - 1] ?? "unknown";
   const arnParts = targetResource.split(":");
@@ -24198,32 +24300,32 @@ var processOneResource = async (ctx, targetResource, params, resourceIndex, poll
     region,
     account,
     mode: params.Mode,
-    maxLoopCount: pollingLimits.maxLoopCount,
-    maxElapsedSeconds: pollingLimits.maxElapsedSeconds
+    maxLoopCount: waitLimits.maxLoopCount,
+    maxElapsedSeconds: waitLimits.maxElapsedSeconds
   });
-  const startedAtMs = await ctx.step(`${stepPrefix}-polling-started-at`, async () => Date.now());
+  const startedAtMs = await ctx.step(`${stepPrefix}-wait-started-at`, async () => Date.now());
   let loopCount = 0;
   let currentState = "";
   do {
     const abortReason = await ctx.step(
-      `${stepPrefix}-poll-limit-check-${loopCount}`,
-      async () => getPollingAbortReason(loopCount, startedAtMs, Date.now(), pollingLimits)
+      `${stepPrefix}-wait-limit-check-${loopCount}`,
+      async () => getWaitAbortReason(loopCount, startedAtMs, Date.now(), waitLimits)
     );
     if (abortReason) {
-      const message = formatResourcePollingFailure(abortReason, {
+      const message = formatResourceWaitFailure(abortReason, {
         identifier,
         mode: params.Mode,
         currentState: currentState || "unknown",
         loopCount,
-        limits: pollingLimits
+        limits: waitLimits
       });
-      ctx.logger.error("processOneResource: polling limit exceeded", {
+      ctx.logger.error("processOneResource: wait limit exceeded", {
         identifier,
         abortReason,
         loopCount,
         currentState,
-        maxLoopCount: pollingLimits.maxLoopCount,
-        maxElapsedSeconds: pollingLimits.maxElapsedSeconds
+        maxLoopCount: waitLimits.maxLoopCount,
+        maxElapsedSeconds: waitLimits.maxElapsedSeconds
       });
       throw new Error(message);
     }
@@ -24280,12 +24382,12 @@ var processOneResource = async (ctx, targetResource, params, resourceIndex, poll
         loopCount += 1;
         continue;
       }
-      const message = formatResourcePollingFailure("UnexpectedInstanceState", {
+      const message = formatResourceWaitFailure("UnexpectedInstanceState", {
         identifier,
         mode,
         currentState,
         loopCount,
-        limits: pollingLimits
+        limits: waitLimits
       });
       ctx.logger.error("processOneResource: unexpected state", {
         identifier,
@@ -24320,11 +24422,11 @@ var handler = withDurableExecution(async (event, ctx) => {
   if (!params?.TagKey || !params?.TagValues || !params?.Mode) {
     throw new Error("Invalid event: Params.TagKey, Params.TagValues, Params.Mode are required.");
   }
-  const pollingLimits = parseResourcePollingLimitsFromEnv();
-  const slackSecretName = import_safe_env_getter2.SafeEnvGetter.getEnv("SLACK_SECRET_NAME");
+  const waitLimits = parseResourceWaitLimitsFromEnv();
+  const slackSecretName = import_strict_env_resolver2.StrictEnvResolver.resolve("SLACK_SECRET_NAME", import_strict_env_resolver2.StrictEnvType.String);
   const slackSecretValue = await ctx.step("fetch-slack-secret", async () => {
     ctx.logger.info("running-scheduler: fetching Slack secret", { secretName: slackSecretName });
-    return import_aws_lambda_secret_fetcher.secretFetcher.getSecretValue(slackSecretName);
+    return import_aws_lambda_secret_fetcher.secretFetcher.getSecretValue(slackSecretName, SLACK_SECRET_FETCH_OPTIONS);
   });
   ctx.logger.info("running-scheduler: Slack secret loaded");
   if (!slackSecretValue?.token || !slackSecretValue?.channel) {
@@ -24352,10 +24454,19 @@ var handler = withDurableExecution(async (event, ctx) => {
     instanceCount: targetResources.length
   });
   const slackParentMessageResult = await ctx.step("post-slack-messages", async () => {
-    return client.chat.postMessage({
-      channel,
-      text: `${params.Mode === "Start" ? "\u{1F606} Starts" : "\u{1F971} Stops"} the scheduled EC2 Instance.`
-    });
+    try {
+      return await client.chat.postMessage({
+        channel,
+        text: `${params.Mode === "Start" ? "\u{1F606} Starts" : "\u{1F971} Stops"} the scheduled EC2 Instance.`
+      });
+    } catch (error) {
+      ctx.logger.error("running-scheduler: Slack post failed", {
+        step: "post-slack-messages",
+        channel,
+        errorMessage: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
   });
   ctx.logger.info("running-scheduler: parent Slack message posted", {
     threadTs: slackParentMessageResult?.ts ?? null
@@ -24372,7 +24483,7 @@ var handler = withDurableExecution(async (event, ctx) => {
     //   ),
     async (mapCtx, targetResource, index) => {
       return mapCtx.runInChildContext(`resource-${index}`, async (childCtx) => {
-        const result = await processOneResource(childCtx, targetResource, params, index, pollingLimits);
+        const result = await processOneResource(childCtx, targetResource, params, index, waitLimits);
         childCtx.logger.info("running-scheduler: posting thread Slack message", {
           index,
           identifier: result.identifier,
@@ -24380,22 +24491,32 @@ var handler = withDurableExecution(async (event, ctx) => {
         });
         await childCtx.step("post-slack-child-messages", async () => {
           const display = getStateDisplay(result.status);
-          return client.chat.postMessage({
-            channel,
-            thread_ts: slackParentMessageResult?.ts,
-            attachments: [
-              {
-                color: "#36a64f",
-                pretext: `${display?.emoji} The status of the EC2 Instance ${result.identifier} changed to ${display?.name} due to the schedule.`,
-                fields: [
-                  { title: "Account", value: result.account, short: true },
-                  { title: "Region", value: result.region, short: true },
-                  { title: "Identifier", value: result.identifier, short: true },
-                  { title: "Status", value: display?.name ?? "Unknown", short: true }
-                ]
-              }
-            ]
-          });
+          try {
+            return await client.chat.postMessage({
+              channel,
+              thread_ts: slackParentMessageResult?.ts,
+              attachments: [
+                {
+                  color: "#36a64f",
+                  pretext: `${display?.emoji} The status of the EC2 Instance ${result.identifier} changed to ${display?.name} due to the schedule.`,
+                  fields: [
+                    { title: "Account", value: result.account, short: true },
+                    { title: "Region", value: result.region, short: true },
+                    { title: "Identifier", value: result.identifier, short: true },
+                    { title: "Status", value: display?.name ?? "Unknown", short: true }
+                  ]
+                }
+              ]
+            });
+          } catch (error) {
+            childCtx.logger.error("running-scheduler: Slack post failed", {
+              step: "post-slack-child-messages",
+              channel,
+              identifier: result.identifier,
+              errorMessage: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+          }
         });
         return result;
       });