@kensio/yulin 1.21.2 → 1.21.4

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

@@ -0,0 +1,84 @@
+import { SimLambdaClockTimer } from "./timer/sim-lambda-clock-timer.js";
+import { SimLambdaInvocationTimers } from "./timer/sim-lambda-invocation-timers.js";
+import { simLambdaProcessTimers } from "./timer/sim-lambda-process-timers.js";
+import { simLambdaTimedOutError } from "./sim-lambda-timed-out.error.js";
+const millisecondsPerSecond = 1000;
+/**
+ * The time one invocation has to finish in, and the timers it gets while it
+ * runs.
+ *
+ * Both wait on the simulation's clock. Whichever arrives first decides: a
+ * handler that answers in time is answered with, and a deadline that arrives
+ * first ends the invocation in the timeout error real Lambda reports. Nothing
+ * waits for a handler that has been timed out, and what it goes on to do
+ * reaches nobody, which is the closest an in-process simulation gets to an
+ * execution environment being taken away.
+ */
+export class SimLambdaInvocationDeadline {
+    #properties;
+    constructor(properties) {
+        this.#properties = properties;
+    }
+    /**
+     * Run the handler with timers of its own, up to this deadline.
+     */
+    async around(handler) {
+        const { background, awsRequestId, timeoutSeconds } = this.#properties;
+        const stopped = Promise.withResolvers();
+        // Read whether or not the race gets that far, so an invocation the handler
+        // wins never leaves this rejection unhandled.
+        // oxlint-disable-next-line unicorn-js/prefer-await -- nothing awaits it.
+        stopped.promise.catch(() => {
+            //
+        });
+        // Everything this invocation has on the clock stops the instant it is
+        // over, and the instant is what matters. Whatever ended it is inside a
+        // clock advance already walking towards the next thing due, and a timer
+        // given up a few turns of the microtask queue later has had time to run
+        // first. So an invocation ends its timers as it ends, rather than as the
+        // answer works its way out through everything wrapped around it.
+        const ending = () => {
+            timers.cancelAll();
+            deadline.cancel();
+        };
+        const failing = (error) => {
+            ending();
+            stopped.reject(error);
+        };
+        const timers = new SimLambdaInvocationTimers({
+            background,
+            failed: failing,
+        });
+        const deadline = new SimLambdaClockTimer({
+            background,
+            run: () => {
+                failing(simLambdaTimedOutError({
+                    at: background.now(),
+                    awsRequestId,
+                    timeoutSeconds,
+                }));
+            },
+        });
+        deadline.startAt(new Date(background.now().getTime() + timeoutSeconds * millisecondsPerSecond));
+        try {
+            return await background.outstanding(async () => await racing(timers, stopped, handler, ending));
+        }
+        finally {
+            ending();
+        }
+    }
+}
+/**
+ * Answer with whichever comes first, the handler or the end of its time.
+ */
+async function racing(timers, stopped, handler, ending) {
+    return await simLambdaProcessTimers.run(timers, async () => {
+        const answer = handler();
+        // Ended as the handler settles rather than as the invocation finishes
+        // unwinding, and read either way, so a handler that fails after being
+        // timed out has nobody left to be unhandled at.
+        // oxlint-disable-next-line unicorn-js/prefer-await -- not waited for.
+        answer.then(ending, ending);
+        return await Promise.race([answer, stopped.promise]);
+    });
+}

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

@@ -0,0 +1,44 @@
+import type { BackgroundScheduler } from "../../../../util/background/background.js";
+import type { SimClock } from "../../../../util/clock/sim-clock.js";
+import type { SimLambdaHandler } from "../sim-lambda-handler.type.js";
+interface SimLambdaInvocationProperties {
+    readonly functionName: string;
+    /** The version the invocation is running, which is `$LATEST` or a number. */
+    readonly functionVersion: string;
+    readonly invokedFunctionArn: string;
+    readonly timeoutSeconds: number;
+    readonly memorySizeMb: number;
+    readonly logGroupName: string;
+    /** The stream this invocation's execution environment writes to. */
+    readonly logStreamName: string;
+    /** The clock the remaining time is measured against. */
+    readonly clock: SimClock;
+    /**
+     * The scheduler this invocation's timers and deadline wait on. A function
+     * built standalone, outside a SimAws instance, has none, and its handler
+     * keeps the host timers every other line in the process uses.
+     */
+    readonly background: BackgroundScheduler | undefined;
+}
+/**
+ * One run of a sim Lambda function's handler.
+ *
+ * It holds what the handler's own context reports, including the request id
+ * the invocation is known by, and it runs the handler inside the time it has
+ * to finish in. A function built standalone, outside a SimAws instance, has no
+ * scheduler for that deadline to wait on, and its handler runs for as long as
+ * it likes on the host timers every other line in the process uses.
+ */
+export declare class SimLambdaInvocation {
+    #private;
+    constructor(properties: SimLambdaInvocationProperties);
+    /**
+     * Run a handler function for one invocation event, up to this invocation's
+     * deadline.
+     *
+     * Resolves with the handler result, or rejects with the handler error or
+     * the timeout.
+     */
+    run(handlerFunction: SimLambdaHandler, event: unknown): Promise<unknown>;
+}
+export {};

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

@@ -0,0 +1,44 @@
+import { randomUUID } from "node:crypto";
+import { SimLambdaHandlerRunner } from "./sim-lambda-handler-runner.js";
+import { SimLambdaInvokeContextBuilder } from "./sim-lambda-invoke-context-builder.js";
+import { SimLambdaInvocationDeadline } from "./sim-lambda-invocation-deadline.js";
+/**
+ * One run of a sim Lambda function's handler.
+ *
+ * It holds what the handler's own context reports, including the request id
+ * the invocation is known by, and it runs the handler inside the time it has
+ * to finish in. A function built standalone, outside a SimAws instance, has no
+ * scheduler for that deadline to wait on, and its handler runs for as long as
+ * it likes on the host timers every other line in the process uses.
+ */
+export class SimLambdaInvocation {
+    #properties;
+    #runner = new SimLambdaHandlerRunner();
+    #awsRequestId = randomUUID();
+    constructor(properties) {
+        this.#properties = properties;
+    }
+    /**
+     * Run a handler function for one invocation event, up to this invocation's
+     * deadline.
+     *
+     * Resolves with the handler result, or rejects with the handler error or
+     * the timeout.
+     */
+    async run(handlerFunction, event) {
+        const contextBuilder = new SimLambdaInvokeContextBuilder({
+            ...this.#properties,
+            awsRequestId: this.#awsRequestId,
+        });
+        const handler = async () => await this.#runner.run(handlerFunction, event, contextBuilder);
+        const { background, timeoutSeconds } = this.#properties;
+        if (background === undefined) {
+            return await handler();
+        }
+        return await new SimLambdaInvocationDeadline({
+            background,
+            timeoutSeconds,
+            awsRequestId: this.#awsRequestId,
+        }).around(handler);
+    }
+}

package/dist/service/lambda/function/invoke/sim-lambda-invoke-context-builder.d.ts

@@ -16,6 +16,12 @@ interface SimLambdaInvokeContextBuilderProperties {
      * handler with a constant budget, rather than one that drains in real time.
      */
     readonly clock?: SimClock | undefined;
+    /**
+     * The request id this invocation is known by. It comes from outside because
+     * the invocation names itself in the error it reports when it runs out of
+     * time, and a handler reading `awsRequestId` has to see the same one.
+     */
+    readonly awsRequestId?: string | undefined;
 }
 /**
  * Builds the AWS-like invocation context passed to a sim Lambda handler.

package/dist/service/lambda/function/invoke/sim-lambda-invoke-context-builder.js

@@ -15,9 +15,8 @@ export class SimLambdaInvokeContextBuilder {
      * Build the context for one invocation.
      */
     build(callback) {
-        const { functionName, functionVersion, invokedFunctionArn, timeoutSeconds, memorySizeMb, logGroupName, logStreamName, clock = new SimRealClock(), } = this.properties;
+        const { functionName, functionVersion, invokedFunctionArn, timeoutSeconds, memorySizeMb, logGroupName, logStreamName, clock = new SimRealClock(), awsRequestId = randomUUID(), } = this.properties;
         const startedAtMs = clock.now().getTime();
-        const awsRequestId = randomUUID();
         return {
             callbackWaitsForEmptyEventLoop: true,
             functionName,

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

@@ -1,3 +1,4 @@
+import type { SimLambdaOutput } from "../logging/sim-lambda-output.js";
 import type { SimLambdaOutputSink } from "../logging/sim-lambda-output-sink.js";
 /**
  * The console methods an invocation's output is taken from.
@@ -63,7 +64,7 @@ export declare class SimLambdaProcessOutput {
     /**
      * Run an invocation with the given sink recording what it prints.
      */
-    run<T>(sink: SimLambdaOutputSink, run: () => Promise<T>): Promise<T>;
+    run<T>(sink: SimLambdaOutputSink, output: SimLambdaOutput, run: () => Promise<T>): Promise<T>;
     /**
      * Tee the process console and standard streams into the invocation store.
      *
@@ -84,6 +85,10 @@ export declare class SimLambdaProcessOutput {
      * console afterwards wraps the patch, so its own interception still sees
      * every write, and one that replaces the console object outright takes the
      * patch with it and gets the output the handler wrote.
+     *
+     * An invocation whose simulated Lambda is capturing only stops at the
+     * recording. A line printed outside any invocation goes to the host as it
+     * always did.
      */
     private patchConsole;
     /**

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

@@ -57,9 +57,9 @@ export class SimLambdaProcessOutput {
     /**
      * Run an invocation with the given sink recording what it prints.
      */
-    async run(sink, run) {
+    async run(sink, output, run) {
         this.install();
-        return await this.storage.run(sink, run);
+        return await this.storage.run({ sink, output }, run);
     }
     /**
      * Tee the process console and standard streams into the invocation store.
@@ -90,6 +90,10 @@ export class SimLambdaProcessOutput {
      * console afterwards wraps the patch, so its own interception still sees
      * every write, and one that replaces the console object outright takes the
      * patch with it and gets the output the handler wrote.
+     *
+     * An invocation whose simulated Lambda is capturing only stops at the
+     * recording. A line printed outside any invocation goes to the host as it
+     * always did.
      */
     patchConsole(hostConsole) {
         for (const method of CONSOLE_METHODS) {
@@ -97,7 +101,11 @@ export class SimLambdaProcessOutput {
             const hostMethod = hostConsole[method].bind(hostConsole);
             // oxlint-disable-next-line security/detect-object-injection -- one of this module's own fixed method names.
             hostConsole[method] = (...arguments_) => {
-                this.storage.getStore()?.write(`${format(...arguments_)}\n`);
+                const recorded = this.storage.getStore();
+                recorded?.sink.write(`${format(...arguments_)}\n`);
+                if (recorded !== undefined && !recorded.output.reachesHost()) {
+                    return;
+                }
                 // Delegated outside the store, because the host console writing to
                 // process.stdout would otherwise record the same line a second time.
                 this.storage.exit(() => {
@@ -118,9 +126,14 @@ export class SimLambdaProcessOutput {
         const hostWrite = hostStream.write.bind(hostStream);
         const decoder = new StringDecoder("utf8");
         hostStream.write = (chunk, ...rest) => {
-            const sink = this.storage.getStore();
-            if (sink !== undefined) {
-                sink.write(typeof chunk === "string" ? chunk : decoder.write(Buffer.from(chunk)));
+            const recorded = this.storage.getStore();
+            if (recorded !== undefined) {
+                recorded.sink.write(typeof chunk === "string" ? chunk : decoder.write(Buffer.from(chunk)));
+                // Written and done with. The stream reports the write as accepted,
+                // which is what it would have answered had the host taken it.
+                if (!recorded.output.reachesHost()) {
+                    return true;
+                }
             }
             return hostWrite(chunk, ...rest);
         };

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