ec2-instance-running-scheduler 0.1.8 → 0.2.0

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

@@ -29,6 +29,27 @@ export interface Secrets {
     /** Name of the Secrets Manager secret containing Slack token and channel. */
     readonly slackSecretName: string;
 }
+/**
+ * CDK-side limits for per-instance stable-state polling in the Durable Lambda handler.
+ *
+ * Values are written to {@link PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV} and
+ * {@link PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV} on the running scheduler function.
+ * Prevents abnormal or stuck transitions from running until the Durable execution timeout.
+ */
+export interface ResourcePollingLimits {
+    /**
+     * Maximum describe/poll loop iterations per instance.
+     *
+     * @default {@link DEFAULT_RESOURCE_POLLING_LIMITS.maxLoopCount} (90)
+     */
+    readonly maxLoopCount?: number;
+    /**
+     * Maximum wall-clock seconds spent polling a single instance.
+     *
+     * @default {@link DEFAULT_RESOURCE_POLLING_LIMITS.maxElapsedSeconds} (1800, 30 minutes)
+     */
+    readonly maxElapsedSeconds?: number;
+}
 /**
  * Properties for creating an EC2 instance running scheduler.
  */
@@ -43,12 +64,21 @@ export interface EC2InstanceRunningSchedulerProps {
     readonly stopSchedule?: Schedule;
     /** Cron schedule for starting instances. */
     readonly startSchedule?: Schedule;
+    /**
+     * Per-instance polling limits for the running scheduler Lambda.
+     *
+     * @default {@link DEFAULT_RESOURCE_POLLING_LIMITS}
+     */
+    readonly resourcePolling?: ResourcePollingLimits;
 }
 /**
  * Provisions EventBridge Scheduler rules and a Durable Execution Lambda that start/stop tagged EC2 instances.
  *
  * Each schedule invokes the function with `Params` (`TagKey`, `TagValues`, `Mode`). The function uses
  * the Resource Groups Tagging API and EC2 APIs; Slack notifications use the secret named in {@link Secrets.slackSecretName}.
+ *
+ * Per-instance polling timeouts are configured via {@link EC2InstanceRunningSchedulerProps.resourcePolling}
+ * and enforced in the handler before the Durable execution timeout.
  */
 export declare class EC2InstanceRunningScheduler extends Construct {
     /**
@@ -56,7 +86,7 @@ export declare class EC2InstanceRunningScheduler extends Construct {
      *
      * @param scope - Parent construct.
      * @param id - Construct id.
-     * @param props - Target tags, optional cron overrides, Slack secret name, and schedule enable flag.
+     * @param props - Target tags, schedules, Slack secret, schedule enable flag, and optional {@link ResourcePollingLimits}.
      */
     constructor(scope: Construct, id: string, props: EC2InstanceRunningSchedulerProps);
 }

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

@@ -12,11 +12,16 @@ const targets = require("aws-cdk-lib/aws-scheduler-targets");
 const aws_secretsmanager_1 = require("aws-cdk-lib/aws-secretsmanager");
 const constructs_1 = require("constructs");
 const running_scheduler_function_1 = require("../funcs/running-scheduler-function");
+const running_scheduler_polling_config_1 = require("../funcs/running-scheduler-polling-config");
+const running_scheduler_predicates_1 = require("../funcs/running-scheduler-predicates");
 /**
  * Provisions EventBridge Scheduler rules and a Durable Execution Lambda that start/stop tagged EC2 instances.
  *
  * Each schedule invokes the function with `Params` (`TagKey`, `TagValues`, `Mode`). The function uses
  * the Resource Groups Tagging API and EC2 APIs; Slack notifications use the secret named in {@link Secrets.slackSecretName}.
+ *
+ * Per-instance polling timeouts are configured via {@link EC2InstanceRunningSchedulerProps.resourcePolling}
+ * and enforced in the handler before the Durable execution timeout.
  */
 class EC2InstanceRunningScheduler extends constructs_1.Construct {
     /**
@@ -24,7 +29,7 @@ class EC2InstanceRunningScheduler extends constructs_1.Construct {
      *
      * @param scope - Parent construct.
      * @param id - Construct id.
-     * @param props - Target tags, optional cron overrides, Slack secret name, and schedule enable flag.
+     * @param props - Target tags, schedules, Slack secret, schedule enable flag, and optional {@link ResourcePollingLimits}.
      */
     constructor(scope, id, props) {
         super(scope, id);
@@ -43,6 +48,8 @@ class EC2InstanceRunningScheduler extends constructs_1.Construct {
             },
             environment: {
                 SLACK_SECRET_NAME: props.secrets.slackSecretName,
+                [running_scheduler_polling_config_1.PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV]: String(props.resourcePolling?.maxLoopCount ?? running_scheduler_predicates_1.DEFAULT_RESOURCE_POLLING_LIMITS.maxLoopCount),
+                [running_scheduler_polling_config_1.PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV]: String(props.resourcePolling?.maxElapsedSeconds ?? running_scheduler_predicates_1.DEFAULT_RESOURCE_POLLING_LIMITS.maxElapsedSeconds),
             },
             paramsAndSecrets: lambda.ParamsAndSecretsLayerVersion.fromVersion(lambda.ParamsAndSecretsVersions.V1_0_103, {
                 cacheSize: 500,
@@ -139,5 +146,5 @@ class EC2InstanceRunningScheduler extends constructs_1.Construct {
 }
 exports.EC2InstanceRunningScheduler = EC2InstanceRunningScheduler;
 _a = JSII_RTTI_SYMBOL_1;
-EC2InstanceRunningScheduler[_a] = { fqn: "ec2-instance-running-scheduler.EC2InstanceRunningScheduler", version: "0.1.8" };
-//# 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 { RunningSchedulerFunction } from '../funcs/running-scheduler-function';\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 * 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\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 */\nexport class EC2InstanceRunningScheduler extends Construct {\n  /**\n   * Defines IAM, logging, two cron schedules (start/stop), 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, optional cron overrides, Slack secret name, and schedule enable flag.\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 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      },\n      paramsAndSecrets: lambda.ParamsAndSecretsLayerVersion.fromVersion(lambda.ParamsAndSecretsVersions.V1_0_103, {\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: new logs.LogGroup(this, 'RunningSchedulerFunctionLogGroup', {\n        retention: logs.RetentionDays.THREE_MONTHS,\n        removalPolicy: RemovalPolicy.DESTROY,\n      }),\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    // 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"]}
+EC2InstanceRunningScheduler[_a] = { fqn: "ec2-instance-running-scheduler.EC2InstanceRunningScheduler", version: "0.2.0" };
+//# 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 { RunningSchedulerFunction } from '../funcs/running-scheduler-function';\nimport {\n  PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV,\n  PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV,\n} from '../funcs/running-scheduler-polling-config';\nimport { DEFAULT_RESOURCE_POLLING_LIMITS } from '../funcs/running-scheduler-predicates';\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 polling in the Durable Lambda handler.\n *\n * Values are written 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 */\nexport interface ResourcePollingLimits {\n  /**\n   * Maximum describe/poll loop iterations per instance.\n   *\n   * @default {@link DEFAULT_RESOURCE_POLLING_LIMITS.maxLoopCount} (90)\n   */\n  readonly maxLoopCount?: number;\n  /**\n   * Maximum wall-clock seconds spent polling a single instance.\n   *\n   * @default {@link DEFAULT_RESOURCE_POLLING_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 polling limits for the running scheduler Lambda.\n   *\n   * @default {@link DEFAULT_RESOURCE_POLLING_LIMITS}\n   */\n  readonly resourcePolling?: ResourcePollingLimits;\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 polling timeouts are configured via {@link EC2InstanceRunningSchedulerProps.resourcePolling}\n * and enforced in the handler before the Durable execution timeout.\n */\nexport class EC2InstanceRunningScheduler extends Construct {\n  /**\n   * Defines IAM, logging, two cron schedules (start/stop), 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, and optional {@link ResourcePollingLimits}.\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 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.resourcePolling?.maxLoopCount ?? DEFAULT_RESOURCE_POLLING_LIMITS.maxLoopCount,\n        ),\n        [PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV]: String(\n          props.resourcePolling?.maxElapsedSeconds ?? DEFAULT_RESOURCE_POLLING_LIMITS.maxElapsedSeconds,\n        ),\n      },\n      paramsAndSecrets: lambda.ParamsAndSecretsLayerVersion.fromVersion(lambda.ParamsAndSecretsVersions.V1_0_103, {\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: new logs.LogGroup(this, 'RunningSchedulerFunctionLogGroup', {\n        retention: logs.RetentionDays.THREE_MONTHS,\n        removalPolicy: RemovalPolicy.DESTROY,\n      }),\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    // 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/funcs/running-scheduler-polling-config.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Environment variable names for per-instance polling limits.
+ *
+ * Values are set by {@link EC2InstanceRunningScheduler} and read at handler cold start.
+ */
+/**
+ * Lambda environment variable name for max poll loop count.
+ *
+ * @see {@link parseResourcePollingLimitsFromEnv} in `running-scheduler-polling-env.ts`
+ */
+export declare const PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV = "PROCESS_RESOURCE_MAX_LOOP_COUNT";
+/**
+ * Lambda environment variable name for max poll elapsed seconds.
+ *
+ * @see {@link parseResourcePollingLimitsFromEnv} in `running-scheduler-polling-env.ts`
+ */
+export declare const PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV = "PROCESS_RESOURCE_MAX_ELAPSED_SECONDS";

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

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Environment variable names for per-instance polling limits.
+ *
+ * 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;
+/**
+ * Lambda environment variable name for max poll loop count.
+ *
+ * @see {@link parseResourcePollingLimitsFromEnv} in `running-scheduler-polling-env.ts`
+ */
+exports.PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV = 'PROCESS_RESOURCE_MAX_LOOP_COUNT';
+/**
+ * Lambda environment variable name for max poll elapsed seconds.
+ *
+ * @see {@link parseResourcePollingLimitsFromEnv} in `running-scheduler-polling-env.ts`
+ */
+exports.PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV = 'PROCESS_RESOURCE_MAX_ELAPSED_SECONDS';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVubmluZy1zY2hlZHVsZXItcG9sbGluZy1jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZnVuY3MvcnVubmluZy1zY2hlZHVsZXItcG9sbGluZy1jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7O0dBSUc7OztBQUVIOzs7O0dBSUc7QUFDVSxRQUFBLG1DQUFtQyxHQUFHLGlDQUFpQyxDQUFDO0FBRXJGOzs7O0dBSUc7QUFDVSxRQUFBLHdDQUF3QyxHQUFHLHNDQUFzQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFbnZpcm9ubWVudCB2YXJpYWJsZSBuYW1lcyBmb3IgcGVyLWluc3RhbmNlIHBvbGxpbmcgbGltaXRzLlxuICpcbiAqIFZhbHVlcyBhcmUgc2V0IGJ5IHtAbGluayBFQzJJbnN0YW5jZVJ1bm5pbmdTY2hlZHVsZXJ9IGFuZCByZWFkIGF0IGhhbmRsZXIgY29sZCBzdGFydC5cbiAqL1xuXG4vKipcbiAqIExhbWJkYSBlbnZpcm9ubWVudCB2YXJpYWJsZSBuYW1lIGZvciBtYXggcG9sbCBsb29wIGNvdW50LlxuICpcbiAqIEBzZWUge0BsaW5rIHBhcnNlUmVzb3VyY2VQb2xsaW5nTGltaXRzRnJvbUVudn0gaW4gYHJ1bm5pbmctc2NoZWR1bGVyLXBvbGxpbmctZW52LnRzYFxuICovXG5leHBvcnQgY29uc3QgUFJPQ0VTU19SRVNPVVJDRV9NQVhfTE9PUF9DT1VOVF9FTlYgPSAnUFJPQ0VTU19SRVNPVVJDRV9NQVhfTE9PUF9DT1VOVCc7XG5cbi8qKlxuICogTGFtYmRhIGVudmlyb25tZW50IHZhcmlhYmxlIG5hbWUgZm9yIG1heCBwb2xsIGVsYXBzZWQgc2Vjb25kcy5cbiAqXG4gKiBAc2VlIHtAbGluayBwYXJzZVJlc291cmNlUG9sbGluZ0xpbWl0c0Zyb21FbnZ9IGluIGBydW5uaW5nLXNjaGVkdWxlci1wb2xsaW5nLWVudi50c2BcbiAqL1xuZXhwb3J0IGNvbnN0IFBST0NFU1NfUkVTT1VSQ0VfTUFYX0VMQVBTRURfU0VDT05EU19FTlYgPSAnUFJPQ0VTU19SRVNPVVJDRV9NQVhfRUxBUFNFRF9TRUNPTkRTJztcbiJdfQ==

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

@@ -0,0 +1,8 @@
+import { type ResourcePollingLimits } from './running-scheduler-predicates';
+/**
+ * Reads per-instance polling limits from Lambda environment variables set by the CDK construct.
+ *
+ * @returns Parsed limits, using {@link DEFAULT_RESOURCE_POLLING_LIMITS} when variables are unset.
+ * @throws {Error} When a set variable is not a positive integer.
+ */
+export declare const parseResourcePollingLimitsFromEnv: () => ResourcePollingLimits;

package/lib/funcs/running-scheduler-polling-env.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseResourcePollingLimitsFromEnv = void 0;
+/**
+ * Lambda-only environment parsing for per-instance polling limits.
+ *
+ * Bundled into the running scheduler function; not imported from CDK constructs.
+ */
+const safe_env_getter_1 = require("safe-env-getter");
+const running_scheduler_polling_config_1 = require("./running-scheduler-polling-config");
+const running_scheduler_predicates_1 = require("./running-scheduler-predicates");
+/**
+ * Ensures a parsed env integer is strictly positive.
+ *
+ * `SafeEnvType.Number` accepts any decimal integer (including zero and negatives);
+ * polling limits require values greater than zero.
+ *
+ * @param key - Environment variable name used in error messages.
+ * @param value - Parsed integer from {@link SafeEnvGetter.getEnvs}.
+ * @returns `value` when it is greater than zero.
+ * @throws {Error} When `value` is zero or negative.
+ */
+const 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;
+};
+/**
+ * Reads per-instance polling limits from Lambda environment variables set by the CDK construct.
+ *
+ * @returns Parsed limits, using {@link DEFAULT_RESOURCE_POLLING_LIMITS} when variables are unset.
+ * @throws {Error} When a set variable is not a positive integer.
+ */
+const parseResourcePollingLimitsFromEnv = () => {
+    const parsed = safe_env_getter_1.SafeEnvGetter.getEnvs({
+        [running_scheduler_polling_config_1.PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV]: [
+            safe_env_getter_1.SafeEnvType.Number,
+            { default: running_scheduler_predicates_1.DEFAULT_RESOURCE_POLLING_LIMITS.maxLoopCount },
+        ],
+        [running_scheduler_polling_config_1.PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV]: [
+            safe_env_getter_1.SafeEnvType.Number,
+            { default: running_scheduler_predicates_1.DEFAULT_RESOURCE_POLLING_LIMITS.maxElapsedSeconds },
+        ],
+    });
+    return {
+        maxLoopCount: assertPositiveEnvInt(running_scheduler_polling_config_1.PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV, parsed[running_scheduler_polling_config_1.PROCESS_RESOURCE_MAX_LOOP_COUNT_ENV]),
+        maxElapsedSeconds: assertPositiveEnvInt(running_scheduler_polling_config_1.PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV, parsed[running_scheduler_polling_config_1.PROCESS_RESOURCE_MAX_ELAPSED_SECONDS_ENV]),
+    };
+};
+exports.parseResourcePollingLimitsFromEnv = parseResourcePollingLimitsFromEnv;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -3,6 +3,23 @@
  */
 /** Value of `Params.Mode` from the EventBridge Scheduler payload. */
 export type RunningSchedulerMode = 'Start' | 'Stop';
+/** Upper bounds for per-instance stable-state polling in the running scheduler Lambda. */
+export interface ResourcePollingLimits {
+    /** Maximum describe/poll iterations before failing (each loop may include a durable wait). */
+    readonly maxLoopCount: number;
+    /** Maximum wall-clock seconds from the first poll iteration before failing. */
+    readonly maxElapsedSeconds: number;
+}
+/** Default polling limits (90 loops × 20s wait ≈ 30 minutes of waits; 30 minutes elapsed). */
+export declare const DEFAULT_RESOURCE_POLLING_LIMITS: ResourcePollingLimits;
+/**
+ * Why per-instance polling stopped with an error.
+ *
+ * - `MaxLoopCountExceeded` – {@link getPollingAbortReason} hit {@link ResourcePollingLimits.maxLoopCount}.
+ * - `MaxElapsedTimeExceeded` – elapsed wall-clock time exceeded {@link ResourcePollingLimits.maxElapsedSeconds}.
+ * - `UnexpectedInstanceState` – state is neither stable, actionable, nor a known transition.
+ */
+export type ResourcePollingFailureReason = 'MaxLoopCountExceeded' | 'MaxElapsedTimeExceeded' | 'UnexpectedInstanceState';
 /**
  * Whether the instance is already in the goal state for the scheduler mode (no start/stop needed).
  *
@@ -11,3 +28,42 @@ export type RunningSchedulerMode = 'Start' | 'Stop';
  * @returns `true` when the instance matches the target state for `mode`.
  */
 export declare const isDesiredStableState: (mode: RunningSchedulerMode, currentState: string) => boolean;
+/**
+ * Whether the instance is in a known transitional state for the scheduler mode.
+ *
+ * @param mode - `Start` or `Stop`.
+ * @param currentState - Instance state from `DescribeInstances`.
+ * @returns `true` when the instance is moving toward the goal state for `mode`.
+ */
+export declare const isTransitioningState: (mode: RunningSchedulerMode, currentState: string) => boolean;
+/**
+ * Returns a polling abort reason when loop count or elapsed time exceeds configured limits.
+ *
+ * @param loopCount - Zero-based iteration count for the current poll loop.
+ * @param startedAtMs - Epoch milliseconds recorded at the start of polling (durable step).
+ * @param nowMs - Current epoch milliseconds (from a durable step when replay matters).
+ * @param limits - Configured {@link ResourcePollingLimits}.
+ * @returns Abort reason, or `undefined` when polling may continue.
+ */
+export declare const getPollingAbortReason: (loopCount: number, startedAtMs: number, nowMs: number, limits: ResourcePollingLimits) => "MaxLoopCountExceeded" | "MaxElapsedTimeExceeded" | undefined;
+/** Inputs for {@link formatResourcePollingFailure}. */
+export interface ResourcePollingFailureContext {
+    /** EC2 instance id parsed from the target ARN. */
+    readonly identifier: string;
+    /** Scheduler mode from the invocation payload. */
+    readonly mode: RunningSchedulerMode;
+    /** Last observed instance state from `DescribeInstances`. */
+    readonly currentState: string;
+    /** Zero-based poll loop iteration when the failure occurred. */
+    readonly loopCount: number;
+    /** Active polling limits for limit-related failure messages. */
+    readonly limits: ResourcePollingLimits;
+}
+/**
+ * Builds a stable, grep-friendly error message for polling failures.
+ *
+ * @param reason - Failure category.
+ * @param context - Instance id, mode, state, loop count, and limits.
+ * @returns Message prefixed with `ResourcePollingFailed:` (e.g. `ResourcePollingFailed:MaxLoopCountExceeded: ...`).
+ */
+export declare const formatResourcePollingFailure: (reason: ResourcePollingFailureReason, context: ResourcePollingFailureContext) => string;

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

@@ -3,7 +3,12 @@
  * Pure predicates for the EC2 running scheduler Lambda (no AWS SDK).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isDesiredStableState = void 0;
+exports.formatResourcePollingFailure = exports.getPollingAbortReason = exports.isTransitioningState = exports.isDesiredStableState = exports.DEFAULT_RESOURCE_POLLING_LIMITS = void 0;
+/** Default polling limits (90 loops × 20s wait ≈ 30 minutes of waits; 30 minutes elapsed). */
+exports.DEFAULT_RESOURCE_POLLING_LIMITS = {
+    maxLoopCount: 90,
+    maxElapsedSeconds: 1800,
+};
 /**
  * Whether the instance is already in the goal state for the scheduler mode (no start/stop needed).
  *
@@ -13,4 +18,52 @@ exports.isDesiredStableState = void 0;
  */
 const isDesiredStableState = (mode, currentState) => (mode === 'Start' && currentState === 'running') || (mode === 'Stop' && currentState === 'stopped');
 exports.isDesiredStableState = isDesiredStableState;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVubmluZy1zY2hlZHVsZXItcHJlZGljYXRlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9mdW5jcy9ydW5uaW5nLXNjaGVkdWxlci1wcmVkaWNhdGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7R0FFRzs7O0FBS0g7Ozs7OztHQU1HO0FBQ0ksTUFBTSxvQkFBb0IsR0FBRyxDQUFDLElBQTBCLEVBQUUsWUFBb0IsRUFBVyxFQUFFLENBQ2hHLENBQUMsSUFBSSxLQUFLLE9BQU8sSUFBSSxZQUFZLEtBQUssU0FBUyxDQUFDLElBQUksQ0FBQyxJQUFJLEtBQUssTUFBTSxJQUFJLFlBQVksS0FBSyxTQUFTLENBQUMsQ0FBQztBQUR6RixRQUFBLG9CQUFvQix3QkFDcUUiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFB1cmUgcHJlZGljYXRlcyBmb3IgdGhlIEVDMiBydW5uaW5nIHNjaGVkdWxlciBMYW1iZGEgKG5vIEFXUyBTREspLlxuICovXG5cbi8qKiBWYWx1ZSBvZiBgUGFyYW1zLk1vZGVgIGZyb20gdGhlIEV2ZW50QnJpZGdlIFNjaGVkdWxlciBwYXlsb2FkLiAqL1xuZXhwb3J0IHR5cGUgUnVubmluZ1NjaGVkdWxlck1vZGUgPSAnU3RhcnQnIHwgJ1N0b3AnO1xuXG4vKipcbiAqIFdoZXRoZXIgdGhlIGluc3RhbmNlIGlzIGFscmVhZHkgaW4gdGhlIGdvYWwgc3RhdGUgZm9yIHRoZSBzY2hlZHVsZXIgbW9kZSAobm8gc3RhcnQvc3RvcCBuZWVkZWQpLlxuICpcbiAqIEBwYXJhbSBtb2RlIC0gYFN0YXJ0YCBleHBlY3RzIGBydW5uaW5nYDsgYFN0b3BgIGV4cGVjdHMgYHN0b3BwZWRgLlxuICogQHBhcmFtIGN1cnJlbnRTdGF0ZSAtIEluc3RhbmNlIHN0YXRlIGZyb20gYERlc2NyaWJlSW5zdGFuY2VzYCAoZS5nLiBgcnVubmluZ2AsIGBwZW5kaW5nYCkuXG4gKiBAcmV0dXJucyBgdHJ1ZWAgd2hlbiB0aGUgaW5zdGFuY2UgbWF0Y2hlcyB0aGUgdGFyZ2V0IHN0YXRlIGZvciBgbW9kZWAuXG4gKi9cbmV4cG9ydCBjb25zdCBpc0Rlc2lyZWRTdGFibGVTdGF0ZSA9IChtb2RlOiBSdW5uaW5nU2NoZWR1bGVyTW9kZSwgY3VycmVudFN0YXRlOiBzdHJpbmcpOiBib29sZWFuID0+XG4gIChtb2RlID09PSAnU3RhcnQnICYmIGN1cnJlbnRTdGF0ZSA9PT0gJ3J1bm5pbmcnKSB8fCAobW9kZSA9PT0gJ1N0b3AnICYmIGN1cnJlbnRTdGF0ZSA9PT0gJ3N0b3BwZWQnKTtcbiJdfQ==
+/**
+ * Whether the instance is in a known transitional state for the scheduler mode.
+ *
+ * @param mode - `Start` or `Stop`.
+ * @param currentState - Instance state from `DescribeInstances`.
+ * @returns `true` when the instance is moving toward the goal state for `mode`.
+ */
+const isTransitioningState = (mode, currentState) => (mode === 'Start' && currentState === 'pending') ||
+    (mode === 'Stop' && (currentState === 'stopping' || currentState === 'shutting-down'));
+exports.isTransitioningState = isTransitioningState;
+/**
+ * Returns a polling abort reason when loop count or elapsed time exceeds configured limits.
+ *
+ * @param loopCount - Zero-based iteration count for the current poll loop.
+ * @param startedAtMs - Epoch milliseconds recorded at the start of polling (durable step).
+ * @param nowMs - Current epoch milliseconds (from a durable step when replay matters).
+ * @param limits - Configured {@link ResourcePollingLimits}.
+ * @returns Abort reason, or `undefined` when polling may continue.
+ */
+const getPollingAbortReason = (loopCount, startedAtMs, nowMs, limits) => {
+    if (loopCount >= limits.maxLoopCount) {
+        return 'MaxLoopCountExceeded';
+    }
+    const elapsedSeconds = (nowMs - startedAtMs) / 1000;
+    if (elapsedSeconds >= limits.maxElapsedSeconds) {
+        return 'MaxElapsedTimeExceeded';
+    }
+    return undefined;
+};
+exports.getPollingAbortReason = getPollingAbortReason;
+/**
+ * Builds a stable, grep-friendly error message for polling failures.
+ *
+ * @param reason - Failure category.
+ * @param context - Instance id, mode, state, loop count, and limits.
+ * @returns Message prefixed with `ResourcePollingFailed:` (e.g. `ResourcePollingFailed:MaxLoopCountExceeded: ...`).
+ */
+const formatResourcePollingFailure = (reason, context) => {
+    const common = `identifier=${context.identifier} mode=${context.mode} currentState=${context.currentState} loopCount=${context.loopCount}`;
+    if (reason === 'MaxLoopCountExceeded') {
+        return `ResourcePollingFailed:MaxLoopCountExceeded: ${common} maxLoopCount=${context.limits.maxLoopCount}`;
+    }
+    if (reason === 'MaxElapsedTimeExceeded') {
+        return `ResourcePollingFailed:MaxElapsedTimeExceeded: ${common} maxElapsedSeconds=${context.limits.maxElapsedSeconds}`;
+    }
+    return `ResourcePollingFailed:UnexpectedInstanceState: ${common}`;
+};
+exports.formatResourcePollingFailure = formatResourcePollingFailure;
+//# 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,8FAA8F;AACjF,QAAA,+BAA+B,GAA0B;IACpE,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,qBAAqB,GAAG,CACnC,SAAiB,EACjB,WAAmB,EACnB,KAAa,EACb,MAA6B,EACkC,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,qBAAqB,yBAchC;AAgBF;;;;;;GAMG;AACI,MAAM,4BAA4B,GAAG,CAC1C,MAAoC,EACpC,OAAsC,EAC9B,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,+CAA+C,MAAM,iBAAiB,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;IAC7G,CAAC;IACD,IAAI,MAAM,KAAK,wBAAwB,EAAE,CAAC;QACxC,OAAO,iDAAiD,MAAM,sBAAsB,OAAO,CAAC,MAAM,CAAC,iBAAiB,EAAE,CAAC;IACzH,CAAC;IACD,OAAO,kDAAkD,MAAM,EAAE,CAAC;AACpE,CAAC,CAAC;AAbW,QAAA,4BAA4B,gCAavC","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 polling in the running scheduler Lambda. */\nexport interface ResourcePollingLimits {\n  /** Maximum describe/poll iterations before failing (each loop may include a durable wait). */\n  readonly maxLoopCount: number;\n  /** Maximum wall-clock seconds from the first poll iteration before failing. */\n  readonly maxElapsedSeconds: number;\n}\n\n/** Default polling limits (90 loops × 20s wait ≈ 30 minutes of waits; 30 minutes elapsed). */\nexport const DEFAULT_RESOURCE_POLLING_LIMITS: ResourcePollingLimits = {\n  maxLoopCount: 90,\n  maxElapsedSeconds: 1800,\n};\n\n/**\n * Why per-instance polling stopped with an error.\n *\n * - `MaxLoopCountExceeded` – {@link getPollingAbortReason} hit {@link ResourcePollingLimits.maxLoopCount}.\n * - `MaxElapsedTimeExceeded` – elapsed wall-clock time exceeded {@link ResourcePollingLimits.maxElapsedSeconds}.\n * - `UnexpectedInstanceState` – state is neither stable, actionable, nor a known transition.\n */\nexport type ResourcePollingFailureReason =\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 polling abort reason when loop count or elapsed time exceeds configured limits.\n *\n * @param loopCount - Zero-based iteration count for the current poll loop.\n * @param startedAtMs - Epoch milliseconds recorded at the start of polling (durable step).\n * @param nowMs - Current epoch milliseconds (from a durable step when replay matters).\n * @param limits - Configured {@link ResourcePollingLimits}.\n * @returns Abort reason, or `undefined` when polling may continue.\n */\nexport const getPollingAbortReason = (\n  loopCount: number,\n  startedAtMs: number,\n  nowMs: number,\n  limits: ResourcePollingLimits,\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 formatResourcePollingFailure}. */\nexport interface ResourcePollingFailureContext {\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 poll loop iteration when the failure occurred. */\n  readonly loopCount: number;\n  /** Active polling limits for limit-related failure messages. */\n  readonly limits: ResourcePollingLimits;\n}\n\n/**\n * Builds a stable, grep-friendly error message for polling failures.\n *\n * @param reason - Failure category.\n * @param context - Instance id, mode, state, loop count, and limits.\n * @returns Message prefixed with `ResourcePollingFailed:` (e.g. `ResourcePollingFailed:MaxLoopCountExceeded: ...`).\n */\nexport const formatResourcePollingFailure = (\n  reason: ResourcePollingFailureReason,\n  context: ResourcePollingFailureContext,\n): string => {\n  const common =\n    `identifier=${context.identifier} mode=${context.mode} currentState=${context.currentState} loopCount=${context.loopCount}`;\n  if (reason === 'MaxLoopCountExceeded') {\n    return `ResourcePollingFailed:MaxLoopCountExceeded: ${common} maxLoopCount=${context.limits.maxLoopCount}`;\n  }\n  if (reason === 'MaxElapsedTimeExceeded') {\n    return `ResourcePollingFailed:MaxElapsedTimeExceeded: ${common} maxElapsedSeconds=${context.limits.maxElapsedSeconds}`;\n  }\n  return `ResourcePollingFailed:UnexpectedInstanceState: ${common}`;\n};\n"]}

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

@@ -6,8 +6,13 @@
  *
  * @see https://docs.aws.amazon.com/lambda/latest/dg/durable-execution-sdk.html
  */
-/** Event payload from EventBridge Scheduler invoking this Lambda. */
+/**
+ * Event payload from EventBridge Scheduler invoking this Lambda.
+ *
+ * @see {@link handler}
+ */
 export interface SchedulerEvent {
+    /** Scheduler invocation parameters (tag filter and start/stop mode). */
     Params: {
         /** Tag key used to select EC2 instances. */
         TagKey: string;
@@ -24,11 +29,15 @@ export interface SchedulerEvent {
  * in parallel (bounded concurrency), posts a parent Slack message and per-instance thread replies,
  * and uses durable `step` / `wait` / `map` so the run can resume across suspensions.
  *
+ * Reads per-instance polling limits from `PROCESS_RESOURCE_MAX_LOOP_COUNT` and
+ * `PROCESS_RESOURCE_MAX_ELAPSED_SECONDS` via {@link parseResourcePollingLimitsFromEnv}.
+ *
  * @param event - Payload from EventBridge Scheduler; must include `Params.TagKey`, `Params.TagValues`, `Params.Mode`.
  * @param ctx - Root durable execution context.
  * @returns
  * - `{ status: 'TargetResourcesNotFound' }` when no instances match the tag filter.
- * - `{ status: 'Completed', processed, results }` when instances were handled (`results` entries match {@link processOneResource}).
- * @throws {Error} If `Params` is invalid, `SLACK_SECRET_NAME` is unset, the Slack secret is incomplete, or instance processing fails.
+ * - `{ status: 'Completed', processed, results }` when instances were handled (`results` entries match {@link processOneResource} return shape).
+ * @throws {Error} If `Params` is invalid, polling env vars are invalid, `SLACK_SECRET_NAME` is unset,
+ *   the Slack secret is incomplete, or instance processing fails (including `ResourcePollingFailed:*` errors).
  */
 export declare const handler: import("@aws/durable-execution-sdk-js").DurableLambdaHandler;