@kensio/yulin 1.21.3 → 1.21.4

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

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.