@kensio/yulin 1.21.21 → 1.21.23

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) {

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

@@ -21,6 +21,8 @@ interface SimSchedulerScheduleProperties {
     readonly state: SimSchedulerScheduleState;
     readonly actionAfterCompletion: SimSchedulerActionAfterCompletion;
     readonly description?: string | undefined;
+    /** The timezone the request named, which a describe reports back. */
+    readonly timeZone?: string | undefined;
     readonly createdAt: Date;
 }
 /**
@@ -51,6 +53,13 @@ export declare class SimSchedulerSchedule {
     readonly target: SimSchedulerTarget;
     readonly actionAfterCompletion: SimSchedulerActionAfterCompletion;
     readonly description: string | undefined;
+    /**
+     * The timezone the schedule was created with, if it named one.
+     *
+     * A schedule created without one runs in UTC, and reports no timezone rather
+     * than reporting the one it fell back to.
+     */
+    readonly timeZone: string | undefined;
     readonly creationDate: Date;
     /**
      * When this schedule falls due, which is read as simulated time advances.

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

@@ -28,6 +28,13 @@ export class SimSchedulerSchedule {
     target;
     actionAfterCompletion;
     description;
+    /**
+     * The timezone the schedule was created with, if it named one.
+     *
+     * A schedule created without one runs in UTC, and reports no timezone rather
+     * than reporting the one it fell back to.
+     */
+    timeZone;
     creationDate;
     /**
      * When this schedule falls due, which is read as simulated time advances.
@@ -45,6 +52,7 @@ export class SimSchedulerSchedule {
         this.target = properties.target;
         this.actionAfterCompletion = properties.actionAfterCompletion;
         this.description = properties.description;
+        this.timeZone = properties.timeZone;
         this.creationDate = properties.createdAt;
         this.modified = properties.createdAt;
         this.held = properties.state;

package/dist/util/schedule/at/sim-at-expression.d.ts

@@ -1,3 +1,4 @@
+import type { SimScheduleZone } from "../sim-schedule-zone.js";
 /**
  * One `at()` expression: a single instant, and never another.
  *
@@ -12,7 +13,7 @@ export declare class SimAtExpression {
     /**
      * Read the instant inside an `at(...)`.
      */
-    static of(source: string): SimAtExpression;
+    static of(source: string, zone: SimScheduleZone): SimAtExpression;
     /**
      * The instant this expression names, once, and nothing after that.
      *

package/dist/util/schedule/at/sim-at-expression.js

@@ -7,6 +7,7 @@ import { SimScheduleExpressionError } from "../sim-schedule.error.js";
  * schedule rather than part of the expression, which is why one written here
  * would be ambiguous rather than helpful.
  */
+const millisecondsPerSecond = 1000;
 const atInstant = /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})T(?<hour>\d{2}):(?<minute>\d{2}):(?<second>\d{2})$/u;
 /**
  * One `at()` expression: a single instant, and never another.
@@ -25,7 +26,7 @@ export class SimAtExpression {
     /**
      * Read the instant inside an `at(...)`.
      */
-    static of(source) {
+    static of(source, zone) {
         const read = atInstant.exec(source.trim())?.groups;
         if (read === undefined) {
             throw new SimScheduleExpressionError(`an at expression is an instant written 'yyyy-mm-ddThh:mm:ss', with ` +
@@ -37,11 +38,14 @@ export class SimAtExpression {
         // JavaScript rolls an impossible date over rather than refusing it, so the
         // thirtieth of February quietly becomes the second of March and half past
         // twenty-five becomes tomorrow morning. Writing the instant back out is
-        // what catches every one of those in one comparison.
+        // what catches every one of those in one comparison. The calendar is read
+        // in UTC for this, since which instant the wall-clock time is depends on
+        // the zone and whether it is a real time of day does not.
         if (!at.toISOString().startsWith(written)) {
             throw new SimScheduleExpressionError(`an at expression names a real instant, and '${source}' is not one`);
         }
-        return new this(source, at);
+        const minuteStart = zone.instantOf(Number(year), Number(month) - 1, Number(day), Number(hour), Number(minute));
+        return new this(source, new Date(minuteStart + Number(second) * millisecondsPerSecond));
     }
     /**
      * The instant this expression names, once, and nothing after that.

package/dist/util/schedule/cron/sim-cron-expression.d.ts

@@ -1,13 +1,16 @@
+import type { SimScheduleZone } from "../sim-schedule-zone.js";
 import type { SimCronFieldSpec } from "./sim-cron-field-spec.js";
 /**
  * One cron expression, read into the instants it falls due at.
  *
- * Everything is read in UTC. AWS runs scheduled rules in UTC and offers a
- * timezone as a separate setting, so a local timezone never enters into this.
+ * The fields name a wall-clock time, and the schedule's zone is what says which
+ * instants those are. An EventBridge rule has no timezone setting and gets the
+ * UTC zone, which reads exactly as the UTC calendar does.
  */
 export declare class SimCronExpression {
     readonly source: string;
     private readonly fields;
+    private readonly zone;
     private constructor();
     /**
      * Read a cron expression against a dialect's fields.
@@ -16,7 +19,7 @@ export declare class SimCronExpression {
      * is refused naming the form expected rather than read as though the missing
      * one were at the end.
      */
-    static of(specs: readonly SimCronFieldSpec[], source: string): SimCronExpression;
+    static of(specs: readonly SimCronFieldSpec[], source: string, zone: SimScheduleZone): SimCronExpression;
     /**
      * The next instant this expression falls due after an instant.
      *

package/dist/util/schedule/cron/sim-cron-expression.js

@@ -17,15 +17,18 @@ function startOfNextMinute(instant) {
 /**
  * One cron expression, read into the instants it falls due at.
  *
- * Everything is read in UTC. AWS runs scheduled rules in UTC and offers a
- * timezone as a separate setting, so a local timezone never enters into this.
+ * The fields name a wall-clock time, and the schedule's zone is what says which
+ * instants those are. An EventBridge rule has no timezone setting and gets the
+ * UTC zone, which reads exactly as the UTC calendar does.
  */
 export class SimCronExpression {
     source;
     fields;
-    constructor(source, fields) {
+    zone;
+    constructor(source, fields, zone) {
         this.source = source;
         this.fields = fields;
+        this.zone = zone;
     }
     /**
      * Read a cron expression against a dialect's fields.
@@ -34,14 +37,14 @@ export class SimCronExpression {
      * is refused naming the form expected rather than read as though the missing
      * one were at the end.
      */
-    static of(specs, source) {
+    static of(specs, source, zone) {
         const written = source.trim().split(whitespace);
         if (written.length !== specs.length) {
             throw new SimScheduleExpressionError(`a cron expression has ${String(specs.length)} fields separated by ` +
                 `spaces, ${specs.map((spec) => spec.name).join(" ")}, and this one ` +
                 `has ${String(written.length)}`);
         }
-        return new this(source, readFields(specs, written));
+        return new this(source, readFields(specs, written), zone);
     }
     /**
      * The next instant this expression falls due after an instant.
@@ -50,7 +53,7 @@ export class SimCronExpression {
      * has, since a cron expression naming only years in the past falls due never.
      */
     nextAfter(instant) {
-        const end = Date.UTC(this.fields.year.maximum + 1, 0, 1);
+        const end = this.zone.instantOf(this.fields.year.maximum + 1, 0, 1);
         let candidate = startOfNextMinute(instant);
         while (candidate < end) {
             const skipTo = this.skipUnmatched(candidate);
@@ -71,27 +74,27 @@ export class SimCronExpression {
      * steps rather than the million minutes they hold.
      */
     skipUnmatched(at) {
-        const date = new Date(at);
-        const year = date.getUTCFullYear();
+        const read = this.zone.partsAt(at);
+        const { year, month, day, hour } = read;
         if (!this.fields.year.allows(year)) {
-            return Date.UTC(year + 1, 0, 1);
+            return this.zone.instantOf(year + 1, 0, 1);
         }
-        const month = date.getUTCMonth();
         if (!this.fields.month.allows(month + 1)) {
-            return Date.UTC(year, month + 1, 1);
+            return this.zone.instantOf(year, month + 1, 1);
         }
-        const day = date.getUTCDate();
-        if (!this.allowsDay(date)) {
-            return Date.UTC(year, month, day + 1);
+        if (!this.allowsDay(read)) {
+            return this.zone.instantOf(year, month, day + 1);
         }
-        const hour = date.getUTCHours();
         if (!this.fields.hours.allows(hour)) {
-            return Date.UTC(year, month, day, hour + 1);
+            return this.zone.instantOf(year, month, day, hour + 1);
         }
-        if (!this.fields.minutes.allows(date.getUTCMinutes())) {
+        if (!this.fields.minutes.allows(read.minute)) {
             return at + millisecondsPerMinute;
         }
-        return undefined;
+        // The second of a repeated hour reads the same wall clock as the first and
+        // has already been answered with. Real Scheduler fires once when the clocks
+        // go back, rather than twice.
+        return this.zone.isCanonical(at) ? undefined : at + millisecondsPerMinute;
     }
     /**
      * Whether this expression names a day.
@@ -99,12 +102,12 @@ export class SimCronExpression {
      * Whichever of the two day fields is not `?` is the one that decides, which
      * is why they cannot both say something.
      */
-    allowsDay(date) {
+    allowsDay(read) {
         if (this.fields.dayOfMonth.isAny) {
             // AWS numbers the week from Sunday as one, and JavaScript from Sunday as
             // zero.
-            return this.fields.dayOfWeek.allows(date.getUTCDay() + 1);
+            return this.fields.dayOfWeek.allows(read.weekday + 1);
         }
-        return this.fields.dayOfMonth.allows(date.getUTCDate());
+        return this.fields.dayOfMonth.allows(read.day);
     }
 }

package/dist/util/schedule/sim-schedule-zone-clock.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The wall-clock reading of one instant, as a schedule expression names it.
+ */
+export interface SimScheduleZoneParts {
+    readonly year: number;
+    /** The month as a JavaScript `Date` numbers it, January being zero. */
+    readonly month: number;
+    readonly day: number;
+    readonly hour: number;
+    readonly minute: number;
+    /** The day of the week, Sunday being zero. */
+    readonly weekday: number;
+}
+/**
+ * Reads what a clock in one zone says at an instant.
+ */
+export type SimScheduleZoneClock = (instant: number) => SimScheduleZoneParts;
+/**
+ * A clock for one zone, refusing a name no zone answers to.
+ *
+ * `Intl.DateTimeFormat` is what knows the offsets, including the two days a
+ * year a zone changes one, so no timezone database travels with this. Which
+ * names there are is therefore the host's own, and a name it has never heard
+ * of is refused here.
+ */
+export declare function simScheduleZoneClock(name: string): SimScheduleZoneClock;

package/dist/util/schedule/sim-schedule-zone-clock.js

@@ -0,0 +1,56 @@
+import { SimScheduleExpressionError } from "./sim-schedule.error.js";
+const weekdays = [
+    "Sun",
+    "Mon",
+    "Tue",
+    "Wed",
+    "Thu",
+    "Fri",
+    "Sat",
+];
+/**
+ * A clock for one zone, refusing a name no zone answers to.
+ *
+ * `Intl.DateTimeFormat` is what knows the offsets, including the two days a
+ * year a zone changes one, so no timezone database travels with this. Which
+ * names there are is therefore the host's own, and a name it has never heard
+ * of is refused here.
+ */
+export function simScheduleZoneClock(name) {
+    const format = zoneFormat(name);
+    return (instant) => {
+        const parts = new Map(format
+            .formatToParts(new Date(instant))
+            .map((part) => [part.type, part.value]));
+        return {
+            year: Number(parts.get("year")),
+            month: Number(parts.get("month")) - 1,
+            day: Number(parts.get("day")),
+            // Midnight reads as 24 under some locales rather than as zero.
+            hour: Number(parts.get("hour")) % 24,
+            minute: Number(parts.get("minute")),
+            weekday: weekdays.indexOf(parts.get("weekday") ?? ""),
+        };
+    };
+}
+/**
+ * The formatter for a zone, which is also what decides the name is one.
+ */
+function zoneFormat(name) {
+    try {
+        return new Intl.DateTimeFormat("en-US", {
+            timeZone: name,
+            hourCycle: "h23",
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+            hour: "2-digit",
+            minute: "2-digit",
+            weekday: "short",
+        });
+    }
+    catch {
+        throw new SimScheduleExpressionError(`'${name}' is not a timezone. A timezone is an IANA name such as ` +
+            `'Europe/London', or 'UTC'`);
+    }
+}