@kensio/yulin 1.21.25 → 1.21.26

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;
+    }
+}

package/docs/sdk/README.md

@@ -172,6 +172,24 @@ specific commands:
 The list accepts command classes or command names. Sending another command throws
 `SimSdkCommandNotInterceptedError`.
 
+## Abort a send
+
+An intercepted client honours the `abortSignal` option of `send`, as the SDK's own HTTP handler does:
+
+`await client.send(command, { abortSignal: AbortSignal.timeout(5000) })`
+
+A signal that has already fired rejects the send before it reaches the simulation. A signal that fires
+while the simulated operation is pending rejects the send then. A Lambda handler sleeping on the
+simulation's clock is one operation that stays pending.
+
+Either way the send rejects with an `AbortError` shaped like the one the SDK throws. Its message is
+`Request aborted` and its `cause` is the signal's reason (a `TimeoutError` for
+`AbortSignal.timeout`). Match it by `error.name`.
+
+A send carrying a signal waits one turn of the host's timers before it reaches the simulation. That
+turn stands in for the request's time on the network. A timeout of 0 or 1 milliseconds set before the
+send aborts it, as it would a request to AWS.
+
 ## Intercept the DynamoDB document client
 
 The DynamoDB document client accepts plain JavaScript values. Intercept the document client object,
@@ -282,6 +300,11 @@ service throws `SimSdkUnknownServiceError`.
 - Simulated errors have SDK-shaped `name` and `$metadata` fields. They are separate classes from the
   SDK exceptions, so match them by `error.name` instead of `instanceof`.
 - The callback form of `send(command, callback)` is not supported. Use the promise form.
+- An aborted send stops waiting for its answer. The simulated operation it started still runs to the
+  end, as a request AWS has already received does.
+- Most simulated operations answer within one turn of the host's timers. A timeout longer than a few
+  milliseconds only fires during an operation that waits, such as a sleeping Lambda handler. A
+  simulated Bedrock answer cannot be delayed.
 - Yulin reads the `marshallOptions` in
   `DynamoDBDocumentClient.from(client, { marshallOptions, unmarshallOptions })` and ignores the
   `unmarshallOptions`. A stored value comes back the way a document client built with no options of

package/docs/services/scheduler/README.md

@@ -303,6 +303,64 @@ regardless of `ActionAfterCompletion`.
 enabling it picks up from the next due instant. What it missed is never replayed. An update that
 changes the expression reschedules from the new one.
 
+### Flexible time windows
+
+`FlexibleTimeWindow: { Mode: "FLEXIBLE", MaximumWindowInMinutes: n }` delays each invocation by up
+to `n` minutes. The schedule still falls due at the times its expression gives. Each occurrence then
+invokes its target at a moment drawn inside `[due, due + n minutes)`. The moment is never before the
+due time and always before the window closes.
+
+The draw is made separately for every occurrence. A test that advances the clock past the end of an
+occurrence's window sees exactly one invocation for it, whatever was drawn. A test that stops inside
+the window may or may not see it. Assert after the window has closed.
+
+The draws come from the `random` source the `SimAws` was built with. It defaults to the host's
+`Math.random`, and the moments differ from run to run. Pass a `SimSeededRandom` to draw the same
+moments every time (to reproduce a failure, for example).
+
+```typescript sim-scheduler-flexible-window
+/**
+ * A schedule invoking its target up to fifteen minutes after each hour.
+ */
+
+import {
+  CreateScheduleCommand,
+  GetScheduleCommand,
+} from "@aws-sdk/client-scheduler";
+
+import { SimAws, SimSeededRandom } from "@kensio/yulin";
+
+// The same seed draws the same invocation moments on every run.
+const simAws = new SimAws({ random: new SimSeededRandom(2026) });
+
+await simAws.scheduler().createSchedule(
+  new CreateScheduleCommand({
+    Name: "hourly-digest",
+    ScheduleExpression: "cron(0 * * * ? *)",
+    FlexibleTimeWindow: { Mode: "FLEXIBLE", MaximumWindowInMinutes: 15 },
+    Target: {
+      Arn: "arn:aws:lambda:us-east-1:888888888888:function:digest",
+      RoleArn: "arn:aws:iam::888888888888:role/SchedulerRole",
+    },
+  }),
+);
+
+const described = await simAws
+  .scheduler()
+  .getSchedule(new GetScheduleCommand({ Name: "hourly-digest" }));
+
+console.log(described.FlexibleTimeWindow);
+// { Mode: "FLEXIBLE", MaximumWindowInMinutes: 15 }
+```
+
+A `FLEXIBLE` window needs `MaximumWindowInMinutes`, a whole number from 1 to 1440. An `OFF` window
+must leave it out. Either mistake is a `ValidationException`. `GetSchedule` reports the window the
+schedule was created with.
+
+A schedule deleted or replaced while an occurrence is waiting inside its window does not invoke for
+that occurrence. A one-time schedule with `ActionAfterCompletion: "DELETE"` is removed once its
+delayed invocation has been made.
+
 ## Running an ECS task on a schedule
 
 A target whose ARN names an ECS cluster runs a [simulated ECS](https://yulinsim.dev/services/ecs/)
@@ -812,6 +870,8 @@ Resources of the same stack.
   authorized against that role's own policies. Lambda targets use asynchronous Event invocation.
 - ECS targets, running a simulated task as the execution role, with the task definition and
   `TaskCount` from `EcsParameters` and container overrides from the target's `Input`.
+- `FlexibleTimeWindow` in both modes, with each `FLEXIBLE` invocation drawn inside its window from
+  the simulation's `random` source.
 - `ActionAfterCompletion`, and `deliveryFailures` for invocations that did not happen.
 - Target retry policies driven by simulated time, and standard SQS dead-letter queues carrying the
   original input and Scheduler diagnostic attributes.
@@ -829,8 +889,8 @@ Resources of the same stack.
 
 - A schedule only fires while a test advances the simulation's clock. The host's clock drives none
   of it, and a simulation left alone in real time never fires however long it is left.
-- Firing is exact and exactly once. Real Scheduler invokes within a minute of the due time, and its
-  promise is at-least-once.
+- Firing is exact and exactly once with the window `OFF`. Real Scheduler invokes within a minute of
+  the due time, and its promise is at-least-once.
 - Retry delays are deterministic powers of two seconds. Real Scheduler uses exponential backoff
   without publishing an exact sequence. The fixed sequence lets a test advance to a known retry
   instant.
@@ -844,9 +904,12 @@ Resources of the same stack.
   real Scheduler holds the group in `DELETING` until they have gone.
 - The `default` schedule group cannot be deleted. AWS leaves the answer to that request
   undocumented.
-- `FlexibleTimeWindow` with `Mode: "FLEXIBLE"` is refused. 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 leaves unpromised.
+- A flexible window draws each invocation moment uniformly, to the millisecond. AWS documents only
+  that the target is invoked inside the window after the scheduled time, and publishes no
+  distribution.
+- The wording of the refusals for a `FLEXIBLE` window with no `MaximumWindowInMinutes`, and an `OFF`
+  window with one, is Yulin's own. AWS refuses both and does not document the message. The range
+  refusals use the API's constraint wording.
 - `ScheduleExpressionTimezone` is read from the host's own timezone data through `Intl`, so a zone
   the host has never heard of is refused even where AWS would take it. A schedule that names none
   runs in UTC.

package/docs/time/README.md

@@ -247,6 +247,24 @@ Yulin uses the clock for:
 - `Date`, global timers, and invocation deadlines inside a simulated Lambda invocation
 - HTTP response `Date` headers
 
+## Values AWS leaves to chance
+
+Some AWS behaviour is unpredictable by design. An EventBridge Scheduler
+[flexible time window](https://yulinsim.dev/services/scheduler/#flexible-time-windows) invokes its
+target at a moment AWS chooses inside the window. Yulin draws those values from the `random` option
+of `SimAws`, which defaults to the host's `Math.random`.
+
+Pass a `SimSeededRandom` to draw the same values on every run:
+
+```typescript
+import { SimAws, SimSeededRandom } from "@kensio/yulin";
+
+const simAws = new SimAws({ random: new SimSeededRandom(2026) });
+```
+
+A test that advances the clock past the end of a window passes whatever was drawn. A seed is for
+reproducing a run (one that failed, for example).
+
 ## Limitations
 
 - Scheduled [EventBridge rules](https://yulinsim.dev/services/eventbridge/#rules-that-fire-on-a-schedule)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kensio/yulin",
-  "version": "1.21.25",
+  "version": "1.21.26",
   "description": "AWS system behaviour simulation for isolated unit testing",
   "repository": "https://github.com/KensioSoftware/yulin",
   "homepage": "https://yulinsim.dev/",
@@ -299,7 +299,7 @@
     "hyparquet": "^1.29.2",
     "hyparquet-writer": "^0.16.9",
     "node-sql-parser": "^5.4.0",
-    "oxfmt": "^0.70.0",
+    "oxfmt": "^0.71.0",
     "oxlint": "^1.77.0",
     "oxlint-tsgolint": "^7.0.2001",
     "semantic-release": "25.0.9",