@kensio/yulin 1.21.25 → 1.21.26

package/dist/index.d.ts

@@ -7,5 +7,6 @@ export { type SimClock, SimFixedClock, SimRealClock, } from "./util/clock/sim-cl
 export { SimControllableClock } from "./util/clock/sim-controllable-clock.js";
 export { SimClockControl } from "./util/clock/sim-clock-control.js";
 export { SimTokenBucket } from "./util/throttle/sim-token-bucket.js";
+export { SimHostRandom, type SimRandom, SimSeededRandom, } from "./util/random/sim-random.js";
 export { SimDuration, type SimDurationInput, SimInvalidDuration, } from "./util/clock/sim-duration.js";
 export { SimAwsTimeNotControllable } from "./service/aws/sim-aws-timekeeping.js";

package/dist/index.js

@@ -4,5 +4,6 @@ export { SimFixedClock, SimRealClock, } from "./util/clock/sim-clock.js";
 export { SimControllableClock } from "./util/clock/sim-controllable-clock.js";
 export { SimClockControl } from "./util/clock/sim-clock-control.js";
 export { SimTokenBucket } from "./util/throttle/sim-token-bucket.js";
+export { SimHostRandom, SimSeededRandom, } from "./util/random/sim-random.js";
 export { SimDuration, SimInvalidDuration, } from "./util/clock/sim-duration.js";
 export { SimAwsTimeNotControllable } from "./service/aws/sim-aws-timekeeping.js";

package/dist/sdk/error/sim-sdk.error.d.ts

@@ -1,3 +1,4 @@
+import type { SimResponseMetadata } from "../../service/aws/metadata/response-metadata.type.js";
 /**
  * Base class for simulated AWS SDK errors.
  */
@@ -44,6 +45,23 @@ export declare class SimSdkAlreadyInterceptedError extends SimSdkError {
 export declare class SimSdkCallbackNotSupportedError extends SimSdkError {
     readonly name = "SimSdkCallbackNotSupportedError";
 }
+/**
+ * An intercepted SDK send was aborted through its `abortSignal` option.
+ *
+ * This reproduces the error the SDK's own HTTP handler throws, so it extends
+ * Error directly and is named `AbortError`, as code catching an aborted send
+ * expects. A signal's Error reason becomes the cause, and any other reason
+ * becomes the message.
+ */
+export declare class SimSdkAbortError extends Error {
+    readonly name = "AbortError";
+    readonly $metadata: SimResponseMetadata;
+    /**
+     * Build the error for a signal that fired with a reason, mirroring
+     * `buildAbortError` in `@smithy/node-http-handler`.
+     */
+    static fromReason(reason: unknown): SimSdkAbortError;
+}
 /**
  * A serialized AWS API request cannot be routed into the simulation.
  *

package/dist/sdk/error/sim-sdk.error.js

@@ -44,6 +44,47 @@ export class SimSdkAlreadyInterceptedError extends SimSdkError {
 export class SimSdkCallbackNotSupportedError extends SimSdkError {
     name = "SimSdkCallbackNotSupportedError";
 }
+/**
+ * An intercepted SDK send was aborted through its `abortSignal` option.
+ *
+ * This reproduces the error the SDK's own HTTP handler throws, so it extends
+ * Error directly and is named `AbortError`, as code catching an aborted send
+ * expects. A signal's Error reason becomes the cause, and any other reason
+ * becomes the message.
+ */
+export class SimSdkAbortError extends Error {
+    name = "AbortError";
+    $metadata = {
+        attempts: 1,
+        totalRetryDelay: 0,
+    };
+    /**
+     * Build the error for a signal that fired with a reason, mirroring
+     * `buildAbortError` in `@smithy/node-http-handler`.
+     */
+    static fromReason(reason) {
+        if (reason instanceof Error) {
+            return new SimSdkAbortError("Request aborted", { cause: reason });
+        }
+        if (isFalsy(reason)) {
+            return new SimSdkAbortError("Request aborted");
+        }
+        // oxlint-disable-next-line typescript/no-base-to-string -- the SDK stringifies any other reason as it is, so this matches whatever it prints.
+        return new SimSdkAbortError(String(reason));
+    }
+}
+/**
+ * Whether an abort reason is falsy, which the SDK treats as no reason.
+ */
+function isFalsy(reason) {
+    return (reason === undefined ||
+        reason === null ||
+        reason === false ||
+        reason === "" ||
+        reason === 0 ||
+        reason === 0n ||
+        Number.isNaN(reason));
+}
 /**
  * A serialized AWS API request cannot be routed into the simulation.
  *

package/dist/sdk/index.d.ts

@@ -7,4 +7,4 @@ export type { SimSdkCallerOptions } from "./router/sim-sdk-caller-options.js";
 export { simSdkEventStream, type SimSdkEventStream, } from "./stream/sim-sdk-event-stream.js";
 export { simSdkStreamBody } from "./stream/sim-sdk-stream-body.js";
 export type { SimSdkStreamBody, SimSdkStreamBodyMethods, } from "./stream/sim-sdk-stream-body.js";
-export { SimSdkError, SimSdkAlreadyInterceptedError, SimSdkCallbackNotSupportedError, SimSdkCommandNotInterceptedError, SimSdkInvalidClientError, SimSdkStreamAlreadyConsumedError, SimSdkUnbridgedWireRequestError, SimSdkUnknownServiceError, SimSdkUnsupportedCommandError, } from "./error/sim-sdk.error.js";
+export { SimSdkError, SimSdkAbortError, SimSdkAlreadyInterceptedError, SimSdkCallbackNotSupportedError, SimSdkCommandNotInterceptedError, SimSdkInvalidClientError, SimSdkStreamAlreadyConsumedError, SimSdkUnbridgedWireRequestError, SimSdkUnknownServiceError, SimSdkUnsupportedCommandError, } from "./error/sim-sdk.error.js";

package/dist/sdk/index.js

@@ -3,4 +3,4 @@ export { SimSdkInterception } from "./sim-sdk-interception.js";
 export { simSdkCallerOptions } from "./router/sim-sdk-caller-options.js";
 export { simSdkEventStream, } from "./stream/sim-sdk-event-stream.js";
 export { simSdkStreamBody } from "./stream/sim-sdk-stream-body.js";
-export { SimSdkError, SimSdkAlreadyInterceptedError, SimSdkCallbackNotSupportedError, SimSdkCommandNotInterceptedError, SimSdkInvalidClientError, SimSdkStreamAlreadyConsumedError, SimSdkUnbridgedWireRequestError, SimSdkUnknownServiceError, SimSdkUnsupportedCommandError, } from "./error/sim-sdk.error.js";
+export { SimSdkError, SimSdkAbortError, SimSdkAlreadyInterceptedError, SimSdkCallbackNotSupportedError, SimSdkCommandNotInterceptedError, SimSdkInvalidClientError, SimSdkStreamAlreadyConsumedError, SimSdkUnbridgedWireRequestError, SimSdkUnknownServiceError, SimSdkUnsupportedCommandError, } from "./error/sim-sdk.error.js";

package/dist/sdk/send-abort.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The abort signal given to one intercepted SDK send, if any.
+ *
+ * The real SDK checks the signal in its HTTP handler. A signal aborted before
+ * the request goes out rejects the send, and one that fires while the request
+ * is pending rejects it then. Either way the send rejects with an AbortError.
+ *
+ * A real request spends at least one turn of the host's timers on the network,
+ * so `AbortSignal.timeout(0)` created for a send aborts it. A simulated
+ * operation can settle within microtasks, so a send carrying a signal waits
+ * one host timer turn before it is dispatched.
+ *
+ * The simulated operation is not cancelled. Once dispatched, it carries on, as
+ * a request already received by AWS does.
+ */
+export declare class SimSdkSendAbort {
+    private readonly signal;
+    private constructor();
+    /**
+     * Read the abort signal from the arguments given to send after the Command.
+     */
+    static fromSendArguments(rest: readonly unknown[]): SimSdkSendAbort;
+    /**
+     * Run a simulated operation unless the signal has already fired, rejecting
+     * with an AbortError if it fires before the operation settles.
+     */
+    run(operation: () => Promise<unknown>): Promise<unknown>;
+}

package/dist/sdk/send-abort.js

@@ -0,0 +1,112 @@
+import { setTimeout } from "node:timers";
+import { SimSdkAbortError } from "./error/sim-sdk.error.js";
+/**
+ * The abort signal given to one intercepted SDK send, if any.
+ *
+ * The real SDK checks the signal in its HTTP handler. A signal aborted before
+ * the request goes out rejects the send, and one that fires while the request
+ * is pending rejects it then. Either way the send rejects with an AbortError.
+ *
+ * A real request spends at least one turn of the host's timers on the network,
+ * so `AbortSignal.timeout(0)` created for a send aborts it. A simulated
+ * operation can settle within microtasks, so a send carrying a signal waits
+ * one host timer turn before it is dispatched.
+ *
+ * The simulated operation is not cancelled. Once dispatched, it carries on, as
+ * a request already received by AWS does.
+ */
+export class SimSdkSendAbort {
+    signal;
+    constructor(signal) {
+        this.signal = signal;
+    }
+    /**
+     * Read the abort signal from the arguments given to send after the Command.
+     */
+    static fromSendArguments(rest) {
+        const options = rest[0];
+        if (typeof options !== "object" || options === null) {
+            return new SimSdkSendAbort(undefined);
+        }
+        const signal = options.abortSignal;
+        if (!isAbortSignal(signal)) {
+            return new SimSdkSendAbort(undefined);
+        }
+        return new SimSdkSendAbort(signal);
+    }
+    /**
+     * Run a simulated operation unless the signal has already fired, rejecting
+     * with an AbortError if it fires before the operation settles.
+     */
+    async run(operation) {
+        const signal = this.signal;
+        if (signal === undefined) {
+            return await operation();
+        }
+        if (signal.aborted) {
+            throw SimSdkAbortError.fromReason(signal.reason);
+        }
+        const abort = Promise.withResolvers();
+        const unsubscribe = subscribe(signal, () => {
+            abort.reject(SimSdkAbortError.fromReason(signal.reason));
+        });
+        try {
+            return await Promise.race([
+                dispatchAfterRoundTrip(signal, operation),
+                abort.promise,
+            ]);
+        }
+        finally {
+            unsubscribe();
+        }
+    }
+}
+/**
+ * Dispatch a simulated operation after one turn of the host's timers, unless
+ * the signal fires first.
+ *
+ * Node runs timers of the same delay in the order they were set, so a signal
+ * set to time out after 0 or 1 milliseconds before the send fires before this
+ * turn ends.
+ */
+async function dispatchAfterRoundTrip(signal, operation) {
+    await new Promise((resolve) => {
+        setTimeout(resolve, 0);
+    });
+    if (signal.aborted) {
+        throw SimSdkAbortError.fromReason(signal.reason);
+    }
+    return await operation();
+}
+/**
+ * Whether a send option is usable as an abort signal.
+ */
+function isAbortSignal(signal) {
+    return (typeof signal === "object" &&
+        signal !== null &&
+        typeof signal.aborted === "boolean");
+}
+/**
+ * Listen for a signal firing, the way the SDK's HTTP handler does: through
+ * addEventListener where the signal has it, and through onabort otherwise.
+ *
+ * Returns the function that stops listening.
+ */
+function subscribe(signal, listener) {
+    if (typeof signal.addEventListener === "function" &&
+        typeof signal.removeEventListener === "function") {
+        signal.addEventListener("abort", listener);
+        return () => {
+            signal.removeEventListener?.("abort", listener);
+        };
+    }
+    // The older Smithy signal offers no addEventListener, so onabort is the only
+    // way to listen, and the previous handler is put back afterwards.
+    const previous = signal.onabort ?? null;
+    // oxlint-disable-next-line unicorn-js/prefer-add-event-listener -- this signal has no addEventListener to prefer.
+    signal.onabort = listener;
+    return () => {
+        // oxlint-disable-next-line unicorn-js/prefer-add-event-listener -- this signal has no addEventListener to prefer.
+        signal.onabort = previous;
+    };
+}

package/dist/sdk/send-patch.js

@@ -1,4 +1,5 @@
 import { SimSdkAlreadyInterceptedError, SimSdkCallbackNotSupportedError, } from "./error/sim-sdk.error.js";
+import { SimSdkSendAbort } from "./send-abort.js";
 /**
  * All send functions installed by simulated SDK interception, so a second
  * interception of an already-intercepted target can be rejected, including
@@ -26,8 +27,9 @@ export function installSendPatch(target, handler) {
             throw new SimSdkCallbackNotSupportedError("Simulated SDK interception does not support callback-style send; " +
                 "use the promise form instead");
         }
+        return await SimSdkSendAbort.fromSendArguments(rest).run(
         // oxlint-disable-next-line unicorn-js/no-this-outside-of-class -- this is the client instance send was called on, which the handler needs for per-send config resolution.
-        return await handler(command, this);
+        async () => await handler(command, this));
     };
     installedSends.add(patched);
     Object.defineProperty(target, "send", {

package/dist/service/aws/factory/sim-aws-account-region-service-builder.js

@@ -250,6 +250,7 @@ export class SimAwsAccountRegionServiceBuilder {
         return new SimScheduler({
             ...this.scoped(scope),
             deliveryTargets: simAwsSchedulerDeliveryTargets(this.simAws),
+            random: this.simAws.random,
         });
     }
     /**

package/dist/service/aws/sim-aws-properties.d.ts

@@ -1,5 +1,6 @@
 import type { BackgroundCompleter, BackgroundScheduler } from "../../util/background/background.js";
 import type { SimClock } from "../../util/clock/sim-clock.js";
+import type { SimRandom } from "../../util/random/sim-random.js";
 import type { SimIamSigV4ExpectedScope } from "../iam/sigv4/sim-iam-sigv4-expected-scope.js";
 import type { SimAwsAccountId } from "./sim-aws-account.js";
 import type { SimAwsDefaultCaller } from "./caller/sim-aws-caller.js";
@@ -52,4 +53,11 @@ export interface SimAwsProperties {
      * its own clock and time control is refused.
      */
     readonly clock?: SimClock;
+    /**
+     * Where this simulation draws the values AWS leaves to chance, such as the
+     * moment a Scheduler flexible time window invokes its target. It defaults to
+     * the host's `Math.random`. Pass a `SimSeededRandom` to make those values
+     * repeatable from run to run.
+     */
+    readonly random?: SimRandom;
 }

package/dist/service/aws/sim-aws.d.ts

@@ -10,6 +10,7 @@ import type { SimClockControl } from "../../util/clock/sim-clock-control.js";
 import type { SimAwsProperties, SimAwsRequestCallerOptions } from "./sim-aws-properties.js";
 import type { SimIamCredentialIdentity } from "../iam/credential/sim-aws-credentials.js";
 import type { SimAwsRequestCaller } from "../iam/request/sim-aws-request-caller.js";
+import { type SimRandom } from "../../util/random/sim-random.js";
 import { type SimCloseOnSignalOptions } from "../../util/process/close-on-signal.js";
 /**
  * Top-level container for simulated AWS.
@@ -32,6 +33,10 @@ export declare class SimAws extends SimAwsServiceAccessors {
      * Sim IAM registry for this sim AWS instance.
      */
     readonly iamRegistry: SimIamRegistry;
+    /**
+     * Where this simulation draws the values AWS leaves to chance.
+     */
+    readonly random: SimRandom;
     private readonly background;
     private readonly scopes;
     private readonly timekeeping;

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

@@ -6,6 +6,7 @@ import { SimAwsServiceAccessors } from "./sim-aws-service-accessors.js";
 import { simAwsRunAsContext } from "./caller/sim-aws-run-as-context.js";
 import { SimAwsTimekeeping } from "./sim-aws-timekeeping.js";
 import { SimAwsRequestAuthentication } from "./sim-aws-request-authentication.js";
+import { SimHostRandom } from "../../util/random/sim-random.js";
 import { closeOnSignal, } from "../../util/process/close-on-signal.js";
 /**
  * Top-level container for simulated AWS.
@@ -28,13 +29,17 @@ export class SimAws extends SimAwsServiceAccessors {
      * Sim IAM registry for this sim AWS instance.
      */
     iamRegistry;
+    /**
+     * Where this simulation draws the values AWS leaves to chance.
+     */
+    random;
     background;
     scopes;
     timekeeping;
     requestAuthentication;
     constructor(properties = {}) {
         super();
-        const { defaultAccountId = DEFAULT_SIM_AWS_ACCOUNT_ID, defaultRegionName = DEFAULT_SIM_AWS_REGION_NAME, clock, defaultCaller, background: suppliedBackground, } = properties;
+        const { defaultAccountId = DEFAULT_SIM_AWS_ACCOUNT_ID, defaultRegionName = DEFAULT_SIM_AWS_REGION_NAME, clock, defaultCaller, background: suppliedBackground, random = new SimHostRandom(), } = properties;
         const timekeeping = new SimAwsTimekeeping({
             clock,
             background: suppliedBackground,
@@ -44,6 +49,7 @@ export class SimAws extends SimAwsServiceAccessors {
         this.defaultRegionName = defaultRegionName;
         this.timekeeping = timekeeping;
         this.background = background;
+        this.random = random;
         this.serviceFactory = new SimAwsServiceFactory({
             simAws: this,
             background,

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