@kensio/yulin 1.21.2 → 1.21.4

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,
+    });
+}

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

@@ -0,0 +1,50 @@
+/**
+ * What a handler passes to `setTimeout` or `setInterval` to be run later.
+ */
+export type SimLambdaTimerCallback = (...arguments_: unknown[]) => void;
+/**
+ * Timer functions of the shape the Node.js runtime gives handler code.
+ */
+export interface SimLambdaTimers {
+    setTimeout(callback: SimLambdaTimerCallback, delay?: number, ...arguments_: unknown[]): SimLambdaTimerHandle | NodeJS.Timeout;
+    setInterval(callback: SimLambdaTimerCallback, delay?: number, ...arguments_: unknown[]): SimLambdaTimerHandle | NodeJS.Timeout;
+}
+/**
+ * Where a timer goes to be given up, which is the set it was made in.
+ */
+export interface SimLambdaTimerOwner {
+    clear(handle: SimLambdaTimerHandle): void;
+}
+/**
+ * The handle a handler gets back from `setTimeout` or `setInterval`.
+ *
+ * Real timer functions answer with an object rather than a number, and the
+ * only thing handler code usually does with it is hand it back to
+ * `clearTimeout`. It carries the set it belongs to, so clearing it reaches
+ * that set rather than whichever invocation happens to be running.
+ *
+ * Referencing is answered because a handler is free to ask. A simulated timer
+ * is unreferenced already: it waits on a clock a test moves, and holds nothing
+ * open whatever it is asked.
+ */
+export declare class SimLambdaTimerHandle {
+    #private;
+    constructor(owner: SimLambdaTimerOwner);
+    /**
+     * Give up this timer, as `clearTimeout` and `clearInterval` do.
+     */
+    cancel(): void;
+    /**
+     * Keep the simulation open for this timer, which it already is.
+     */
+    ref(): this;
+    /**
+     * Stop keeping the simulation open for this timer, which it never was.
+     */
+    unref(): this;
+    /**
+     * Whether this timer holds the process open, which a simulated one never
+     * does.
+     */
+    hasRef(): boolean;
+}

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

@@ -0,0 +1,43 @@
+/**
+ * The handle a handler gets back from `setTimeout` or `setInterval`.
+ *
+ * Real timer functions answer with an object rather than a number, and the
+ * only thing handler code usually does with it is hand it back to
+ * `clearTimeout`. It carries the set it belongs to, so clearing it reaches
+ * that set rather than whichever invocation happens to be running.
+ *
+ * Referencing is answered because a handler is free to ask. A simulated timer
+ * is unreferenced already: it waits on a clock a test moves, and holds nothing
+ * open whatever it is asked.
+ */
+export class SimLambdaTimerHandle {
+    #owner;
+    constructor(owner) {
+        this.#owner = owner;
+    }
+    /**
+     * Give up this timer, as `clearTimeout` and `clearInterval` do.
+     */
+    cancel() {
+        this.#owner.clear(this);
+    }
+    /**
+     * Keep the simulation open for this timer, which it already is.
+     */
+    ref() {
+        return this;
+    }
+    /**
+     * Stop keeping the simulation open for this timer, which it never was.
+     */
+    unref() {
+        return this;
+    }
+    /**
+     * Whether this timer holds the process open, which a simulated one never
+     * does.
+     */
+    hasRef() {
+        return false;
+    }
+}

package/dist/service/lambda/function/logging/sim-lambda-function-logging.d.ts

@@ -1,6 +1,7 @@
 import type { SimClock } from "../../../../util/clock/sim-clock.js";
 import type { SimLogsServiceWriter } from "../../../logs/write/sim-logs-service-writer.js";
 import type { SimLambdaOutputSink } from "./sim-lambda-output-sink.js";
+import { SimLambdaOutput } from "./sim-lambda-output.js";
 import type { SimLambdaExecutableCode } from "../code/sim-lambda-executable-code.js";
 interface SimLambdaFunctionLoggingProperties {
     readonly functionName: string;
@@ -10,6 +11,12 @@ interface SimLambdaFunctionLoggingProperties {
      * instance, has no simulated CloudWatch Logs to record to.
      */
     readonly logs?: SimLogsServiceWriter | undefined;
+    /**
+     * Where this function's output goes besides its log group. Shared with every
+     * other function of the same simulated Lambda, and read as each line is
+     * written.
+     */
+    readonly output?: SimLambdaOutput | undefined;
 }
 /**
  * One function's side of writing its output to a log group.
@@ -28,6 +35,8 @@ interface SimLambdaFunctionLoggingProperties {
 export declare class SimLambdaFunctionLogging {
     #private;
     readonly logGroupName: string;
+    /** Where this function's output goes besides its log group. */
+    readonly output: SimLambdaOutput;
     constructor(properties: SimLambdaFunctionLoggingProperties);
     /**
      * The stream this function's execution environment writes to, opening it if
@@ -53,6 +62,14 @@ export declare class SimLambdaFunctionLogging {
      * console and standard streams tee into.
      */
     outputSink(): SimLambdaOutputSink | undefined;
+    /**
+     * Both halves of where a host-scope invocation's output goes, ready to
+     * bridge to the process globals it prints through.
+     */
+    outputScope(): {
+        readonly output: SimLambdaOutputSink | undefined;
+        readonly outputSettings: SimLambdaOutput;
+    };
     /**
      * Run an invocation, recording whatever it left unterminated once it is
      * over, and the error it ended in when it ended in one.

package/dist/service/lambda/function/logging/sim-lambda-function-logging.js

@@ -1,3 +1,4 @@
+import { SimLambdaOutput } from "./sim-lambda-output.js";
 import { simLambdaInvokeErrorLine } from "./sim-lambda-invoke-error-log.js";
 import { SimLambdaLogWriter } from "./sim-lambda-log-writer.js";
 import { simLambdaLogGroupName, simLambdaLogStreamName, } from "./sim-lambda-log-stream-name.js";
@@ -17,6 +18,8 @@ import { simLambdaLogGroupName, simLambdaLogStreamName, } from "./sim-lambda-log
  */
 export class SimLambdaFunctionLogging {
     logGroupName;
+    /** Where this function's output goes besides its log group. */
+    output;
     #logs;
     #clock;
     #writer;
@@ -25,6 +28,7 @@ export class SimLambdaFunctionLogging {
         this.logGroupName = simLambdaLogGroupName(properties.functionName);
         this.#logs = properties.logs;
         this.#clock = properties.clock;
+        this.output = properties.output ?? new SimLambdaOutput();
     }
     /**
      * The stream this function's execution environment writes to, opening it if
@@ -47,7 +51,7 @@ export class SimLambdaFunctionLogging {
     recordFrom(code) {
         const writer = this.#writer;
         if (writer !== undefined) {
-            code.recordOutputTo(writer);
+            code.recordOutputTo(writer, this.output);
         }
     }
     /**
@@ -61,6 +65,13 @@ export class SimLambdaFunctionLogging {
     outputSink() {
         return this.#writer;
     }
+    /**
+     * Both halves of where a host-scope invocation's output goes, ready to
+     * bridge to the process globals it prints through.
+     */
+    outputScope() {
+        return { output: this.#writer, outputSettings: this.output };
+    }
     /**
      * Run an invocation, recording whatever it left unterminated once it is
      * over, and the error it ended in when it ended in one.

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

@@ -0,0 +1,56 @@
+/**
+ * Where a simulated Lambda's functions send what they print.
+ *
+ * Function output always reaches the function's log group. This settles the
+ * second destination, the host console the test run itself prints to. Real
+ * Lambda sends output to CloudWatch Logs and nowhere else, and Yulin forwards
+ * it to the host as well so that a failing test is as easy to read as one
+ * whose handler was never simulated.
+ *
+ * A handler that logs on every request makes that forwarding expensive. AWS
+ * Lambda Powertools writes an Embedded Metric Format document for every metric
+ * it counts, and a suite invoking a function a few hundred times buries its own
+ * output under them. `captureOnly` turns the forwarding off for every function
+ * of one simulated Lambda:
+ *
+ * ```typescript
+ * simAws.lambda().output().captureOnly();
+ * ```
+ *
+ * Nothing is lost by it. The log group holds every line either way, and
+ * `FilterLogEvents` reads them back.
+ *
+ * ## What it leaves alone
+ *
+ * A function with no simulated CloudWatch Logs behind it keeps printing to the
+ * host whatever this says. That is a function built on a standalone SimLambda,
+ * outside a SimAws instance, and it has no log group for its output to be read
+ * back out of. Silencing it would lose the output altogether.
+ *
+ * The setting is read as each line is written, so a test can turn forwarding
+ * off part way through a run and the functions that have already cold started
+ * follow it.
+ */
+export declare class SimLambdaOutput {
+    #private;
+    /**
+     * Record function output to its log group alone.
+     *
+     * Lines written from then on stay out of the host console. Everything
+     * written before it is already printed.
+     */
+    captureOnly(): void;
+    /**
+     * Forward function output to the host console as well as recording it, which
+     * is what a simulated Lambda does until told otherwise.
+     */
+    teeToHost(): void;
+    /**
+     * Whether a recorded line still reaches the host console.
+     *
+     * Read by the two paths that write one, the vm sandbox's standard streams
+     * and the process globals a host-scope handler prints through.
+     * @internal
+     */
+    reachesHost(): boolean;
+}

package/dist/service/lambda/function/logging/sim-lambda-output.js

@@ -0,0 +1,62 @@
+/**
+ * Where a simulated Lambda's functions send what they print.
+ *
+ * Function output always reaches the function's log group. This settles the
+ * second destination, the host console the test run itself prints to. Real
+ * Lambda sends output to CloudWatch Logs and nowhere else, and Yulin forwards
+ * it to the host as well so that a failing test is as easy to read as one
+ * whose handler was never simulated.
+ *
+ * A handler that logs on every request makes that forwarding expensive. AWS
+ * Lambda Powertools writes an Embedded Metric Format document for every metric
+ * it counts, and a suite invoking a function a few hundred times buries its own
+ * output under them. `captureOnly` turns the forwarding off for every function
+ * of one simulated Lambda:
+ *
+ * ```typescript
+ * simAws.lambda().output().captureOnly();
+ * ```
+ *
+ * Nothing is lost by it. The log group holds every line either way, and
+ * `FilterLogEvents` reads them back.
+ *
+ * ## What it leaves alone
+ *
+ * A function with no simulated CloudWatch Logs behind it keeps printing to the
+ * host whatever this says. That is a function built on a standalone SimLambda,
+ * outside a SimAws instance, and it has no log group for its output to be read
+ * back out of. Silencing it would lose the output altogether.
+ *
+ * The setting is read as each line is written, so a test can turn forwarding
+ * off part way through a run and the functions that have already cold started
+ * follow it.
+ */
+export class SimLambdaOutput {
+    #toHost = true;
+    /**
+     * Record function output to its log group alone.
+     *
+     * Lines written from then on stay out of the host console. Everything
+     * written before it is already printed.
+     */
+    captureOnly() {
+        this.#toHost = false;
+    }
+    /**
+     * Forward function output to the host console as well as recording it, which
+     * is what a simulated Lambda does until told otherwise.
+     */
+    teeToHost() {
+        this.#toHost = true;
+    }
+    /**
+     * Whether a recorded line still reaches the host console.
+     *
+     * Read by the two paths that write one, the vm sandbox's standard streams
+     * and the process globals a host-scope handler prints through.
+     * @internal
+     */
+    reachesHost() {
+        return this.#toHost;
+    }
+}

package/dist/service/lambda/function/outbound/sim-lambda-aws-api-outbound.d.ts

@@ -36,6 +36,7 @@ interface SimLambdaAwsApiOutboundProperties {
  */
 export declare class SimLambdaAwsApiOutbound implements SimLambdaOutboundHttp {
     private readonly dispatcher;
+    private readonly s3;
     constructor(properties: SimLambdaAwsApiOutboundProperties);
     /**
      * Whether a hostname is one of the AWS service API endpoints.
@@ -43,6 +44,13 @@ export declare class SimLambdaAwsApiOutbound implements SimLambdaOutboundHttp {
     serves(hostname: string): boolean;
     /**
      * Answer an AWS API request from the simulated operation it names.
+     *
+     * A request signed for S3 goes to the endpoint that reads S3's protocol,
+     * since S3 names its operation where the wire dispatcher looks for a header.
+     * No caller travels with it. The SDK signed it with the placeholder
+     * credentials the runtime puts in the environment, and the invocation is
+     * already running as the execution Role, the ambient caller every other call
+     * out of function code runs as.
      */
     fetch(request: Request): Promise<Response>;
 }