@kensio/yulin 1.21.21 → 1.21.22

package/dist/service/lambda/event-source/poll/sim-lambda-event-source-delivery.d.ts

@@ -1,6 +1,7 @@
 import type { SimLambdaFunction } from "../../function/sim-lambda-function.js";
 import type { SimSqsPollMessage } from "../../../sqs/poll/sim-sqs-poll-message.js";
-import type { SimLambdaEventSourceBatchOutcome, SimLambdaEventSourceBatchResponse } from "./sim-lambda-event-source-batch-response.js";
+import { SimLambdaEventSourceBatchOutcome, type SimLambdaEventSourceBatchResponse } from "./sim-lambda-event-source-batch-response.js";
+import type { SimLambdaFilterCriteria } from "../filter/sim-lambda-filter-criteria.js";
 /**
  * One record of an event source event.
  *
@@ -25,10 +26,16 @@ export interface SimLambdaEventSourceEvent {
  */
 export interface SimLambdaEventSourceEventBuilder {
     of(messages: readonly SimSqsPollMessage[]): SimLambdaEventSourceEvent;
+    /**
+     * What a mapping's filters read one message as, which is the source's own
+     * translation.
+     */
+    filterDocumentOf(message: SimSqsPollMessage): Record<string, unknown>;
 }
 interface SimLambdaEventSourceDeliveryProperties {
     readonly eventBuilder: SimLambdaEventSourceEventBuilder;
     readonly batchResponse: SimLambdaEventSourceBatchResponse;
+    readonly filterCriteria: SimLambdaFilterCriteria | undefined;
 }
 /**
  * Hands one batch to a function and reads what became of it.
@@ -43,10 +50,23 @@ interface SimLambdaEventSourceDeliveryProperties {
 export declare class SimLambdaEventSourceDelivery {
     private readonly eventBuilder;
     private readonly batchResponse;
+    private readonly filterCriteria;
     constructor(properties: SimLambdaEventSourceDeliveryProperties);
     /**
      * Deliver a batch, answering with what to delete and what to leave.
      */
     to(simFunction: SimLambdaFunction, messages: readonly SimSqsPollMessage[]): Promise<SimLambdaEventSourceBatchOutcome>;
+    /**
+     * One batch of matching messages, handed over and read back.
+     */
+    private invoked;
+    /**
+     * An outcome with the filtered-out messages counted as handled, which deletes
+     * them whatever the function said about the rest.
+     *
+     * A message the function never saw is in neither list the outcome carries,
+     * which is what picks it out of the batch that was read.
+     */
+    private alsoHandling;
 }
 export {};

package/dist/service/lambda/event-source/poll/sim-lambda-event-source-delivery.js

@@ -1,3 +1,5 @@
+import { SimLambdaEventSourceBatchOutcome, } from "./sim-lambda-event-source-batch-response.js";
+import { simLambdaFilteredDelivery } from "../filter/sim-lambda-filtered-delivery.js";
 /**
  * Hands one batch to a function and reads what became of it.
  *
@@ -11,22 +13,50 @@
 export class SimLambdaEventSourceDelivery {
     eventBuilder;
     batchResponse;
+    filterCriteria;
     constructor(properties) {
         this.eventBuilder = properties.eventBuilder;
         this.batchResponse = properties.batchResponse;
+        this.filterCriteria = properties.filterCriteria;
     }
     /**
      * Deliver a batch, answering with what to delete and what to leave.
      */
     async to(simFunction, messages) {
+        return await simLambdaFilteredDelivery({
+            criteria: this.filterCriteria,
+            records: messages,
+            documentOf: (message) => this.eventBuilder.filterDocumentOf(message),
+            // A message the filters excluded is deleted from the queue without the
+            // function seeing it, the way real Lambda deletes one.
+            handled: () => new SimLambdaEventSourceBatchOutcome(messages, []),
+            invoke: async (delivered) => this.alsoHandling(messages, await this.invoked(simFunction, delivered)),
+        });
+    }
+    /**
+     * One batch of matching messages, handed over and read back.
+     */
+    async invoked(simFunction, delivered) {
         try {
-            return this.batchResponse.handled(messages, await simFunction.invoke(this.eventBuilder.of(messages)));
+            return this.batchResponse.handled(delivered, await simFunction.invoke(this.eventBuilder.of(delivered)));
         }
         catch {
             // As on real Lambda, the handler error goes to the function's logs and
             // not to whoever sent the message. What the sender sees is the batch
             // coming back to the source.
-            return this.batchResponse.failed(messages);
+            return this.batchResponse.failed(delivered);
         }
     }
+    /**
+     * An outcome with the filtered-out messages counted as handled, which deletes
+     * them whatever the function said about the rest.
+     *
+     * A message the function never saw is in neither list the outcome carries,
+     * which is what picks it out of the batch that was read.
+     */
+    alsoHandling(messages, outcome) {
+        const seen = new Set([...outcome.handled, ...outcome.returned]);
+        const excluded = messages.filter((message) => !seen.has(message));
+        return new SimLambdaEventSourceBatchOutcome([...outcome.handled, ...excluded], outcome.returned);
+    }
 }

package/dist/service/lambda/event-source/poll/sim-lambda-sqs-delivery.js

@@ -12,5 +12,6 @@ export function makeSimLambdaSqsDelivery(properties) {
     return new SimLambdaEventSourceDelivery({
         eventBuilder: new SimLambdaSqsEventBuilder(properties.eventSourceArn),
         batchResponse: new SimLambdaSqsBatchResponse(properties.mapping.reportsBatchItemFailures),
+        filterCriteria: properties.mapping.filterCriteria,
     });
 }

package/dist/service/lambda/event-source/poll/sim-lambda-sqs-event.d.ts

@@ -50,6 +50,14 @@ export declare class SimLambdaSqsEventBuilder {
      * The event for a batch of messages.
      */
     of(messages: readonly SimSqsPollMessage[]): SimLambdaSqsEvent;
+    /**
+     * What a mapping's filters read one message as.
+     *
+     * Real Lambda filters an SQS message on its body alone, and reads the body as
+     * JSON where it holds JSON. Nothing else about the message is here, because a
+     * pattern naming anything else was refused when the mapping was created.
+     */
+    filterDocumentOf(message: SimSqsPollMessage): Record<string, unknown>;
     private record;
     private messageAttributes;
 }

package/dist/service/lambda/event-source/poll/sim-lambda-sqs-event.js

@@ -1,3 +1,4 @@
+import { simLambdaFilterData } from "../filter/sim-lambda-filtered-records.js";
 /**
  * Builds the SQS event for one batch of polled messages.
  *
@@ -17,6 +18,16 @@ export class SimLambdaSqsEventBuilder {
     of(messages) {
         return { Records: messages.map((message) => this.record(message)) };
     }
+    /**
+     * What a mapping's filters read one message as.
+     *
+     * Real Lambda filters an SQS message on its body alone, and reads the body as
+     * JSON where it holds JSON. Nothing else about the message is here, because a
+     * pattern naming anything else was refused when the mapping was created.
+     */
+    filterDocumentOf(message) {
+        return { body: simLambdaFilterData(message.Body) };
+    }
     record(message) {
         return {
             messageId: message.MessageId,

package/dist/service/lambda/event-source/sim-lambda-event-source-mapping.d.ts

@@ -1,6 +1,7 @@
 import type { SimLambdaStreamDestinationConfiguration } from "./sim-lambda-stream-destination-config.js";
 import type { SimLambdaDestinationTargets } from "../destination/sim-lambda-destination-targets.js";
 import type { SimAwsAccountRegionScope } from "../../aws/sim-aws-account-region-scope.js";
+import type { SimLambdaFilterCriteria, SimLambdaFilterCriteriaInput } from "./filter/sim-lambda-filter-criteria.js";
 import type { SimLambdaFunctionArn } from "../function/sim-lambda-function-configuration.js";
 import type { SimLambdaStreamRetryLimits, SimLambdaStreamRetryLimitsConfiguration } from "./sim-lambda-stream-retry-limits.js";
 import type { SimLambdaEventSourceStart, SimLambdaEventSourceStartingPosition } from "./sim-lambda-event-source-starting-position.js";
@@ -35,6 +36,7 @@ interface SimLambdaEventSourceMappingProperties {
     readonly streamRetryLimits?: SimLambdaStreamRetryLimits | undefined;
     readonly destinationConfig?: SimLambdaStreamDestinationConfiguration | undefined;
     readonly destinations?: SimLambdaDestinationTargets | undefined;
+    readonly filterCriteria?: SimLambdaFilterCriteria | undefined;
     readonly createdAt: Date;
 }
 /**
@@ -53,6 +55,7 @@ export interface SimLambdaEventSourceMappingConfiguration extends Partial<SimLam
     readonly StartingPositionTimestamp?: Date | undefined;
     readonly MaximumBatchingWindowInSeconds: number;
     readonly FunctionResponseTypes: readonly SimLambdaFunctionResponseType[];
+    readonly FilterCriteria?: SimLambdaFilterCriteriaInput | undefined;
     readonly State: SimLambdaEventSourceMappingState;
     readonly StateTransitionReason: string;
     readonly LastModified: Date;
@@ -89,6 +92,13 @@ export declare class SimLambdaEventSourceMapping {
      */
     readonly start: SimLambdaEventSourceStart | undefined;
     readonly functionResponseTypes: readonly SimLambdaFunctionResponseType[];
+    /**
+     * The filters a record has to match before it is delivered, if this mapping
+     * was created with any.
+     *
+     * A mapping with none delivers every record its source hands it.
+     */
+    readonly filterCriteria: SimLambdaFilterCriteria | undefined;
     /**
      * When this mapping stops delivering a batch its function keeps failing, for
      * a source that leaves the counting to the mapping.

package/dist/service/lambda/event-source/sim-lambda-event-source-mapping.js

@@ -31,6 +31,13 @@ export class SimLambdaEventSourceMapping {
      */
     start;
     functionResponseTypes;
+    /**
+     * The filters a record has to match before it is delivered, if this mapping
+     * was created with any.
+     *
+     * A mapping with none delivers every record its source hands it.
+     */
+    filterCriteria;
     /**
      * When this mapping stops delivering a batch its function keeps failing, for
      * a source that leaves the counting to the mapping.
@@ -59,6 +66,7 @@ export class SimLambdaEventSourceMapping {
         // cannot change what this mapping does with a batch afterwards.
         this.functionResponseTypes = [...(properties.functionResponseTypes ?? [])];
         this.streamRetryLimits = properties.streamRetryLimits;
+        this.filterCriteria = properties.filterCriteria;
         this.enabled = properties.enabled ?? true;
         this.lastModified = properties.createdAt;
     }
@@ -120,6 +128,9 @@ export class SimLambdaEventSourceMapping {
             // them out rather than reporting a limit it does not have.
             ...this.streamRetryLimits?.configuration(),
             FunctionResponseTypes: this.functionResponseTypes,
+            // A mapping created without filters reports none, as real Lambda does,
+            // rather than reporting an empty list of them.
+            FilterCriteria: this.filterCriteria?.configuration(),
             State: this.#state,
             StateTransitionReason: "USER_INITIATED",
             LastModified: this.lastModified,

package/dist/service/lambda/event-source/stream/sim-lambda-stream-cascade-guard.d.ts

@@ -1,4 +1,15 @@
 import type { SimLambdaEventSourceMapping } from "../sim-lambda-event-source-mapping.js";
+import type { SimLambdaStreamHalt } from "./sim-lambda-stream-halt.js";
+/**
+ * How many deliveries in a row may feed the source that invoked them before the
+ * simulation is refused.
+ *
+ * One write back is a handler doing its job, and the delivery it causes is the
+ * chance for that work to finish. A handler that settles takes two or three
+ * links of chain. A handler that loops takes every link there is, and the
+ * simulation has to say so before the test times out.
+ */
+export declare const simLambdaStreamCascadeLimit = 10;
 /**
  * The source a guard watches, said in the terms its own service uses.
  */
@@ -20,33 +31,49 @@ export interface SimLambdaStreamCascadeSource {
 interface SimLambdaStreamCascadeGuardProperties {
     readonly mapping: SimLambdaEventSourceMapping;
     readonly source: SimLambdaStreamCascadeSource;
+    /**
+     * What a refusal stops, since a mapping polling on from a checkpoint the
+     * refusal left where it was would deliver the same records again.
+     */
+    readonly halt: SimLambdaStreamHalt;
 }
 /**
- * Watches one mapping's deliveries for the function writing back into the
+ * Watches one mapping's deliveries for a chain of the function feeding the
  * source whose stream invoked it.
  *
  * The delivery runs inside its own asynchronous context, so a record written by
  * the handler is told apart from one written by anything else that happened to
  * be running at the same time. That distinction is the whole point: several
  * records written at once are an ordinary batch, and a handler feeding its own
- * source is a loop.
+ * source is the start of a chain.
+ *
+ * What the guard counts is the chain, and never the shape of one write. A
+ * handler that writes back and then finds its own work done writes nothing the
+ * second time round, the chain ends at one link, and the simulation settles. A
+ * handler that writes back every time takes the chain to
+ * `simLambdaStreamCascadeLimit` and is refused there.
  */
 export declare class SimLambdaStreamCascadeGuard {
     private readonly properties;
-    private cascaded;
+    private fedRecords;
+    private chained;
     constructor(properties: SimLambdaStreamCascadeGuardProperties);
     /**
-     * Run one delivery, refusing afterwards if the function fed its own source.
+     * Run one delivery, refusing afterwards if the chain has gone on long enough
+     * to say the simulation will never settle.
      *
      * The refusal comes after the delivery rather than during it, so the handler
-     * sees its own write succeed and the loop is reported to whoever is waiting
+     * sees its own write succeed and the chain is reported to whoever is waiting
      * for the simulation to settle.
      */
     around<Result>(delivery: () => Promise<Result>): Promise<Result>;
     /**
-     * Note a record written to the polled stream, answering with whether this
-     * mapping's own function wrote it.
+     * Note a record written to the polled stream, which counts only while this
+     * mapping's own function is the thing that is running.
+     *
+     * Counted rather than flagged, so a delivery can tell whether the count moved
+     * while it ran without the flag having to be put back afterwards.
      */
-    noteRecordWritten(): boolean;
+    noteRecordWritten(): void;
 }
 export {};

package/dist/service/lambda/event-source/stream/sim-lambda-stream-cascade-guard.js

@@ -1,51 +1,74 @@
 import { simLambdaEventSourceDeliveryContext } from "./sim-lambda-event-source-delivery-context.js";
 import { SimLambdaStreamCascadeError } from "./sim-lambda-stream-cascade.error.js";
 /**
- * Watches one mapping's deliveries for the function writing back into the
+ * How many deliveries in a row may feed the source that invoked them before the
+ * simulation is refused.
+ *
+ * One write back is a handler doing its job, and the delivery it causes is the
+ * chance for that work to finish. A handler that settles takes two or three
+ * links of chain. A handler that loops takes every link there is, and the
+ * simulation has to say so before the test times out.
+ */
+export const simLambdaStreamCascadeLimit = 10;
+/**
+ * Watches one mapping's deliveries for a chain of the function feeding the
  * source whose stream invoked it.
  *
  * The delivery runs inside its own asynchronous context, so a record written by
  * the handler is told apart from one written by anything else that happened to
  * be running at the same time. That distinction is the whole point: several
  * records written at once are an ordinary batch, and a handler feeding its own
- * source is a loop.
+ * source is the start of a chain.
+ *
+ * What the guard counts is the chain, and never the shape of one write. A
+ * handler that writes back and then finds its own work done writes nothing the
+ * second time round, the chain ends at one link, and the simulation settles. A
+ * handler that writes back every time takes the chain to
+ * `simLambdaStreamCascadeLimit` and is refused there.
  */
 export class SimLambdaStreamCascadeGuard {
     properties;
-    cascaded = false;
+    fedRecords = 0;
+    chained = 0;
     constructor(properties) {
         this.properties = properties;
     }
     /**
-     * Run one delivery, refusing afterwards if the function fed its own source.
+     * Run one delivery, refusing afterwards if the chain has gone on long enough
+     * to say the simulation will never settle.
      *
      * The refusal comes after the delivery rather than during it, so the handler
-     * sees its own write succeed and the loop is reported to whoever is waiting
+     * sees its own write succeed and the chain is reported to whoever is waiting
      * for the simulation to settle.
      */
     async around(delivery) {
+        const fedBefore = this.fedRecords;
         const result = await simLambdaEventSourceDeliveryContext.run(this, delivery);
-        if (this.cascaded) {
+        this.chained = this.fedRecords > fedBefore ? this.chained + 1 : 0;
+        if (this.chained >= simLambdaStreamCascadeLimit) {
             const { mapping, source } = this.properties;
+            this.properties.halt.stop();
             throw new SimLambdaStreamCascadeError({
                 functionName: mapping.functionName,
                 streamArn: source.streamArn,
                 wroteTo: source.wroteTo,
                 sourceRelation: source.sourceRelation,
                 advice: source.advice,
+                deliveries: this.chained,
             });
         }
         return result;
     }
     /**
-     * Note a record written to the polled stream, answering with whether this
-     * mapping's own function wrote it.
+     * Note a record written to the polled stream, which counts only while this
+     * mapping's own function is the thing that is running.
+     *
+     * Counted rather than flagged, so a delivery can tell whether the count moved
+     * while it ran without the flag having to be put back afterwards.
      */
     noteRecordWritten() {
-        if (!simLambdaEventSourceDeliveryContext.isDelivering(this)) {
-            return false;
+        if (simLambdaEventSourceDeliveryContext.isDelivering(this)) {
+            this.fedRecords += 1;
         }
-        this.cascaded = true;
-        return true;
     }
 }

package/dist/service/lambda/event-source/stream/sim-lambda-stream-cascade.error.d.ts

@@ -17,19 +17,28 @@ interface SimLambdaStreamCascadeErrorProperties {
      * in a second table, and a Kinesis result belongs on a second stream.
      */
     readonly advice: string;
+    /**
+     * How many deliveries in a row fed the source, which is the chain the guard
+     * counted before it gave up on the simulation settling.
+     */
+    readonly deliveries: number;
 }
 /**
- * A function writing back into the source whose stream invoked it.
+ * A function feeding the source whose stream invoked it, delivery after
+ * delivery.
  *
  * Every one of those writes is another stream record, which is another
  * delivery, which is another write. Real Lambda runs that loop for as long as
  * the account is willing to pay for it. Nothing here stops on its own, so the
  * simulation would go round until the test timed out with nothing to point at.
  *
+ * A handler that writes back and then settles is left alone. This is the chain
+ * that carried on, counted by `SimLambdaStreamCascadeGuard` up to
+ * `simLambdaStreamCascadeLimit`.
+ *
  * This is a simulator guard rather than AWS behaviour, and it is deliberately
- * not silent: a projection or an aggregate belongs in a second table or on a
- * second stream, and a test whose handler writes to its own source is testing a
- * loop.
+ * not silent: a projection or an aggregate that keeps going belongs in a second
+ * table or on a second stream.
  */
 export declare class SimLambdaStreamCascadeError extends SimLambdaError {
     readonly name = "SimLambdaStreamCascadeError";

package/dist/service/lambda/event-source/stream/sim-lambda-stream-cascade.error.js

@@ -1,23 +1,29 @@
 import { SimLambdaError } from "../../error/sim-lambda.error.js";
 /**
- * A function writing back into the source whose stream invoked it.
+ * A function feeding the source whose stream invoked it, delivery after
+ * delivery.
  *
  * Every one of those writes is another stream record, which is another
  * delivery, which is another write. Real Lambda runs that loop for as long as
  * the account is willing to pay for it. Nothing here stops on its own, so the
  * simulation would go round until the test timed out with nothing to point at.
  *
+ * A handler that writes back and then settles is left alone. This is the chain
+ * that carried on, counted by `SimLambdaStreamCascadeGuard` up to
+ * `simLambdaStreamCascadeLimit`.
+ *
  * This is a simulator guard rather than AWS behaviour, and it is deliberately
- * not silent: a projection or an aggregate belongs in a second table or on a
- * second stream, and a test whose handler writes to its own source is testing a
- * loop.
+ * not silent: a projection or an aggregate that keeps going belongs in a second
+ * table or on a second stream.
  */
 export class SimLambdaStreamCascadeError extends SimLambdaError {
     name = "SimLambdaStreamCascadeError";
     constructor(properties) {
         super(`Function ${properties.functionName} ${properties.wroteTo} while ` +
             `handling records from ${properties.sourceRelation} ` +
-            `${properties.streamArn}. Each write would be delivered back to the ` +
-            `function, so the simulation would never settle. ${properties.advice}`);
+            `${properties.streamArn} on ${String(properties.deliveries)} ` +
+            `deliveries in a row. Each of those writes was delivered back to the ` +
+            `function and brought on the next one, and the simulation is still ` +
+            `going round. ${properties.advice}`);
     }
 }

package/dist/service/lambda/event-source/stream/sim-lambda-stream-halt.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Whether a mapping has finished polling, and the one place that says so.
+ *
+ * Two things finish a mapping. Deleting it stops the poller, and the cascade
+ * guard refusing a chain of the function's own writes stops it too. A poll
+ * reads one answer either way, and neither side has to know about the other.
+ */
+export declare class SimLambdaStreamHalt {
+    private halted;
+    /**
+     * Whether polling has finished.
+     */
+    get stopped(): boolean;
+    /**
+     * Finish polling.
+     */
+    stop(): void;
+}

package/dist/service/lambda/event-source/stream/sim-lambda-stream-halt.js

@@ -0,0 +1,22 @@
+/**
+ * Whether a mapping has finished polling, and the one place that says so.
+ *
+ * Two things finish a mapping. Deleting it stops the poller, and the cascade
+ * guard refusing a chain of the function's own writes stops it too. A poll
+ * reads one answer either way, and neither side has to know about the other.
+ */
+export class SimLambdaStreamHalt {
+    halted = false;
+    /**
+     * Whether polling has finished.
+     */
+    get stopped() {
+        return this.halted;
+    }
+    /**
+     * Finish polling.
+     */
+    stop() {
+        this.halted = true;
+    }
+}

package/dist/service/scheduler/command/schedule/schedule.command.d.ts

@@ -95,6 +95,7 @@ export interface SimGetScheduleCommandOutput {
     readonly Name?: string | undefined;
     readonly GroupName?: string | undefined;
     readonly ScheduleExpression?: string | undefined;
+    readonly ScheduleExpressionTimezone?: string | undefined;
     readonly State?: string | undefined;
     readonly Description?: string | undefined;
     readonly ActionAfterCompletion?: string | undefined;

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

@@ -12,6 +12,7 @@ export function describedSchedule(schedule) {
         Name: schedule.name.value,
         GroupName: schedule.groupName,
         ScheduleExpression: schedule.schedule.source,
+        ScheduleExpressionTimezone: schedule.timeZone,
         State: schedule.state.value,
         Description: schedule.description,
         ActionAfterCompletion: schedule.actionAfterCompletion,

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

@@ -33,7 +33,8 @@ export class SimSchedulerScheduleWriter {
             name: requested.name,
             groupName: requested.groupName,
             accountRegionScope: this.accountRegionScope,
-            schedule: schedulerSchedule(input.ScheduleExpression),
+            schedule: schedulerSchedule(input.ScheduleExpression, input.ScheduleExpressionTimezone),
+            timeZone: input.ScheduleExpressionTimezone,
             target: SimSchedulerTarget.of(input.Target),
             state: SimSchedulerScheduleState.of(input.State),
             actionAfterCompletion: actionAfterCompletionIn(input.ActionAfterCompletion),

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

@@ -2,8 +2,8 @@ import type { SimSchedulerScheduleInput } from "./schedule.command.js";
 /**
  * Refuse the schedule request inputs this simulation does not model.
  *
- * A timezone is refused rather than ignored: a schedule whose cron expression
- * quietly ran in UTC when it was written for another zone would fire at the
- * wrong hour, which is precisely the thing a test of a nightly job is checking.
+ * A timezone is one it does model. A name no zone answers to is refused here
+ * rather than left to the expression reader, which would report it against
+ * `ScheduleExpression` and send the caller to the wrong parameter.
  */
 export declare function refuseUnsimulatedScheduleInput(input: SimSchedulerScheduleInput): void;

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

@@ -1,10 +1,23 @@
 import { SimSchedulerUnsimulatedInputException, SimSchedulerValidationException, } from "../../error/sim-scheduler.error.js";
+import { SimScheduleZone } from "../../../../util/schedule/sim-schedule-zone.js";
 import { refuseUnsimulatedTarget } from "./sim-scheduler-unsimulated-target.js";
 const maximumDescriptionLength = 512;
 /**
- * The timezone every simulated schedule runs in.
+ * Refuse a timezone no zone answers to, naming the parameter it came in on.
  */
-const simulatedTimezone = "UTC";
+function refuseUnknownTimezone(timezone) {
+    if (timezone === undefined) {
+        return;
+    }
+    try {
+        SimScheduleZone.of(timezone);
+    }
+    catch {
+        throw new SimSchedulerValidationException(`Invalid parameter: ScheduleExpressionTimezone Reason: ` +
+            `'${timezone}' is not a timezone. A timezone is an IANA name such ` +
+            `as 'Europe/London', or 'UTC'`);
+    }
+}
 /**
  * Read the flexible time window, which AWS requires on every request.
  *
@@ -32,19 +45,14 @@ function refuseFlexibleWindow(input) {
 /**
  * Refuse the schedule request inputs this simulation does not model.
  *
- * A timezone is refused rather than ignored: a schedule whose cron expression
- * quietly ran in UTC when it was written for another zone would fire at the
- * wrong hour, which is precisely the thing a test of a nightly job is checking.
+ * A timezone is one it does model. A name no zone answers to is refused here
+ * rather than left to the expression reader, which would report it against
+ * `ScheduleExpression` and send the caller to the wrong parameter.
  */
 export function refuseUnsimulatedScheduleInput(input) {
     refuseFlexibleWindow(input);
     refuseUnsimulatedTarget(input.Target);
-    const timezone = input.ScheduleExpressionTimezone;
-    if (timezone !== undefined && timezone !== simulatedTimezone) {
-        throw new SimSchedulerUnsimulatedInputException(`ScheduleExpressionTimezone '${timezone}' is not simulated. Every ` +
-            `simulated schedule runs in ${simulatedTimezone}, and running this ` +
-            `one there anyway would fire it at the wrong hour.`);
-    }
+    refuseUnknownTimezone(input.ScheduleExpressionTimezone);
     if (input.StartDate !== undefined || input.EndDate !== undefined) {
         throw new SimSchedulerUnsimulatedInputException("A schedule StartDate and EndDate are not simulated, so a schedule " +
             "carrying either is refused rather than created as one that fires " +

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

@@ -11,10 +11,12 @@ import type { SimScheduleDialect } from "../../../util/schedule/sim-schedule-dia
  */
 export declare const schedulerScheduleDialect: SimScheduleDialect;
 /**
- * Read the `ScheduleExpression` a request carried.
+ * Read the `ScheduleExpression` a request carried, in the zone it named.
  *
  * The shared parser knows nothing about Scheduler, so its refusals become this
  * service's own errors here. Which of the two a caller gets tells them whether
- * the expression is wrong or whether it is right and unsimulated.
+ * the expression is wrong or whether it is right and unsimulated. A timezone no
+ * zone answers to is refused the same way, since the parser is what knows which
+ * names there are.
  */
-export declare function schedulerSchedule(source: string | undefined): SimSchedule;
+export declare function schedulerSchedule(source: string | undefined, timeZone?: string): SimSchedule;

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

@@ -21,13 +21,15 @@ export const schedulerScheduleDialect = {
     allowsOneTime: true,
 };
 /**
- * Read the `ScheduleExpression` a request carried.
+ * Read the `ScheduleExpression` a request carried, in the zone it named.
  *
  * The shared parser knows nothing about Scheduler, so its refusals become this
  * service's own errors here. Which of the two a caller gets tells them whether
- * the expression is wrong or whether it is right and unsimulated.
+ * the expression is wrong or whether it is right and unsimulated. A timezone no
+ * zone answers to is refused the same way, since the parser is what knows which
+ * names there are.
  */
-export function schedulerSchedule(source) {
+export function schedulerSchedule(source, timeZone) {
     if (source === undefined || source === "") {
         throw new SimSchedulerValidationException("ScheduleExpression is required");
     }
@@ -36,7 +38,7 @@ export function schedulerSchedule(source) {
             `characters, and this one is ${String(source.length)}`);
     }
     try {
-        return SimSchedule.of(source, schedulerScheduleDialect);
+        return SimSchedule.of(source, schedulerScheduleDialect, timeZone);
     }
     catch (error) {
         if (error instanceof SimUnsimulatedScheduleExpressionError) {