ec2-instance-running-scheduler 0.3.6 → 0.4.1

package/lib/constructs/ec2-instance-running-scheduler.d.ts

@@ -1,4 +1,5 @@
-import { TimeZone } from 'aws-cdk-lib';
+import { Duration, RemovalPolicy, TimeZone } from 'aws-cdk-lib';
+import * as logs from 'aws-cdk-lib/aws-logs';
 import { Construct } from 'constructs';
 import { type FailureDetectionAlarms, type RunningSchedulerFailureDetection } from './running-scheduler-failure-detection';
 export type { FailureDetectionAlarms, RunningSchedulerFailureDetection, RunningSchedulerFailureDetectionProps, } from './running-scheduler-failure-detection';
@@ -17,6 +18,10 @@ export interface Schedule {
 }
 /**
  * Defines which EC2 instances are targeted by tag key and values.
+ *
+ * Instances must already have this tag. IAM allows `ec2:StartInstances` /
+ * `ec2:StopInstances` only on instances in the stack account and region whose
+ * `aws:ResourceTag/<tagKey>` matches one of {@link TargetResource.tagValues}.
  */
 export interface TargetResource {
     /** Tag key used to select instances (e.g. Schedule). */
@@ -53,6 +58,79 @@ export interface ResourceWaitLimits {
      * @default {@link DEFAULT_RESOURCE_WAIT_LIMITS.maxElapsedSeconds} (1800, 30 minutes)
      */
     readonly maxElapsedSeconds?: number;
+    /**
+     * Seconds to wait between describe iterations after start/stop or while transitioning.
+     *
+     * Lower values detect state changes sooner; higher values reduce DescribeInstances calls.
+     *
+     * @default {@link DEFAULT_RESOURCE_WAIT_LIMITS.statusChangeWaitSeconds} (20)
+     */
+    readonly statusChangeWaitSeconds?: number;
+}
+/**
+ * Lambda invoke settings and bounded parallelism for the running scheduler function.
+ *
+ * Increase {@link memorySize} and {@link maxConcurrency} when a single invocation targets
+ * many instances or regions.
+ */
+export interface RunningSchedulerRuntimeProps {
+    /**
+     * Memory allocated to the running scheduler Lambda, in MB.
+     *
+     * @default 512
+     */
+    readonly memorySize?: number;
+    /**
+     * Invoke timeout for the Lambda function (not the durable execution timeout).
+     *
+     * AWS Lambda's maximum invoke timeout is 15 minutes. Durable waits can continue
+     * beyond this via {@link RunningSchedulerDurableProps.executionTimeout}.
+     *
+     * @default Duration.minutes(15)
+     */
+    readonly timeout?: Duration;
+    /**
+     * Maximum number of instances processed in parallel by the durable `map`.
+     *
+     * @default {@link DEFAULT_MAX_CONCURRENCY} (10)
+     */
+    readonly maxConcurrency?: number;
+}
+/**
+ * Durable Execution timeout and history retention for the running scheduler Lambda.
+ */
+export interface RunningSchedulerDurableProps {
+    /**
+     * Maximum duration of a durable execution.
+     *
+     * Increase when many instances are processed with long per-instance waits.
+     *
+     * @default Duration.hours(2)
+     */
+    readonly executionTimeout?: Duration;
+    /**
+     * How long to retain durable execution history.
+     *
+     * @default Duration.days(1)
+     */
+    readonly retentionPeriod?: Duration;
+}
+/**
+ * CloudWatch Logs settings for the running scheduler function log group.
+ */
+export interface RunningSchedulerLogGroupProps {
+    /**
+     * How long to retain application logs.
+     *
+     * @default RetentionDays.THREE_MONTHS
+     */
+    readonly retention?: logs.RetentionDays;
+    /**
+     * Removal policy for the log group.
+     *
+     * @default RemovalPolicy.DESTROY
+     */
+    readonly removalPolicy?: RemovalPolicy;
 }
 /**
  * Properties for creating an EC2 instance running scheduler.
@@ -74,6 +152,24 @@ export interface EC2InstanceRunningSchedulerProps {
      * @default {@link DEFAULT_RESOURCE_WAIT_LIMITS}
      */
     readonly resourceWait?: ResourceWaitLimits;
+    /**
+     * Lambda memory, invoke timeout, and per-invocation instance concurrency.
+     *
+     * @default 512 MB, 15 minutes, {@link DEFAULT_MAX_CONCURRENCY} (10)
+     */
+    readonly runtime?: RunningSchedulerRuntimeProps;
+    /**
+     * Durable Execution timeout and history retention.
+     *
+     * @default executionTimeout 2 hours, retentionPeriod 1 day
+     */
+    readonly durable?: RunningSchedulerDurableProps;
+    /**
+     * CloudWatch Logs retention and removal policy for the function log group.
+     *
+     * @default RetentionDays.THREE_MONTHS, RemovalPolicy.DESTROY
+     */
+    readonly logGroup?: RunningSchedulerLogGroupProps;
     /**
      * Optional CloudWatch alarms and log-based metrics for failure detection.
      *
@@ -90,7 +186,11 @@ export interface EC2InstanceRunningSchedulerProps {
  * the Resource Groups Tagging API and EC2 APIs; Slack notifications use the secret named in {@link Secrets.slackSecretName}.
  *
  * Per-instance wait timeouts are configured via {@link EC2InstanceRunningSchedulerProps.resourceWait}
- * and enforced in the handler before the Durable execution timeout. Optional CloudWatch failure
+ * and enforced in the handler before the Durable execution timeout. Lambda memory, invoke timeout,
+ * and map concurrency are set via {@link EC2InstanceRunningSchedulerProps.runtime}; Durable
+ * execution timeout and history retention via {@link EC2InstanceRunningSchedulerProps.durable};
+ * log retention via {@link EC2InstanceRunningSchedulerProps.logGroup}. Start/stop IAM is limited
+ * to instances tagged as {@link TargetResource}. Optional CloudWatch failure
  * detection is available via {@link EC2InstanceRunningSchedulerProps.failureDetection}.
  */
 export declare class EC2InstanceRunningScheduler extends Construct {
@@ -103,7 +203,9 @@ export declare class EC2InstanceRunningScheduler extends Construct {
      * @param scope - Parent construct.
      * @param id - Construct id.
      * @param props - Target tags, schedules, Slack secret, schedule enable flag, optional
-     *   {@link ResourceWaitLimits}, and optional {@link FailureDetectionAlarms}.
+     *   {@link ResourceWaitLimits}, {@link RunningSchedulerRuntimeProps},
+     *   {@link RunningSchedulerDurableProps}, {@link RunningSchedulerLogGroupProps},
+     *   and optional {@link FailureDetectionAlarms}.
      */
     constructor(scope: Construct, id: string, props: EC2InstanceRunningSchedulerProps);
 }

package/lib/constructs/ec2-instance-running-scheduler.js

@@ -47,6 +47,76 @@ const running_scheduler_failure_detection_1 = require("./running-scheduler-failu
 const running_scheduler_function_1 = require("../funcs/running-scheduler-function");
 const running_scheduler_predicates_1 = require("../funcs/running-scheduler-predicates");
 const running_scheduler_wait_config_1 = require("../funcs/running-scheduler-wait-config");
+const DEFAULT_LAMBDA_MEMORY_SIZE = 512;
+const DEFAULT_LAMBDA_TIMEOUT = aws_cdk_lib_1.Duration.minutes(15);
+const DEFAULT_DURABLE_EXECUTION_TIMEOUT = aws_cdk_lib_1.Duration.hours(2);
+const DEFAULT_DURABLE_RETENTION_PERIOD = aws_cdk_lib_1.Duration.days(1);
+/**
+ * Returns `value` when set, otherwise `defaultValue`.
+ *
+ * @param name - Property path used in the error message.
+ * @param value - Optional positive integer from construct props.
+ * @param defaultValue - Fallback when `value` is omitted.
+ * @returns A positive integer.
+ * @throws {Error} When `value` is set and is not a positive integer.
+ */
+const resolvePositiveInteger = (name, value, defaultValue) => {
+    if (value === undefined) {
+        return defaultValue;
+    }
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new Error(`${name} must be a positive integer (got ${String(value)})`);
+    }
+    return value;
+};
+/**
+ * Ensures {@link TargetResource} can be used in IAM `aws:ResourceTag` conditions.
+ *
+ * @param targetResource - Tag key and values used to select EC2 instances.
+ * @throws {Error} When `tagKey` is empty or `tagValues` is empty.
+ */
+const assertTargetResourceForIam = (targetResource) => {
+    if (targetResource.tagKey === '') {
+        throw new Error('targetResource.tagKey must be a non-empty string');
+    }
+    if (targetResource.tagValues.length === 0) {
+        throw new Error('targetResource.tagValues must contain at least one value');
+    }
+};
+/**
+ * IAM statement that allows start/stop only on EC2 instances in this account and region
+ * whose tags match {@link TargetResource}.
+ *
+ * `tag:GetResources` and `ec2:DescribeInstances` cannot use resource-level ARNs or
+ * resource-tag conditions (AWS API limitation). Start/stop are scoped instead so a
+ * compromised function cannot start or stop untagged instances.
+ *
+ * @param scope - Construct used to resolve the stack ARN partition, region, and account.
+ * @param targetResource - Tag key and values required on target instances.
+ * @returns Policy statement for `ec2:StartInstances` and `ec2:StopInstances`.
+ */
+const taggedInstanceStartStopStatement = (scope, targetResource) => {
+    const instanceArn = aws_cdk_lib_1.Stack.of(scope).formatArn({
+        service: 'ec2',
+        resource: 'instance',
+        resourceName: '*',
+        arnFormat: aws_cdk_lib_1.ArnFormat.SLASH_RESOURCE_NAME,
+    });
+    return new iam.PolicyStatement({
+        sid: 'Ec2StartStopTaggedInstances',
+        effect: iam.Effect.ALLOW,
+        actions: [
+            'ec2:StartInstances',
+            'ec2:StopInstances',
+        ],
+        resources: [instanceArn],
+        conditions: {
+            StringEquals: {
+                [`aws:ResourceTag/${targetResource.tagKey}`]: targetResource.tagValues,
+            },
+        },
+    });
+};
 /**
  * Provisions EventBridge Scheduler rules and a Durable Execution Lambda that start/stop tagged EC2 instances.
  *
@@ -54,11 +124,15 @@ const running_scheduler_wait_config_1 = require("../funcs/running-scheduler-wait
  * the Resource Groups Tagging API and EC2 APIs; Slack notifications use the secret named in {@link Secrets.slackSecretName}.
  *
  * Per-instance wait timeouts are configured via {@link EC2InstanceRunningSchedulerProps.resourceWait}
- * and enforced in the handler before the Durable execution timeout. Optional CloudWatch failure
+ * and enforced in the handler before the Durable execution timeout. Lambda memory, invoke timeout,
+ * and map concurrency are set via {@link EC2InstanceRunningSchedulerProps.runtime}; Durable
+ * execution timeout and history retention via {@link EC2InstanceRunningSchedulerProps.durable};
+ * log retention via {@link EC2InstanceRunningSchedulerProps.logGroup}. Start/stop IAM is limited
+ * to instances tagged as {@link TargetResource}. Optional CloudWatch failure
  * detection is available via {@link EC2InstanceRunningSchedulerProps.failureDetection}.
  */
 class EC2InstanceRunningScheduler extends constructs_1.Construct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "ec2-instance-running-scheduler.EC2InstanceRunningScheduler", version: "0.3.6" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "ec2-instance-running-scheduler.EC2InstanceRunningScheduler", version: "0.4.1" };
     /** Failure detection alarms, when {@link EC2InstanceRunningSchedulerProps.failureDetection} is enabled. */
     failureDetection;
     /**
@@ -68,31 +142,41 @@ class EC2InstanceRunningScheduler extends constructs_1.Construct {
      * @param scope - Parent construct.
      * @param id - Construct id.
      * @param props - Target tags, schedules, Slack secret, schedule enable flag, optional
-     *   {@link ResourceWaitLimits}, and optional {@link FailureDetectionAlarms}.
+     *   {@link ResourceWaitLimits}, {@link RunningSchedulerRuntimeProps},
+     *   {@link RunningSchedulerDurableProps}, {@link RunningSchedulerLogGroupProps},
+     *   and optional {@link FailureDetectionAlarms}.
      */
     constructor(scope, id, props) {
         super(scope, id);
+        assertTargetResourceForIam(props.targetResource);
         const slackSecret = aws_secretsmanager_1.Secret.fromSecretNameV2(this, 'SlackSecret', props.secrets.slackSecretName);
+        const maxLoopCount = resolvePositiveInteger('resourceWait.maxLoopCount', props.resourceWait?.maxLoopCount, running_scheduler_predicates_1.DEFAULT_RESOURCE_WAIT_LIMITS.maxLoopCount);
+        const maxElapsedSeconds = resolvePositiveInteger('resourceWait.maxElapsedSeconds', props.resourceWait?.maxElapsedSeconds, running_scheduler_predicates_1.DEFAULT_RESOURCE_WAIT_LIMITS.maxElapsedSeconds);
+        const statusChangeWaitSeconds = resolvePositiveInteger('resourceWait.statusChangeWaitSeconds', props.resourceWait?.statusChangeWaitSeconds, running_scheduler_predicates_1.DEFAULT_RESOURCE_WAIT_LIMITS.statusChangeWaitSeconds);
+        const maxConcurrency = resolvePositiveInteger('runtime.maxConcurrency', props.runtime?.maxConcurrency, running_scheduler_predicates_1.DEFAULT_MAX_CONCURRENCY);
+        const memorySize = resolvePositiveInteger('runtime.memorySize', props.runtime?.memorySize, DEFAULT_LAMBDA_MEMORY_SIZE);
         // Durable Functions-based Running Scheduler (previous Step Functions logic implemented in Lambda).
         // Durable Execution requires Node.js 22+.
         const runningScheduleFunctionLogGroup = new logs.LogGroup(this, 'RunningSchedulerFunctionLogGroup', {
-            retention: logs.RetentionDays.THREE_MONTHS,
-            removalPolicy: aws_cdk_lib_1.RemovalPolicy.DESTROY,
+            retention: props.logGroup?.retention ?? logs.RetentionDays.THREE_MONTHS,
+            removalPolicy: props.logGroup?.removalPolicy ?? aws_cdk_lib_1.RemovalPolicy.DESTROY,
         });
         const runningScheduleFunction = new running_scheduler_function_1.RunningSchedulerFunction(this, 'RunningSchedulerFunction', {
             description: 'Starts and stops tagged EC2 instances on EventBridge Scheduler schedules.',
             architecture: lambda.Architecture.ARM_64,
-            timeout: aws_cdk_lib_1.Duration.minutes(15),
-            memorySize: 512,
+            timeout: props.runtime?.timeout ?? DEFAULT_LAMBDA_TIMEOUT,
+            memorySize,
             retryAttempts: 2,
             durableConfig: {
-                executionTimeout: aws_cdk_lib_1.Duration.hours(2),
-                retentionPeriod: aws_cdk_lib_1.Duration.days(1),
+                executionTimeout: props.durable?.executionTimeout ?? DEFAULT_DURABLE_EXECUTION_TIMEOUT,
+                retentionPeriod: props.durable?.retentionPeriod ?? DEFAULT_DURABLE_RETENTION_PERIOD,
             },
             environment: {
                 SLACK_SECRET_NAME: props.secrets.slackSecretName,
-                [running_scheduler_wait_config_1.PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV]: String(props.resourceWait?.maxLoopCount ?? running_scheduler_predicates_1.DEFAULT_RESOURCE_WAIT_LIMITS.maxLoopCount),
-                [running_scheduler_wait_config_1.PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV]: String(props.resourceWait?.maxElapsedSeconds ?? running_scheduler_predicates_1.DEFAULT_RESOURCE_WAIT_LIMITS.maxElapsedSeconds),
+                [running_scheduler_wait_config_1.PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV]: String(maxLoopCount),
+                [running_scheduler_wait_config_1.PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV]: String(maxElapsedSeconds),
+                [running_scheduler_wait_config_1.PROCESS_RESOURCE_STATUS_CHANGE_WAIT_SECONDS_ENV]: String(statusChangeWaitSeconds),
+                [running_scheduler_wait_config_1.PROCESS_RESOURCES_MAX_CONCURRENCY_ENV]: String(maxConcurrency),
             },
             paramsAndSecrets: lambda.ParamsAndSecretsLayerVersion.fromVersion(lambda.ParamsAndSecretsVersions.V1_0_103, {
                 // Required by aws-lambda-secret-fetcher (extension HTTP API on localhost; port from PARAMETERS_SECRETS_EXTENSION_HTTP_PORT).
@@ -100,7 +184,7 @@ class EC2InstanceRunningScheduler extends constructs_1.Construct {
                 logLevel: lambda.ParamsAndSecretsLogLevel.INFO,
             }),
             role: new iam.Role(this, 'RunningSchedulerFunctionRole', {
-                description: 'Allows the running scheduler to describe, start, and stop EC2 instances and read Slack secrets.',
+                description: 'Allows the running scheduler to describe instances and start/stop tagged EC2 instances, and to read Slack secrets.',
                 assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),
                 managedPolicies: [
                     iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicExecutionRole'),
@@ -118,19 +202,19 @@ class EC2InstanceRunningScheduler extends constructs_1.Construct {
             actions: [
                 'tag:GetResources',
             ],
+            // Resource Groups Tagging API does not support resource-level permissions.
             resources: ['*'],
         }));
-        // EC2: describe instances and start/stop by instance id
         runningScheduleFunction.addToRolePolicy(new iam.PolicyStatement({
-            sid: 'Ec2RunningControl',
+            sid: 'Ec2DescribeInstances',
             effect: iam.Effect.ALLOW,
             actions: [
                 'ec2:DescribeInstances',
-                'ec2:StartInstances',
-                'ec2:StopInstances',
             ],
+            // Describe* APIs do not support resource-level permissions or resource-tag conditions.
             resources: ['*'],
         }));
+        runningScheduleFunction.addToRolePolicy(taggedInstanceStartStopStatement(this, props.targetResource));
         // Grant read access to the Slack secret
         slackSecret.grantRead(runningScheduleFunction);
         this.failureDetection = (0, running_scheduler_failure_detection_1.createRunningSchedulerFailureDetection)(this, 'FailureDetection', {
@@ -191,4 +275,4 @@ class EC2InstanceRunningScheduler extends constructs_1.Construct {
     }
 }
 exports.EC2InstanceRunningScheduler = EC2InstanceRunningScheduler;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ec2-instance-running-scheduler.js","sourceRoot":"","sources":["../../src/constructs/ec2-instance-running-scheduler.ts"],"names":[],"mappings":"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","sourcesContent":["import { Duration, RemovalPolicy, TimeZone } from 'aws-cdk-lib';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport * as logs from 'aws-cdk-lib/aws-logs';\nimport * as scheduler from 'aws-cdk-lib/aws-scheduler';\nimport * as targets from 'aws-cdk-lib/aws-scheduler-targets';\nimport { Secret } from 'aws-cdk-lib/aws-secretsmanager';\nimport { Construct } from 'constructs';\nimport {\n  createRunningSchedulerFailureDetection,\n  type FailureDetectionAlarms,\n  type RunningSchedulerFailureDetection,\n} from './running-scheduler-failure-detection';\nimport { RunningSchedulerFunction } from '../funcs/running-scheduler-function';\nimport { DEFAULT_RESOURCE_WAIT_LIMITS } from '../funcs/running-scheduler-predicates';\nimport {\n  PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV,\n  PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV,\n} from '../funcs/running-scheduler-wait-config';\n\nexport type {\n  FailureDetectionAlarms,\n  RunningSchedulerFailureDetection,\n  RunningSchedulerFailureDetectionProps,\n} from './running-scheduler-failure-detection';\n\n/**\n * Cron-style schedule configuration for start/stop actions.\n */\nexport interface Schedule {\n  /** Time zone for the schedule (e.g. ETC_UTC). */\n  readonly timezone: TimeZone;\n  /** Cron minute (0–59). */\n  readonly minute?: string;\n  /** Cron hour (0–23). */\n  readonly hour?: string;\n  /** Cron day of week (e.g. MON-FRI). */\n  readonly week?: string;\n}\n\n/**\n * Defines which EC2 instances are targeted by tag key and values.\n */\nexport interface TargetResource {\n  /** Tag key used to select instances (e.g. Schedule). */\n  readonly tagKey: string;\n  /** Tag values that match instances to include. */\n  readonly tagValues: string[];\n}\n\n/**\n * Secret identifiers required by the scheduler (e.g. Slack).\n */\nexport interface Secrets {\n  /** Name of the Secrets Manager secret containing Slack token and channel. */\n  readonly slackSecretName: string;\n}\n\n/**\n * CDK-side limits for per-instance stable-state waiting in the Durable Lambda handler.\n *\n * Optional fields map to {@link PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV} and\n * {@link PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV} on the running scheduler function.\n * Prevents abnormal or stuck transitions from running until the Durable execution timeout.\n *\n * @see {@link ResourceWaitLimits} in `running-scheduler-predicates.ts` for the handler-side required shape.\n */\nexport interface ResourceWaitLimits {\n  /**\n   * Maximum describe/wait loop iterations per instance.\n   *\n   * @default {@link DEFAULT_RESOURCE_WAIT_LIMITS.maxLoopCount} (90)\n   */\n  readonly maxLoopCount?: number;\n  /**\n   * Maximum wall-clock seconds spent waiting for a single instance to stabilize.\n   *\n   * @default {@link DEFAULT_RESOURCE_WAIT_LIMITS.maxElapsedSeconds} (1800, 30 minutes)\n   */\n  readonly maxElapsedSeconds?: number;\n}\n\n/**\n * Properties for creating an EC2 instance running scheduler.\n */\nexport interface EC2InstanceRunningSchedulerProps {\n  /** Tag-based targeting for EC2 instances to start/stop. */\n  readonly targetResource: TargetResource;\n  /** Whether EventBridge Scheduler rules are enabled. Defaults to true if omitted. */\n  readonly enableScheduling?: boolean;\n  /** Secrets (e.g. Slack) used for notifications. */\n  readonly secrets: Secrets;\n  /** Cron schedule for stopping instances. */\n  readonly stopSchedule?: Schedule;\n  /** Cron schedule for starting instances. */\n  readonly startSchedule?: Schedule;\n  /**\n   * Per-instance wait limits for the running scheduler Lambda.\n   *\n   * @default {@link DEFAULT_RESOURCE_WAIT_LIMITS}\n   */\n  readonly resourceWait?: ResourceWaitLimits;\n  /**\n   * Optional CloudWatch alarms and log-based metrics for failure detection.\n   *\n   * Set `enabled: true` to create alarms; optionally pass `alarmTopic` for SNS notifications.\n   *\n   * @default disabled when omitted\n   */\n  readonly failureDetection?: FailureDetectionAlarms;\n}\n\n/**\n * Provisions EventBridge Scheduler rules and a Durable Execution Lambda that start/stop tagged EC2 instances.\n *\n * Each schedule invokes the function with `Params` (`TagKey`, `TagValues`, `Mode`). The function uses\n * the Resource Groups Tagging API and EC2 APIs; Slack notifications use the secret named in {@link Secrets.slackSecretName}.\n *\n * Per-instance wait timeouts are configured via {@link EC2InstanceRunningSchedulerProps.resourceWait}\n * and enforced in the handler before the Durable execution timeout. Optional CloudWatch failure\n * detection is available via {@link EC2InstanceRunningSchedulerProps.failureDetection}.\n */\nexport class EC2InstanceRunningScheduler extends Construct {\n  /** Failure detection alarms, when {@link EC2InstanceRunningSchedulerProps.failureDetection} is enabled. */\n  public readonly failureDetection?: RunningSchedulerFailureDetection;\n\n  /**\n   * Defines IAM, logging, optional failure detection alarms, two cron schedules (start/stop),\n   * and the bundled running-scheduler Lambda (Node.js, Durable Execution).\n   *\n   * @param scope - Parent construct.\n   * @param id - Construct id.\n   * @param props - Target tags, schedules, Slack secret, schedule enable flag, optional\n   *   {@link ResourceWaitLimits}, and optional {@link FailureDetectionAlarms}.\n   */\n  constructor(scope: Construct, id: string, props: EC2InstanceRunningSchedulerProps) {\n    super(scope, id);\n\n    const slackSecret = Secret.fromSecretNameV2(this, 'SlackSecret', props.secrets.slackSecretName);\n\n    // Durable Functions-based Running Scheduler (previous Step Functions logic implemented in Lambda).\n    // Durable Execution requires Node.js 22+.\n    const runningScheduleFunctionLogGroup = new logs.LogGroup(this, 'RunningSchedulerFunctionLogGroup', {\n      retention: logs.RetentionDays.THREE_MONTHS,\n      removalPolicy: RemovalPolicy.DESTROY,\n    });\n\n    const runningScheduleFunction = new RunningSchedulerFunction(this, 'RunningSchedulerFunction', {\n      description: 'Starts and stops tagged EC2 instances on EventBridge Scheduler schedules.',\n      architecture: lambda.Architecture.ARM_64,\n      timeout: Duration.minutes(15),\n      memorySize: 512,\n      retryAttempts: 2,\n      durableConfig: {\n        executionTimeout: Duration.hours(2),\n        retentionPeriod: Duration.days(1),\n      },\n      environment: {\n        SLACK_SECRET_NAME: props.secrets.slackSecretName,\n        [PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV]: String(\n          props.resourceWait?.maxLoopCount ?? DEFAULT_RESOURCE_WAIT_LIMITS.maxLoopCount,\n        ),\n        [PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV]: String(\n          props.resourceWait?.maxElapsedSeconds ?? DEFAULT_RESOURCE_WAIT_LIMITS.maxElapsedSeconds,\n        ),\n      },\n      paramsAndSecrets: lambda.ParamsAndSecretsLayerVersion.fromVersion(lambda.ParamsAndSecretsVersions.V1_0_103, {\n        // Required by aws-lambda-secret-fetcher (extension HTTP API on localhost; port from PARAMETERS_SECRETS_EXTENSION_HTTP_PORT).\n        cacheSize: 500,\n        logLevel: lambda.ParamsAndSecretsLogLevel.INFO,\n      }),\n      role: new iam.Role(this, 'RunningSchedulerFunctionRole', {\n        description: 'Allows the running scheduler to describe, start, and stop EC2 instances and read Slack secrets.',\n        assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),\n        managedPolicies: [\n          iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicExecutionRole'),\n          iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicDurableExecutionRolePolicy'),\n        ],\n      }),\n      logGroup: runningScheduleFunctionLogGroup,\n      loggingFormat: lambda.LoggingFormat.JSON,\n      systemLogLevelV2: lambda.SystemLogLevel.INFO,\n      applicationLogLevelV2: lambda.ApplicationLogLevel.INFO,\n    });\n    runningScheduleFunction.addToRolePolicy(new iam.PolicyStatement({\n      sid: 'GetResources',\n      effect: iam.Effect.ALLOW,\n      actions: [\n        'tag:GetResources',\n      ],\n      resources: ['*'],\n    }));\n    // EC2: describe instances and start/stop by instance id\n    runningScheduleFunction.addToRolePolicy(new iam.PolicyStatement({\n      sid: 'Ec2RunningControl',\n      effect: iam.Effect.ALLOW,\n      actions: [\n        'ec2:DescribeInstances',\n        'ec2:StartInstances',\n        'ec2:StopInstances',\n      ],\n      resources: ['*'],\n    }));\n    // Grant read access to the Slack secret\n    slackSecret.grantRead(runningScheduleFunction);\n\n    this.failureDetection = createRunningSchedulerFailureDetection(this, 'FailureDetection', {\n      failureDetection: props.failureDetection,\n      runningScheduleFunction,\n      logGroup: runningScheduleFunctionLogGroup,\n    });\n\n    // See: https://docs.aws.amazon.com/lambda/latest/dg/durable-getting-started-iac.html\n    const runningScheduleFunctionAlias = runningScheduleFunction.addAlias('live');\n\n    // Whether schedules are enabled (default true unless explicitly disabled).\n    const scheduleEnabled: boolean = (() => {\n      if (props.enableScheduling === undefined || props.enableScheduling) {\n        return true;\n      } else {\n        return false;\n      }\n    })();\n\n    // Durable Functions: Lambda performs tag lookup and instance start/stop in a single run.\n    new scheduler.Schedule(this, 'RunningStartSchedule', {\n      description: 'running start schedule',\n      enabled: scheduleEnabled,\n      schedule: scheduler.ScheduleExpression.cron({\n        minute: props.startSchedule?.minute ?? '50',\n        hour: props.startSchedule?.hour ?? '7',\n        weekDay: props.startSchedule?.week ?? 'MON-FRI',\n        timeZone: props.startSchedule?.timezone ?? TimeZone.ETC_UTC,\n      }),\n      target: new targets.LambdaInvoke(runningScheduleFunctionAlias, {\n        input: scheduler.ScheduleTargetInput.fromObject({\n          Params: {\n            TagKey: props.targetResource.tagKey,\n            TagValues: props.targetResource.tagValues,\n            Mode: 'Start',\n          },\n        }),\n      }),\n    });\n\n    new scheduler.Schedule(this, 'RunningStopSchedule', {\n      description: 'running stop schedule',\n      enabled: scheduleEnabled,\n      schedule: scheduler.ScheduleExpression.cron({\n        minute: props.stopSchedule?.minute ?? '5',\n        hour: props.stopSchedule?.hour ?? '19',\n        weekDay: props.stopSchedule?.week ?? 'MON-FRI',\n        timeZone: props.stopSchedule?.timezone ?? TimeZone.ETC_UTC,\n      }),\n      target: new targets.LambdaInvoke(runningScheduleFunctionAlias, {\n        input: scheduler.ScheduleTargetInput.fromObject({\n          Params: {\n            TagKey: props.targetResource.tagKey,\n            TagValues: props.targetResource.tagValues,\n            Mode: 'Stop',\n          },\n        }),\n      }),\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ec2-instance-running-scheduler.js","sourceRoot":"","sources":["../../src/constructs/ec2-instance-running-scheduler.ts"],"names":[],"mappings":"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","sourcesContent":["import { ArnFormat, Duration, RemovalPolicy, Stack, TimeZone } from 'aws-cdk-lib';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport * as logs from 'aws-cdk-lib/aws-logs';\nimport * as scheduler from 'aws-cdk-lib/aws-scheduler';\nimport * as targets from 'aws-cdk-lib/aws-scheduler-targets';\nimport { Secret } from 'aws-cdk-lib/aws-secretsmanager';\nimport { Construct } from 'constructs';\nimport {\n  createRunningSchedulerFailureDetection,\n  type FailureDetectionAlarms,\n  type RunningSchedulerFailureDetection,\n} from './running-scheduler-failure-detection';\nimport { RunningSchedulerFunction } from '../funcs/running-scheduler-function';\nimport {\n  DEFAULT_MAX_CONCURRENCY,\n  DEFAULT_RESOURCE_WAIT_LIMITS,\n} from '../funcs/running-scheduler-predicates';\nimport {\n  PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV,\n  PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV,\n  PROCESS_RESOURCE_STATUS_CHANGE_WAIT_SECONDS_ENV,\n  PROCESS_RESOURCES_MAX_CONCURRENCY_ENV,\n} from '../funcs/running-scheduler-wait-config';\n\nexport type {\n  FailureDetectionAlarms,\n  RunningSchedulerFailureDetection,\n  RunningSchedulerFailureDetectionProps,\n} from './running-scheduler-failure-detection';\n\n/**\n * Cron-style schedule configuration for start/stop actions.\n */\nexport interface Schedule {\n  /** Time zone for the schedule (e.g. ETC_UTC). */\n  readonly timezone: TimeZone;\n  /** Cron minute (0–59). */\n  readonly minute?: string;\n  /** Cron hour (0–23). */\n  readonly hour?: string;\n  /** Cron day of week (e.g. MON-FRI). */\n  readonly week?: string;\n}\n\n/**\n * Defines which EC2 instances are targeted by tag key and values.\n *\n * Instances must already have this tag. IAM allows `ec2:StartInstances` /\n * `ec2:StopInstances` only on instances in the stack account and region whose\n * `aws:ResourceTag/<tagKey>` matches one of {@link TargetResource.tagValues}.\n */\nexport interface TargetResource {\n  /** Tag key used to select instances (e.g. Schedule). */\n  readonly tagKey: string;\n  /** Tag values that match instances to include. */\n  readonly tagValues: string[];\n}\n\n/**\n * Secret identifiers required by the scheduler (e.g. Slack).\n */\nexport interface Secrets {\n  /** Name of the Secrets Manager secret containing Slack token and channel. */\n  readonly slackSecretName: string;\n}\n\n/**\n * CDK-side limits for per-instance stable-state waiting in the Durable Lambda handler.\n *\n * Optional fields map to {@link PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV} and\n * {@link PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV} on the running scheduler function.\n * Prevents abnormal or stuck transitions from running until the Durable execution timeout.\n *\n * @see {@link ResourceWaitLimits} in `running-scheduler-predicates.ts` for the handler-side required shape.\n */\nexport interface ResourceWaitLimits {\n  /**\n   * Maximum describe/wait loop iterations per instance.\n   *\n   * @default {@link DEFAULT_RESOURCE_WAIT_LIMITS.maxLoopCount} (90)\n   */\n  readonly maxLoopCount?: number;\n  /**\n   * Maximum wall-clock seconds spent waiting for a single instance to stabilize.\n   *\n   * @default {@link DEFAULT_RESOURCE_WAIT_LIMITS.maxElapsedSeconds} (1800, 30 minutes)\n   */\n  readonly maxElapsedSeconds?: number;\n  /**\n   * Seconds to wait between describe iterations after start/stop or while transitioning.\n   *\n   * Lower values detect state changes sooner; higher values reduce DescribeInstances calls.\n   *\n   * @default {@link DEFAULT_RESOURCE_WAIT_LIMITS.statusChangeWaitSeconds} (20)\n   */\n  readonly statusChangeWaitSeconds?: number;\n}\n\n/**\n * Lambda invoke settings and bounded parallelism for the running scheduler function.\n *\n * Increase {@link memorySize} and {@link maxConcurrency} when a single invocation targets\n * many instances or regions.\n */\nexport interface RunningSchedulerRuntimeProps {\n  /**\n   * Memory allocated to the running scheduler Lambda, in MB.\n   *\n   * @default 512\n   */\n  readonly memorySize?: number;\n  /**\n   * Invoke timeout for the Lambda function (not the durable execution timeout).\n   *\n   * AWS Lambda's maximum invoke timeout is 15 minutes. Durable waits can continue\n   * beyond this via {@link RunningSchedulerDurableProps.executionTimeout}.\n   *\n   * @default Duration.minutes(15)\n   */\n  readonly timeout?: Duration;\n  /**\n   * Maximum number of instances processed in parallel by the durable `map`.\n   *\n   * @default {@link DEFAULT_MAX_CONCURRENCY} (10)\n   */\n  readonly maxConcurrency?: number;\n}\n\n/**\n * Durable Execution timeout and history retention for the running scheduler Lambda.\n */\nexport interface RunningSchedulerDurableProps {\n  /**\n   * Maximum duration of a durable execution.\n   *\n   * Increase when many instances are processed with long per-instance waits.\n   *\n   * @default Duration.hours(2)\n   */\n  readonly executionTimeout?: Duration;\n  /**\n   * How long to retain durable execution history.\n   *\n   * @default Duration.days(1)\n   */\n  readonly retentionPeriod?: Duration;\n}\n\n/**\n * CloudWatch Logs settings for the running scheduler function log group.\n */\nexport interface RunningSchedulerLogGroupProps {\n  /**\n   * How long to retain application logs.\n   *\n   * @default RetentionDays.THREE_MONTHS\n   */\n  readonly retention?: logs.RetentionDays;\n  /**\n   * Removal policy for the log group.\n   *\n   * @default RemovalPolicy.DESTROY\n   */\n  readonly removalPolicy?: RemovalPolicy;\n}\n\n/**\n * Properties for creating an EC2 instance running scheduler.\n */\nexport interface EC2InstanceRunningSchedulerProps {\n  /** Tag-based targeting for EC2 instances to start/stop. */\n  readonly targetResource: TargetResource;\n  /** Whether EventBridge Scheduler rules are enabled. Defaults to true if omitted. */\n  readonly enableScheduling?: boolean;\n  /** Secrets (e.g. Slack) used for notifications. */\n  readonly secrets: Secrets;\n  /** Cron schedule for stopping instances. */\n  readonly stopSchedule?: Schedule;\n  /** Cron schedule for starting instances. */\n  readonly startSchedule?: Schedule;\n  /**\n   * Per-instance wait limits for the running scheduler Lambda.\n   *\n   * @default {@link DEFAULT_RESOURCE_WAIT_LIMITS}\n   */\n  readonly resourceWait?: ResourceWaitLimits;\n  /**\n   * Lambda memory, invoke timeout, and per-invocation instance concurrency.\n   *\n   * @default 512 MB, 15 minutes, {@link DEFAULT_MAX_CONCURRENCY} (10)\n   */\n  readonly runtime?: RunningSchedulerRuntimeProps;\n  /**\n   * Durable Execution timeout and history retention.\n   *\n   * @default executionTimeout 2 hours, retentionPeriod 1 day\n   */\n  readonly durable?: RunningSchedulerDurableProps;\n  /**\n   * CloudWatch Logs retention and removal policy for the function log group.\n   *\n   * @default RetentionDays.THREE_MONTHS, RemovalPolicy.DESTROY\n   */\n  readonly logGroup?: RunningSchedulerLogGroupProps;\n  /**\n   * Optional CloudWatch alarms and log-based metrics for failure detection.\n   *\n   * Set `enabled: true` to create alarms; optionally pass `alarmTopic` for SNS notifications.\n   *\n   * @default disabled when omitted\n   */\n  readonly failureDetection?: FailureDetectionAlarms;\n}\n\nconst DEFAULT_LAMBDA_MEMORY_SIZE = 512;\nconst DEFAULT_LAMBDA_TIMEOUT = Duration.minutes(15);\nconst DEFAULT_DURABLE_EXECUTION_TIMEOUT = Duration.hours(2);\nconst DEFAULT_DURABLE_RETENTION_PERIOD = Duration.days(1);\n\n/**\n * Returns `value` when set, otherwise `defaultValue`.\n *\n * @param name - Property path used in the error message.\n * @param value - Optional positive integer from construct props.\n * @param defaultValue - Fallback when `value` is omitted.\n * @returns A positive integer.\n * @throws {Error} When `value` is set and is not a positive integer.\n */\nconst resolvePositiveInteger = (name: string, value: number | undefined, defaultValue: number): number => {\n  if (value === undefined) {\n    return defaultValue;\n  }\n  if (!Number.isInteger(value) || value <= 0) {\n    throw new Error(`${name} must be a positive integer (got ${String(value)})`);\n  }\n  return value;\n};\n\n/**\n * Ensures {@link TargetResource} can be used in IAM `aws:ResourceTag` conditions.\n *\n * @param targetResource - Tag key and values used to select EC2 instances.\n * @throws {Error} When `tagKey` is empty or `tagValues` is empty.\n */\nconst assertTargetResourceForIam = (targetResource: TargetResource): void => {\n  if (targetResource.tagKey === '') {\n    throw new Error('targetResource.tagKey must be a non-empty string');\n  }\n  if (targetResource.tagValues.length === 0) {\n    throw new Error('targetResource.tagValues must contain at least one value');\n  }\n};\n\n/**\n * IAM statement that allows start/stop only on EC2 instances in this account and region\n * whose tags match {@link TargetResource}.\n *\n * `tag:GetResources` and `ec2:DescribeInstances` cannot use resource-level ARNs or\n * resource-tag conditions (AWS API limitation). Start/stop are scoped instead so a\n * compromised function cannot start or stop untagged instances.\n *\n * @param scope - Construct used to resolve the stack ARN partition, region, and account.\n * @param targetResource - Tag key and values required on target instances.\n * @returns Policy statement for `ec2:StartInstances` and `ec2:StopInstances`.\n */\nconst taggedInstanceStartStopStatement = (\n  scope: Construct,\n  targetResource: TargetResource,\n): iam.PolicyStatement => {\n  const instanceArn = Stack.of(scope).formatArn({\n    service: 'ec2',\n    resource: 'instance',\n    resourceName: '*',\n    arnFormat: ArnFormat.SLASH_RESOURCE_NAME,\n  });\n\n  return new iam.PolicyStatement({\n    sid: 'Ec2StartStopTaggedInstances',\n    effect: iam.Effect.ALLOW,\n    actions: [\n      'ec2:StartInstances',\n      'ec2:StopInstances',\n    ],\n    resources: [instanceArn],\n    conditions: {\n      StringEquals: {\n        [`aws:ResourceTag/${targetResource.tagKey}`]: targetResource.tagValues,\n      },\n    },\n  });\n};\n\n/**\n * Provisions EventBridge Scheduler rules and a Durable Execution Lambda that start/stop tagged EC2 instances.\n *\n * Each schedule invokes the function with `Params` (`TagKey`, `TagValues`, `Mode`). The function uses\n * the Resource Groups Tagging API and EC2 APIs; Slack notifications use the secret named in {@link Secrets.slackSecretName}.\n *\n * Per-instance wait timeouts are configured via {@link EC2InstanceRunningSchedulerProps.resourceWait}\n * and enforced in the handler before the Durable execution timeout. Lambda memory, invoke timeout,\n * and map concurrency are set via {@link EC2InstanceRunningSchedulerProps.runtime}; Durable\n * execution timeout and history retention via {@link EC2InstanceRunningSchedulerProps.durable};\n * log retention via {@link EC2InstanceRunningSchedulerProps.logGroup}. Start/stop IAM is limited\n * to instances tagged as {@link TargetResource}. Optional CloudWatch failure\n * detection is available via {@link EC2InstanceRunningSchedulerProps.failureDetection}.\n */\nexport class EC2InstanceRunningScheduler extends Construct {\n  /** Failure detection alarms, when {@link EC2InstanceRunningSchedulerProps.failureDetection} is enabled. */\n  public readonly failureDetection?: RunningSchedulerFailureDetection;\n\n  /**\n   * Defines IAM, logging, optional failure detection alarms, two cron schedules (start/stop),\n   * and the bundled running-scheduler Lambda (Node.js, Durable Execution).\n   *\n   * @param scope - Parent construct.\n   * @param id - Construct id.\n   * @param props - Target tags, schedules, Slack secret, schedule enable flag, optional\n   *   {@link ResourceWaitLimits}, {@link RunningSchedulerRuntimeProps},\n   *   {@link RunningSchedulerDurableProps}, {@link RunningSchedulerLogGroupProps},\n   *   and optional {@link FailureDetectionAlarms}.\n   */\n  constructor(scope: Construct, id: string, props: EC2InstanceRunningSchedulerProps) {\n    super(scope, id);\n\n    assertTargetResourceForIam(props.targetResource);\n\n    const slackSecret = Secret.fromSecretNameV2(this, 'SlackSecret', props.secrets.slackSecretName);\n\n    const maxLoopCount = resolvePositiveInteger(\n      'resourceWait.maxLoopCount',\n      props.resourceWait?.maxLoopCount,\n      DEFAULT_RESOURCE_WAIT_LIMITS.maxLoopCount,\n    );\n    const maxElapsedSeconds = resolvePositiveInteger(\n      'resourceWait.maxElapsedSeconds',\n      props.resourceWait?.maxElapsedSeconds,\n      DEFAULT_RESOURCE_WAIT_LIMITS.maxElapsedSeconds,\n    );\n    const statusChangeWaitSeconds = resolvePositiveInteger(\n      'resourceWait.statusChangeWaitSeconds',\n      props.resourceWait?.statusChangeWaitSeconds,\n      DEFAULT_RESOURCE_WAIT_LIMITS.statusChangeWaitSeconds,\n    );\n    const maxConcurrency = resolvePositiveInteger(\n      'runtime.maxConcurrency',\n      props.runtime?.maxConcurrency,\n      DEFAULT_MAX_CONCURRENCY,\n    );\n    const memorySize = resolvePositiveInteger(\n      'runtime.memorySize',\n      props.runtime?.memorySize,\n      DEFAULT_LAMBDA_MEMORY_SIZE,\n    );\n\n    // Durable Functions-based Running Scheduler (previous Step Functions logic implemented in Lambda).\n    // Durable Execution requires Node.js 22+.\n    const runningScheduleFunctionLogGroup = new logs.LogGroup(this, 'RunningSchedulerFunctionLogGroup', {\n      retention: props.logGroup?.retention ?? logs.RetentionDays.THREE_MONTHS,\n      removalPolicy: props.logGroup?.removalPolicy ?? RemovalPolicy.DESTROY,\n    });\n\n    const runningScheduleFunction = new RunningSchedulerFunction(this, 'RunningSchedulerFunction', {\n      description: 'Starts and stops tagged EC2 instances on EventBridge Scheduler schedules.',\n      architecture: lambda.Architecture.ARM_64,\n      timeout: props.runtime?.timeout ?? DEFAULT_LAMBDA_TIMEOUT,\n      memorySize,\n      retryAttempts: 2,\n      durableConfig: {\n        executionTimeout: props.durable?.executionTimeout ?? DEFAULT_DURABLE_EXECUTION_TIMEOUT,\n        retentionPeriod: props.durable?.retentionPeriod ?? DEFAULT_DURABLE_RETENTION_PERIOD,\n      },\n      environment: {\n        SLACK_SECRET_NAME: props.secrets.slackSecretName,\n        [PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV]: String(maxLoopCount),\n        [PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV]: String(maxElapsedSeconds),\n        [PROCESS_RESOURCE_STATUS_CHANGE_WAIT_SECONDS_ENV]: String(statusChangeWaitSeconds),\n        [PROCESS_RESOURCES_MAX_CONCURRENCY_ENV]: String(maxConcurrency),\n      },\n      paramsAndSecrets: lambda.ParamsAndSecretsLayerVersion.fromVersion(lambda.ParamsAndSecretsVersions.V1_0_103, {\n        // Required by aws-lambda-secret-fetcher (extension HTTP API on localhost; port from PARAMETERS_SECRETS_EXTENSION_HTTP_PORT).\n        cacheSize: 500,\n        logLevel: lambda.ParamsAndSecretsLogLevel.INFO,\n      }),\n      role: new iam.Role(this, 'RunningSchedulerFunctionRole', {\n        description: 'Allows the running scheduler to describe instances and start/stop tagged EC2 instances, and to read Slack secrets.',\n        assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),\n        managedPolicies: [\n          iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicExecutionRole'),\n          iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicDurableExecutionRolePolicy'),\n        ],\n      }),\n      logGroup: runningScheduleFunctionLogGroup,\n      loggingFormat: lambda.LoggingFormat.JSON,\n      systemLogLevelV2: lambda.SystemLogLevel.INFO,\n      applicationLogLevelV2: lambda.ApplicationLogLevel.INFO,\n    });\n    runningScheduleFunction.addToRolePolicy(new iam.PolicyStatement({\n      sid: 'GetResources',\n      effect: iam.Effect.ALLOW,\n      actions: [\n        'tag:GetResources',\n      ],\n      // Resource Groups Tagging API does not support resource-level permissions.\n      resources: ['*'],\n    }));\n    runningScheduleFunction.addToRolePolicy(new iam.PolicyStatement({\n      sid: 'Ec2DescribeInstances',\n      effect: iam.Effect.ALLOW,\n      actions: [\n        'ec2:DescribeInstances',\n      ],\n      // Describe* APIs do not support resource-level permissions or resource-tag conditions.\n      resources: ['*'],\n    }));\n    runningScheduleFunction.addToRolePolicy(\n      taggedInstanceStartStopStatement(this, props.targetResource),\n    );\n    // Grant read access to the Slack secret\n    slackSecret.grantRead(runningScheduleFunction);\n\n    this.failureDetection = createRunningSchedulerFailureDetection(this, 'FailureDetection', {\n      failureDetection: props.failureDetection,\n      runningScheduleFunction,\n      logGroup: runningScheduleFunctionLogGroup,\n    });\n\n    // See: https://docs.aws.amazon.com/lambda/latest/dg/durable-getting-started-iac.html\n    const runningScheduleFunctionAlias = runningScheduleFunction.addAlias('live');\n\n    // Whether schedules are enabled (default true unless explicitly disabled).\n    const scheduleEnabled: boolean = (() => {\n      if (props.enableScheduling === undefined || props.enableScheduling) {\n        return true;\n      } else {\n        return false;\n      }\n    })();\n\n    // Durable Functions: Lambda performs tag lookup and instance start/stop in a single run.\n    new scheduler.Schedule(this, 'RunningStartSchedule', {\n      description: 'running start schedule',\n      enabled: scheduleEnabled,\n      schedule: scheduler.ScheduleExpression.cron({\n        minute: props.startSchedule?.minute ?? '50',\n        hour: props.startSchedule?.hour ?? '7',\n        weekDay: props.startSchedule?.week ?? 'MON-FRI',\n        timeZone: props.startSchedule?.timezone ?? TimeZone.ETC_UTC,\n      }),\n      target: new targets.LambdaInvoke(runningScheduleFunctionAlias, {\n        input: scheduler.ScheduleTargetInput.fromObject({\n          Params: {\n            TagKey: props.targetResource.tagKey,\n            TagValues: props.targetResource.tagValues,\n            Mode: 'Start',\n          },\n        }),\n      }),\n    });\n\n    new scheduler.Schedule(this, 'RunningStopSchedule', {\n      description: 'running stop schedule',\n      enabled: scheduleEnabled,\n      schedule: scheduler.ScheduleExpression.cron({\n        minute: props.stopSchedule?.minute ?? '5',\n        hour: props.stopSchedule?.hour ?? '19',\n        weekDay: props.stopSchedule?.week ?? 'MON-FRI',\n        timeZone: props.stopSchedule?.timezone ?? TimeZone.ETC_UTC,\n      }),\n      target: new targets.LambdaInvoke(runningScheduleFunctionAlias, {\n        input: scheduler.ScheduleTargetInput.fromObject({\n          Params: {\n            TagKey: props.targetResource.tagKey,\n            TagValues: props.targetResource.tagValues,\n            Mode: 'Stop',\n          },\n        }),\n      }),\n    });\n  }\n}\n"]}

package/lib/constructs/running-scheduler-failure-detection.js

@@ -88,7 +88,7 @@ const createLogSumAlarm = (scope, id, props) => {
  * Custom metrics are published under the `EC2InstanceRunningScheduler` namespace.
  */
 class RunningSchedulerFailureDetection extends constructs_1.Construct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "ec2-instance-running-scheduler.RunningSchedulerFailureDetection", version: "0.3.6" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "ec2-instance-running-scheduler.RunningSchedulerFailureDetection", version: "0.4.1" };
     /** SNS topic used for alarm actions, when configured. */
     alarmTopic;
     /** Fires when the Lambda `Errors` metric is non-zero. */

package/lib/funcs/running-scheduler-predicates.d.ts

@@ -9,9 +9,13 @@ export interface ResourceWaitLimits {
     readonly maxLoopCount: number;
     /** Maximum wall-clock seconds from the first wait iteration before failing. */
     readonly maxElapsedSeconds: number;
+    /** Seconds between describe iterations after start/stop or while transitioning. */
+    readonly statusChangeWaitSeconds: number;
 }
 /** Default wait limits (90 loops × 20s wait ≈ 30 minutes of waits; 30 minutes elapsed). */
 export declare const DEFAULT_RESOURCE_WAIT_LIMITS: ResourceWaitLimits;
+/** Default bounded parallelism for durable `map` over target instances. */
+export declare const DEFAULT_MAX_CONCURRENCY = 10;
 /**
  * Why per-instance waiting stopped with an error.
  *

package/lib/funcs/running-scheduler-predicates.js

@@ -3,12 +3,15 @@
  * Pure predicates for the EC2 running scheduler Lambda (no AWS SDK).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatResourceWaitFailure = exports.getWaitAbortReason = exports.isTransitioningState = exports.isDesiredStableState = exports.DEFAULT_RESOURCE_WAIT_LIMITS = void 0;
+exports.formatResourceWaitFailure = exports.getWaitAbortReason = exports.isTransitioningState = exports.isDesiredStableState = exports.DEFAULT_MAX_CONCURRENCY = exports.DEFAULT_RESOURCE_WAIT_LIMITS = void 0;
 /** Default wait limits (90 loops × 20s wait ≈ 30 minutes of waits; 30 minutes elapsed). */
 exports.DEFAULT_RESOURCE_WAIT_LIMITS = {
     maxLoopCount: 90,
     maxElapsedSeconds: 1800,
+    statusChangeWaitSeconds: 20,
 };
+/** Default bounded parallelism for durable `map` over target instances. */
+exports.DEFAULT_MAX_CONCURRENCY = 10;
 /**
  * Whether the instance is already in the goal state for the scheduler mode (no start/stop needed).
  *
@@ -66,4 +69,4 @@ const formatResourceWaitFailure = (reason, context) => {
     return `ResourceWaitFailed:UnexpectedInstanceState: ${common}`;
 };
 exports.formatResourceWaitFailure = formatResourceWaitFailure;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"running-scheduler-predicates.js","sourceRoot":"","sources":["../../src/funcs/running-scheduler-predicates.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAaH,2FAA2F;AAC9E,QAAA,4BAA4B,GAAuB;IAC9D,YAAY,EAAE,EAAE;IAChB,iBAAiB,EAAE,IAAI;CACxB,CAAC;AAcF;;;;;;GAMG;AACI,MAAM,oBAAoB,GAAG,CAAC,IAA0B,EAAE,YAAoB,EAAW,EAAE,CAChG,CAAC,IAAI,KAAK,OAAO,IAAI,YAAY,KAAK,SAAS,CAAC,IAAI,CAAC,IAAI,KAAK,MAAM,IAAI,YAAY,KAAK,SAAS,CAAC,CAAC;AADzF,QAAA,oBAAoB,wBACqE;AAEtG;;;;;;GAMG;AACI,MAAM,oBAAoB,GAAG,CAAC,IAA0B,EAAE,YAAoB,EAAW,EAAE,CAChG,CAAC,IAAI,KAAK,OAAO,IAAI,YAAY,KAAK,SAAS,CAAC;IAChD,CAAC,IAAI,KAAK,MAAM,IAAI,CAAC,YAAY,KAAK,UAAU,IAAI,YAAY,KAAK,eAAe,CAAC,CAAC,CAAC;AAF5E,QAAA,oBAAoB,wBAEwD;AAEzF;;;;;;;;GAQG;AACI,MAAM,kBAAkB,GAAG,CAChC,SAAiB,EACjB,WAAmB,EACnB,KAAa,EACb,MAA0B,EACqC,EAAE;IACjE,IAAI,SAAS,IAAI,MAAM,CAAC,YAAY,EAAE,CAAC;QACrC,OAAO,sBAAsB,CAAC;IAChC,CAAC;IACD,MAAM,cAAc,GAAG,CAAC,KAAK,GAAG,WAAW,CAAC,GAAG,IAAI,CAAC;IACpD,IAAI,cAAc,IAAI,MAAM,CAAC,iBAAiB,EAAE,CAAC;QAC/C,OAAO,wBAAwB,CAAC;IAClC,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC,CAAC;AAdW,QAAA,kBAAkB,sBAc7B;AAgBF;;;;;;GAMG;AACI,MAAM,yBAAyB,GAAG,CACvC,MAAiC,EACjC,OAAmC,EAC3B,EAAE;IACV,MAAM,MAAM,GACV,cAAc,OAAO,CAAC,UAAU,SAAS,OAAO,CAAC,IAAI,iBAAiB,OAAO,CAAC,YAAY,cAAc,OAAO,CAAC,SAAS,EAAE,CAAC;IAC9H,IAAI,MAAM,KAAK,sBAAsB,EAAE,CAAC;QACtC,OAAO,4CAA4C,MAAM,iBAAiB,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;IAC1G,CAAC;IACD,IAAI,MAAM,KAAK,wBAAwB,EAAE,CAAC;QACxC,OAAO,8CAA8C,MAAM,sBAAsB,OAAO,CAAC,MAAM,CAAC,iBAAiB,EAAE,CAAC;IACtH,CAAC;IACD,OAAO,+CAA+C,MAAM,EAAE,CAAC;AACjE,CAAC,CAAC;AAbW,QAAA,yBAAyB,6BAapC","sourcesContent":["/**\n * Pure predicates for the EC2 running scheduler Lambda (no AWS SDK).\n */\n\n/** Value of `Params.Mode` from the EventBridge Scheduler payload. */\nexport type RunningSchedulerMode = 'Start' | 'Stop';\n\n/** Upper bounds for per-instance stable-state waiting in the running scheduler Lambda handler. */\nexport interface ResourceWaitLimits {\n  /** Maximum describe/wait loop iterations before failing (each loop may include a durable wait). */\n  readonly maxLoopCount: number;\n  /** Maximum wall-clock seconds from the first wait iteration before failing. */\n  readonly maxElapsedSeconds: number;\n}\n\n/** Default wait limits (90 loops × 20s wait ≈ 30 minutes of waits; 30 minutes elapsed). */\nexport const DEFAULT_RESOURCE_WAIT_LIMITS: ResourceWaitLimits = {\n  maxLoopCount: 90,\n  maxElapsedSeconds: 1800,\n};\n\n/**\n * Why per-instance waiting stopped with an error.\n *\n * - `MaxLoopCountExceeded` – {@link getWaitAbortReason} hit {@link ResourceWaitLimits.maxLoopCount}.\n * - `MaxElapsedTimeExceeded` – elapsed wall-clock time exceeded {@link ResourceWaitLimits.maxElapsedSeconds}.\n * - `UnexpectedInstanceState` – state is neither stable, actionable, nor a known transition.\n */\nexport type ResourceWaitFailureReason =\n  | 'MaxLoopCountExceeded'\n  | 'MaxElapsedTimeExceeded'\n  | 'UnexpectedInstanceState';\n\n/**\n * Whether the instance is already in the goal state for the scheduler mode (no start/stop needed).\n *\n * @param mode - `Start` expects `running`; `Stop` expects `stopped`.\n * @param currentState - Instance state from `DescribeInstances` (e.g. `running`, `pending`).\n * @returns `true` when the instance matches the target state for `mode`.\n */\nexport const isDesiredStableState = (mode: RunningSchedulerMode, currentState: string): boolean =>\n  (mode === 'Start' && currentState === 'running') || (mode === 'Stop' && currentState === 'stopped');\n\n/**\n * Whether the instance is in a known transitional state for the scheduler mode.\n *\n * @param mode - `Start` or `Stop`.\n * @param currentState - Instance state from `DescribeInstances`.\n * @returns `true` when the instance is moving toward the goal state for `mode`.\n */\nexport const isTransitioningState = (mode: RunningSchedulerMode, currentState: string): boolean =>\n  (mode === 'Start' && currentState === 'pending') ||\n  (mode === 'Stop' && (currentState === 'stopping' || currentState === 'shutting-down'));\n\n/**\n * Returns a wait abort reason when loop count or elapsed time exceeds configured limits.\n *\n * @param loopCount - Zero-based iteration count for the current wait loop.\n * @param startedAtMs - Epoch milliseconds recorded at the start of waiting (durable step).\n * @param nowMs - Current epoch milliseconds (from a durable step when replay matters).\n * @param limits - Configured {@link ResourceWaitLimits}.\n * @returns Abort reason, or `undefined` when waiting may continue.\n */\nexport const getWaitAbortReason = (\n  loopCount: number,\n  startedAtMs: number,\n  nowMs: number,\n  limits: ResourceWaitLimits,\n): 'MaxLoopCountExceeded' | 'MaxElapsedTimeExceeded' | undefined => {\n  if (loopCount >= limits.maxLoopCount) {\n    return 'MaxLoopCountExceeded';\n  }\n  const elapsedSeconds = (nowMs - startedAtMs) / 1000;\n  if (elapsedSeconds >= limits.maxElapsedSeconds) {\n    return 'MaxElapsedTimeExceeded';\n  }\n  return undefined;\n};\n\n/** Inputs for {@link formatResourceWaitFailure}. */\nexport interface ResourceWaitFailureContext {\n  /** EC2 instance id parsed from the target ARN. */\n  readonly identifier: string;\n  /** Scheduler mode from the invocation payload. */\n  readonly mode: RunningSchedulerMode;\n  /** Last observed instance state from `DescribeInstances`. */\n  readonly currentState: string;\n  /** Zero-based wait loop iteration when the failure occurred. */\n  readonly loopCount: number;\n  /** Active wait limits for limit-related failure messages. */\n  readonly limits: ResourceWaitLimits;\n}\n\n/**\n * Builds a stable, grep-friendly error message for wait failures.\n *\n * @param reason - Failure category.\n * @param context - Instance id, mode, state, loop count, and limits.\n * @returns Message prefixed with `ResourceWaitFailed:` (e.g. `ResourceWaitFailed:MaxLoopCountExceeded: ...`).\n */\nexport const formatResourceWaitFailure = (\n  reason: ResourceWaitFailureReason,\n  context: ResourceWaitFailureContext,\n): string => {\n  const common =\n    `identifier=${context.identifier} mode=${context.mode} currentState=${context.currentState} loopCount=${context.loopCount}`;\n  if (reason === 'MaxLoopCountExceeded') {\n    return `ResourceWaitFailed:MaxLoopCountExceeded: ${common} maxLoopCount=${context.limits.maxLoopCount}`;\n  }\n  if (reason === 'MaxElapsedTimeExceeded') {\n    return `ResourceWaitFailed:MaxElapsedTimeExceeded: ${common} maxElapsedSeconds=${context.limits.maxElapsedSeconds}`;\n  }\n  return `ResourceWaitFailed:UnexpectedInstanceState: ${common}`;\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"running-scheduler-predicates.js","sourceRoot":"","sources":["../../src/funcs/running-scheduler-predicates.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAeH,2FAA2F;AAC9E,QAAA,4BAA4B,GAAuB;IAC9D,YAAY,EAAE,EAAE;IAChB,iBAAiB,EAAE,IAAI;IACvB,uBAAuB,EAAE,EAAE;CAC5B,CAAC;AAEF,2EAA2E;AAC9D,QAAA,uBAAuB,GAAG,EAAE,CAAC;AAc1C;;;;;;GAMG;AACI,MAAM,oBAAoB,GAAG,CAAC,IAA0B,EAAE,YAAoB,EAAW,EAAE,CAChG,CAAC,IAAI,KAAK,OAAO,IAAI,YAAY,KAAK,SAAS,CAAC,IAAI,CAAC,IAAI,KAAK,MAAM,IAAI,YAAY,KAAK,SAAS,CAAC,CAAC;AADzF,QAAA,oBAAoB,wBACqE;AAEtG;;;;;;GAMG;AACI,MAAM,oBAAoB,GAAG,CAAC,IAA0B,EAAE,YAAoB,EAAW,EAAE,CAChG,CAAC,IAAI,KAAK,OAAO,IAAI,YAAY,KAAK,SAAS,CAAC;IAChD,CAAC,IAAI,KAAK,MAAM,IAAI,CAAC,YAAY,KAAK,UAAU,IAAI,YAAY,KAAK,eAAe,CAAC,CAAC,CAAC;AAF5E,QAAA,oBAAoB,wBAEwD;AAEzF;;;;;;;;GAQG;AACI,MAAM,kBAAkB,GAAG,CAChC,SAAiB,EACjB,WAAmB,EACnB,KAAa,EACb,MAA0B,EACqC,EAAE;IACjE,IAAI,SAAS,IAAI,MAAM,CAAC,YAAY,EAAE,CAAC;QACrC,OAAO,sBAAsB,CAAC;IAChC,CAAC;IACD,MAAM,cAAc,GAAG,CAAC,KAAK,GAAG,WAAW,CAAC,GAAG,IAAI,CAAC;IACpD,IAAI,cAAc,IAAI,MAAM,CAAC,iBAAiB,EAAE,CAAC;QAC/C,OAAO,wBAAwB,CAAC;IAClC,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC,CAAC;AAdW,QAAA,kBAAkB,sBAc7B;AAgBF;;;;;;GAMG;AACI,MAAM,yBAAyB,GAAG,CACvC,MAAiC,EACjC,OAAmC,EAC3B,EAAE;IACV,MAAM,MAAM,GACV,cAAc,OAAO,CAAC,UAAU,SAAS,OAAO,CAAC,IAAI,iBAAiB,OAAO,CAAC,YAAY,cAAc,OAAO,CAAC,SAAS,EAAE,CAAC;IAC9H,IAAI,MAAM,KAAK,sBAAsB,EAAE,CAAC;QACtC,OAAO,4CAA4C,MAAM,iBAAiB,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;IAC1G,CAAC;IACD,IAAI,MAAM,KAAK,wBAAwB,EAAE,CAAC;QACxC,OAAO,8CAA8C,MAAM,sBAAsB,OAAO,CAAC,MAAM,CAAC,iBAAiB,EAAE,CAAC;IACtH,CAAC;IACD,OAAO,+CAA+C,MAAM,EAAE,CAAC;AACjE,CAAC,CAAC;AAbW,QAAA,yBAAyB,6BAapC","sourcesContent":["/**\n * Pure predicates for the EC2 running scheduler Lambda (no AWS SDK).\n */\n\n/** Value of `Params.Mode` from the EventBridge Scheduler payload. */\nexport type RunningSchedulerMode = 'Start' | 'Stop';\n\n/** Upper bounds for per-instance stable-state waiting in the running scheduler Lambda handler. */\nexport interface ResourceWaitLimits {\n  /** Maximum describe/wait loop iterations before failing (each loop may include a durable wait). */\n  readonly maxLoopCount: number;\n  /** Maximum wall-clock seconds from the first wait iteration before failing. */\n  readonly maxElapsedSeconds: number;\n  /** Seconds between describe iterations after start/stop or while transitioning. */\n  readonly statusChangeWaitSeconds: number;\n}\n\n/** Default wait limits (90 loops × 20s wait ≈ 30 minutes of waits; 30 minutes elapsed). */\nexport const DEFAULT_RESOURCE_WAIT_LIMITS: ResourceWaitLimits = {\n  maxLoopCount: 90,\n  maxElapsedSeconds: 1800,\n  statusChangeWaitSeconds: 20,\n};\n\n/** Default bounded parallelism for durable `map` over target instances. */\nexport const DEFAULT_MAX_CONCURRENCY = 10;\n\n/**\n * Why per-instance waiting stopped with an error.\n *\n * - `MaxLoopCountExceeded` – {@link getWaitAbortReason} hit {@link ResourceWaitLimits.maxLoopCount}.\n * - `MaxElapsedTimeExceeded` – elapsed wall-clock time exceeded {@link ResourceWaitLimits.maxElapsedSeconds}.\n * - `UnexpectedInstanceState` – state is neither stable, actionable, nor a known transition.\n */\nexport type ResourceWaitFailureReason =\n  | 'MaxLoopCountExceeded'\n  | 'MaxElapsedTimeExceeded'\n  | 'UnexpectedInstanceState';\n\n/**\n * Whether the instance is already in the goal state for the scheduler mode (no start/stop needed).\n *\n * @param mode - `Start` expects `running`; `Stop` expects `stopped`.\n * @param currentState - Instance state from `DescribeInstances` (e.g. `running`, `pending`).\n * @returns `true` when the instance matches the target state for `mode`.\n */\nexport const isDesiredStableState = (mode: RunningSchedulerMode, currentState: string): boolean =>\n  (mode === 'Start' && currentState === 'running') || (mode === 'Stop' && currentState === 'stopped');\n\n/**\n * Whether the instance is in a known transitional state for the scheduler mode.\n *\n * @param mode - `Start` or `Stop`.\n * @param currentState - Instance state from `DescribeInstances`.\n * @returns `true` when the instance is moving toward the goal state for `mode`.\n */\nexport const isTransitioningState = (mode: RunningSchedulerMode, currentState: string): boolean =>\n  (mode === 'Start' && currentState === 'pending') ||\n  (mode === 'Stop' && (currentState === 'stopping' || currentState === 'shutting-down'));\n\n/**\n * Returns a wait abort reason when loop count or elapsed time exceeds configured limits.\n *\n * @param loopCount - Zero-based iteration count for the current wait loop.\n * @param startedAtMs - Epoch milliseconds recorded at the start of waiting (durable step).\n * @param nowMs - Current epoch milliseconds (from a durable step when replay matters).\n * @param limits - Configured {@link ResourceWaitLimits}.\n * @returns Abort reason, or `undefined` when waiting may continue.\n */\nexport const getWaitAbortReason = (\n  loopCount: number,\n  startedAtMs: number,\n  nowMs: number,\n  limits: ResourceWaitLimits,\n): 'MaxLoopCountExceeded' | 'MaxElapsedTimeExceeded' | undefined => {\n  if (loopCount >= limits.maxLoopCount) {\n    return 'MaxLoopCountExceeded';\n  }\n  const elapsedSeconds = (nowMs - startedAtMs) / 1000;\n  if (elapsedSeconds >= limits.maxElapsedSeconds) {\n    return 'MaxElapsedTimeExceeded';\n  }\n  return undefined;\n};\n\n/** Inputs for {@link formatResourceWaitFailure}. */\nexport interface ResourceWaitFailureContext {\n  /** EC2 instance id parsed from the target ARN. */\n  readonly identifier: string;\n  /** Scheduler mode from the invocation payload. */\n  readonly mode: RunningSchedulerMode;\n  /** Last observed instance state from `DescribeInstances`. */\n  readonly currentState: string;\n  /** Zero-based wait loop iteration when the failure occurred. */\n  readonly loopCount: number;\n  /** Active wait limits for limit-related failure messages. */\n  readonly limits: ResourceWaitLimits;\n}\n\n/**\n * Builds a stable, grep-friendly error message for wait failures.\n *\n * @param reason - Failure category.\n * @param context - Instance id, mode, state, loop count, and limits.\n * @returns Message prefixed with `ResourceWaitFailed:` (e.g. `ResourceWaitFailed:MaxLoopCountExceeded: ...`).\n */\nexport const formatResourceWaitFailure = (\n  reason: ResourceWaitFailureReason,\n  context: ResourceWaitFailureContext,\n): string => {\n  const common =\n    `identifier=${context.identifier} mode=${context.mode} currentState=${context.currentState} loopCount=${context.loopCount}`;\n  if (reason === 'MaxLoopCountExceeded') {\n    return `ResourceWaitFailed:MaxLoopCountExceeded: ${common} maxLoopCount=${context.limits.maxLoopCount}`;\n  }\n  if (reason === 'MaxElapsedTimeExceeded') {\n    return `ResourceWaitFailed:MaxElapsedTimeExceeded: ${common} maxElapsedSeconds=${context.limits.maxElapsedSeconds}`;\n  }\n  return `ResourceWaitFailed:UnexpectedInstanceState: ${common}`;\n};\n"]}

package/lib/funcs/running-scheduler-wait-config.d.ts

@@ -1,5 +1,5 @@
 /**
- * Environment variable names for per-instance wait limits.
+ * Environment variable names for running scheduler handler configuration.
  *
  * Values are set by {@link EC2InstanceRunningScheduler} and read at handler cold start.
  */
@@ -15,3 +15,15 @@ export declare const PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV = "PROCESS_RESOURCE_MAX
  * @see {@link parseResourceWaitLimitsFromEnv} in `running-scheduler-wait-env.ts`
  */
 export declare const PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV = "PROCESS_RESOURCE_MAX_ELAPSED_SECONDS";
+/**
+ * Lambda environment variable name for seconds between describe/wait iterations.
+ *
+ * @see {@link parseResourceWaitLimitsFromEnv} in `running-scheduler-wait-env.ts`
+ */
+export declare const PROCESS_RESOURCE_STATUS_CHANGE_WAIT_SECONDS_ENV = "PROCESS_RESOURCE_STATUS_CHANGE_WAIT_SECONDS";
+/**
+ * Lambda environment variable name for durable `map` bounded concurrency.
+ *
+ * @see {@link parseMaxConcurrencyFromEnv} in `running-scheduler-wait-env.ts`
+ */
+export declare const PROCESS_RESOURCES_MAX_CONCURRENCY_ENV = "PROCESS_RESOURCES_MAX_CONCURRENCY";

package/lib/funcs/running-scheduler-wait-config.js

@@ -1,11 +1,11 @@
 "use strict";
 /**
- * Environment variable names for per-instance wait limits.
+ * Environment variable names for running scheduler handler configuration.
  *
  * Values are set by {@link EC2InstanceRunningScheduler} and read at handler cold start.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV = exports.PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV = void 0;
+exports.PROCESS_RESOURCES_MAX_CONCURRENCY_ENV = exports.PROCESS_RESOURCE_STATUS_CHANGE_WAIT_SECONDS_ENV = exports.PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV = exports.PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV = void 0;
 /**
  * Lambda environment variable name for max wait loop count.
  *
@@ -18,4 +18,16 @@ exports.PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV = 'PROCESS_RESOURCE_MAX_LOOP_COUNT';
  * @see {@link parseResourceWaitLimitsFromEnv} in `running-scheduler-wait-env.ts`
  */
 exports.PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV = 'PROCESS_RESOURCE_MAX_ELAPSED_SECONDS';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVubmluZy1zY2hlZHVsZXItd2FpdC1jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZnVuY3MvcnVubmluZy1zY2hlZHVsZXItd2FpdC1jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7O0dBSUc7OztBQUVIOzs7O0dBSUc7QUFDVSxRQUFBLG1DQUFtQyxHQUFHLGlDQUFpQyxDQUFDO0FBRXJGOzs7O0dBSUc7QUFDVSxRQUFBLHdDQUF3QyxHQUFHLHNDQUFzQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFbnZpcm9ubWVudCB2YXJpYWJsZSBuYW1lcyBmb3IgcGVyLWluc3RhbmNlIHdhaXQgbGltaXRzLlxuICpcbiAqIFZhbHVlcyBhcmUgc2V0IGJ5IHtAbGluayBFQzJJbnN0YW5jZVJ1bm5pbmdTY2hlZHVsZXJ9IGFuZCByZWFkIGF0IGhhbmRsZXIgY29sZCBzdGFydC5cbiAqL1xuXG4vKipcbiAqIExhbWJkYSBlbnZpcm9ubWVudCB2YXJpYWJsZSBuYW1lIGZvciBtYXggd2FpdCBsb29wIGNvdW50LlxuICpcbiAqIEBzZWUge0BsaW5rIHBhcnNlUmVzb3VyY2VXYWl0TGltaXRzRnJvbUVudn0gaW4gYHJ1bm5pbmctc2NoZWR1bGVyLXdhaXQtZW52LnRzYFxuICovXG5leHBvcnQgY29uc3QgUFJPQ0VTU19SRVNPVVJDRV9NQVhfTE9PUF9DT1VOVF9FTlYgPSAnUFJPQ0VTU19SRVNPVVJDRV9NQVhfTE9PUF9DT1VOVCc7XG5cbi8qKlxuICogTGFtYmRhIGVudmlyb25tZW50IHZhcmlhYmxlIG5hbWUgZm9yIG1heCB3YWl0IGVsYXBzZWQgc2Vjb25kcy5cbiAqXG4gKiBAc2VlIHtAbGluayBwYXJzZVJlc291cmNlV2FpdExpbWl0c0Zyb21FbnZ9IGluIGBydW5uaW5nLXNjaGVkdWxlci13YWl0LWVudi50c2BcbiAqL1xuZXhwb3J0IGNvbnN0IFBST0NFU1NfUkVTT1VSQ0VfTUFYX0VMQVBTRURfU0VDT05EU19FTlYgPSAnUFJPQ0VTU19SRVNPVVJDRV9NQVhfRUxBUFNFRF9TRUNPTkRTJztcbiJdfQ==
+/**
+ * Lambda environment variable name for seconds between describe/wait iterations.
+ *
+ * @see {@link parseResourceWaitLimitsFromEnv} in `running-scheduler-wait-env.ts`
+ */
+exports.PROCESS_RESOURCE_STATUS_CHANGE_WAIT_SECONDS_ENV = 'PROCESS_RESOURCE_STATUS_CHANGE_WAIT_SECONDS';
+/**
+ * Lambda environment variable name for durable `map` bounded concurrency.
+ *
+ * @see {@link parseMaxConcurrencyFromEnv} in `running-scheduler-wait-env.ts`
+ */
+exports.PROCESS_RESOURCES_MAX_CONCURRENCY_ENV = 'PROCESS_RESOURCES_MAX_CONCURRENCY';
+//# sourceMappingURL=data:application/json;base64,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

package/lib/funcs/running-scheduler-wait-env.d.ts

@@ -3,7 +3,13 @@ import { type ResourceWaitLimits } from './running-scheduler-predicates';
  * Reads per-instance wait limits from Lambda environment variables set by the CDK construct.
  *
  * @returns Parsed limits, using {@link DEFAULT_RESOURCE_WAIT_LIMITS} when variables are unset.
- * @throws {import('strict-env-resolver').StrictEnvValidationError} When a set variable is not a finite number.
- * @throws {Error} When a set variable is zero or negative.
+ * @throws {import('strict-env-resolver').StrictEnvValidationError} When a set variable is not a positive integer.
  */
 export declare const parseResourceWaitLimitsFromEnv: () => ResourceWaitLimits;
+/**
+ * Reads durable `map` bounded concurrency from the Lambda environment.
+ *
+ * @returns Parsed concurrency, using {@link DEFAULT_MAX_CONCURRENCY} when unset.
+ * @throws {import('strict-env-resolver').StrictEnvValidationError} When a set variable is not a positive integer.
+ */
+export declare const parseMaxConcurrencyFromEnv: () => number;