@kensio/yulin 1.21.8 → 1.21.10

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.
@@ -31,6 +15,11 @@ export declare class SimLambdaStreamProgress {
      * Where the next read starts.
      */
     get position(): SimLambdaEventSourceStreamPosition;
+    /**
+     * How many records the next read may take, which is the mapping's batch size
+     * until a batch is being bisected.
+     */
+    batchSizeWithin(batchSize: number): number;
     /**
      * Take a read that came back with nothing.
      *
@@ -40,9 +29,18 @@ export declare class SimLambdaStreamProgress {
      */
     caughtUp(batch: SimLambdaEventSourceStreamProgressBatch): void;
     /**
-     * Take what became of a batch: move past it, or wait and try it again.
+     * Drop the records at the front of a batch that are too old to hand over,
+     * answering with where the live ones start.
+     *
+     * Records that aged out are as finished with as records the function took, so
+     * a batch being split counts them off its remainder too.
+     */
+    before(records: readonly SimLambdaStreamRecordTime[], batch: SimLambdaEventSourceStreamProgressBatch, simFunction: SimLambdaFunction): Promise<number>;
+    /**
+     * Take what became of a batch: move past it, split 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 +48,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,28 @@
-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;
+    }
+    /**
+     * How many records the next read may take, which is the mapping's batch size
+     * until a batch is being bisected.
+     */
+    batchSizeWithin(batchSize) {
+        return this.state.bisect.sizeWithin(batchSize);
     }
     /**
      * Take a read that came back with nothing.
@@ -51,17 +32,44 @@ export class SimLambdaStreamProgress {
      * than working out a new one each time.
      */
     caughtUp(batch) {
-        this.checkpoint.advanceTo(batch.next);
+        this.state.cursor.advanceTo(batch.next);
     }
     /**
-     * Take what became of a batch: move past it, or wait and try it again.
+     * Drop the records at the front of a batch that are too old to hand over,
+     * answering with where the live ones start.
+     *
+     * Records that aged out are as finished with as records the function took, so
+     * a batch being split counts them off its remainder too.
      */
-    after(outcome, batch) {
+    async before(records, batch, simFunction) {
+        const firstLive = await this.state.expiry.before(records, batch, simFunction);
+        this.state.bisect.finished(firstLive);
+        return firstLive;
+    }
+    /**
+     * Take what became of a batch: move past it, split it, or wait and try it
+     * again.
+     */
+    async after(outcome, batch, simFunction) {
+        this.state.failures.invoked(outcome);
         if (outcome.isHandled) {
+            this.state.bisect.finished(outcome.records.length);
             this.handled(batch);
             return;
         }
-        this.failed(outcome, batch);
+        if (this.state.bisect.split(outcome)) {
+            this.state.retry.reset();
+        }
+        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.state.bisect.finished(outcome.records.length);
+            this.handled(batch);
+        }
+        else {
+            this.state.cursor.resume(again);
+        }
+        await notification;
     }
     /**
      * Move past a batch that is finished with, and read on.
@@ -70,32 +78,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-event-source-retry-limits.d.ts

@@ -1,12 +1,13 @@
 import { type SimLambdaEventSourceRetryLimitsInput, SimLambdaStreamRetryLimits } from "./sim-lambda-stream-retry-limits.js";
 /**
- * Whether the event source a mapping names has failed-batch limits at all.
+ * Whether the event source a mapping names decides for itself what becomes of
+ * a failed batch.
  *
- * A stream does: a record stays on the stream whatever the function makes of
- * it, so the mapping is the only thing that decides when to stop trying. A
- * queue does not, because a message the function never handles goes to the
- * queue's own redrive policy, and real Lambda refuses a request that names
- * either limit for one.
+ * A stream leaves it to the mapping: a record stays on the stream whatever the
+ * function makes of it, so the mapping is the only thing that decides when to
+ * stop trying and whether to split the batch first. A queue does not, because a
+ * message the function never handles goes to the queue's own redrive policy,
+ * and real Lambda refuses a request that names any of the three for one.
  */
 export interface SimLambdaEventSourceRetryLimitRules {
     /**
@@ -23,7 +24,7 @@ export declare class SimLambdaNoRetryLimits implements SimLambdaEventSourceRetry
     private readonly insteadDescription;
     constructor(sourceDescription: string, insteadDescription: string);
     /**
-     * Refuse both limits, since this source is not the one counting.
+     * Refuse all three, since this source is not the one counting.
      */
     limitsIn(input: SimLambdaEventSourceRetryLimitsInput): SimLambdaStreamRetryLimits | undefined;
 }

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

@@ -11,7 +11,7 @@ export class SimLambdaNoRetryLimits {
         this.insteadDescription = insteadDescription;
     }
     /**
-     * Refuse both limits, since this source is not the one counting.
+     * Refuse all three, since this source is not the one counting.
      */
     limitsIn(input) {
         const named = namedLimit(input);
@@ -40,7 +40,10 @@ function namedLimit(input) {
     if (input.maximumRetryAttempts !== undefined) {
         return "MaximumRetryAttempts";
     }
-    return input.maximumRecordAgeInSeconds === undefined
+    if (input.maximumRecordAgeInSeconds !== undefined) {
+        return "MaximumRecordAgeInSeconds";
+    }
+    return input.bisectBatchOnFunctionError === undefined
         ? undefined
-        : "MaximumRecordAgeInSeconds";
+        : "BisectBatchOnFunctionError";
 }

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;

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

@@ -0,0 +1,38 @@
+import { isRecord } from "../../../util/type-guard/record.js";
+import { SimLambdaDestinationArn } from "../destination/sim-lambda-destination-arn.js";
+import { SimLambdaInvalidParameterValueException } from "../error/sim-lambda.error.js";
+/** Validate the same destination shape for SDK and CloudFormation requests. */
+export function simLambdaStreamDestinationConfig(value, sourceKind) {
+    if (value === undefined)
+        return undefined;
+    if (sourceKind === "sqs") {
+        throw new SimLambdaInvalidParameterValueException("DestinationConfig is not supported for SQS event source mappings.");
+    }
+    if (!isRecord(value) ||
+        Object.keys(value).some((key) => key !== "OnFailure")) {
+        throw invalid();
+    }
+    const failure = value["OnFailure"];
+    if (failure === undefined)
+        return {};
+    if (!isRecord(failure) ||
+        Object.keys(failure).some((key) => key !== "Destination")) {
+        throw invalid();
+    }
+    const destination = failure["Destination"];
+    if (destination === undefined)
+        return { OnFailure: {} };
+    if (typeof destination !== "string")
+        throw invalid();
+    if (destination !== "") {
+        const arn = SimLambdaDestinationArn.of(destination);
+        if ((arn.service !== "sqs" && arn.service !== "sns") ||
+            arn.resource.endsWith(".fifo")) {
+            throw invalid();
+        }
+    }
+    return { OnFailure: { Destination: destination } };
+}
+function invalid() {
+    return new SimLambdaInvalidParameterValueException("DestinationConfig supports only OnFailure with a standard SQS queue or SNS topic ARN.");
+}

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

@@ -9,6 +9,7 @@
 export interface SimLambdaEventSourceRetryLimitsInput {
     readonly maximumRetryAttempts?: number | undefined;
     readonly maximumRecordAgeInSeconds?: number | undefined;
+    readonly bisectBatchOnFunctionError?: boolean | undefined;
 }
 /**
  * The failed-batch limits a mapping reports back, as Lambda names them.
@@ -16,22 +17,29 @@ export interface SimLambdaEventSourceRetryLimitsInput {
 export interface SimLambdaStreamRetryLimitsConfiguration {
     readonly MaximumRetryAttempts: number;
     readonly MaximumRecordAgeInSeconds: number;
+    readonly BisectBatchOnFunctionError: boolean;
 }
 /**
- * When a stream mapping stops delivering a batch its function keeps failing.
+ * What a stream mapping does with 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.
+ * The three settings are one thing rather than three, because they run the same
+ * lifecycle. A failing batch is split around the record that broke it where the
+ * mapping was asked to bisect, and a record leaves the mapping when it has had
+ * its retries or when it is too old to be worth another, whichever comes first.
+ * The limits 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;
+    /**
+     * Whether a batch the function threw on is split in half and delivered again
+     * as two batches.
+     */
+    readonly bisectBatchOnFunctionError: boolean;
     constructor(input?: SimLambdaEventSourceRetryLimitsInput);
     /**
-     * The two limits as a Get, a List or a create response reports them.
+     * The three settings as a Get, a List or a create response reports them.
      */
     configuration(): SimLambdaStreamRetryLimitsConfiguration;
     /**