@kensio/yulin 1.21.3 → 1.21.4

package/dist/service/lambda/event-source/sim-lambda-stream-retry-limits.d.ts

@@ -0,0 +1,56 @@
+/**
+ * The parts of a request that say how long a failed batch keeps being
+ * delivered.
+ *
+ * Taken as its own small input rather than as the whole command input, so the
+ * rules stay with the event source they belong to rather than importing the
+ * command they are read from.
+ */
+export interface SimLambdaEventSourceRetryLimitsInput {
+    readonly maximumRetryAttempts?: number | undefined;
+    readonly maximumRecordAgeInSeconds?: number | undefined;
+}
+/**
+ * The failed-batch limits a mapping reports back, as Lambda names them.
+ */
+export interface SimLambdaStreamRetryLimitsConfiguration {
+    readonly MaximumRetryAttempts: number;
+    readonly MaximumRecordAgeInSeconds: number;
+}
+/**
+ * When a stream mapping stops delivering a batch its function keeps failing.
+ *
+ * The two limits are one thing rather than two, because they end the same
+ * lifecycle: a record leaves the mapping when it has had its retries or when it
+ * is too old to be worth another, whichever comes first. Both are held as
+ * Lambda states them, with `-1` for no limit, so a Get or a List reports back
+ * exactly what was asked for.
+ */
+export declare class SimLambdaStreamRetryLimits {
+    readonly maximumRetryAttempts: number;
+    readonly maximumRecordAgeInSeconds: number;
+    constructor(input?: SimLambdaEventSourceRetryLimitsInput);
+    /**
+     * The two limits as a Get, a List or a create response reports them.
+     */
+    configuration(): SimLambdaStreamRetryLimitsConfiguration;
+    /**
+     * How many times a failed batch is delivered again before it is discarded.
+     *
+     * A mapping that named neither limit gets the simulator's own cap of five,
+     * which is what keeps a handler that always throws from leaving the clock
+     * with work falling due forever. A mapping that named a record age has an end
+     * of its own, so the cap is out of the way and the records age out as they do
+     * on AWS.
+     */
+    get attemptLimit(): number;
+    /**
+     * Whether a record written at an instant is too old to be handed over again.
+     *
+     * A record the stream gave up without a time has no age to read, and is
+     * discarded alongside the ones that aged out rather than kept forever against
+     * a limit that is about age. Both simulated stream services stamp every
+     * record, so this is a guard rather than a case a test can reach.
+     */
+    hasAgedOut(writtenAt: Date | undefined, now: Date): boolean;
+}

package/dist/service/lambda/event-source/sim-lambda-stream-retry-limits.js

@@ -0,0 +1,110 @@
+import { SimLambdaValidationException } from "../error/sim-lambda.error.js";
+/**
+ * The value both settings take to mean no limit, and what a mapping that named
+ * neither of them reports.
+ */
+const infinite = -1;
+/**
+ * The largest number of retries Lambda takes.
+ */
+const maximumRetryAttemptsLimit = 10_000;
+/**
+ * The oldest record age Lambda takes, which is seven days.
+ */
+const maximumRecordAgeLimit = 604_800;
+/**
+ * How many times a failed batch is delivered again when the mapping asked for
+ * no limit of its own.
+ *
+ * A batch a handler always throws on has to stop somewhere. AWS keeps retrying
+ * until the records age out of the stream, a day later, and waiting out a
+ * simulated day is a hang with more steps.
+ */
+const defaultAttemptLimit = 5;
+const millisecondsPerSecond = 1000;
+/**
+ * When a stream mapping stops delivering a batch its function keeps failing.
+ *
+ * The two limits are one thing rather than two, because they end the same
+ * lifecycle: a record leaves the mapping when it has had its retries or when it
+ * is too old to be worth another, whichever comes first. Both are held as
+ * Lambda states them, with `-1` for no limit, so a Get or a List reports back
+ * exactly what was asked for.
+ */
+export class SimLambdaStreamRetryLimits {
+    maximumRetryAttempts;
+    maximumRecordAgeInSeconds;
+    constructor(input = {}) {
+        this.maximumRetryAttempts = checkedLimit({
+            value: input.maximumRetryAttempts,
+            field: "maximumRetryAttempts",
+            maximum: maximumRetryAttemptsLimit,
+            unit: "retries",
+        });
+        this.maximumRecordAgeInSeconds = checkedLimit({
+            value: input.maximumRecordAgeInSeconds,
+            field: "maximumRecordAgeInSeconds",
+            maximum: maximumRecordAgeLimit,
+            unit: "seconds",
+        });
+    }
+    /**
+     * The two limits as a Get, a List or a create response reports them.
+     */
+    configuration() {
+        return {
+            MaximumRetryAttempts: this.maximumRetryAttempts,
+            MaximumRecordAgeInSeconds: this.maximumRecordAgeInSeconds,
+        };
+    }
+    /**
+     * How many times a failed batch is delivered again before it is discarded.
+     *
+     * A mapping that named neither limit gets the simulator's own cap of five,
+     * which is what keeps a handler that always throws from leaving the clock
+     * with work falling due forever. A mapping that named a record age has an end
+     * of its own, so the cap is out of the way and the records age out as they do
+     * on AWS.
+     */
+    get attemptLimit() {
+        if (this.maximumRetryAttempts !== infinite) {
+            return this.maximumRetryAttempts;
+        }
+        return this.maximumRecordAgeInSeconds === infinite
+            ? defaultAttemptLimit
+            : Infinity;
+    }
+    /**
+     * Whether a record written at an instant is too old to be handed over again.
+     *
+     * A record the stream gave up without a time has no age to read, and is
+     * discarded alongside the ones that aged out rather than kept forever against
+     * a limit that is about age. Both simulated stream services stamp every
+     * record, so this is a guard rather than a case a test can reach.
+     */
+    hasAgedOut(writtenAt, now) {
+        if (this.maximumRecordAgeInSeconds === infinite) {
+            return false;
+        }
+        if (writtenAt === undefined) {
+            return true;
+        }
+        const age = now.getTime() - writtenAt.getTime();
+        return age > this.maximumRecordAgeInSeconds * millisecondsPerSecond;
+    }
+}
+/**
+ * One limit as Lambda takes it, refusing a value outside the range it documents.
+ */
+function checkedLimit(properties) {
+    const { value, field, maximum, unit } = properties;
+    if (value === undefined) {
+        return infinite;
+    }
+    if (!Number.isSafeInteger(value) || value < infinite || value > maximum) {
+        throw new SimLambdaValidationException(`1 validation error detected: Value ${String(value)} at '${field}' ` +
+            "failed to satisfy constraint: Member must be a whole number of " +
+            `${unit} between 0 and ${String(maximum)}, or -1 for no limit`);
+    }
+    return value;
+}

package/dist/service/lambda/event-source/stream/kinesis/sim-lambda-kinesis-event-source-arn.d.ts

@@ -1,4 +1,5 @@
 import type { SimLambdaEventSourceBatchRules } from "../../sim-lambda-event-source-batch-rules.js";
+import type { SimLambdaEventSourceRetryLimitRules } from "../../sim-lambda-event-source-retry-limits.js";
 import { SimLambdaEventSourcePollingPermission } from "../../sim-lambda-event-source-polling-permission.js";
 import type { SimLambdaEventSourceStartingPositionRules } from "../../sim-lambda-event-source-starting-position.js";
 /**
@@ -42,6 +43,10 @@ export declare class SimLambdaKinesisEventSourceArn {
      * The starting positions a mapping on this stream may be created with.
      */
     get startingPositionRules(): SimLambdaEventSourceStartingPositionRules;
+    /**
+     * The failed-batch limits a mapping on this stream may be created with.
+     */
+    get retryLimitRules(): SimLambdaEventSourceRetryLimitRules;
     /**
      * Whether this stream is in an Account and Region.
      */

package/dist/service/lambda/event-source/stream/kinesis/sim-lambda-kinesis-event-source-arn.js

@@ -1,6 +1,6 @@
 import { SimLambdaInvalidParameterValueException } from "../../../error/sim-lambda.error.js";
 import { SimLambdaEventSourcePollingPermission } from "../../sim-lambda-event-source-polling-permission.js";
-import { kinesisStreamBatchRules, kinesisStreamPollingOperations, kinesisStreamStartingPositionRules, } from "./sim-lambda-kinesis-event-source-rules.js";
+import { kinesisStreamBatchRules, kinesisStreamPollingOperations, kinesisStreamRetryLimitRules, kinesisStreamStartingPositionRules, } from "./sim-lambda-kinesis-event-source-rules.js";
 /**
  * A Kinesis stream ARN carries the stream name after a `stream/` separator, and
  * a stream name holds no colon and no slash, so the ARN is read in one piece.
@@ -78,6 +78,12 @@ export class SimLambdaKinesisEventSourceArn {
     get startingPositionRules() {
         return kinesisStreamStartingPositionRules;
     }
+    /**
+     * The failed-batch limits a mapping on this stream may be created with.
+     */
+    get retryLimitRules() {
+        return kinesisStreamRetryLimitRules;
+    }
     /**
      * Whether this stream is in an Account and Region.
      */

package/dist/service/lambda/event-source/stream/kinesis/sim-lambda-kinesis-event-source-rules.d.ts

@@ -1,4 +1,5 @@
 import { SimLambdaEventSourceBatchRules } from "../../sim-lambda-event-source-batch-rules.js";
+import { SimLambdaStreamRetryLimitRules } from "../../sim-lambda-event-source-retry-limits.js";
 import { SimLambdaStreamStartingPosition } from "../../sim-lambda-event-source-starting-position.js";
 /**
  * What a function's execution role has to be allowed to do on a stream for
@@ -25,3 +26,8 @@ export declare const kinesisStreamBatchRules: SimLambdaEventSourceBatchRules;
  * its records carry the instant they arrived.
  */
 export declare const kinesisStreamStartingPositionRules: SimLambdaStreamStartingPosition;
+/**
+ * A Kinesis stream mapping counts a failed batch's attempts itself, so it takes
+ * both of Lambda's failed-batch limits.
+ */
+export declare const kinesisStreamRetryLimitRules: SimLambdaStreamRetryLimitRules;

package/dist/service/lambda/event-source/stream/kinesis/sim-lambda-kinesis-event-source-rules.js

@@ -1,4 +1,5 @@
 import { SimLambdaEventSourceBatchRules } from "../../sim-lambda-event-source-batch-rules.js";
+import { SimLambdaStreamRetryLimitRules } from "../../sim-lambda-event-source-retry-limits.js";
 import { SimLambdaStreamStartingPosition } from "../../sim-lambda-event-source-starting-position.js";
 /**
  * What a function's execution role has to be allowed to do on a stream for
@@ -37,3 +38,8 @@ export const kinesisStreamStartingPositionRules = new SimLambdaStreamStartingPos
     positions: ["TRIM_HORIZON", "LATEST", "AT_TIMESTAMP"],
     sourceDescription: "a Kinesis stream",
 });
+/**
+ * A Kinesis stream mapping counts a failed batch's attempts itself, so it takes
+ * both of Lambda's failed-batch limits.
+ */
+export const kinesisStreamRetryLimitRules = new SimLambdaStreamRetryLimitRules();

package/dist/service/lambda/event-source/stream/sim-lambda-dynamodb-stream-event-source-arn.d.ts

@@ -1,5 +1,6 @@
 import type { SimLambdaEventSourceBatchRules } from "../sim-lambda-event-source-batch-rules.js";
-import { SimLambdaEventSourcePollingPermission } from "../sim-lambda-event-source-polling-permission.js";
+import type { SimLambdaEventSourcePollingPermission } from "../sim-lambda-event-source-polling-permission.js";
+import type { SimLambdaEventSourceRetryLimitRules } from "../sim-lambda-event-source-retry-limits.js";
 import type { SimLambdaEventSourceStartingPositionRules } from "../sim-lambda-event-source-starting-position.js";
 /**
  * The DynamoDB stream ARN an event source mapping is created for.
@@ -44,6 +45,10 @@ export declare class SimLambdaDynamoDbStreamEventSourceArn {
      * The starting positions a mapping on this stream may be created with.
      */
     get startingPositionRules(): SimLambdaEventSourceStartingPositionRules;
+    /**
+     * The failed-batch limits a mapping on this stream may be created with.
+     */
+    get retryLimitRules(): SimLambdaEventSourceRetryLimitRules;
     /**
      * Whether this stream is in an Account and Region.
      */

package/dist/service/lambda/event-source/stream/sim-lambda-dynamodb-stream-event-source-arn.js

@@ -1,6 +1,5 @@
 import { SimLambdaInvalidParameterValueException } from "../../error/sim-lambda.error.js";
-import { SimLambdaEventSourcePollingPermission } from "../sim-lambda-event-source-polling-permission.js";
-import { dynamoDbStreamBatchRules, dynamoDbStreamPollingOperations, dynamoDbStreamStartingPositionRules, } from "./sim-lambda-dynamodb-stream-event-source-rules.js";
+import { dynamoDbStreamBatchRules, dynamoDbStreamPollingPermissions, dynamoDbStreamRetryLimitRules, dynamoDbStreamStartingPositionRules, } from "./sim-lambda-dynamodb-stream-event-source-rules.js";
 /**
  * A stream ARN is a table ARN with a label after it, and the label is an ISO
  * timestamp carrying two colons of its own. Splitting the ARN on colons
@@ -37,10 +36,7 @@ export class SimLambdaDynamoDbStreamEventSourceArn {
         this.accountId = parts["account"] ?? "";
         this.tableName = parts["table"] ?? "";
         this.label = parts["label"] ?? "";
-        this.pollingPermissions = [
-            ...dynamoDbStreamPollingOperations.map((operation) => new SimLambdaEventSourcePollingPermission(`dynamodb:${operation}`, value)),
-            new SimLambdaEventSourcePollingPermission("dynamodb:ListStreams", "*"),
-        ];
+        this.pollingPermissions = dynamoDbStreamPollingPermissions(value);
     }
     /**
      * Read a stream ARN, answering with nothing when the ARN names something
@@ -78,6 +74,12 @@ export class SimLambdaDynamoDbStreamEventSourceArn {
     get startingPositionRules() {
         return dynamoDbStreamStartingPositionRules;
     }
+    /**
+     * The failed-batch limits a mapping on this stream may be created with.
+     */
+    get retryLimitRules() {
+        return dynamoDbStreamRetryLimitRules;
+    }
     /**
      * Whether this stream is in an Account and Region.
      */

package/dist/service/lambda/event-source/stream/sim-lambda-dynamodb-stream-event-source-rules.d.ts

@@ -1,15 +1,12 @@
 import { SimLambdaEventSourceBatchRules } from "../sim-lambda-event-source-batch-rules.js";
+import { SimLambdaEventSourcePollingPermission } from "../sim-lambda-event-source-polling-permission.js";
+import { SimLambdaStreamRetryLimitRules } from "../sim-lambda-event-source-retry-limits.js";
 import { SimLambdaStreamStartingPosition } from "../sim-lambda-event-source-starting-position.js";
 /**
- * What a function's execution role has to be allowed to do on a stream for
- * Lambda to poll it.
- *
- * These are the three operations a poller performs on the stream itself.
- * `ListStreams` goes with them, on every stream rather than on one: nothing
- * here ever calls it, but both the AWS managed policy and CDK's own grant
- * include it, so a role that would work on AWS is a role that works here.
+ * What an execution role has to be allowed before a mapping on one stream can
+ * be created, as the permissions simulated IAM is asked for.
  */
-export declare const dynamoDbStreamPollingOperations: readonly ["DescribeStream", "GetRecords", "GetShardIterator"];
+export declare function dynamoDbStreamPollingPermissions(streamArn: string): readonly SimLambdaEventSourcePollingPermission[];
 /**
  * The batch sizes a DynamoDB stream event source delivers with.
  *
@@ -25,3 +22,8 @@ export declare const dynamoDbStreamBatchRules: SimLambdaEventSourceBatchRules;
  * Kinesis stream, and real Lambda refuses it here.
  */
 export declare const dynamoDbStreamStartingPositionRules: SimLambdaStreamStartingPosition;
+/**
+ * A DynamoDB stream mapping counts a failed batch's attempts itself, so it
+ * takes both of Lambda's failed-batch limits.
+ */
+export declare const dynamoDbStreamRetryLimitRules: SimLambdaStreamRetryLimitRules;

package/dist/service/lambda/event-source/stream/sim-lambda-dynamodb-stream-event-source-rules.js

@@ -1,4 +1,6 @@
 import { SimLambdaEventSourceBatchRules } from "../sim-lambda-event-source-batch-rules.js";
+import { SimLambdaEventSourcePollingPermission } from "../sim-lambda-event-source-polling-permission.js";
+import { SimLambdaStreamRetryLimitRules } from "../sim-lambda-event-source-retry-limits.js";
 import { SimLambdaStreamStartingPosition } from "../sim-lambda-event-source-starting-position.js";
 /**
  * What a function's execution role has to be allowed to do on a stream for
@@ -9,11 +11,21 @@ import { SimLambdaStreamStartingPosition } from "../sim-lambda-event-source-star
  * here ever calls it, but both the AWS managed policy and CDK's own grant
  * include it, so a role that would work on AWS is a role that works here.
  */
-export const dynamoDbStreamPollingOperations = [
+const dynamoDbStreamPollingOperations = [
     "DescribeStream",
     "GetRecords",
     "GetShardIterator",
 ];
+/**
+ * What an execution role has to be allowed before a mapping on one stream can
+ * be created, as the permissions simulated IAM is asked for.
+ */
+export function dynamoDbStreamPollingPermissions(streamArn) {
+    return [
+        ...dynamoDbStreamPollingOperations.map((operation) => new SimLambdaEventSourcePollingPermission(`dynamodb:${operation}`, streamArn)),
+        new SimLambdaEventSourcePollingPermission("dynamodb:ListStreams", "*"),
+    ];
+}
 /**
  * The batch sizes a DynamoDB stream event source delivers with.
  *
@@ -38,3 +50,8 @@ export const dynamoDbStreamStartingPositionRules = new SimLambdaStreamStartingPo
     sourceDescription: "a DynamoDB stream",
     positionElsewhere: "AT_TIMESTAMP is for a Kinesis stream",
 });
+/**
+ * A DynamoDB stream mapping counts a failed batch's attempts itself, so it
+ * takes both of Lambda's failed-batch limits.
+ */
+export const dynamoDbStreamRetryLimitRules = new SimLambdaStreamRetryLimitRules();

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

@@ -1,4 +1,5 @@
 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 { SimLambdaHandler } from "../sim-lambda-handler.type.js";
 /**
@@ -32,8 +33,12 @@ export interface SimLambdaExecutableCode {
     /**
      * Record what this code writes to its standard streams, so an invocation's
      * output reaches the function's log group.
+     *
+     * The output settings come with the sink because they decide what happens to
+     * a line once it has been recorded, and only code with somewhere to record
+     * is ever given either.
      */
-    recordOutputTo(sink: SimLambdaOutputSink): void;
+    recordOutputTo(sink: SimLambdaOutputSink, output: SimLambdaOutput): void;
     /**
      * This code under changed function settings, cold rather than warm.
      *
@@ -63,7 +68,8 @@ export declare class SimLambdaHandlerReferenceCode implements SimLambdaExecutabl
      * function closing over the test's own module scope, and it prints through
      * the process console and the process standard streams. Its invocation is
      * run with those bridged to the function's sink instead, the way the clock
-     * and process.env are bridged for the same code.
+     * and process.env are bridged for the same code. The output settings reach
+     * that bridge by the same route.
      */
     recordOutputTo(): void;
     /**

package/dist/service/lambda/function/code/sim-lambda-executable-code.js

@@ -18,7 +18,8 @@ export class SimLambdaHandlerReferenceCode {
      * function closing over the test's own module scope, and it prints through
      * the process console and the process standard streams. Its invocation is
      * run with those bridged to the function's sink instead, the way the clock
-     * and process.env are bridged for the same code.
+     * and process.env are bridged for the same code. The output settings reach
+     * that bridge by the same route.
      */
     recordOutputTo() {
         // Recorded by the invocation, from the process globals.

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

@@ -3,6 +3,7 @@ import type { SimLambdaHandler } from "../sim-lambda-handler.type.js";
 import { type SimLambdaVmSdkModuleProvider } from "./vm/sdk/sim-lambda-vm-sdk-module-provider.js";
 import type { SimLambdaCodeConfiguration, SimLambdaExecutableCode } from "./sim-lambda-executable-code.js";
 import { type SimLambdaVmContextProperties } from "./vm/sim-lambda-vm-context.js";
+import type { SimLambdaOutput } from "../logging/sim-lambda-output.js";
 import { type SimLambdaOutputSink } from "../logging/sim-lambda-output-sink.js";
 /**
  * The archive and handler this code runs, on top of everything its sandbox is
@@ -37,7 +38,7 @@ export declare class SimLambdaVmZipCode implements SimLambdaExecutableCode {
      * asks for the handler, so the streams function code is handed already carry
      * the sink by the time any of it runs.
      */
-    recordOutputTo(sink: SimLambdaOutputSink): void;
+    recordOutputTo(sink: SimLambdaOutputSink, output: SimLambdaOutput): void;
     /**
      * This archive under changed function settings, ready to cold start again.
      *
@@ -53,15 +54,5 @@ export declare class SimLambdaVmZipCode implements SimLambdaExecutableCode {
      */
     handlerFunction(): SimLambdaHandler;
     private coldStart;
-    /**
-     * 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.
-     */
-    private exportedHandler;
-    private importHandlerModule;
 }
 export {};

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