@kensio/yulin 1.21.24 → 1.21.26

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.

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

@@ -0,0 +1,33 @@
+import type { SimRandom } from "../../../util/random/sim-random.js";
+import type { SimSchedulerFlexibleTimeWindow } from "../command/schedule/schedule.command.js";
+/**
+ * When, relative to its due time, a schedule invokes its target.
+ *
+ * With `OFF` that is the due time itself. With `FLEXIBLE` it is some moment
+ * after the due time and inside the window, which AWS chooses and does not
+ * reveal. Firing on the dot instead would let a test pass by relying on
+ * timing AWS does not promise, so each occurrence draws its own moment.
+ */
+export declare class SimSchedulerTimeWindow {
+    /**
+     * The window length in minutes, or nothing when the mode is `OFF`.
+     */
+    readonly minutes: number | undefined;
+    private constructor();
+    /**
+     * Read the window a request carries, which AWS requires on every one.
+     */
+    static of(window: SimSchedulerFlexibleTimeWindow | undefined): SimSchedulerTimeWindow;
+    /**
+     * The window as GetSchedule reports it, which is what the request sent.
+     */
+    get declared(): SimSchedulerFlexibleTimeWindow;
+    /**
+     * The instant one occurrence invokes its target, drawn from `random`.
+     *
+     * It is never before the due time and always before the window closes, so
+     * a test that moves the clock past the end of the window sees the
+     * invocation whatever was drawn.
+     */
+    invocationAt(due: Date, random: SimRandom): Date;
+}

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

@@ -0,0 +1,93 @@
+import { SimSchedulerValidationException } from "../error/sim-scheduler.error.js";
+const minimumWindowInMinutes = 1;
+const maximumWindowInMinutes = 1440;
+const millisecondsPerMinute = 60_000;
+/**
+ * Refuse a value the API model's own constraints reject, in the words AWS
+ * uses for them.
+ */
+function constraintFailure(value, member, constraint) {
+    return new SimSchedulerValidationException(`1 validation error detected: Value '${value}' at ` +
+        `'flexibleTimeWindow.${member}' failed to satisfy constraint: ` +
+        `Member must ${constraint}`);
+}
+/**
+ * Read the length of a flexible window, refusing one outside 1 to 1440.
+ */
+function windowLength(minutes) {
+    if (minutes === undefined) {
+        throw new SimSchedulerValidationException("Invalid parameter: FlexibleTimeWindow Reason: a FLEXIBLE window " +
+            "needs MaximumWindowInMinutes, from 1 to 1440");
+    }
+    if (!Number.isSafeInteger(minutes)) {
+        throw new SimSchedulerValidationException(`Invalid parameter: FlexibleTimeWindow Reason: MaximumWindowInMinutes ` +
+            `is a whole number of minutes, and ${String(minutes)} is not`);
+    }
+    if (minutes < minimumWindowInMinutes) {
+        throw constraintFailure(String(minutes), "maximumWindowInMinutes", `have value greater than or equal to ${String(minimumWindowInMinutes)}`);
+    }
+    if (minutes > maximumWindowInMinutes) {
+        throw constraintFailure(String(minutes), "maximumWindowInMinutes", `have value less than or equal to ${String(maximumWindowInMinutes)}`);
+    }
+    return minutes;
+}
+/**
+ * When, relative to its due time, a schedule invokes its target.
+ *
+ * With `OFF` that is the due time itself. With `FLEXIBLE` it is some moment
+ * after the due time and inside the window, which AWS chooses and does not
+ * reveal. Firing on the dot instead would let a test pass by relying on
+ * timing AWS does not promise, so each occurrence draws its own moment.
+ */
+export class SimSchedulerTimeWindow {
+    /**
+     * The window length in minutes, or nothing when the mode is `OFF`.
+     */
+    minutes;
+    constructor(minutes) {
+        this.minutes = minutes;
+    }
+    /**
+     * Read the window a request carries, which AWS requires on every one.
+     */
+    static of(window) {
+        const mode = window?.Mode;
+        if (mode === undefined) {
+            throw new SimSchedulerValidationException("FlexibleTimeWindow is required, and its Mode is OFF or FLEXIBLE");
+        }
+        if (mode === "FLEXIBLE") {
+            return new SimSchedulerTimeWindow(windowLength(window?.MaximumWindowInMinutes));
+        }
+        if (mode !== "OFF") {
+            throw constraintFailure(mode, "mode", "satisfy enum value set: [OFF, FLEXIBLE]");
+        }
+        if (window?.MaximumWindowInMinutes !== undefined) {
+            throw new SimSchedulerValidationException("Invalid parameter: FlexibleTimeWindow Reason: " +
+                "MaximumWindowInMinutes is only allowed when Mode is FLEXIBLE");
+        }
+        return new SimSchedulerTimeWindow(undefined);
+    }
+    /**
+     * The window as GetSchedule reports it, which is what the request sent.
+     */
+    get declared() {
+        if (this.minutes === undefined) {
+            return { Mode: "OFF" };
+        }
+        return { Mode: "FLEXIBLE", MaximumWindowInMinutes: this.minutes };
+    }
+    /**
+     * The instant one occurrence invokes its target, drawn from `random`.
+     *
+     * It is never before the due time and always before the window closes, so
+     * a test that moves the clock past the end of the window sees the
+     * invocation whatever was drawn.
+     */
+    invocationAt(due, random) {
+        if (this.minutes === undefined) {
+            return due;
+        }
+        const offset = Math.floor(random.next() * this.minutes * millisecondsPerMinute);
+        return new Date(due.getTime() + offset);
+    }
+}

package/dist/service/scheduler/sim-scheduler.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 { SimSdkCommandRouter } from "../../sdk/router/sim-sdk-command-router.type.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";
@@ -21,6 +22,11 @@ interface SimSchedulerProperties {
      * in another simulated service is only reachable through SimAws.
      */
     readonly deliveryTargets?: SimSchedulerDeliveryTargets;
+    /**
+     * Where a flexible time window draws the moment each occurrence is invoked,
+     * which is the host's `Math.random` unless a test supplies its own.
+     */
+    readonly random?: SimRandom;
 }
 /**
  * Simulated EventBridge Scheduler. Handles SDK commands. Emulates AWS

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

@@ -1,4 +1,5 @@
 import { BackgroundTasks, } from "../../util/background/background.js";
+import { SimHostRandom } from "../../util/random/sim-random.js";
 import { simAwsAccountRegionScopeFactory } from "../aws/sim-aws-account-region-scope.factory.js";
 import { simIamInRegion } from "../iam/authorize/sim-iam-region-auth-z.js";
 import { SimSchedulerCommands } from "./command/sim-scheduler-commands.js";
@@ -30,7 +31,7 @@ export class SimScheduler extends SimSchedulerInspection {
     });
     constructor(properties = {}) {
         super();
-        const { accountRegionScope = simAwsAccountRegionScopeFactory.make(), background = new BackgroundTasks(), } = properties;
+        const { accountRegionScope = simAwsAccountRegionScopeFactory.make(), background = new BackgroundTasks(), random = new SimHostRandom(), } = properties;
         const iam = simIamInRegion(properties.iam, accountRegionScope.regionName);
         this.background = background;
         this.groupStore = new SimSchedulerScheduleGroupStore({
@@ -44,6 +45,7 @@ export class SimScheduler extends SimSchedulerInspection {
             background,
             deliveryTargets: properties.deliveryTargets,
             accountRegionScope,
+            random,
         });
     }
     /**

package/dist/util/random/sim-random.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Where a simulation draws the values AWS leaves to chance.
+ *
+ * Some AWS behaviour is unpredictable by design, such as the moment inside a
+ * Scheduler flexible time window at which the target is invoked. A simulation
+ * draws those values from here, so a test can make them repeatable by passing
+ * a seeded source and leave them unpredictable otherwise.
+ */
+export interface SimRandom {
+    /**
+     * The next value, at least 0 and less than 1.
+     */
+    next(): number;
+}
+/**
+ * Draws from the host's `Math.random`, so values differ from run to run.
+ *
+ * This is the default, because a test that passes only for one particular
+ * draw is relying on something AWS does not promise.
+ */
+export declare class SimHostRandom implements SimRandom {
+    next(): number;
+}
+/**
+ * Draws a repeatable sequence from a seed.
+ *
+ * Two sources built from the same seed give the same values in the same order,
+ * so a failure seen once can be reproduced. The generator is mulberry32, which
+ * is small and fast and has nothing to do with security.
+ */
+export declare class SimSeededRandom implements SimRandom {
+    private state;
+    constructor(seed: number);
+    next(): number;
+}

package/dist/util/random/sim-random.js

@@ -0,0 +1,33 @@
+/**
+ * Draws from the host's `Math.random`, so values differ from run to run.
+ *
+ * This is the default, because a test that passes only for one particular
+ * draw is relying on something AWS does not promise.
+ */
+export class SimHostRandom {
+    next() {
+        return Math.random();
+    }
+}
+/**
+ * Draws a repeatable sequence from a seed.
+ *
+ * Two sources built from the same seed give the same values in the same order,
+ * so a failure seen once can be reproduced. The generator is mulberry32, which
+ * is small and fast and has nothing to do with security.
+ */
+export class SimSeededRandom {
+    state;
+    constructor(seed) {
+        // Only the low 32 bits of the seed take part, as the generator works on
+        // 32-bit integers.
+        this.state = Math.trunc(seed) >>> 0;
+    }
+    next() {
+        this.state = (this.state + 0x6d_2b_79_f5) >>> 0;
+        let mixed = this.state;
+        mixed = Math.imul(mixed ^ (mixed >>> 15), mixed | 1);
+        mixed ^= mixed + Math.imul(mixed ^ (mixed >>> 7), mixed | 61);
+        return ((mixed ^ (mixed >>> 14)) >>> 0) / 4_294_967_296;
+    }
+}