ec2-instance-running-scheduler 0.3.6 → 0.4.0

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

@@ -20305,7 +20305,7 @@ var require_lib = __commonJS({
   "node_modules/fetch-retrier/lib/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.fetchRetrier = exports2.FetchRetrierUnreachableError = exports2.FetchRetrierNetworkError = exports2.FetchRetrierHttpError = exports2.FetchRetrierAlreadyAbortedError = exports2.FetchRetrierAbortError = void 0;
+    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 {
       /**
        * @param message - Human-readable reason (default: `'Aborted'`)
@@ -20332,10 +20332,12 @@ var require_lib = __commonJS({
       /**
        * @param message - Error description
        * @param status - HTTP status code from the last non-OK response
+       * @param body - Response body text already read via `response.text()` for that attempt
        */
-      constructor(message, status) {
+      constructor(message, status, body) {
         super(message);
         this.status = status;
+        this.body = body;
         this.name = "FetchRetrierHttpError";
         Object.setPrototypeOf(this, _FetchRetrierHttpError.prototype);
       }
@@ -20354,6 +20356,17 @@ var require_lib = __commonJS({
       }
     };
     exports2.FetchRetrierNetworkError = FetchRetrierNetworkError;
+    var FetchRetrierInvalidOptionsError = class _FetchRetrierInvalidOptionsError extends TypeError {
+      /**
+       * @param message - Human-readable reason describing the invalid option
+       */
+      constructor(message) {
+        super(message);
+        this.name = "FetchRetrierInvalidOptionsError";
+        Object.setPrototypeOf(this, _FetchRetrierInvalidOptionsError.prototype);
+      }
+    };
+    exports2.FetchRetrierInvalidOptionsError = FetchRetrierInvalidOptionsError;
     var FetchRetrierUnreachableError = class _FetchRetrierUnreachableError extends Error {
       /**
        * @param message - Human-readable reason (default: `'Unreachable'`)
@@ -20365,11 +20378,26 @@ var require_lib = __commonJS({
       }
     };
     exports2.FetchRetrierUnreachableError = FetchRetrierUnreachableError;
-    var defaultShouldRetry = (res) => {
-      return [429, 500, 502, 503, 504].includes(res.status);
+    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 = defaultShouldRetry } = 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();
@@ -20398,11 +20426,11 @@ var require_lib = __commonJS({
           const isContinue = shouldRetry(res, text);
           if (isContinue) {
             if (attempt === retries) {
-              throw new FetchRetrierHttpError(`HTTP ${res.status}`, res.status);
+              throw new FetchRetrierHttpError(`HTTP ${res.status}`, res.status, text);
             }
-            await wait(fullJitter(baseBackoffMs, attempt));
+            await wait(resolveRetryDelayMs(res, baseBackoffMs, attempt));
           } else {
-            throw new FetchRetrierHttpError(`Non-retriable HTTP error: ${res.status}`, res.status);
+            throw new FetchRetrierHttpError(`Non-retriable HTTP error: ${res.status}`, res.status, text);
           }
         } catch (err) {
           clearTimeout(timer);
@@ -20432,12 +20460,68 @@ var require_lib = __commonJS({
       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/strict-env-resolver/lib/index.js
+// node_modules/quiet-json-parser/lib/index.js
 var require_lib2 = __commonJS({
-  "node_modules/strict-env-resolver/lib/index.js"(exports2) {
+  "node_modules/quiet-json-parser/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;
+  }
+});
+
+// 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) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.StrictEnvResolver = exports2.StrictEnvType = exports2.StrictEnvValidationError = exports2.StrictEnvError = void 0;
@@ -20594,13 +20678,14 @@ ${lines.join("\n")}`;
 });
 
 // node_modules/aws-lambda-secret-fetcher/lib/index.js
-var require_lib3 = __commonJS({
+var require_lib4 = __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 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);
@@ -20614,10 +20699,12 @@ var require_lib3 = __commonJS({
         timeoutMs,
         baseBackoffMs,
         shouldRetry: (res, body) => {
-          if ([429, 500, 502, 503, 504].includes(res.status))
+          if ((0, fetch_retrier_1.defaultShouldRetry)(res, body)) {
             return true;
-          if (res.status === 400 && /not\s+ready.*traffic/i.test(body))
+          }
+          if (res.status === 400 && /not\s+ready.*traffic/i.test(body)) {
             return true;
+          }
           return false;
         }
       };
@@ -20627,11 +20714,7 @@ var require_lib3 = __commonJS({
         throw new Error("Invalid secret response format");
       }
       const data = raw;
-      const secretString = data.SecretString;
-      if (looksLikeJson(secretString)) {
-        return JSON.parse(secretString);
-      }
-      return secretString;
+      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;
@@ -20669,15 +20752,212 @@ var require_lib3 = __commonJS({
       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/strict-env-resolver/lib/index.js
+var require_lib5 = __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;
+    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;
+    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 defaultTrimForSpec = (spec) => spec.type !== "string";
+    var normalizeEnvRaw = (raw, trim) => {
+      if (raw == null) {
+        return void 0;
+      }
+      if (!trim) {
+        return raw;
+      }
+      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.max !== void 0 && n > constraints.max) {
+        return {
+          key,
+          message: `Env ${key}: must be <= ${constraints.max}, 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
+    });
+    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" }
+        };
+      }
+      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 };
+        }
+        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 };
+      }
+    };
+    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 { 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.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
+    };
+  }
+});
+
 // src/funcs/running-scheduler.lambda.ts
 var running_scheduler_lambda_exports = {};
 __export(running_scheduler_lambda_exports, {
@@ -24203,14 +24483,16 @@ 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_lib3());
-var import_strict_env_resolver2 = __toESM(require_lib2());
+var import_aws_lambda_secret_fetcher = __toESM(require_lib4());
+var import_strict_env_resolver2 = __toESM(require_lib5());
 
 // src/funcs/running-scheduler-predicates.ts
 var DEFAULT_RESOURCE_WAIT_LIMITS = {
   maxLoopCount: 90,
-  maxElapsedSeconds: 1800
+  maxElapsedSeconds: 1800,
+  statusChangeWaitSeconds: 20
 };
+var DEFAULT_MAX_CONCURRENCY = 10;
 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 getWaitAbortReason = (loopCount, startedAtMs, nowMs, limits) => {
@@ -24235,54 +24517,71 @@ var formatResourceWaitFailure = (reason, context) => {
 };
 
 // src/funcs/running-scheduler-wait-env.ts
-var import_strict_env_resolver = __toESM(require_lib2());
+var import_strict_env_resolver = __toESM(require_lib5());
 
 // 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";
+var PROCESS_RESOURCE_STATUS_CHANGE_WAIT_SECONDS_ENV = "PROCESS_RESOURCE_STATUS_CHANGE_WAIT_SECONDS";
+var PROCESS_RESOURCES_MAX_CONCURRENCY_ENV = "PROCESS_RESOURCES_MAX_CONCURRENCY";
 
 // src/funcs/running-scheduler-wait-env.ts
-var assertPositiveEnvInt = (key, value) => {
-  if (value <= 0) {
-    const raw = process.env[key];
-    throw new Error(`Invalid ${key}: must be a positive integer (got "${raw ?? ""}")`);
-  }
-  return value;
-};
 var parseResourceWaitLimitsFromEnv = () => {
   const parsed = import_strict_env_resolver.StrictEnvResolver.resolveAll({
     [PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV]: [
-      import_strict_env_resolver.StrictEnvType.Number,
+      import_strict_env_resolver.StrictEnvType.PositiveInt,
       { default: DEFAULT_RESOURCE_WAIT_LIMITS.maxLoopCount }
     ],
     [PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV]: [
-      import_strict_env_resolver.StrictEnvType.Number,
+      import_strict_env_resolver.StrictEnvType.PositiveInt,
       { default: DEFAULT_RESOURCE_WAIT_LIMITS.maxElapsedSeconds }
+    ],
+    [PROCESS_RESOURCE_STATUS_CHANGE_WAIT_SECONDS_ENV]: [
+      import_strict_env_resolver.StrictEnvType.PositiveInt,
+      { default: DEFAULT_RESOURCE_WAIT_LIMITS.statusChangeWaitSeconds }
     ]
   });
   return {
-    maxLoopCount: assertPositiveEnvInt(
-      PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV,
-      parsed[PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV]
-    ),
-    maxElapsedSeconds: assertPositiveEnvInt(
-      PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV,
-      parsed[PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV]
-    )
+    maxLoopCount: parsed[PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV],
+    maxElapsedSeconds: parsed[PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV],
+    statusChangeWaitSeconds: parsed[PROCESS_RESOURCE_STATUS_CHANGE_WAIT_SECONDS_ENV]
   };
 };
+var parseMaxConcurrencyFromEnv = () => {
+  const parsed = import_strict_env_resolver.StrictEnvResolver.resolveAll({
+    [PROCESS_RESOURCES_MAX_CONCURRENCY_ENV]: [
+      import_strict_env_resolver.StrictEnvType.PositiveInt,
+      { default: DEFAULT_MAX_CONCURRENCY }
+    ]
+  });
+  return parsed[PROCESS_RESOURCES_MAX_CONCURRENCY_ENV];
+};
 
 // src/funcs/running-scheduler.lambda.ts
 var STATE_LIST = [
   { name: "RUNNING", emoji: "\u{1F606}", state: "running" },
   { 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 isSlackSecret = (value) => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  if (!("token" in value) || !("channel" in value)) {
+    return false;
+  }
+  if (typeof value.token !== "string" || value.token === "") {
+    return false;
+  }
+  if (typeof value.channel !== "string" || value.channel === "") {
+    return false;
+  }
+  return true;
+};
 var getStateDisplay = (current) => {
   const found = STATE_LIST.find((s) => s.state === current);
   return found ? { emoji: found.emoji, name: found.name } : void 0;
@@ -24301,7 +24600,8 @@ var processOneResource = async (ctx, targetResource, params, resourceIndex, wait
     account,
     mode: params.Mode,
     maxLoopCount: waitLimits.maxLoopCount,
-    maxElapsedSeconds: waitLimits.maxElapsedSeconds
+    maxElapsedSeconds: waitLimits.maxElapsedSeconds,
+    statusChangeWaitSeconds: waitLimits.statusChangeWaitSeconds
   });
   const startedAtMs = await ctx.step(`${stepPrefix}-wait-started-at`, async () => Date.now());
   let loopCount = 0;
@@ -24349,9 +24649,9 @@ var processOneResource = async (ctx, targetResource, params, resourceIndex, wait
       });
       ctx.logger.info("processOneResource: wait after start", {
         identifier,
-        seconds: STATUS_CHANGE_WAIT_SECONDS
+        seconds: waitLimits.statusChangeWaitSeconds
       });
-      await ctx.wait({ seconds: STATUS_CHANGE_WAIT_SECONDS });
+      await ctx.wait({ seconds: waitLimits.statusChangeWaitSeconds });
       loopCount += 1;
       continue;
     }
@@ -24363,9 +24663,9 @@ var processOneResource = async (ctx, targetResource, params, resourceIndex, wait
       });
       ctx.logger.info("processOneResource: wait after stop", {
         identifier,
-        seconds: STATUS_CHANGE_WAIT_SECONDS
+        seconds: waitLimits.statusChangeWaitSeconds
       });
-      await ctx.wait({ seconds: STATUS_CHANGE_WAIT_SECONDS });
+      await ctx.wait({ seconds: waitLimits.statusChangeWaitSeconds });
       loopCount += 1;
       continue;
     }
@@ -24376,9 +24676,9 @@ var processOneResource = async (ctx, targetResource, params, resourceIndex, wait
           loopCount,
           currentState,
           mode,
-          seconds: STATUS_CHANGE_WAIT_SECONDS
+          seconds: waitLimits.statusChangeWaitSeconds
         });
-        await ctx.wait({ seconds: STATUS_CHANGE_WAIT_SECONDS });
+        await ctx.wait({ seconds: waitLimits.statusChangeWaitSeconds });
         loopCount += 1;
         continue;
       }
@@ -24423,13 +24723,14 @@ var handler = withDurableExecution(async (event, ctx) => {
     throw new Error("Invalid event: Params.TagKey, Params.TagValues, Params.Mode are required.");
   }
   const waitLimits = parseResourceWaitLimitsFromEnv();
+  const maxConcurrency = parseMaxConcurrencyFromEnv();
   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, SLACK_SECRET_FETCH_OPTIONS);
   });
   ctx.logger.info("running-scheduler: Slack secret loaded");
-  if (!slackSecretValue?.token || !slackSecretValue?.channel) {
+  if (!isSlackSecret(slackSecretValue)) {
     throw new Error("Slack secret must contain token and channel.");
   }
   const targetResources = await ctx.step("get-target-resources", async () => {
@@ -24473,7 +24774,7 @@ var handler = withDurableExecution(async (event, ctx) => {
   });
   ctx.logger.info("running-scheduler: starting parallel instance processing", {
     count: targetResources.length,
-    maxConcurrency: 10
+    maxConcurrency
   });
   const results = await ctx.map(
     targetResources,
@@ -24521,7 +24822,7 @@ var handler = withDurableExecution(async (event, ctx) => {
         return result;
       });
     },
-    { maxConcurrency: 10 }
+    { maxConcurrency }
   );
   const resultList = Array.isArray(results) ? results : [];
   ctx.logger.info("running-scheduler: completed", {