@kensio/yulin 1.21.7 → 1.21.9

package/dist/service/lambda/event-source/poll/sim-lambda-stream-failure-context.d.ts

@@ -0,0 +1,3 @@
+import type { SimLambdaStreamFailureRecord, StreamFailureRecordProperties } from "./sim-lambda-stream-failure-record.js";
+/** Build invocation metadata for a stream failure notification. */
+export declare function streamFailureContext(properties: StreamFailureRecordProperties): Pick<SimLambdaStreamFailureRecord, "requestContext" | "responseContext">;

package/dist/service/lambda/event-source/poll/sim-lambda-stream-failure-context.js

@@ -0,0 +1,19 @@
+import { randomUUID } from "node:crypto";
+/** Build invocation metadata for a stream failure notification. */
+export function streamFailureContext(properties) {
+    return {
+        requestContext: {
+            requestId: randomUUID(),
+            functionArn: properties.mapping.functionArn,
+            condition: properties.discard.condition,
+            approximateInvokeCount: properties.invokeCount,
+        },
+        ...(properties.invokeCount > 0 && {
+            responseContext: {
+                statusCode: 200,
+                executedVersion: properties.simFunction.version,
+                ...(properties.functionError && { functionError: "Unhandled" }),
+            },
+        }),
+    };
+}

package/dist/service/lambda/event-source/poll/sim-lambda-stream-failure-destination.d.ts

@@ -0,0 +1,15 @@
+import type { SimLambdaStreamBatchOutcome } from "./sim-lambda-stream-batch-outcome.js";
+import type { SimLambdaFunction } from "../../function/sim-lambda-function.js";
+import type { SimLambdaEventSourceMapping } from "../sim-lambda-event-source-mapping.js";
+import type { SimLambdaEventSourceStreamProgressBatch } from "../stream/sim-lambda-event-source-streams.js";
+import { type SimLambdaStreamDiscard } from "./sim-lambda-stream-failure-record.js";
+/** Count invocations and send discarded batch metadata through the destination service. */
+export declare class SimLambdaStreamFailureDestination {
+    private readonly mapping;
+    private invokeCount;
+    private functionError;
+    constructor(mapping: SimLambdaEventSourceMapping);
+    invoked(outcome: SimLambdaStreamBatchOutcome): void;
+    reset(): void;
+    deliver(discard: SimLambdaStreamDiscard | undefined, batch: SimLambdaEventSourceStreamProgressBatch, simFunction: SimLambdaFunction): Promise<void>;
+}

package/dist/service/lambda/event-source/poll/sim-lambda-stream-failure-destination.js

@@ -0,0 +1,38 @@
+import { SimLambdaDestinationArn } from "../../destination/sim-lambda-destination-arn.js";
+import { simLambdaStreamFailureRecord, } from "./sim-lambda-stream-failure-record.js";
+/** Count invocations and send discarded batch metadata through the destination service. */
+export class SimLambdaStreamFailureDestination {
+    mapping;
+    invokeCount = 0;
+    functionError = false;
+    constructor(mapping) {
+        this.mapping = mapping;
+    }
+    invoked(outcome) {
+        this.invokeCount += 1;
+        this.functionError = outcome.functionError;
+    }
+    reset() {
+        this.invokeCount = 0;
+    }
+    async deliver(discard, batch, simFunction) {
+        const mapping = this.mapping;
+        const arn = mapping.failureDestinationArn;
+        if (discard === undefined || arn === undefined || arn === "")
+            return;
+        const record = simLambdaStreamFailureRecord({
+            mapping,
+            simFunction,
+            discard,
+            invokeCount: this.invokeCount,
+            shardId: batch.shardId,
+            functionError: this.functionError,
+        });
+        await mapping.destinations.deliver({
+            destinationArn: SimLambdaDestinationArn.of(arn),
+            sourceFunctionArn: mapping.functionArn,
+            sourceFunctionRoleArn: simFunction.roleArn,
+            record,
+        });
+    }
+}

package/dist/service/lambda/event-source/poll/sim-lambda-stream-failure-record.d.ts

@@ -0,0 +1,41 @@
+import { type SimLambdaStreamBatchInfo } from "./sim-lambda-stream-batch-info.js";
+import type { SimLambdaFunction } from "../../function/sim-lambda-function.js";
+import type { SimLambdaEventSourceMapping } from "../sim-lambda-event-source-mapping.js";
+import type { SimLambdaStreamRecordTime } from "./sim-lambda-stream-record-times.js";
+export type SimLambdaStreamFailureCondition = "RetryAttemptsExhausted" | "RecordAgeExceeded";
+export interface SimLambdaStreamDiscard {
+    readonly records: readonly SimLambdaStreamRecordTime[];
+    readonly condition: SimLambdaStreamFailureCondition;
+    readonly at: Date;
+}
+export interface SimLambdaStreamFailureRecord {
+    readonly version: string;
+    readonly timestamp: string;
+    readonly requestContext: {
+        readonly requestId: string;
+        readonly functionArn: string;
+        readonly condition: SimLambdaStreamFailureCondition;
+        readonly approximateInvokeCount: number;
+    };
+    readonly responseContext?: {
+        readonly statusCode: number;
+        readonly executedVersion: string;
+        readonly functionError?: string;
+    };
+    readonly DDBStreamBatchInfo?: SimLambdaStreamBatchInfo;
+    readonly KinesisBatchInfo?: SimLambdaStreamBatchInfo;
+}
+export interface StreamFailureRecordProperties {
+    readonly mapping: SimLambdaEventSourceMapping;
+    readonly simFunction: SimLambdaFunction;
+    readonly shardId: string | undefined;
+    readonly discard: SimLambdaStreamDiscard;
+    readonly invokeCount: number;
+    readonly functionError: boolean;
+}
+/**
+ * SQS and SNS receive metadata identifying the discarded records.
+ * @see https://docs.aws.amazon.com/lambda/latest/dg/services-dynamodb-errors.html
+ * @see https://docs.aws.amazon.com/lambda/latest/dg/kinesis-on-failure-destination.html
+ */
+export declare function simLambdaStreamFailureRecord(properties: StreamFailureRecordProperties): SimLambdaStreamFailureRecord;

package/dist/service/lambda/event-source/poll/sim-lambda-stream-failure-record.js

@@ -0,0 +1,17 @@
+import { streamFailureContext } from "./sim-lambda-stream-failure-context.js";
+import { simLambdaStreamBatchInfo, streamFailureBatchInfo, } from "./sim-lambda-stream-batch-info.js";
+/**
+ * SQS and SNS receive metadata identifying the discarded records.
+ * @see https://docs.aws.amazon.com/lambda/latest/dg/services-dynamodb-errors.html
+ * @see https://docs.aws.amazon.com/lambda/latest/dg/kinesis-on-failure-destination.html
+ */
+export function simLambdaStreamFailureRecord(properties) {
+    const { mapping, discard, shardId } = properties;
+    const info = simLambdaStreamBatchInfo(discard.records, mapping.eventSourceArn, shardId);
+    return {
+        version: "1.0",
+        timestamp: discard.at.toISOString(),
+        ...streamFailureContext(properties),
+        ...streamFailureBatchInfo(mapping.eventSourceArn, info),
+    };
+}

package/dist/service/lambda/event-source/poll/sim-lambda-stream-progress-state.d.ts

@@ -0,0 +1,21 @@
+import { SimLambdaStreamExpiry } from "./sim-lambda-stream-expiry.js";
+import { SimLambdaStreamFailureDestination } from "./sim-lambda-stream-failure-destination.js";
+import { SimLambdaStreamCursor } from "./sim-lambda-stream-cursor.js";
+import { SimLambdaStreamRetry } from "./sim-lambda-stream-retry.js";
+import type { BackgroundScheduler, BackgroundTask } from "../../../../util/background/background.js";
+import type { SimLambdaEventSourceMapping } from "../sim-lambda-event-source-mapping.js";
+import type { SimLambdaEventSourceStreamProgressBatch } from "../stream/sim-lambda-event-source-streams.js";
+export interface SimLambdaStreamProgressProperties {
+    readonly mapping: SimLambdaEventSourceMapping;
+    readonly background: BackgroundScheduler;
+    readonly poll: BackgroundTask;
+}
+/** Own the per-shard retry state and its expiry and destination collaborators. */
+export declare class SimLambdaStreamProgressState {
+    readonly expiry: SimLambdaStreamExpiry;
+    readonly failures: SimLambdaStreamFailureDestination;
+    readonly cursor: SimLambdaStreamCursor;
+    readonly retry: SimLambdaStreamRetry;
+    constructor(properties: SimLambdaStreamProgressProperties);
+    handled(batch: SimLambdaEventSourceStreamProgressBatch): void;
+}

package/dist/service/lambda/event-source/poll/sim-lambda-stream-progress-state.js

@@ -0,0 +1,39 @@
+import { SimLambdaStreamExpiry } from "./sim-lambda-stream-expiry.js";
+import { SimLambdaStreamBatchAge } from "./sim-lambda-stream-batch-age.js";
+import { SimLambdaStreamFailureDestination } from "./sim-lambda-stream-failure-destination.js";
+import { SimLambdaStreamCursor } from "./sim-lambda-stream-cursor.js";
+import { SimLambdaStreamRetry } from "./sim-lambda-stream-retry.js";
+import { PollSchedule } from "../../../../util/background/poll-schedule.js";
+import { assertDefined } from "../../../../util/type-guard/defined.js";
+/** Own the per-shard retry state and its expiry and destination collaborators. */
+export class SimLambdaStreamProgressState {
+    expiry;
+    failures;
+    cursor;
+    retry;
+    constructor(properties) {
+        const { mapping, background } = properties;
+        this.failures = new SimLambdaStreamFailureDestination(mapping);
+        // A stream mapping is refused at creation unless it names a starting
+        // position, so one that has got this far without one is the simulator
+        // having gone wrong rather than a request having been wrong.
+        const { start, streamRetryLimits } = mapping;
+        assertDefined(start, "stream mapping start position");
+        assertDefined(streamRetryLimits, "stream mapping retry limits");
+        this.cursor = new SimLambdaStreamCursor(start, new PollSchedule(properties));
+        this.retry = new SimLambdaStreamRetry(streamRetryLimits, background);
+        this.expiry = new SimLambdaStreamExpiry({
+            age: new SimLambdaStreamBatchAge(streamRetryLimits, background),
+            cursor: this.cursor,
+            failures: this.failures,
+            handled: (batch) => {
+                this.handled(batch);
+            },
+        });
+    }
+    handled(batch) {
+        this.failures.reset();
+        this.retry.reset();
+        this.cursor.handled(batch);
+    }
+}

package/dist/service/lambda/event-source/poll/sim-lambda-stream-progress.d.ts

@@ -1,27 +1,11 @@
-import type { BackgroundScheduler, BackgroundTask } from "../../../../util/background/background.js";
-import type { SimLambdaEventSourceMapping } from "../sim-lambda-event-source-mapping.js";
+import { type SimLambdaStreamProgressProperties } from "./sim-lambda-stream-progress-state.js";
+import type { SimLambdaStreamRecordTime } from "./sim-lambda-stream-record-times.js";
+import type { SimLambdaFunction } from "../../function/sim-lambda-function.js";
 import type { SimLambdaEventSourceStreamPosition, SimLambdaEventSourceStreamProgressBatch } from "../stream/sim-lambda-event-source-streams.js";
 import type { SimLambdaStreamBatchOutcome } from "./sim-lambda-stream-batch-outcome.js";
-interface SimLambdaStreamProgressProperties {
-    readonly mapping: SimLambdaEventSourceMapping;
-    readonly background: BackgroundScheduler;
-    readonly poll: BackgroundTask;
-}
-/**
- * How far along its stream one mapping has got, and what it does next.
- *
- * The two belong together because they are the same decision. A batch the
- * function took moves the checkpoint and the mapping reads on; a batch it threw
- * on leaves the checkpoint where it is and the mapping tries the same records
- * again after a wait; a batch it reported failing partway through moves the
- * checkpoint back to the record it named. Nothing behind a failing batch is
- * read until it is through, which is what it means for a stream mapping to
- * block its shard.
- */
+/** Apply a stream batch outcome to its checkpoint and retry schedule. */
 export declare class SimLambdaStreamProgress {
-    private readonly checkpoint;
-    private readonly retry;
-    private readonly schedule;
+    private readonly state;
     constructor(properties: SimLambdaStreamProgressProperties);
     /**
      * Poll as soon as the simulation gets to it.
@@ -39,10 +23,11 @@ export declare class SimLambdaStreamProgress {
      * than working out a new one each time.
      */
     caughtUp(batch: SimLambdaEventSourceStreamProgressBatch): void;
+    before(records: readonly SimLambdaStreamRecordTime[], batch: SimLambdaEventSourceStreamProgressBatch, simFunction: SimLambdaFunction): Promise<number>;
     /**
      * Take what became of a batch: move past it, or wait and try it again.
      */
-    after(outcome: SimLambdaStreamBatchOutcome, batch: SimLambdaEventSourceStreamProgressBatch): void;
+    after(outcome: SimLambdaStreamBatchOutcome, batch: SimLambdaEventSourceStreamProgressBatch, simFunction: SimLambdaFunction): Promise<void>;
     /**
      * Move past a batch that is finished with, and read on.
      *
@@ -50,19 +35,4 @@ export declare class SimLambdaStreamProgress {
      * given up on.
      */
     handled(batch: SimLambdaEventSourceStreamProgressBatch): void;
-    /**
-     * Wait and hand a failed batch over again, or give up on it.
-     *
-     * Giving up discards the records and carries on with the stream, which is
-     * what AWS does when a stream mapping's error handling runs out. Parking the
-     * shard instead would be a simulator invention.
-     *
-     * A batch runs out either by having had its retries or by every record left
-     * in it being older than the mapping will carry. Records that aged out of the
-     * front of a batch are left behind, and the ones behind them go over again,
-     * so a mapping given a record age keeps working through its shard rather than
-     * stalling on the oldest record on it.
-     */
-    failed(outcome: SimLambdaStreamBatchOutcome, batch: SimLambdaEventSourceStreamProgressBatch): void;
 }
-export {};

package/dist/service/lambda/event-source/poll/sim-lambda-stream-progress.js

@@ -1,47 +1,21 @@
-import { assertDefined } from "../../../../util/type-guard/defined.js";
-import { PollSchedule } from "../../../../util/background/poll-schedule.js";
-import { SimLambdaStreamCheckpoint } from "./sim-lambda-stream-checkpoint.js";
-import { SimLambdaStreamRetry } from "./sim-lambda-stream-retry.js";
-/**
- * How far along its stream one mapping has got, and what it does next.
- *
- * The two belong together because they are the same decision. A batch the
- * function took moves the checkpoint and the mapping reads on; a batch it threw
- * on leaves the checkpoint where it is and the mapping tries the same records
- * again after a wait; a batch it reported failing partway through moves the
- * checkpoint back to the record it named. Nothing behind a failing batch is
- * read until it is through, which is what it means for a stream mapping to
- * block its shard.
- */
+import { SimLambdaStreamProgressState, } from "./sim-lambda-stream-progress-state.js";
+/** Apply a stream batch outcome to its checkpoint and retry schedule. */
 export class SimLambdaStreamProgress {
-    checkpoint;
-    retry;
-    schedule;
+    state;
     constructor(properties) {
-        // A stream mapping is refused at creation unless it names a starting
-        // position, so one that has got this far without one is the simulator
-        // having gone wrong rather than a request having been wrong.
-        const { start, streamRetryLimits } = properties.mapping;
-        assertDefined(start, "stream mapping start position");
-        assertDefined(streamRetryLimits, "stream mapping retry limits");
-        this.checkpoint = new SimLambdaStreamCheckpoint(start);
-        this.retry = new SimLambdaStreamRetry({
-            limits: streamRetryLimits,
-            clock: properties.background,
-        });
-        this.schedule = new PollSchedule(properties);
+        this.state = new SimLambdaStreamProgressState(properties);
     }
     /**
      * Poll as soon as the simulation gets to it.
      */
     pollNow() {
-        this.schedule.now();
+        this.state.cursor.pollNow();
     }
     /**
      * Where the next read starts.
      */
     get position() {
-        return this.checkpoint.position;
+        return this.state.cursor.position;
     }
     /**
      * Take a read that came back with nothing.
@@ -51,17 +25,29 @@ export class SimLambdaStreamProgress {
      * than working out a new one each time.
      */
     caughtUp(batch) {
-        this.checkpoint.advanceTo(batch.next);
+        this.state.cursor.advanceTo(batch.next);
+    }
+    async before(records, batch, simFunction) {
+        return await this.state.expiry.before(records, batch, simFunction);
     }
     /**
      * Take what became of a batch: move past it, or wait and try it again.
      */
-    after(outcome, batch) {
+    async after(outcome, batch, simFunction) {
+        this.state.failures.invoked(outcome);
         if (outcome.isHandled) {
             this.handled(batch);
             return;
         }
-        this.failed(outcome, batch);
+        const again = this.state.retry.after(outcome, this.position);
+        const notification = this.state.failures.deliver(this.state.retry.discarded, batch, simFunction);
+        if (again === undefined) {
+            this.handled(batch);
+        }
+        else {
+            this.state.cursor.resume(again);
+        }
+        await notification;
     }
     /**
      * Move past a batch that is finished with, and read on.
@@ -70,32 +56,6 @@ export class SimLambdaStreamProgress {
      * given up on.
      */
     handled(batch) {
-        this.retry.reset();
-        this.checkpoint.advanceTo(batch.next);
-        if (!batch.drained) {
-            this.schedule.now();
-        }
-    }
-    /**
-     * Wait and hand a failed batch over again, or give up on it.
-     *
-     * Giving up discards the records and carries on with the stream, which is
-     * what AWS does when a stream mapping's error handling runs out. Parking the
-     * shard instead would be a simulator invention.
-     *
-     * A batch runs out either by having had its retries or by every record left
-     * in it being older than the mapping will carry. Records that aged out of the
-     * front of a batch are left behind, and the ones behind them go over again,
-     * so a mapping given a record age keeps working through its shard rather than
-     * stalling on the oldest record on it.
-     */
-    failed(outcome, batch) {
-        const again = this.retry.after(outcome, this.checkpoint.position);
-        if (again === undefined) {
-            this.handled(batch);
-            return;
-        }
-        this.checkpoint.advanceTo(again.position);
-        this.schedule.afterSeconds(again.afterSeconds);
+        this.state.handled(batch);
     }
 }

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

@@ -1,11 +1,8 @@
+import type { SimLambdaStreamDiscard } from "./sim-lambda-stream-failure-record.js";
 import type { SimClock } from "../../../../util/clock/sim-clock.js";
 import type { SimLambdaStreamRetryLimits } from "../sim-lambda-stream-retry-limits.js";
 import type { SimLambdaEventSourceStreamPosition } from "../stream/sim-lambda-event-source-streams.js";
 import type { SimLambdaStreamBatchOutcome } from "./sim-lambda-stream-batch-outcome.js";
-interface SimLambdaStreamRetryProperties {
-    readonly limits: SimLambdaStreamRetryLimits;
-    readonly clock: SimClock;
-}
 /**
  * One more delivery of a failed batch: where it starts, and how long the
  * mapping waits first.
@@ -14,26 +11,12 @@ export interface SimLambdaStreamRetryAttempt {
     readonly position: SimLambdaEventSourceStreamPosition;
     readonly afterSeconds: number;
 }
-/**
- * Whether a failed batch is handed over again, and from which record.
- *
- * Both of Lambda's failed-batch limits end here because they end the same
- * thing. A batch stops being delivered when it has had its retries, and a
- * record stops being delivered when it is older than the mapping will carry;
- * whichever comes first, what is left of the batch is discarded and the mapping
- * reads on. Records age out of the front of a batch, because a batch is in
- * stream order, so the answer is one record to start from rather than a list of
- * survivors.
- *
- * Ages are read at the instant the next delivery falls due rather than now,
- * because the wait before it is what ages the records out. A record judged now
- * would be handed to the function and only then found to be too old.
- */
+/** Tracks the retry quota and checkpoint of one failed stream batch. */
 export declare class SimLambdaStreamRetry {
-    private readonly limits;
+    discarded: SimLambdaStreamDiscard | undefined;
     private readonly clock;
     private readonly backoff;
-    constructor(properties: SimLambdaStreamRetryProperties);
+    constructor(limits: SimLambdaStreamRetryLimits, clock: SimClock);
     /**
      * The next delivery of a failed batch, or nothing when the batch is finished
      * with.
@@ -43,22 +26,4 @@ export declare class SimLambdaStreamRetry {
      * Start counting again, which a batch that is finished with does.
      */
     reset(): void;
-    /**
-     * Where the next delivery starts, or nothing when every record left in the
-     * batch has aged out.
-     */
-    private retryPosition;
-    /**
-     * The first record from `from` on that is still young enough to deliver.
-     */
-    private firstLiveIndex;
-    /**
-     * When the next delivery falls due, which is what a record's age is judged
-     * against.
-     *
-     * Judging it now would hand a record over and only then notice that it was
-     * too old to be worth handing over, since the wait is what makes it too old.
-     */
-    private deliveryAt;
 }
-export {};

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

@@ -1,44 +1,29 @@
 import { SimLambdaStreamRetryBackoff } from "./sim-lambda-stream-retry-backoff.js";
-const millisecondsPerSecond = 1000;
-/**
- * Whether a failed batch is handed over again, and from which record.
- *
- * Both of Lambda's failed-batch limits end here because they end the same
- * thing. A batch stops being delivered when it has had its retries, and a
- * record stops being delivered when it is older than the mapping will carry;
- * whichever comes first, what is left of the batch is discarded and the mapping
- * reads on. Records age out of the front of a batch, because a batch is in
- * stream order, so the answer is one record to start from rather than a list of
- * survivors.
- *
- * Ages are read at the instant the next delivery falls due rather than now,
- * because the wait before it is what ages the records out. A record judged now
- * would be handed to the function and only then found to be too old.
- */
+/** Tracks the retry quota and checkpoint of one failed stream batch. */
 export class SimLambdaStreamRetry {
-    limits;
+    discarded;
     clock;
     backoff;
-    constructor(properties) {
-        this.limits = properties.limits;
-        this.clock = properties.clock;
-        this.backoff = new SimLambdaStreamRetryBackoff(properties.limits.attemptLimit);
+    constructor(limits, clock) {
+        this.clock = clock;
+        this.backoff = new SimLambdaStreamRetryBackoff(limits.attemptLimit);
     }
     /**
      * The next delivery of a failed batch, or nothing when the batch is finished
      * with.
      */
     after(outcome, readFrom) {
+        this.discarded = undefined;
         if (this.backoff.isExhausted) {
+            this.discarded = {
+                records: outcome.records.slice(outcome.retryIndex),
+                condition: "RetryAttemptsExhausted",
+                at: this.clock.now(),
+            };
             return undefined;
         }
         const afterSeconds = this.backoff.nextSeconds();
-        const deliveryAt = this.deliveryAt(afterSeconds);
-        const position = this.retryPosition(outcome, readFrom, deliveryAt);
-        if (position === undefined) {
-            return undefined;
-        }
-        return { position, afterSeconds };
+        return { position: outcome.retryPosition(readFrom), afterSeconds };
     }
     /**
      * Start counting again, which a batch that is finished with does.
@@ -46,41 +31,4 @@ export class SimLambdaStreamRetry {
     reset() {
         this.backoff.reset();
     }
-    /**
-     * Where the next delivery starts, or nothing when every record left in the
-     * batch has aged out.
-     */
-    retryPosition(outcome, readFrom, deliveryAt) {
-        const { records, retryIndex } = outcome;
-        const live = this.firstLiveIndex(records, retryIndex, deliveryAt);
-        if (live === undefined) {
-            return undefined;
-        }
-        const sequenceNumber = records.at(live)?.sequenceNumber;
-        // Nothing aged out of the front, so the batch goes back exactly where the
-        // report left it. A record that aged out but cannot be named leaves the
-        // batch where it was too, since skipping past a record the mapping cannot
-        // name would skip the records after it as well.
-        if (live === retryIndex || sequenceNumber === undefined) {
-            return outcome.retryPosition(readFrom);
-        }
-        return { kind: "sequence", sequenceNumber };
-    }
-    /**
-     * The first record from `from` on that is still young enough to deliver.
-     */
-    firstLiveIndex(records, from, deliveryAt) {
-        const index = records.findIndex((record, position) => position >= from && !this.limits.hasAgedOut(record.at, deliveryAt));
-        return index === -1 ? undefined : index;
-    }
-    /**
-     * When the next delivery falls due, which is what a record's age is judged
-     * against.
-     *
-     * Judging it now would hand a record over and only then notice that it was
-     * too old to be worth handing over, since the wait is what makes it too old.
-     */
-    deliveryAt(afterSeconds) {
-        return new Date(this.clock.now().getTime() + afterSeconds * millisecondsPerSecond);
-    }
 }

package/dist/service/lambda/event-source/sim-lambda-event-source-mapping.d.ts

@@ -1,3 +1,5 @@
+import type { SimLambdaStreamDestinationConfiguration } from "./sim-lambda-stream-destination-config.js";
+import type { SimLambdaDestinationTargets } from "../destination/sim-lambda-destination-targets.js";
 import type { SimAwsAccountRegionScope } from "../../aws/sim-aws-account-region-scope.js";
 import type { SimLambdaFunctionArn } from "../function/sim-lambda-function-configuration.js";
 import type { SimLambdaStreamRetryLimits, SimLambdaStreamRetryLimitsConfiguration } from "./sim-lambda-stream-retry-limits.js";
@@ -31,6 +33,8 @@ interface SimLambdaEventSourceMappingProperties {
     readonly enabled?: boolean | undefined;
     readonly functionResponseTypes?: readonly SimLambdaFunctionResponseType[] | undefined;
     readonly streamRetryLimits?: SimLambdaStreamRetryLimits | undefined;
+    readonly destinationConfig?: SimLambdaStreamDestinationConfiguration | undefined;
+    readonly destinations?: SimLambdaDestinationTargets | undefined;
     readonly createdAt: Date;
 }
 /**
@@ -39,6 +43,7 @@ interface SimLambdaEventSourceMappingProperties {
  * DeleteEventSourceMapping responses all report it.
  */
 export interface SimLambdaEventSourceMappingConfiguration extends Partial<SimLambdaStreamRetryLimitsConfiguration> {
+    readonly DestinationConfig?: SimLambdaStreamDestinationConfiguration | undefined;
     readonly UUID: string;
     readonly EventSourceMappingArn: SimLambdaEventSourceMappingArn;
     readonly EventSourceArn: string;
@@ -64,6 +69,7 @@ export interface SimLambdaEventSourceMappingConfiguration extends Partial<SimLam
  */
 export declare class SimLambdaEventSourceMapping {
     #private;
+    readonly destinations: SimLambdaDestinationTargets;
     readonly uuid: string;
     readonly eventSourceArn: string;
     readonly functionName: string;
@@ -91,13 +97,14 @@ export declare class SimLambdaEventSourceMapping {
      * the queue's own problem once the batch comes back.
      */
     readonly streamRetryLimits: SimLambdaStreamRetryLimits | undefined;
+    private readonly destinationConfig;
     private readonly accountRegionScope;
     private readonly enabled;
     private readonly lastModified;
     constructor(properties: SimLambdaEventSourceMappingProperties);
-    /**
-     * The ARN naming this mapping.
-     */
+    /** The configured failure queue or topic ARN. */
+    get failureDestinationArn(): string | undefined;
+    /** The ARN naming this mapping. */
     get arn(): SimLambdaEventSourceMappingArn;
     /**
      * The state this mapping is in.

package/dist/service/lambda/event-source/sim-lambda-event-source-mapping.js

@@ -1,3 +1,4 @@
+import { SimLambdaNoDestinationTargets } from "../destination/sim-lambda-destination-targets.js";
 import { randomUUID } from "node:crypto";
 /**
  * One simulated Lambda event source mapping, from an event source to a
@@ -10,6 +11,7 @@ import { randomUUID } from "node:crypto";
  * it.
  */
 export class SimLambdaEventSourceMapping {
+    destinations;
     uuid = randomUUID();
     eventSourceArn;
     functionName;
@@ -37,11 +39,15 @@ export class SimLambdaEventSourceMapping {
      * the queue's own problem once the batch comes back.
      */
     streamRetryLimits;
+    destinationConfig;
     accountRegionScope;
     enabled;
     lastModified;
     #state = "Creating";
     constructor(properties) {
+        this.destinationConfig = properties.destinationConfig;
+        this.destinations =
+            properties.destinations ?? new SimLambdaNoDestinationTargets();
         this.accountRegionScope = properties.accountRegionScope;
         this.eventSourceArn = properties.eventSourceArn;
         this.functionName = properties.functionName;
@@ -56,9 +62,11 @@ export class SimLambdaEventSourceMapping {
         this.enabled = properties.enabled ?? true;
         this.lastModified = properties.createdAt;
     }
-    /**
-     * The ARN naming this mapping.
-     */
+    /** The configured failure queue or topic ARN. */
+    get failureDestinationArn() {
+        return this.destinationConfig?.OnFailure?.Destination;
+    }
+    /** The ARN naming this mapping. */
     get arn() {
         const { regionName, accountId } = this.accountRegionScope;
         return `arn:aws:lambda:${regionName}:${accountId}:event-source-mapping:${this.uuid}`;
@@ -96,6 +104,7 @@ export class SimLambdaEventSourceMapping {
      */
     configuration() {
         return {
+            DestinationConfig: structuredClone(this.destinationConfig),
             UUID: this.uuid,
             EventSourceMappingArn: this.arn,
             EventSourceArn: this.eventSourceArn,

package/dist/service/lambda/event-source/sim-lambda-stream-destination-config.d.ts

@@ -0,0 +1,7 @@
+export interface SimLambdaStreamDestinationConfiguration {
+    readonly OnFailure?: {
+        readonly Destination?: string | undefined;
+    } | undefined;
+}
+/** Validate the same destination shape for SDK and CloudFormation requests. */
+export declare function simLambdaStreamDestinationConfig(value: unknown, sourceKind?: string): SimLambdaStreamDestinationConfiguration | undefined;