@kensio/yulin 1.21.20 → 1.21.22

package/dist/service/lambda/function/invoke/sim-lambda-stall-watch.js

@@ -0,0 +1,78 @@
+import { clearTimeout, setTimeout } from "node:timers";
+const millisecondsPerSecond = 1000;
+/** The least host time a stopped clock gets before an invocation is stalled. */
+const shortestWatchMilliseconds = 1000;
+/** The most host time a stopped clock gets, whatever the function's timeout. */
+const longestWatchMilliseconds = 2000;
+/**
+ * A watch on host time for an invocation the simulated clock has left behind.
+ *
+ * A handler's timers wait on the simulation's clock, and so does the
+ * invocation's deadline. Simulated time standing still holds both, and the
+ * invocation runs on until the test framework gives up on the test around it.
+ * Elapsed host time is the only thing separating that from a test meaning to
+ * start an invocation, advance the clock and then wait for it, which is why
+ * host time is what this watches.
+ *
+ * A turn that finds simulated time has moved starts the wait again, so a test
+ * advancing the clock in steps is left alone. The host timer is unreferenced,
+ * and an invocation nobody is driving never holds the process open.
+ */
+export class SimLambdaStallWatch {
+    #properties;
+    #delay;
+    #seenAt = 0;
+    #hostTimer;
+    constructor(properties) {
+        this.#properties = properties;
+        this.#delay = simLambdaStallWatchDelay(properties.timeoutSeconds);
+    }
+    /**
+     * Start watching, from the instant the clock reads now.
+     */
+    start() {
+        this.#seenAt = this.#properties.background.now().getTime();
+        this.#arm();
+    }
+    /**
+     * Give up watching, as an invocation that has ended does.
+     */
+    cancel() {
+        clearTimeout(this.#hostTimer);
+        this.#hostTimer = undefined;
+    }
+    #arm() {
+        this.#hostTimer = setTimeout(() => {
+            this.#hostTimer = undefined;
+            this.#check();
+        }, this.#delay);
+        this.#hostTimer.unref();
+    }
+    /**
+     * See whether the invocation still has a way to finish, and watch on where
+     * it has: either simulated time has moved since the last turn, or the
+     * handler is busy with something other than a timer.
+     */
+    #check() {
+        const now = this.#properties.background.now().getTime();
+        const waitingOn = this.#properties.waitingOn();
+        if (waitingOn === undefined || now !== this.#seenAt) {
+            this.#seenAt = now;
+            this.#arm();
+            return;
+        }
+        this.#properties.stalled(waitingOn, this.#delay);
+    }
+}
+/**
+ * How long the host waits before it calls an invocation stalled.
+ *
+ * The function's own timeout is the bound that fits, since an invocation the
+ * deadline would have ended already has nothing left to wait for. It is held
+ * between one and two seconds. Below that a loaded host could fail a test that
+ * was about to advance the clock, and above it a test framework's own timeout
+ * arrives first and takes the diagnostic with it.
+ */
+function simLambdaStallWatchDelay(timeoutSeconds) {
+    return Math.min(Math.max(timeoutSeconds * millisecondsPerSecond, shortestWatchMilliseconds), longestWatchMilliseconds);
+}

package/dist/service/lambda/function/invoke/sim-lambda-stalled.error.d.ts

@@ -0,0 +1,23 @@
+import { SimLambdaRuntimeError } from "../../error/sim-lambda-runtime.error.js";
+import type { SimLambdaPendingTimer } from "./timer/sim-lambda-pending-timer.js";
+interface SimLambdaStalledProperties {
+    readonly awsRequestId: string;
+    /** The simulated instant the clock has stopped at. */
+    readonly at: Date;
+    /** The timer the invocation is waiting on. */
+    readonly waitingOn: SimLambdaPendingTimer;
+    /** How long the host has watched simulated time stand still. */
+    readonly waitedMilliseconds: number;
+}
+/**
+ * The error an invocation gets when nothing is left that could end it.
+ *
+ * A handler's timers wait on the simulation's clock, and so does the
+ * invocation's own deadline. Simulated time standing still holds both, and the
+ * invocation would otherwise run until the test framework gave up on the test
+ * around it, reporting the test rather than the timer. This names the timer
+ * the handler is waiting on, the instant it is due at, and what to do about
+ * it.
+ */
+export declare function simLambdaStalledError(properties: SimLambdaStalledProperties): SimLambdaRuntimeError;
+export {};

package/dist/service/lambda/function/invoke/sim-lambda-stalled.error.js

@@ -0,0 +1,22 @@
+import { SimLambdaRuntimeError } from "../../error/sim-lambda-runtime.error.js";
+/** What Yulin calls an invocation the clock is never going to release. */
+const stalledErrorType = "Yulin.StalledInvocation";
+/**
+ * The error an invocation gets when nothing is left that could end it.
+ *
+ * A handler's timers wait on the simulation's clock, and so does the
+ * invocation's own deadline. Simulated time standing still holds both, and the
+ * invocation would otherwise run until the test framework gave up on the test
+ * around it, reporting the test rather than the timer. This names the timer
+ * the handler is waiting on, the instant it is due at, and what to do about
+ * it.
+ */
+export function simLambdaStalledError(properties) {
+    const { awsRequestId, at, waitingOn, waitedMilliseconds } = properties;
+    const error = new SimLambdaRuntimeError(stalledErrorType, `${at.toISOString()} ${awsRequestId} Task is waiting on a ${waitingOn.delay} ms timer due at ${waitingOn.dueTime.toISOString()}. Simulated time has stood still for ${waitedMilliseconds} ms of host time, leaving both that timer and the invocation deadline out of reach. Advance the simulation's clock past the timer delay to release it.`);
+    // Nothing in the handler threw, so its frames say nothing about why the
+    // invocation is stuck, and the simulator's own frames say less. The timeout
+    // this stands in for is reported without a stack too.
+    error.stack = `${error.name}: ${error.message}`;
+    return error;
+}

package/dist/service/lambda/function/invoke/timer/sim-lambda-clock-timer.d.ts

@@ -21,6 +21,10 @@ interface SimLambdaClockTimerProperties {
 export declare class SimLambdaClockTimer {
     #private;
     constructor(properties: SimLambdaClockTimerProperties);
+    /** The delay this timer was last started with, in milliseconds. */
+    get delay(): number;
+    /** The simulated instant this timer's work is due to run at. */
+    get dueTime(): Date;
     /**
      * Wait a delay of simulated time, and answer with how long that turned out
      * to be. A delay of nothing leaves the timer due where the clock already

package/dist/service/lambda/function/invoke/timer/sim-lambda-clock-timer.js

@@ -31,6 +31,14 @@ export class SimLambdaClockTimer {
         this.#run = properties.run;
         this.#dueTime = properties.background.now();
     }
+    /** The delay this timer was last started with, in milliseconds. */
+    get delay() {
+        return this.#delay;
+    }
+    /** The simulated instant this timer's work is due to run at. */
+    get dueTime() {
+        return new Date(this.#dueTime);
+    }
     /**
      * Wait a delay of simulated time, and answer with how long that turned out
      * to be. A delay of nothing leaves the timer due where the clock already

package/dist/service/lambda/function/invoke/timer/sim-lambda-invocation-timers.d.ts

@@ -1,4 +1,5 @@
 import type { BackgroundScheduler } from "../../../../../util/background/background.js";
+import type { SimLambdaPendingTimer } from "./sim-lambda-pending-timer.js";
 import { type SimLambdaTimerCallback, SimLambdaTimerHandle, type SimLambdaTimerOwner, type SimLambdaTimers } from "./sim-lambda-timer-handle.js";
 interface SimLambdaInvocationTimersProperties {
     readonly background: BackgroundScheduler;
@@ -31,6 +32,15 @@ export declare class SimLambdaInvocationTimers implements SimLambdaTimers, SimLa
      * Run a callback every time simulated time moves on by a delay.
      */
     setInterval(callback: SimLambdaTimerCallback, delay?: number, ...arguments_: unknown[]): SimLambdaTimerHandle;
+    /**
+     * The timer this invocation is waiting on, the earliest due one where it
+     * has several.
+     *
+     * A timer due at the instant the clock already reads is waiting for nothing:
+     * the next turn of the host event loop runs it. Only a timer the clock has
+     * yet to reach counts.
+     */
+    pending(): SimLambdaPendingTimer | undefined;
     /**
      * Give up one timer, as `clearTimeout` and `clearInterval` do.
      */

package/dist/service/lambda/function/invoke/timer/sim-lambda-invocation-timers.js

@@ -42,6 +42,27 @@ export class SimLambdaInvocationTimers {
             this.#call(callback, arguments_);
         });
     }
+    /**
+     * The timer this invocation is waiting on, the earliest due one where it
+     * has several.
+     *
+     * A timer due at the instant the clock already reads is waiting for nothing:
+     * the next turn of the host event loop runs it. Only a timer the clock has
+     * yet to reach counts.
+     */
+    pending() {
+        const now = this.#background.now().getTime();
+        let earliest;
+        for (const timer of this.#running.values()) {
+            if (timer.dueTime.getTime() > now && isEarlier(timer, earliest)) {
+                earliest = timer;
+            }
+        }
+        if (earliest === undefined) {
+            return undefined;
+        }
+        return { delay: earliest.delay, dueTime: earliest.dueTime };
+    }
     /**
      * Give up one timer, as `clearTimeout` and `clearInterval` do.
      */
@@ -110,3 +131,10 @@ export class SimLambdaInvocationTimers {
         this.#released = undefined;
     }
 }
+/**
+ * Whether a timer comes due before the earliest one found so far. The first
+ * timer looked at has nothing to beat.
+ */
+function isEarlier(timer, earliest) {
+    return earliest === undefined || timer.dueTime < earliest.dueTime;
+}

package/dist/service/lambda/function/invoke/timer/sim-lambda-pending-timer.d.ts

@@ -0,0 +1,9 @@
+/**
+ * A timer one invocation is waiting on, and the instant it comes due.
+ */
+export interface SimLambdaPendingTimer {
+    /** The delay the code under test asked for, in milliseconds. */
+    readonly delay: number;
+    /** The simulated instant the timer's work runs at. */
+    readonly dueTime: Date;
+}

package/dist/service/lambda/function/invoke/timer/sim-lambda-pending-timer.js

@@ -0,0 +1 @@
+export {};

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;