@kensio/yulin 1.21.3 → 1.21.5

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

@@ -0,0 +1,15 @@
+import { SimLambdaRuntimeError } from "../../error/sim-lambda-runtime.error.js";
+interface SimLambdaTimedOutProperties {
+    /** The instant the invocation's time ran out. */
+    readonly at: Date;
+    readonly awsRequestId: string;
+    readonly timeoutSeconds: number;
+}
+/**
+ * The error real Lambda answers a caller with when time ran out.
+ *
+ * The message names the invocation and how long it had, the way the runtime
+ * writes it to the log group and puts it in the Invoke response payload.
+ */
+export declare function simLambdaTimedOutError(properties: SimLambdaTimedOutProperties): SimLambdaRuntimeError;
+export {};

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

@@ -0,0 +1,18 @@
+import { SimLambdaRuntimeError } from "../../error/sim-lambda-runtime.error.js";
+/** What real Lambda calls an invocation that ran out of time. */
+const timedOutErrorType = "Sandbox.Timedout";
+/**
+ * The error real Lambda answers a caller with when time ran out.
+ *
+ * The message names the invocation and how long it had, the way the runtime
+ * writes it to the log group and puts it in the Invoke response payload.
+ */
+export function simLambdaTimedOutError(properties) {
+    const { at, awsRequestId, timeoutSeconds } = properties;
+    const error = new SimLambdaRuntimeError(timedOutErrorType, `${at.toISOString()} ${awsRequestId} Task timed out after ${timeoutSeconds.toFixed(2)} seconds`);
+    // Nothing in the handler threw, so there are no handler frames to report,
+    // and the simulator's own are no use to whoever reads the payload. Real
+    // Lambda reports a timeout without a stack at all.
+    error.stack = `${error.name}: ${error.message}`;
+    return error;
+}

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

@@ -0,0 +1,12 @@
+import { SimLambdaTimerHandle } from "./sim-lambda-timer-handle.js";
+/** Whatever a caller passes to `clearTimeout` or `clearInterval`. */
+type SimLambdaTimerGiven = SimLambdaTimerHandle | NodeJS.Timeout | undefined;
+/**
+ * Give up a timer, whichever kind of timer it turned out to be.
+ */
+export declare function simLambdaClearTimeout(handle: SimLambdaTimerGiven): void;
+/**
+ * Give up a repeating timer, whichever kind of timer it turned out to be.
+ */
+export declare function simLambdaClearInterval(handle: SimLambdaTimerGiven): void;
+export {};

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

@@ -0,0 +1,28 @@
+import { clearInterval as hostClearInterval, clearTimeout as hostClearTimeout, } from "node:timers";
+import { SimLambdaTimerHandle } from "./sim-lambda-timer-handle.js";
+/**
+ * Give up a timer, whichever kind of timer it turned out to be.
+ */
+export function simLambdaClearTimeout(handle) {
+    giveUp(handle, hostClearTimeout);
+}
+/**
+ * Give up a repeating timer, whichever kind of timer it turned out to be.
+ */
+export function simLambdaClearInterval(handle) {
+    giveUp(handle, hostClearInterval);
+}
+/**
+ * Give up a timer on the timeline it was made on.
+ *
+ * The handle says which. A simulated one is given up on the invocation that
+ * made it rather than on whichever invocation is running now, so a handle
+ * passed around clears what it names.
+ */
+function giveUp(handle, hostClear) {
+    if (handle instanceof SimLambdaTimerHandle) {
+        handle.cancel();
+        return;
+    }
+    hostClear(handle);
+}

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

@@ -0,0 +1,46 @@
+import type { BackgroundScheduler } from "../../../../../util/background/background.js";
+interface SimLambdaClockTimerProperties {
+    readonly background: BackgroundScheduler;
+    /** What happens once simulated time reaches this timer's instant. */
+    readonly run: () => void;
+}
+/**
+ * One thing that happens when a simulation's clock reaches an instant.
+ *
+ * The instant is what decides, and simulated time can arrive at it two ways. A
+ * test that moves the clock brings it there at once, which is what the
+ * scheduler's own clock-waiting queue is for. A simulation left running keeps
+ * time with the host, and nothing dispatches that queue, so the timer also
+ * keeps a host timer of its own and asks the clock again when it fires. A
+ * clock that has not got there yet is asked again later, which is what makes a
+ * frozen clock hold a timer indefinitely without spinning on it.
+ *
+ * The host timer is unreferenced, so a simulation nobody is driving never
+ * holds the process open.
+ */
+export declare class SimLambdaClockTimer {
+    #private;
+    constructor(properties: SimLambdaClockTimerProperties);
+    /**
+     * 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
+     * reads, which is not waiting on the clock at all.
+     */
+    startIn(delay: number | undefined): number;
+    /**
+     * Wait the same delay again, measured from the instant this timer was last
+     * due rather than from the time its work ran, so an advance covering several
+     * periods runs the work once for each of them.
+     */
+    again(): void;
+    /**
+     * Wait for simulated time to reach an instant, giving up whatever this timer
+     * was waiting for before.
+     */
+    startAt(dueTime: Date): void;
+    /**
+     * Give up on this timer, on both timelines.
+     */
+    cancel(): void;
+}
+export {};

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

@@ -0,0 +1,104 @@
+import { clearTimeout, setTimeout } from "node:timers";
+import { simLambdaTimerDelay } from "./sim-lambda-timer-delay.js";
+/** The longest delay a host timer takes before it fires straight away. */
+const longestHostDelayMilliseconds = 2_147_483_647;
+/**
+ * One thing that happens when a simulation's clock reaches an instant.
+ *
+ * The instant is what decides, and simulated time can arrive at it two ways. A
+ * test that moves the clock brings it there at once, which is what the
+ * scheduler's own clock-waiting queue is for. A simulation left running keeps
+ * time with the host, and nothing dispatches that queue, so the timer also
+ * keeps a host timer of its own and asks the clock again when it fires. A
+ * clock that has not got there yet is asked again later, which is what makes a
+ * frozen clock hold a timer indefinitely without spinning on it.
+ *
+ * The host timer is unreferenced, so a simulation nobody is driving never
+ * holds the process open.
+ */
+export class SimLambdaClockTimer {
+    #background;
+    #run;
+    #task = () => {
+        this.#dispatch();
+        return Promise.resolve();
+    };
+    #dueTime;
+    #delay = 0;
+    #hostTimer;
+    constructor(properties) {
+        this.#background = properties.background;
+        this.#run = properties.run;
+        this.#dueTime = properties.background.now();
+    }
+    /**
+     * 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
+     * reads, which is not waiting on the clock at all.
+     */
+    startIn(delay) {
+        this.#delay = simLambdaTimerDelay(delay);
+        this.startAt(new Date(this.#background.now().getTime() + this.#delay));
+        return this.#delay;
+    }
+    /**
+     * Wait the same delay again, measured from the instant this timer was last
+     * due rather than from the time its work ran, so an advance covering several
+     * periods runs the work once for each of them.
+     */
+    again() {
+        this.startAt(new Date(this.#dueTime.getTime() + this.#delay));
+    }
+    /**
+     * Wait for simulated time to reach an instant, giving up whatever this timer
+     * was waiting for before.
+     */
+    startAt(dueTime) {
+        this.cancel();
+        this.#dueTime = dueTime;
+        this.#background.scheduleAt(dueTime, this.#task);
+        this.#armHostTimer();
+    }
+    /**
+     * Give up on this timer, on both timelines.
+     */
+    cancel() {
+        this.#background.cancelScheduled(this.#task);
+        clearTimeout(this.#hostTimer);
+        this.#hostTimer = undefined;
+    }
+    /**
+     * Run this timer's work, on whichever timeline got there first.
+     *
+     * Taking it off both timelines first is what makes it happen once, and what
+     * leaves work that starts this timer again beginning from nothing rather
+     * than from a turn already queued.
+     */
+    #dispatch() {
+        this.cancel();
+        this.#run();
+    }
+    /**
+     * Ask the clock again when the host gets to the delay this timer has left.
+     */
+    #armHostTimer() {
+        this.#hostTimer = setTimeout(() => {
+            this.#hostTimer = undefined;
+            if (this.#dueTime.getTime() <= this.#background.now().getTime()) {
+                this.#dispatch();
+                return;
+            }
+            this.#armHostTimer();
+        }, this.#remainingHostDelay());
+        this.#hostTimer.unref();
+    }
+    /**
+     * How long the host should wait before asking the clock again, kept inside
+     * what a host timer can hold: a longer one fires at once, and a timer that
+     * fired at once and found nothing due would spin.
+     */
+    #remainingHostDelay() {
+        const remaining = this.#dueTime.getTime() - this.#background.now().getTime();
+        return Math.min(Math.max(remaining, 0), longestHostDelayMilliseconds);
+    }
+}

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

@@ -0,0 +1,24 @@
+import type { SimLambdaTimerCallback, SimLambdaTimers } from "./sim-lambda-timer-handle.js";
+/**
+ * The timers code outside a sim Lambda invocation gets, which are the host's
+ * own.
+ *
+ * A test run's own timers, a test framework's, and one simulation's while
+ * another is running an invocation all come through here, so the substitutes
+ * installed over the globals behave exactly as the globals they replaced.
+ */
+declare class SimLambdaHostTimers implements SimLambdaTimers {
+    /**
+     * Run a callback once a delay of real time has passed.
+     */
+    setTimeout(callback: SimLambdaTimerCallback, delay?: number, ...arguments_: unknown[]): NodeJS.Timeout;
+    /**
+     * Run a callback every time a delay of real time passes.
+     */
+    setInterval(callback: SimLambdaTimerCallback, delay?: number, ...arguments_: unknown[]): NodeJS.Timeout;
+}
+/**
+ * Shared because it holds nothing: every caller wants the same host timers.
+ */
+export declare const simLambdaHostTimers: SimLambdaHostTimers;
+export {};

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

@@ -0,0 +1,27 @@
+import { setInterval as hostSetInterval, setTimeout as hostSetTimeout, } from "node:timers";
+/**
+ * The timers code outside a sim Lambda invocation gets, which are the host's
+ * own.
+ *
+ * A test run's own timers, a test framework's, and one simulation's while
+ * another is running an invocation all come through here, so the substitutes
+ * installed over the globals behave exactly as the globals they replaced.
+ */
+class SimLambdaHostTimers {
+    /**
+     * Run a callback once a delay of real time has passed.
+     */
+    setTimeout(callback, delay, ...arguments_) {
+        return hostSetTimeout(callback, delay, ...arguments_);
+    }
+    /**
+     * Run a callback every time a delay of real time passes.
+     */
+    setInterval(callback, delay, ...arguments_) {
+        return hostSetInterval(callback, delay, ...arguments_);
+    }
+}
+/**
+ * Shared because it holds nothing: every caller wants the same host timers.
+ */
+export const simLambdaHostTimers = new SimLambdaHostTimers();

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

@@ -0,0 +1,43 @@
+import type { BackgroundScheduler } from "../../../../../util/background/background.js";
+import { type SimLambdaTimerCallback, SimLambdaTimerHandle, type SimLambdaTimerOwner, type SimLambdaTimers } from "./sim-lambda-timer-handle.js";
+interface SimLambdaInvocationTimersProperties {
+    readonly background: BackgroundScheduler;
+    /** Where an error thrown out of a timer callback goes. */
+    readonly failed: (error: unknown) => void;
+}
+/**
+ * The timers one sim Lambda invocation has asked for.
+ *
+ * A handler's `setTimeout` measures its delay on the simulation's clock, so a
+ * test advancing time by the delay is what releases a sleeping handler, and a
+ * frozen clock leaves it asleep for as long as the test likes. The timers
+ * belong to the invocation rather than to the process: two simulations running
+ * at once each keep their own, and each one's are given up when its invocation
+ * ends, the way a real execution environment is frozen once it has answered.
+ *
+ * While any of them is outstanding the invocation is waiting on the clock, so
+ * whatever is waiting for the simulation to settle stops waiting for it.
+ * Nothing but the clock is going to release it, and moving the clock is what
+ * that wait is holding up.
+ */
+export declare class SimLambdaInvocationTimers implements SimLambdaTimers, SimLambdaTimerOwner {
+    #private;
+    constructor(properties: SimLambdaInvocationTimersProperties);
+    /**
+     * Run a callback once simulated time has moved on by a delay.
+     */
+    setTimeout(callback: SimLambdaTimerCallback, delay?: number, ...arguments_: unknown[]): SimLambdaTimerHandle;
+    /**
+     * Run a callback every time simulated time moves on by a delay.
+     */
+    setInterval(callback: SimLambdaTimerCallback, delay?: number, ...arguments_: unknown[]): SimLambdaTimerHandle;
+    /**
+     * Give up one timer, as `clearTimeout` and `clearInterval` do.
+     */
+    clear(handle: SimLambdaTimerHandle): void;
+    /**
+     * Give up every timer this invocation still has outstanding.
+     */
+    cancelAll(): void;
+}
+export {};

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

@@ -0,0 +1,112 @@
+import { SimLambdaClockTimer } from "./sim-lambda-clock-timer.js";
+import { SimLambdaTimerHandle, } from "./sim-lambda-timer-handle.js";
+/**
+ * The timers one sim Lambda invocation has asked for.
+ *
+ * A handler's `setTimeout` measures its delay on the simulation's clock, so a
+ * test advancing time by the delay is what releases a sleeping handler, and a
+ * frozen clock leaves it asleep for as long as the test likes. The timers
+ * belong to the invocation rather than to the process: two simulations running
+ * at once each keep their own, and each one's are given up when its invocation
+ * ends, the way a real execution environment is frozen once it has answered.
+ *
+ * While any of them is outstanding the invocation is waiting on the clock, so
+ * whatever is waiting for the simulation to settle stops waiting for it.
+ * Nothing but the clock is going to release it, and moving the clock is what
+ * that wait is holding up.
+ */
+export class SimLambdaInvocationTimers {
+    #background;
+    #failed;
+    #running = new Map();
+    #released;
+    constructor(properties) {
+        this.#background = properties.background;
+        this.#failed = properties.failed;
+    }
+    /**
+     * Run a callback once simulated time has moved on by a delay.
+     */
+    setTimeout(callback, delay, ...arguments_) {
+        return this.#start(delay, (handle) => {
+            this.#forget(handle);
+            this.#call(callback, arguments_);
+        });
+    }
+    /**
+     * Run a callback every time simulated time moves on by a delay.
+     */
+    setInterval(callback, delay, ...arguments_) {
+        return this.#start(delay, (_handle, timer) => {
+            timer.again();
+            this.#call(callback, arguments_);
+        });
+    }
+    /**
+     * Give up one timer, as `clearTimeout` and `clearInterval` do.
+     */
+    clear(handle) {
+        this.#running.get(handle)?.cancel();
+        this.#forget(handle);
+    }
+    /**
+     * Give up every timer this invocation still has outstanding.
+     */
+    cancelAll() {
+        for (const timer of this.#running.values()) {
+            timer.cancel();
+        }
+        this.#running.clear();
+        this.#stopWaitingOnClock();
+    }
+    /**
+     * Put one timer on the clock, and keep it while it is outstanding.
+     *
+     * The work a timer does needs the timer itself, to start the next turn of an
+     * interval, and the timer needs the work to be built with, so the work is
+     * given both once both exist.
+     */
+    #start(delay, work) {
+        const handle = new SimLambdaTimerHandle(this);
+        const timer = new SimLambdaClockTimer({
+            background: this.#background,
+            run: () => {
+                work(handle, timer);
+            },
+        });
+        this.#running.set(handle, timer);
+        // A timer with nothing to wait for is not waiting on the clock: it is due
+        // at the instant the clock already reads, and the next turn of the host
+        // event loop runs it.
+        if (timer.startIn(delay) > 0) {
+            this.#released ??= this.#background.waitingOnClock();
+        }
+        return handle;
+    }
+    /**
+     * Run one timer's callback, failing the invocation where it throws.
+     *
+     * An uncaught exception out of a timer callback ends a real invocation, and
+     * this one has a whole simulation around it: left to escape, the error would
+     * come out of whatever moved the clock instead, which is nothing to do with
+     * the handler that scheduled it.
+     */
+    #call(callback, arguments_) {
+        try {
+            callback(...arguments_);
+        }
+        catch (error) {
+            this.#failed(error);
+        }
+    }
+    #forget(handle) {
+        this.#running.delete(handle);
+        if (this.#running.size === 0) {
+            this.#stopWaitingOnClock();
+        }
+    }
+    #stopWaitingOnClock() {
+        this.#released?.();
+        this.#released = undefined;
+    }
+}

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

@@ -0,0 +1,57 @@
+import type { SimLambdaInvocationTimers } from "./sim-lambda-invocation-timers.js";
+import type { SimLambdaTimerCallback, SimLambdaTimerHandle, SimLambdaTimers } from "./sim-lambda-timer-handle.js";
+/**
+ * The timer functions the code running now should be using.
+ *
+ * A handler function reference is a closure over its own module scope, so it
+ * reaches for the same global `setTimeout` as every other line in the test
+ * run. Zip code has a sandbox of its own and is given these directly. Both
+ * paths end up here, and both find the invocation that is running now through
+ * Node.js asynchronous context tracking, exactly as the substitute Date does.
+ *
+ * Outside an invocation there is nothing to find, and the host's own timers
+ * answer instead. That is what keeps the substitutes inert for a test run's
+ * own timers, for a test framework's, and for one simulation while another is
+ * running an invocation.
+ */
+declare class SimLambdaProcessTimers {
+    private readonly storage;
+    private installed;
+    /**
+     * Run an invocation with timers of its own.
+     */
+    run<T>(timers: SimLambdaInvocationTimers, run: () => Promise<T>): Promise<T>;
+    /**
+     * The timers the code running now should use.
+     */
+    current(): SimLambdaTimers;
+    /**
+     * Replace the global timer functions with ones that follow the store.
+     *
+     * Installed on the first invocation of host-scope code rather than at
+     * import, so a test run that never invokes one is left completely alone.
+     * Sandboxed code needs none of this: its own globals are built for it, and
+     * they are given the same substitutes directly.
+     *
+     * With no invocation running the substitutes call the host functions and
+     * answer with what they answer, so an installed patch behaves exactly like
+     * no patch at all. They are never removed, because removing one would be
+     * unsafe while another invocation is in flight and there is nothing to gain.
+     */
+    install(): void;
+}
+/**
+ * Shared because it patches process globals: one patch, one store.
+ */
+export declare const simLambdaProcessTimers: SimLambdaProcessTimers;
+/**
+ * Run a callback once a delay has passed, on the clock of the invocation
+ * running now.
+ */
+export declare function simLambdaSetTimeout(callback: SimLambdaTimerCallback, delay?: number, ...arguments_: unknown[]): SimLambdaTimerHandle | NodeJS.Timeout;
+/**
+ * Run a callback every time a delay passes, on the clock of the invocation
+ * running now.
+ */
+export declare function simLambdaSetInterval(callback: SimLambdaTimerCallback, delay?: number, ...arguments_: unknown[]): SimLambdaTimerHandle | NodeJS.Timeout;
+export {};

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

@@ -0,0 +1,79 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { simLambdaClearInterval, simLambdaClearTimeout, } from "./sim-lambda-clear-timer.js";
+import { simLambdaHostTimers } from "./sim-lambda-host-timers.js";
+import { defineSimLambdaTimer } from "./sim-lambda-timer-global.js";
+/**
+ * The timer functions the code running now should be using.
+ *
+ * A handler function reference is a closure over its own module scope, so it
+ * reaches for the same global `setTimeout` as every other line in the test
+ * run. Zip code has a sandbox of its own and is given these directly. Both
+ * paths end up here, and both find the invocation that is running now through
+ * Node.js asynchronous context tracking, exactly as the substitute Date does.
+ *
+ * Outside an invocation there is nothing to find, and the host's own timers
+ * answer instead. That is what keeps the substitutes inert for a test run's
+ * own timers, for a test framework's, and for one simulation while another is
+ * running an invocation.
+ */
+class SimLambdaProcessTimers {
+    storage = new AsyncLocalStorage();
+    installed = false;
+    /**
+     * Run an invocation with timers of its own.
+     */
+    async run(timers, run) {
+        return await this.storage.run(timers, run);
+    }
+    /**
+     * The timers the code running now should use.
+     */
+    current() {
+        return this.storage.getStore() ?? simLambdaHostTimers;
+    }
+    /**
+     * Replace the global timer functions with ones that follow the store.
+     *
+     * Installed on the first invocation of host-scope code rather than at
+     * import, so a test run that never invokes one is left completely alone.
+     * Sandboxed code needs none of this: its own globals are built for it, and
+     * they are given the same substitutes directly.
+     *
+     * With no invocation running the substitutes call the host functions and
+     * answer with what they answer, so an installed patch behaves exactly like
+     * no patch at all. They are never removed, because removing one would be
+     * unsafe while another invocation is in flight and there is nothing to gain.
+     */
+    install() {
+        if (this.installed) {
+            return;
+        }
+        this.installed = true;
+        defineSimLambdaTimer("setTimeout", simLambdaSetTimeout);
+        defineSimLambdaTimer("clearTimeout", simLambdaClearTimeout);
+        defineSimLambdaTimer("setInterval", simLambdaSetInterval);
+        defineSimLambdaTimer("clearInterval", simLambdaClearInterval);
+    }
+}
+/**
+ * Shared because it patches process globals: one patch, one store.
+ */
+export const simLambdaProcessTimers = new SimLambdaProcessTimers();
+/**
+ * Run a callback once a delay has passed, on the clock of the invocation
+ * running now.
+ */
+export function simLambdaSetTimeout(callback, delay, ...arguments_) {
+    return simLambdaProcessTimers
+        .current()
+        .setTimeout(callback, delay, ...arguments_);
+}
+/**
+ * Run a callback every time a delay passes, on the clock of the invocation
+ * running now.
+ */
+export function simLambdaSetInterval(callback, delay, ...arguments_) {
+    return simLambdaProcessTimers
+        .current()
+        .setInterval(callback, delay, ...arguments_);
+}

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

@@ -0,0 +1,10 @@
+/**
+ * The delay a timer waits, in whole milliseconds of simulated time.
+ *
+ * A delay that is missing, negative or not a number is no delay at all, which
+ * leaves the timer due at the instant it was asked for. Node.js rounds those
+ * up to a millisecond of host time; simulated time has nothing to round up to,
+ * and a handler yielding with `setTimeout(resolve, 0)` should not need a test
+ * to move the clock before it gets going again.
+ */
+export declare function simLambdaTimerDelay(delay: number | undefined): number;

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

@@ -0,0 +1,15 @@
+/**
+ * The delay a timer waits, in whole milliseconds of simulated time.
+ *
+ * A delay that is missing, negative or not a number is no delay at all, which
+ * leaves the timer due at the instant it was asked for. Node.js rounds those
+ * up to a millisecond of host time; simulated time has nothing to round up to,
+ * and a handler yielding with `setTimeout(resolve, 0)` should not need a test
+ * to move the clock before it gets going again.
+ */
+export function simLambdaTimerDelay(delay) {
+    if (delay === undefined || !Number.isFinite(delay)) {
+        return 0;
+    }
+    return Math.max(Math.trunc(delay), 0);
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Put a substitute in a global timer function's place, keeping everything else
+ * about it.
+ *
+ * The property stays the configurable, writable, non-enumerable global it
+ * already was, so anything else replacing it later finds what it expects. The
+ * host function's own symbols come across too: `setTimeout` carries the one
+ * that makes `util.promisify` answer with the promise form, and code reaching
+ * for that would otherwise get a promise of the handle instead.
+ */
+export declare function defineSimLambdaTimer(name: string, substitute: object): void;

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

@@ -0,0 +1,24 @@
+/**
+ * Put a substitute in a global timer function's place, keeping everything else
+ * about it.
+ *
+ * The property stays the configurable, writable, non-enumerable global it
+ * already was, so anything else replacing it later finds what it expects. The
+ * host function's own symbols come across too: `setTimeout` carries the one
+ * that makes `util.promisify` answer with the promise form, and code reaching
+ * for that would otherwise get a promise of the handle instead.
+ */
+export function defineSimLambdaTimer(name, substitute) {
+    const host = Reflect.get(globalThis, name);
+    for (const symbol of Object.getOwnPropertySymbols(host)) {
+        Object.defineProperty(substitute, symbol, {
+            configurable: true,
+            value: Reflect.get(host, symbol),
+        });
+    }
+    Object.defineProperty(globalThis, name, {
+        configurable: true,
+        writable: true,
+        value: substitute,
+    });
+}