@kensio/yulin 1.21.25 → 1.21.27

package/dist/service/eventbridge/target/sim-event-target-retry-policy.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A target's `RetryPolicy`, as a request or a template carries it.
+ */
+export interface SimEventTargetRetryPolicyInput {
+    readonly MaximumEventAgeInSeconds?: number | undefined;
+    readonly MaximumRetryAttempts?: number | undefined;
+}
+/**
+ * The retry limits one target declares, and the values they come to.
+ *
+ * A limit the policy leaves out takes EventBridge's own default, which is 185
+ * retries over at most 24 hours.
+ */
+export declare class SimEventTargetRetryPolicy {
+    readonly declared: SimEventTargetRetryPolicyInput;
+    readonly maximumEventAgeInSeconds: number;
+    readonly maximumRetryAttempts: number;
+    private constructor();
+    /**
+     * Read the retry policy a target may leave out.
+     */
+    static optional(policy: SimEventTargetRetryPolicyInput | undefined): SimEventTargetRetryPolicy | undefined;
+    /**
+     * Read a retry policy, refusing values outside EventBridge's ranges.
+     */
+    static of(policy: SimEventTargetRetryPolicyInput): SimEventTargetRetryPolicy;
+    private static requireWholeNumber;
+}

package/dist/service/eventbridge/target/sim-event-target-retry-policy.js

@@ -0,0 +1,53 @@
+import { SimEventBridgeValidationException } from "../error/sim-event-bridge.error.js";
+/**
+ * The longest EventBridge keeps retrying an event, and the most retries it
+ * makes, when a target's retry policy leaves either out.
+ */
+const defaultMaximumEventAgeInSeconds = 86_400;
+const defaultMaximumRetryAttempts = 185;
+const minimumEventAgeInSeconds = 60;
+/**
+ * The retry limits one target declares, and the values they come to.
+ *
+ * A limit the policy leaves out takes EventBridge's own default, which is 185
+ * retries over at most 24 hours.
+ */
+export class SimEventTargetRetryPolicy {
+    declared;
+    maximumEventAgeInSeconds;
+    maximumRetryAttempts;
+    constructor(policy) {
+        this.declared = { ...policy };
+        this.maximumEventAgeInSeconds =
+            policy.MaximumEventAgeInSeconds ?? defaultMaximumEventAgeInSeconds;
+        this.maximumRetryAttempts =
+            policy.MaximumRetryAttempts ?? defaultMaximumRetryAttempts;
+    }
+    /**
+     * Read the retry policy a target may leave out.
+     */
+    static optional(policy) {
+        if (policy === undefined) {
+            return undefined;
+        }
+        return this.of(policy);
+    }
+    /**
+     * Read a retry policy, refusing values outside EventBridge's ranges.
+     */
+    static of(policy) {
+        this.requireWholeNumber("MaximumEventAgeInSeconds", policy.MaximumEventAgeInSeconds, minimumEventAgeInSeconds, defaultMaximumEventAgeInSeconds);
+        this.requireWholeNumber("MaximumRetryAttempts", policy.MaximumRetryAttempts, 0, defaultMaximumRetryAttempts);
+        return new this(policy);
+    }
+    static requireWholeNumber(name, value, minimum, maximum) {
+        if (value === undefined) {
+            return;
+        }
+        if (!Number.isSafeInteger(value) || value < minimum || value > maximum) {
+            throw new SimEventBridgeValidationException(`Invalid parameter: Target RetryPolicy ${name} Reason: it is a whole ` +
+                `number between ${String(minimum)} and ${String(maximum)}, and ` +
+                `${String(value)} is not.`);
+        }
+    }
+}

package/dist/service/eventbridge/target/sim-event-target.d.ts

@@ -1,4 +1,6 @@
 import { SimEventTargetArn } from "./sim-event-target-arn.js";
+import { SimEventTargetDeadLetterConfig, type SimEventTargetDeadLetterConfigInput } from "./sim-event-target-dead-letter-config.js";
+import { SimEventTargetRetryPolicy, type SimEventTargetRetryPolicyInput } from "./sim-event-target-retry-policy.js";
 import { SimEventTargetEcs, type SimEventTargetTaskProperties } from "./sim-event-target-ecs.js";
 /**
  * One place a rule sends the events it matches.
@@ -29,6 +31,19 @@ export declare class SimEventTarget {
      * is what the task overrides instead.
      */
     readonly ecs: SimEventTargetEcs | undefined;
+    /**
+     * How long and how often a failed delivery is retried, where the target
+     * says.
+     *
+     * A target without one is delivered once. Real EventBridge retries such a
+     * target for up to 24 hours by default, and that divergence is documented.
+     */
+    readonly retryPolicy: SimEventTargetRetryPolicy | undefined;
+    /**
+     * The queue an event goes to once delivery is given up, where the target
+     * names one.
+     */
+    readonly deadLetterConfig: SimEventTargetDeadLetterConfig | undefined;
     private constructor();
     /**
      * Read a target from request input.
@@ -36,6 +51,8 @@ export declare class SimEventTarget {
     static of(properties: SimEventTargetTaskProperties & {
         readonly Id?: string | undefined;
         readonly Arn?: string | undefined;
+        readonly RetryPolicy?: SimEventTargetRetryPolicyInput | undefined;
+        readonly DeadLetterConfig?: SimEventTargetDeadLetterConfigInput | undefined;
     }): SimEventTarget;
     /**
      * Read a target's fixed input, which has to be JSON.

package/dist/service/eventbridge/target/sim-event-target.js

@@ -1,5 +1,7 @@
 import { SimEventBridgeValidationException } from "../error/sim-event-bridge.error.js";
 import { SimEventTargetArn } from "./sim-event-target-arn.js";
+import { SimEventTargetDeadLetterConfig, } from "./sim-event-target-dead-letter-config.js";
+import { SimEventTargetRetryPolicy, } from "./sim-event-target-retry-policy.js";
 import { SimEventTargetEcs, } from "./sim-event-target-ecs.js";
 /**
  * Real EventBridge allows alphanumerics, full stops, hyphens and underscores,
@@ -35,11 +37,26 @@ export class SimEventTarget {
      * is what the task overrides instead.
      */
     ecs;
+    /**
+     * How long and how often a failed delivery is retried, where the target
+     * says.
+     *
+     * A target without one is delivered once. Real EventBridge retries such a
+     * target for up to 24 hours by default, and that divergence is documented.
+     */
+    retryPolicy;
+    /**
+     * The queue an event goes to once delivery is given up, where the target
+     * names one.
+     */
+    deadLetterConfig;
     constructor(properties) {
         this.id = properties.id;
         this.arn = properties.arn;
         this.input = properties.input;
         this.ecs = properties.ecs;
+        this.retryPolicy = properties.retryPolicy;
+        this.deadLetterConfig = properties.deadLetterConfig;
     }
     /**
      * Read a target from request input.
@@ -51,6 +68,8 @@ export class SimEventTarget {
             arn,
             input: this.readInput(properties.Input),
             ecs: SimEventTargetEcs.of(arn, properties),
+            retryPolicy: SimEventTargetRetryPolicy.optional(properties.RetryPolicy),
+            deadLetterConfig: SimEventTargetDeadLetterConfig.optional(properties.DeadLetterConfig),
         });
     }
     /**

package/dist/service/scheduler/cfn/sim-cfn-schedule-properties.d.ts

@@ -33,10 +33,6 @@ export declare class SimCfnScheduleProperties {
      * than refusing it for being the wrong type.
      */
     scheduleInput(): SimSchedulerScheduleInput;
-    /**
-     * The time window, which AWS requires on this Resource type.
-     */
-    private flexibleTimeWindow;
     /**
      * The schedule's target, which AWS requires on this Resource type.
      *

package/dist/service/scheduler/cfn/sim-cfn-schedule-properties.js

@@ -1,6 +1,7 @@
 import { isRecord } from "../../../util/type-guard/record.js";
 import { SimCfnGeneratedResourceName } from "../../cloudformation/resource/name/sim-cfn-generated-resource-name.js";
 import { schedulerScheduleResourceType, simCfnSchedulerResourceError, } from "./sim-cfn-scheduler-resource-error.js";
+import { cfnFlexibleTimeWindow } from "./sim-cfn-schedule-time-window.js";
 const maximumNameLength = 64;
 /**
  * Reads AWS::Scheduler::Schedule properties into the shape CreateSchedule
@@ -52,7 +53,7 @@ export class SimCfnScheduleProperties {
             GroupName: this.stringProperty("GroupName"),
             ScheduleExpression: this.stringProperty("ScheduleExpression"),
             ScheduleExpressionTimezone: this.stringProperty("ScheduleExpressionTimezone"),
-            FlexibleTimeWindow: this.flexibleTimeWindow(),
+            FlexibleTimeWindow: cfnFlexibleTimeWindow(this.properties.get("FlexibleTimeWindow"), (reason) => this.propertyError(reason)),
             Target: this.target(),
             State: this.stringProperty("State"),
             Description: this.stringProperty("Description"),
@@ -62,24 +63,6 @@ export class SimCfnScheduleProperties {
             KmsKeyArn: this.stringProperty("KmsKeyArn"),
         };
     }
-    /**
-     * The time window, which AWS requires on this Resource type.
-     */
-    flexibleTimeWindow() {
-        const window = this.properties.get("FlexibleTimeWindow");
-        if (window === undefined) {
-            return undefined;
-        }
-        if (!isRecord(window)) {
-            throw this.propertyError("FlexibleTimeWindow is an object");
-        }
-        return {
-            Mode: typeof window["Mode"] === "string" ? window["Mode"] : undefined,
-            MaximumWindowInMinutes: typeof window["MaximumWindowInMinutes"] === "number"
-                ? window["MaximumWindowInMinutes"]
-                : undefined,
-        };
-    }
     /**
      * The schedule's target, which AWS requires on this Resource type.
      *

package/dist/service/scheduler/cfn/sim-cfn-schedule-time-window.d.ts

@@ -0,0 +1,10 @@
+import type { SimCfnTemplateValue } from "../../cloudformation/template/value/sim-cfn-template-value.js";
+import type { SimSchedulerFlexibleTimeWindow } from "../command/schedule/schedule.command.js";
+/**
+ * Read an `AWS::Scheduler::Schedule` time window into the shape
+ * CreateSchedule takes.
+ *
+ * Whether the window is valid is left to simulated Scheduler, so a template
+ * and an SDK request are refused for the same reasons.
+ */
+export declare function cfnFlexibleTimeWindow(window: SimCfnTemplateValue | undefined, propertyError: (reason: string) => Error): SimSchedulerFlexibleTimeWindow | undefined;

package/dist/service/scheduler/cfn/sim-cfn-schedule-time-window.js

@@ -0,0 +1,37 @@
+import { isRecord } from "../../../util/type-guard/record.js";
+/**
+ * Read a window length, which a template may give as a number or, through a
+ * Number Parameter, as a numeric string such as "15" or "15.0". Whether the
+ * number is a valid length is left to simulated Scheduler.
+ */
+function windowMinutes(value, propertyError) {
+    if (value === undefined || typeof value === "number") {
+        return value;
+    }
+    if (typeof value === "string" && value.trim() !== "") {
+        const minutes = Number(value);
+        if (Number.isFinite(minutes)) {
+            return minutes;
+        }
+    }
+    throw propertyError("FlexibleTimeWindow MaximumWindowInMinutes is a number");
+}
+/**
+ * Read an `AWS::Scheduler::Schedule` time window into the shape
+ * CreateSchedule takes.
+ *
+ * Whether the window is valid is left to simulated Scheduler, so a template
+ * and an SDK request are refused for the same reasons.
+ */
+export function cfnFlexibleTimeWindow(window, propertyError) {
+    if (window === undefined) {
+        return undefined;
+    }
+    if (!isRecord(window)) {
+        throw propertyError("FlexibleTimeWindow is an object");
+    }
+    return {
+        Mode: typeof window["Mode"] === "string" ? window["Mode"] : undefined,
+        MaximumWindowInMinutes: windowMinutes(window["MaximumWindowInMinutes"], propertyError),
+    };
+}

package/dist/service/scheduler/command/schedule/sim-scheduler-described-schedule.d.ts

@@ -5,8 +5,7 @@ import type { SimGetScheduleCommandOutput, SimSchedulerListedSchedule } from "./
  *
  * The expression comes back as the string it was created with rather than a
  * re-serialised version of it, so a caller comparing what they read against
- * what they sent sees what they sent. `FlexibleTimeWindow` always reports `OFF`
- * because that is the only mode this simulation takes.
+ * what they sent sees what they sent. The same goes for `FlexibleTimeWindow`.
  */
 export declare function describedSchedule(schedule: SimSchedulerSchedule): Omit<SimGetScheduleCommandOutput, "$metadata">;
 /**

package/dist/service/scheduler/command/schedule/sim-scheduler-described-schedule.js

@@ -3,8 +3,7 @@
  *
  * The expression comes back as the string it was created with rather than a
  * re-serialised version of it, so a caller comparing what they read against
- * what they sent sees what they sent. `FlexibleTimeWindow` always reports `OFF`
- * because that is the only mode this simulation takes.
+ * what they sent sees what they sent. The same goes for `FlexibleTimeWindow`.
  */
 export function describedSchedule(schedule) {
     return {
@@ -16,7 +15,7 @@ export function describedSchedule(schedule) {
         State: schedule.state.value,
         Description: schedule.description,
         ActionAfterCompletion: schedule.actionAfterCompletion,
-        FlexibleTimeWindow: { Mode: "OFF" },
+        FlexibleTimeWindow: schedule.timeWindow.declared,
         Target: {
             Arn: schedule.target.arn.value,
             RoleArn: schedule.target.roleArn,

package/dist/service/scheduler/command/schedule/sim-scheduler-schedule-writer.js

@@ -2,6 +2,7 @@ import { schedulerSchedule } from "../../schedule/sim-scheduler-schedule-express
 import { actionAfterCompletionIn } from "../../schedule/sim-scheduler-action-after-completion.js";
 import { SimSchedulerSchedule } from "../../schedule/sim-scheduler-schedule.js";
 import { SimSchedulerScheduleState } from "../../schedule/sim-scheduler-schedule-state.js";
+import { SimSchedulerTimeWindow } from "../../schedule/sim-scheduler-time-window.js";
 import { SimSchedulerTarget } from "../../target/sim-scheduler-target.js";
 import { refuseUnsimulatedScheduleInput } from "./sim-scheduler-unsimulated-input.js";
 /**
@@ -27,6 +28,7 @@ export class SimSchedulerScheduleWriter {
      * replacing a schedule does not create a new one as far as AWS is concerned.
      */
     write(input, requested, createdAt) {
+        const timeWindow = SimSchedulerTimeWindow.of(input.FlexibleTimeWindow);
         refuseUnsimulatedScheduleInput(input);
         const now = this.clock.now();
         const schedule = new SimSchedulerSchedule({
@@ -35,6 +37,7 @@ export class SimSchedulerScheduleWriter {
             accountRegionScope: this.accountRegionScope,
             schedule: schedulerSchedule(input.ScheduleExpression, input.ScheduleExpressionTimezone),
             timeZone: input.ScheduleExpressionTimezone,
+            timeWindow,
             target: SimSchedulerTarget.of(input.Target),
             state: SimSchedulerScheduleState.of(input.State),
             actionAfterCompletion: actionAfterCompletionIn(input.ActionAfterCompletion),

package/dist/service/scheduler/command/schedule/sim-scheduler-unsimulated-input.js

@@ -18,30 +18,6 @@ function refuseUnknownTimezone(timezone) {
             `as 'Europe/London', or 'UTC'`);
     }
 }
-/**
- * Read the flexible time window, which AWS requires on every request.
- *
- * `FLEXIBLE` is refused rather than treated as `OFF`. The whole point of it is
- * that AWS invokes the target at some unpredictable moment inside the window,
- * and a simulation firing at the exact due time instead would let a test assert
- * on a precision real Scheduler does not offer.
- */
-function refuseFlexibleWindow(input) {
-    const mode = input.FlexibleTimeWindow?.Mode;
-    if (mode === undefined) {
-        throw new SimSchedulerValidationException("FlexibleTimeWindow is required, and its Mode is OFF or FLEXIBLE");
-    }
-    if (mode === "FLEXIBLE") {
-        throw new SimSchedulerUnsimulatedInputException("FlexibleTimeWindow Mode FLEXIBLE is not simulated. Real Scheduler " +
-            "invokes the target at an unpredictable moment inside the window, " +
-            "and firing at the exact due time instead would let a test rely on " +
-            "timing AWS does not promise. Use Mode OFF.");
-    }
-    if (mode !== "OFF") {
-        throw new SimSchedulerValidationException(`Invalid parameter: FlexibleTimeWindow Mode Reason: '${mode}' is not a ` +
-            `mode. A window is OFF or FLEXIBLE.`);
-    }
-}
 /**
  * Refuse the schedule request inputs this simulation does not model.
  *
@@ -50,7 +26,6 @@ function refuseFlexibleWindow(input) {
  * `ScheduleExpression` and send the caller to the wrong parameter.
  */
 export function refuseUnsimulatedScheduleInput(input) {
-    refuseFlexibleWindow(input);
     refuseUnsimulatedTarget(input.Target);
     refuseUnknownTimezone(input.ScheduleExpressionTimezone);
     if (input.StartDate !== undefined || input.EndDate !== undefined) {

package/dist/service/scheduler/command/sim-scheduler-commands.d.ts

@@ -1,4 +1,5 @@
 import type { BackgroundScheduler } from "../../../util/background/background.js";
+import type { SimRandom } from "../../../util/random/sim-random.js";
 import type { SimAwsAccountRegionScope } from "../../aws/sim-aws-account-region-scope.js";
 import type { SimIamInterServiceAuthZ } from "../../iam/authorize/sim-iam-inter-service-auth-z.js";
 import type { SimSchedulerDeliveryTargets } from "../delivery/sim-scheduler-delivery.js";
@@ -17,6 +18,7 @@ interface SimSchedulerCommandsProperties {
     readonly background: BackgroundScheduler;
     readonly deliveryTargets?: SimSchedulerDeliveryTargets | undefined;
     readonly accountRegionScope: SimAwsAccountRegionScope;
+    readonly random: SimRandom;
 }
 /**
  * Every command handler one simulated Scheduler scope delegates to.

package/dist/service/scheduler/command/sim-scheduler-commands.js

@@ -43,6 +43,7 @@ export class SimSchedulerCommands {
             schedules,
             delivery: this.delivery,
             background,
+            random: properties.random,
         });
         this.scheduleCreation = new SimSchedulerCreateSchedule({
             schedules,

package/dist/service/scheduler/schedule/sim-scheduler-pending-occurrences.d.ts

@@ -0,0 +1,23 @@
+import type { SimSchedulerSchedule } from "./sim-scheduler-schedule.js";
+/**
+ * The occurrences of each schedule that have fallen due and are waiting
+ * inside a flexible window to be invoked.
+ *
+ * A window longer than the gap between due instants lets occurrences overlap,
+ * and a finite schedule's last occurrence can then be invoked before an
+ * earlier one. The schedule has completed once its last occurrence has fallen
+ * due and nothing is left waiting.
+ */
+export declare class SimSchedulerPendingOccurrences {
+    private readonly waiting;
+    private readonly lastFallenDue;
+    /**
+     * Note an occurrence that has fallen due and will be invoked later.
+     */
+    begin(schedule: SimSchedulerSchedule): void;
+    /**
+     * Note an occurrence that has been invoked, or given up on, and answer
+     * whether the schedule has now completed.
+     */
+    end(schedule: SimSchedulerSchedule, last: boolean): boolean;
+}

package/dist/service/scheduler/schedule/sim-scheduler-pending-occurrences.js

@@ -0,0 +1,36 @@
+/**
+ * The occurrences of each schedule that have fallen due and are waiting
+ * inside a flexible window to be invoked.
+ *
+ * A window longer than the gap between due instants lets occurrences overlap,
+ * and a finite schedule's last occurrence can then be invoked before an
+ * earlier one. The schedule has completed once its last occurrence has fallen
+ * due and nothing is left waiting.
+ */
+export class SimSchedulerPendingOccurrences {
+    waiting = new Map();
+    lastFallenDue = new Set();
+    /**
+     * Note an occurrence that has fallen due and will be invoked later.
+     */
+    begin(schedule) {
+        this.waiting.set(schedule, (this.waiting.get(schedule) ?? 0) + 1);
+    }
+    /**
+     * Note an occurrence that has been invoked, or given up on, and answer
+     * whether the schedule has now completed.
+     */
+    end(schedule, last) {
+        const remaining = (this.waiting.get(schedule) ?? 1) - 1;
+        this.waiting.set(schedule, remaining);
+        if (last) {
+            this.lastFallenDue.add(schedule);
+        }
+        if (remaining > 0 || !this.lastFallenDue.has(schedule)) {
+            return false;
+        }
+        this.waiting.delete(schedule);
+        this.lastFallenDue.delete(schedule);
+        return true;
+    }
+}

package/dist/service/scheduler/schedule/sim-scheduler-schedule.d.ts

@@ -3,6 +3,7 @@ import type { SimAwsAccountRegionScope } from "../../aws/sim-aws-account-region-
 import type { SimSchedulerTarget } from "../target/sim-scheduler-target.js";
 import type { SimSchedulerScheduleName } from "./sim-scheduler-schedule-name.js";
 import type { SimSchedulerScheduleState } from "./sim-scheduler-schedule-state.js";
+import type { SimSchedulerTimeWindow } from "./sim-scheduler-time-window.js";
 /**
  * What Scheduler does with a schedule once it has finished invoking its target.
  *
@@ -23,6 +24,8 @@ interface SimSchedulerScheduleProperties {
     readonly description?: string | undefined;
     /** The timezone the request named, which a describe reports back. */
     readonly timeZone?: string | undefined;
+    /** When, relative to each due time, the target is invoked. */
+    readonly timeWindow: SimSchedulerTimeWindow;
     readonly createdAt: Date;
 }
 /**
@@ -60,6 +63,10 @@ export declare class SimSchedulerSchedule {
      * than reporting the one it fell back to.
      */
     readonly timeZone: string | undefined;
+    /**
+     * The flexible time window each occurrence is invoked inside.
+     */
+    readonly timeWindow: SimSchedulerTimeWindow;
     readonly creationDate: Date;
     /**
      * When this schedule falls due, which is read as simulated time advances.

package/dist/service/scheduler/schedule/sim-scheduler-schedule.js

@@ -35,6 +35,10 @@ export class SimSchedulerSchedule {
      * than reporting the one it fell back to.
      */
     timeZone;
+    /**
+     * The flexible time window each occurrence is invoked inside.
+     */
+    timeWindow;
     creationDate;
     /**
      * When this schedule falls due, which is read as simulated time advances.
@@ -53,6 +57,7 @@ export class SimSchedulerSchedule {
         this.actionAfterCompletion = properties.actionAfterCompletion;
         this.description = properties.description;
         this.timeZone = properties.timeZone;
+        this.timeWindow = properties.timeWindow;
         this.creationDate = properties.createdAt;
         this.modified = properties.createdAt;
         this.held = properties.state;

package/dist/service/scheduler/schedule/sim-scheduler-schedules.d.ts

@@ -1,4 +1,5 @@
 import type { BackgroundScheduler } from "../../../util/background/background.js";
+import type { SimRandom } from "../../../util/random/sim-random.js";
 import type { SimSchedulerTargetDelivery } from "../delivery/sim-scheduler-target-delivery.js";
 import type { SimSchedulerSchedule } from "./sim-scheduler-schedule.js";
 import type { SimSchedulerScheduleStore } from "./sim-scheduler-schedule-store.js";
@@ -6,6 +7,8 @@ interface SimSchedulerSchedulesProperties {
     readonly schedules: SimSchedulerScheduleStore;
     readonly delivery: SimSchedulerTargetDelivery;
     readonly background: BackgroundScheduler;
+    /** Where each occurrence's moment inside a flexible window is drawn. */
+    readonly random: SimRandom;
 }
 /**
  * What makes a schedule fire, which is simulated time reaching it.
@@ -22,11 +25,19 @@ interface SimSchedulerSchedulesProperties {
  * no timer to cancel, only a firing that finds itself out of date. That is also
  * what makes an update reschedule from the new expression rather than keeping
  * the old due times, since an update stores a new schedule and arms it.
+ *
+ * A schedule with a flexible time window is armed for each due instant all
+ * the same, and then invokes its target at a moment drawn inside the window.
+ * The next occurrence is armed from the due instant rather than from the
+ * invocation, so the window delays each invocation without moving the
+ * schedule.
  */
 export declare class SimSchedulerSchedules {
     private readonly schedules;
     private readonly delivery;
     private readonly background;
+    private readonly random;
+    private readonly pending;
     constructor(properties: SimSchedulerSchedulesProperties);
     /**
      * Start a schedule, from now.
@@ -40,9 +51,24 @@ export declare class SimSchedulerSchedules {
      */
     private armAfter;
     /**
-     * Fire a schedule that has fallen due, and arm it for the next time.
+     * Handle a schedule that has fallen due: arm the next occurrence, and
+     * invoke the target at the moment its time window gives this one.
+     */
+    private occur;
+    /**
+     * Invoke a schedule's target for one occurrence.
+     *
+     * A schedule deleted or replaced while its occurrence waited inside the
+     * window is not invoked. The delivery carries the due instant rather than
+     * the moment it was made, since that is the occurrence it belongs to. A
+     * schedule completes with whichever occurrence is invoked last, which need
+     * not be its last due instant when windows overlap.
      */
     private fire;
+    /**
+     * Whether a schedule has been deleted or replaced since it was armed.
+     */
+    private isStale;
     /**
      * Deal with a schedule that has no next occurrence.
      *

package/dist/service/scheduler/schedule/sim-scheduler-schedules.js

@@ -1,3 +1,4 @@
+import { SimSchedulerPendingOccurrences } from "./sim-scheduler-pending-occurrences.js";
 /**
  * What makes a schedule fire, which is simulated time reaching it.
  *
@@ -13,15 +14,24 @@
  * no timer to cancel, only a firing that finds itself out of date. That is also
  * what makes an update reschedule from the new expression rather than keeping
  * the old due times, since an update stores a new schedule and arms it.
+ *
+ * A schedule with a flexible time window is armed for each due instant all
+ * the same, and then invokes its target at a moment drawn inside the window.
+ * The next occurrence is armed from the due instant rather than from the
+ * invocation, so the window delays each invocation without moving the
+ * schedule.
  */
 export class SimSchedulerSchedules {
     schedules;
     delivery;
     background;
+    random;
+    pending = new SimSchedulerPendingOccurrences();
     constructor(properties) {
         this.schedules = properties.schedules;
         this.delivery = properties.delivery;
         this.background = properties.background;
+        this.random = properties.random;
     }
     /**
      * Start a schedule, from now.
@@ -41,15 +51,45 @@ export class SimSchedulerSchedules {
             return;
         }
         this.background.scheduleAt(due, () => {
-            this.fire(schedule, due);
+            this.occur(schedule, due);
+            return Promise.resolve();
+        });
+    }
+    /**
+     * Handle a schedule that has fallen due: arm the next occurrence, and
+     * invoke the target at the moment its time window gives this one.
+     */
+    occur(schedule, due) {
+        if (this.isStale(schedule)) {
+            return;
+        }
+        const last = schedule.schedule.nextAfter(due) === undefined;
+        if (!last) {
+            this.armAfter(schedule, due);
+        }
+        const at = schedule.timeWindow.invocationAt(due, this.random);
+        this.pending.begin(schedule);
+        if (at.getTime() === due.getTime()) {
+            this.fire(schedule, due, last);
+            return;
+        }
+        this.background.scheduleAt(at, () => {
+            this.fire(schedule, due, last);
             return Promise.resolve();
         });
     }
     /**
-     * Fire a schedule that has fallen due, and arm it for the next time.
+     * Invoke a schedule's target for one occurrence.
+     *
+     * A schedule deleted or replaced while its occurrence waited inside the
+     * window is not invoked. The delivery carries the due instant rather than
+     * the moment it was made, since that is the occurrence it belongs to. A
+     * schedule completes with whichever occurrence is invoked last, which need
+     * not be its last due instant when windows overlap.
      */
-    fire(schedule, due) {
-        if (this.schedules.find(schedule.groupName, schedule.name.value) !== schedule) {
+    fire(schedule, due, last) {
+        const completed = this.pending.end(schedule, last);
+        if (this.isStale(schedule)) {
             return;
         }
         const invoked = schedule.state.isEnabled;
@@ -58,11 +98,15 @@ export class SimSchedulerSchedules {
                 await this.delivery.deliver({ schedule, at: due });
             });
         }
-        if (schedule.schedule.nextAfter(due) !== undefined) {
-            this.armAfter(schedule, due);
-            return;
+        if (completed) {
+            this.completed(schedule, invoked);
         }
-        this.completed(schedule, invoked);
+    }
+    /**
+     * Whether a schedule has been deleted or replaced since it was armed.
+     */
+    isStale(schedule) {
+        return (this.schedules.find(schedule.groupName, schedule.name.value) !== schedule);
     }
     /**
      * Deal with a schedule that has no next occurrence.