@kensio/yulin 1.21.3 → 1.21.5

package/dist/service/lambda/function/code/sim-lambda-vm-zip-code.js

@@ -4,6 +4,7 @@ import { parseLambdaHandlerName } from "./sim-lambda-handler-name.js";
 import { makeSimLambdaVmContext, } from "./vm/sim-lambda-vm-context.js";
 import { simLambdaNoOutputSink, } from "../logging/sim-lambda-output-sink.js";
 import { SimLambdaVmModules } from "./vm/sim-lambda-vm-modules.js";
+import { importSimLambdaHandlerModule, simLambdaExportedHandler, } from "./vm/sim-lambda-vm-handler-lookup.js";
 /**
  * Executable sim Lambda code compiled from a zip archive in a vm context.
  *
@@ -20,7 +21,10 @@ export class SimLambdaVmZipCode {
      */
     runsInHostScope = false;
     #handler;
-    #sink = simLambdaNoOutputSink;
+    /** Where this execution environment's output goes, and what happens to it. */
+    #recording = {
+        sink: simLambdaNoOutputSink,
+    };
     constructor(properties) {
         this.properties = properties;
     }
@@ -31,8 +35,8 @@ export class SimLambdaVmZipCode {
      * asks for the handler, so the streams function code is handed already carry
      * the sink by the time any of it runs.
      */
-    recordOutputTo(sink) {
-        this.#sink = sink;
+    recordOutputTo(sink, output) {
+        this.#recording = { sink, output };
     }
     /**
      * This archive under changed function settings, ready to cold start again.
@@ -62,47 +66,17 @@ export class SimLambdaVmZipCode {
         const parsedName = parseLambdaHandlerName(handlerName);
         const modules = new SimLambdaVmModules({
             archive,
-            context: makeSimLambdaVmContext({ ...this.properties, sink: this.#sink }),
+            context: makeSimLambdaVmContext({
+                ...this.properties,
+                ...this.#recording,
+            }),
             sdkModuleProvider: sdkModuleProvider ?? new SimLambdaNoVmSdkModuleProvider(),
         });
-        const moduleExports = this.importHandlerModule(modules, parsedName.modulePath);
-        const handler = this.exportedHandler(moduleExports, parsedName.exportName);
+        const moduleExports = importSimLambdaHandlerModule(modules, parsedName.modulePath);
+        const handler = simLambdaExportedHandler(moduleExports, parsedName.exportName);
         if (typeof handler !== "function") {
             throw new SimLambdaRuntimeError("Runtime.HandlerNotFound", `${handlerName} is undefined or not exported by ${parsedName.modulePath}`);
         }
         return handler;
     }
-    /**
-     * Look up the handler export, tolerating a module that exported a nullish
-     * value so the lookup still reports Runtime.HandlerNotFound.
-     *
-     * Only own exports count. Walking the prototype chain would let a handler
-     * name like `index.constructor` resolve to an `Object.prototype` member and
-     * be invoked as the handler, where real Lambda reports HandlerNotFound.
-     */
-    exportedHandler(moduleExports, exportName) {
-        if (moduleExports === null || moduleExports === undefined) {
-            return undefined;
-        }
-        const exportedValues = moduleExports;
-        if (!Object.hasOwn(exportedValues, exportName)) {
-            return undefined;
-        }
-        return Reflect.get(exportedValues, exportName);
-    }
-    importHandlerModule(modules, modulePath) {
-        try {
-            return modules.requireModule(`./${modulePath}`);
-        }
-        catch (error) {
-            if (error instanceof SimLambdaRuntimeError) {
-                throw error;
-            }
-            let message = String(error);
-            if (error instanceof Error) {
-                message = error.message;
-            }
-            throw new SimLambdaRuntimeError("Runtime.ImportModuleError", message);
-        }
-    }
 }

package/dist/service/lambda/function/code/vm/sim-lambda-vm-context.d.ts

@@ -1,6 +1,7 @@
 import vm from "node:vm";
 import { type SimClock } from "../../../../../util/clock/sim-clock.js";
 import type { SimLambdaEnvironment } from "../../environment/sim-lambda-environment.js";
+import type { SimLambdaOutput } from "../../logging/sim-lambda-output.js";
 import { type SimLambdaOutputSink } from "../../logging/sim-lambda-output-sink.js";
 import type { SimLambdaOutboundHttp } from "../../outbound/sim-lambda-outbound-http.js";
 /**
@@ -12,6 +13,12 @@ export interface SimLambdaVmContextProperties {
     readonly clock?: SimClock | undefined;
     /** Where the sandbox's output is recorded, nowhere by default. */
     readonly sink?: SimLambdaOutputSink | undefined;
+    /**
+     * Whether what the sandbox prints also reaches the host standard streams.
+     * A sandbox given none forwards everything, which is what a function with
+     * nowhere to record its output needs.
+     */
+    readonly output?: SimLambdaOutput | undefined;
     /**
      * Where the sandbox's `fetch` requests to hostnames the simulation serves
      * are answered. Without one every request reaches the network, as the host

package/dist/service/lambda/function/code/vm/sim-lambda-vm-context.js

@@ -4,6 +4,8 @@ import { makeSimClockDate } from "../../../../../util/clock/sim-clock-date.js";
 import { SimRealClock, } from "../../../../../util/clock/sim-clock.js";
 import { simLambdaNoOutputSink, } from "../../logging/sim-lambda-output-sink.js";
 import { makeSimLambdaOutboundFetch } from "../../outbound/sim-lambda-outbound-fetch.js";
+import { simLambdaClearInterval, simLambdaClearTimeout, } from "../../invoke/timer/sim-lambda-clear-timer.js";
+import { simLambdaSetInterval, simLambdaSetTimeout, } from "../../invoke/timer/sim-lambda-process-timers.js";
 import { SimLambdaVmOutputStream } from "./sim-lambda-vm-output-stream.js";
 /**
  * Create the sandbox vm context that sim Lambda function code runs in.
@@ -22,12 +24,12 @@ import { SimLambdaVmOutputStream } from "./sim-lambda-vm-output-stream.js";
  * from the simulation for the hostnames the simulation serves.
  */
 export function makeSimLambdaVmContext(properties) {
-    const { environment, clock = new SimRealClock(), sink = simLambdaNoOutputSink, outboundHttp, } = properties;
+    const { environment, clock = new SimRealClock(), sink = simLambdaNoOutputSink, output, outboundHttp, } = properties;
     // Writable standard streams, as the real runtime provides. Code that builds
     // its own console over them, as AWS Lambda Powertools' logger does, throws
     // at module load without them.
-    const stdout = new SimLambdaVmOutputStream(() => process.stdout);
-    const stderr = new SimLambdaVmOutputStream(() => process.stderr);
+    const stdout = new SimLambdaVmOutputStream(() => process.stdout, output);
+    const stderr = new SimLambdaVmOutputStream(() => process.stderr, output);
     // What function code writes reaches the function's log group through here.
     stdout.recordTo(sink);
     stderr.recordTo(sink);
@@ -45,10 +47,14 @@ export function makeSimLambdaVmContext(properties) {
         // Function code asking JavaScript for the time gets the simulation's
         // time, so a frozen or advanced clock reaches the code under test.
         Date: makeSimClockDate(clock),
-        setTimeout,
-        clearTimeout,
-        setInterval,
-        clearInterval,
+        // Timers wait on the simulation's clock too, so a sandboxed handler that
+        // sleeps is released by a test advancing time rather than by the host.
+        // They belong to whichever invocation is running in the sandbox, which is
+        // why they are resolved per call rather than built into it.
+        setTimeout: simLambdaSetTimeout,
+        clearTimeout: simLambdaClearTimeout,
+        setInterval: simLambdaSetInterval,
+        clearInterval: simLambdaClearInterval,
         setImmediate,
         queueMicrotask,
         TextEncoder,

package/dist/service/lambda/function/code/vm/sim-lambda-vm-handler-lookup.d.ts

@@ -0,0 +1,23 @@
+import type { SimLambdaVmModules } from "./sim-lambda-vm-modules.js";
+/**
+ * Importing a function's handler module and finding the export it names.
+ *
+ * Both steps report the AWS-like `Runtime.*` error a real cold start reports,
+ * which is why they sit together.
+ */
+/**
+ * Import the module a handler name points at.
+ *
+ * Anything the import threw that is not already a runtime error becomes a
+ * `Runtime.ImportModuleError`, as it does on real Lambda.
+ */
+export declare function importSimLambdaHandlerModule(modules: SimLambdaVmModules, modulePath: string): unknown;
+/**
+ * Look up the handler export, tolerating a module that exported a nullish
+ * value so the lookup still reports Runtime.HandlerNotFound.
+ *
+ * Only own exports count. Walking the prototype chain would let a handler
+ * name like `index.constructor` resolve to an `Object.prototype` member and
+ * be invoked as the handler, where real Lambda reports HandlerNotFound.
+ */
+export declare function simLambdaExportedHandler(moduleExports: unknown, exportName: string): unknown;

package/dist/service/lambda/function/code/vm/sim-lambda-vm-handler-lookup.js

@@ -0,0 +1,42 @@
+import { SimLambdaRuntimeError } from "../../../error/sim-lambda-runtime.error.js";
+/**
+ * Importing a function's handler module and finding the export it names.
+ *
+ * Both steps report the AWS-like `Runtime.*` error a real cold start reports,
+ * which is why they sit together.
+ */
+/**
+ * Import the module a handler name points at.
+ *
+ * Anything the import threw that is not already a runtime error becomes a
+ * `Runtime.ImportModuleError`, as it does on real Lambda.
+ */
+export function importSimLambdaHandlerModule(modules, modulePath) {
+    try {
+        return modules.requireModule(`./${modulePath}`);
+    }
+    catch (error) {
+        if (error instanceof SimLambdaRuntimeError) {
+            throw error;
+        }
+        throw new SimLambdaRuntimeError("Runtime.ImportModuleError", error instanceof Error ? error.message : String(error));
+    }
+}
+/**
+ * Look up the handler export, tolerating a module that exported a nullish
+ * value so the lookup still reports Runtime.HandlerNotFound.
+ *
+ * Only own exports count. Walking the prototype chain would let a handler
+ * name like `index.constructor` resolve to an `Object.prototype` member and
+ * be invoked as the handler, where real Lambda reports HandlerNotFound.
+ */
+export function simLambdaExportedHandler(moduleExports, exportName) {
+    if (moduleExports === null || moduleExports === undefined) {
+        return undefined;
+    }
+    const exportedValues = moduleExports;
+    if (!Object.hasOwn(exportedValues, exportName)) {
+        return undefined;
+    }
+    return Reflect.get(exportedValues, exportName);
+}

package/dist/service/lambda/function/code/vm/sim-lambda-vm-output-stream.d.ts

@@ -1,4 +1,5 @@
 import { Writable } from "node:stream";
+import type { SimLambdaOutput } from "../../logging/sim-lambda-output.js";
 import { type SimLambdaOutputSink } from "../../logging/sim-lambda-output-sink.js";
 /**
  * One of the standard output streams the sim Lambda vm sandbox gives function
@@ -20,19 +21,26 @@ import { type SimLambdaOutputSink } from "../../logging/sim-lambda-output-sink.j
  * standard output to standard output and standard error to standard error, and
  * recorded to the sink the code was given, which is what puts a handler's
  * output in its log group. Forwarding to the host is a tee rather than a
- * redirect: real Lambda sends output to CloudWatch Logs and nowhere else, but
- * a test tool that swallowed it would make a failing test harder to debug than
- * it is with none of this.
+ * redirect. Real Lambda sends output to CloudWatch Logs and nowhere else, and a
+ * test tool that swallowed it would make a failing test harder to debug than it
+ * is with none of this.
  * The sandbox's own console is built over these streams too, so a handler's
  * output arrives there whether it printed through the console or wrote to the
  * stream itself, instead of one of the two disappearing. The host stream is
  * read per write, so a test that starts capturing host output after the
  * function has cold-started still sees what the handler writes.
+ *
+ * A simulated Lambda told to capture only (see `SimLambdaOutput`) drops the
+ * forwarding and carries on recording. Those settings are read per write as
+ * well, so a sandbox that has already cold started follows a change. A stream
+ * built without them forwards everything, which is what a function with
+ * nowhere to record its output needs.
  */
 export declare class SimLambdaVmOutputStream extends Writable {
     #private;
     private readonly hostStream;
-    constructor(hostStream: () => NodeJS.WritableStream);
+    private readonly output?;
+    constructor(hostStream: () => NodeJS.WritableStream, output?: SimLambdaOutput | undefined);
     /**
      * Record everything written here to a sink from now on.
      */

package/dist/service/lambda/function/code/vm/sim-lambda-vm-output-stream.js

@@ -21,17 +21,24 @@ import { simLambdaNoOutputSink, } from "../../logging/sim-lambda-output-sink.js"
  * standard output to standard output and standard error to standard error, and
  * recorded to the sink the code was given, which is what puts a handler's
  * output in its log group. Forwarding to the host is a tee rather than a
- * redirect: real Lambda sends output to CloudWatch Logs and nowhere else, but
- * a test tool that swallowed it would make a failing test harder to debug than
- * it is with none of this.
+ * redirect. Real Lambda sends output to CloudWatch Logs and nowhere else, and a
+ * test tool that swallowed it would make a failing test harder to debug than it
+ * is with none of this.
  * The sandbox's own console is built over these streams too, so a handler's
  * output arrives there whether it printed through the console or wrote to the
  * stream itself, instead of one of the two disappearing. The host stream is
  * read per write, so a test that starts capturing host output after the
  * function has cold-started still sees what the handler writes.
+ *
+ * A simulated Lambda told to capture only (see `SimLambdaOutput`) drops the
+ * forwarding and carries on recording. Those settings are read per write as
+ * well, so a sandbox that has already cold started follows a change. A stream
+ * built without them forwards everything, which is what a function with
+ * nowhere to record its output needs.
  */
 export class SimLambdaVmOutputStream extends Writable {
     hostStream;
+    output;
     #sink = simLambdaNoOutputSink;
     /**
      * Decodes what is recorded, rather than each chunk being decoded on its own.
@@ -44,9 +51,10 @@ export class SimLambdaVmOutputStream extends Writable {
      * bytes left over at the end of an invocation belong to the next one.
      */
     #decoder = new StringDecoder("utf8");
-    constructor(hostStream) {
+    constructor(hostStream, output) {
         super();
         this.hostStream = hostStream;
+        this.output = output;
     }
     /**
      * Record everything written here to a sink from now on.
@@ -65,7 +73,9 @@ export class SimLambdaVmOutputStream extends Writable {
      */
     _write(chunk, _encoding, done) {
         this.#sink.write(this.#decoder.write(chunk));
-        this.hostStream().write(chunk);
+        if (this.output?.reachesHost() ?? true) {
+            this.hostStream().write(chunk);
+        }
         done();
     }
 }

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

@@ -1,4 +1,5 @@
 import type { SimClock } from "../../../../util/clock/sim-clock.js";
+import type { SimLambdaOutput } from "../logging/sim-lambda-output.js";
 import type { SimLambdaOutputSink } from "../logging/sim-lambda-output-sink.js";
 import type { SimLambdaOutboundHttp } from "../outbound/sim-lambda-outbound-http.js";
 /**
@@ -19,6 +20,12 @@ interface SimLambdaHostScope {
      * and its output reaches the host console alone.
      */
     readonly output: SimLambdaOutputSink | undefined;
+    /**
+     * Whether what the invocation prints also reaches the host console once it
+     * has been recorded. Read only where there is a sink, because a function
+     * with nowhere to record has the host console alone.
+     */
+    readonly outputSettings: SimLambdaOutput;
 }
 /**
  * Run an invocation of code in the host scope with the process globals it

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

@@ -1,6 +1,7 @@
 import { simLambdaProcessClock } from "./sim-lambda-process-clock.js";
 import { simLambdaProcessOutbound } from "./sim-lambda-process-outbound.js";
 import { simLambdaProcessOutput } from "./sim-lambda-process-output.js";
+import { simLambdaProcessTimers } from "./timer/sim-lambda-process-timers.js";
 /**
  * Run an invocation of code in the host scope with the process globals it
  * reads bridged to its simulation.
@@ -11,10 +12,13 @@ import { simLambdaProcessOutput } from "./sim-lambda-process-output.js";
  * here.
  */
 export async function runSimLambdaInHostScope(scope, run) {
-    const { clock, outboundHttp, output } = scope;
+    const { clock, outboundHttp, output, outputSettings } = scope;
+    // Host-scope code reaches for the global timer functions, so the invocation
+    // its handler runs in has to be findable from them.
+    simLambdaProcessTimers.install();
     const recording = output === undefined
         ? run
-        : async () => await simLambdaProcessOutput.run(output, run);
+        : async () => await simLambdaProcessOutput.run(output, outputSettings, run);
     const reachingTheSimulation = outboundHttp === undefined
         ? recording
         : async () => await simLambdaProcessOutbound.run(outboundHttp, recording);

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

@@ -0,0 +1,26 @@
+import type { BackgroundScheduler } from "../../../../util/background/background.js";
+interface SimLambdaInvocationDeadlineProperties {
+    readonly background: BackgroundScheduler;
+    readonly timeoutSeconds: number;
+    readonly awsRequestId: string;
+}
+/**
+ * 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 declare class SimLambdaInvocationDeadline {
+    #private;
+    constructor(properties: SimLambdaInvocationDeadlineProperties);
+    /**
+     * Run the handler with timers of its own, up to this deadline.
+     */
+    around<T>(handler: () => Promise<T>): Promise<T>;
+}
+export {};

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