@kensio/yulin 1.21.3 → 1.21.5

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

@@ -1,4 +1,5 @@
 import { SimLambdaStreamBatchOutcome } from "./sim-lambda-stream-batch-outcome.js";
+import type { SimLambdaStreamRecordTime } from "./sim-lambda-stream-record-times.js";
 /**
  * Reads what a function said about the batch of stream records it was given.
  *
@@ -18,15 +19,15 @@ export declare class SimLambdaStreamBatchResponse {
     /**
      * What became of a batch the function returned from.
      *
-     * The sequence numbers are the batch's own, in stream order, and each source
-     * cuts them out of its own record shape. A record carrying none is left out
-     * rather than given an empty name, so a report entry with no identifier names
-     * nothing and the whole batch goes back.
+     * The records are the batch's own, in stream order, and each source cuts them
+     * out of its own record shape. A record carrying no sequence number cannot be
+     * named, and is left out of the names a report is read against, so a report
+     * entry with no identifier names nothing and the whole batch goes back.
      */
-    handled(sequenceNumbers: readonly string[], result: unknown): SimLambdaStreamBatchOutcome;
+    handled(records: readonly SimLambdaStreamRecordTime[], result: unknown): SimLambdaStreamBatchOutcome;
     /**
      * What becomes of a batch the function threw on: the whole of it is read
      * again.
      */
-    failed(): SimLambdaStreamBatchOutcome;
+    failed(records: readonly SimLambdaStreamRecordTime[]): SimLambdaStreamBatchOutcome;
 }

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

@@ -1,5 +1,6 @@
 import { SimLambdaBatchItemFailures } from "./sim-lambda-batch-item-failures.js";
 import { SimLambdaStreamBatchOutcome } from "./sim-lambda-stream-batch-outcome.js";
+import { simLambdaStreamSequenceNumbers } from "./sim-lambda-stream-sequence-numbers.js";
 /**
  * Reads what a function said about the batch of stream records it was given.
  *
@@ -21,28 +22,28 @@ export class SimLambdaStreamBatchResponse {
     /**
      * What became of a batch the function returned from.
      *
-     * The sequence numbers are the batch's own, in stream order, and each source
-     * cuts them out of its own record shape. A record carrying none is left out
-     * rather than given an empty name, so a report entry with no identifier names
-     * nothing and the whole batch goes back.
+     * The records are the batch's own, in stream order, and each source cuts them
+     * out of its own record shape. A record carrying no sequence number cannot be
+     * named, and is left out of the names a report is read against, so a report
+     * entry with no identifier names nothing and the whole batch goes back.
      */
-    handled(sequenceNumbers, result) {
+    handled(records, result) {
         const failedIds = this.batchItemFailures.idsIn(result);
         if (failedIds === undefined) {
-            return SimLambdaStreamBatchOutcome.handled();
+            return SimLambdaStreamBatchOutcome.handled(records);
         }
-        const rewindTo = rewindPoint(failedIds, sequenceNumbers);
+        const rewindTo = rewindPoint(failedIds, records);
         if (rewindTo === undefined) {
-            return this.failed();
+            return this.failed(records);
         }
-        return SimLambdaStreamBatchOutcome.failedFrom(rewindTo);
+        return SimLambdaStreamBatchOutcome.failedFrom(records, rewindTo);
     }
     /**
      * What becomes of a batch the function threw on: the whole of it is read
      * again.
      */
-    failed() {
-        return SimLambdaStreamBatchOutcome.failed();
+    failed(records) {
+        return SimLambdaStreamBatchOutcome.failed(records);
     }
 }
 /**
@@ -52,7 +53,8 @@ export class SimLambdaStreamBatchResponse {
  * The batch is in stream order, so the first record the report names is the
  * lowest sequence number it named.
  */
-function rewindPoint(failedIds, sequenceNumbers) {
+function rewindPoint(failedIds, records) {
+    const sequenceNumbers = simLambdaStreamSequenceNumbers(records.map((record) => record.sequenceNumber));
     if (failedIds.some((failedId) => !sequenceNumbers.includes(failedId))) {
         return undefined;
     }

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

@@ -1,15 +1,16 @@
 import type { SimLambdaEventSourceStart } from "../sim-lambda-event-source-starting-position.js";
 import type { SimLambdaEventSourceStreamPosition } from "../stream/sim-lambda-event-source-streams.js";
-import type { SimLambdaStreamBatchOutcome } from "./sim-lambda-stream-batch-outcome.js";
 /**
  * How far along its stream one mapping has got.
  *
  * This is the difference between a stream and a queue. A queue hands a message
  * out and hides it, so a failed batch is the queue's problem afterwards. A
  * stream hands out a place, and the reader is the only thing that remembers it,
- * so a batch that failed is read again from exactly where it was. The
- * checkpoint therefore only moves when a batch is finished with: handled, or
- * discarded after its retries.
+ * so a batch that failed is read again from exactly where it was.
+ *
+ * The place is all this holds. Which place the next read starts from is decided
+ * by what became of the batch and what the mapping is willing to keep trying,
+ * and that decision is made elsewhere.
  */
 export declare class SimLambdaStreamCheckpoint {
     #private;
@@ -19,17 +20,10 @@ export declare class SimLambdaStreamCheckpoint {
      */
     get position(): SimLambdaEventSourceStreamPosition;
     /**
-     * Move past a batch that is finished with.
-     */
-    advanceTo(position: SimLambdaEventSourceStreamPosition): void;
-    /**
-     * Take a batch the function did not finish.
+     * Move to where the next read starts.
      *
-     * A batch that failed whole is read again from where it was. One the function
-     * reported failing partway through moves the checkpoint to the record it
-     * named, so that record and everything after it goes over again, including
-     * the records after it that the function did handle. The records before it
-     * are finished with.
+     * That is past a batch the mapping is finished with, and back to the record a
+     * batch it is not finished with is delivered again from.
      */
-    retry(outcome: SimLambdaStreamBatchOutcome): void;
+    advanceTo(position: SimLambdaEventSourceStreamPosition): void;
 }

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

@@ -4,9 +4,11 @@
  * This is the difference between a stream and a queue. A queue hands a message
  * out and hides it, so a failed batch is the queue's problem afterwards. A
  * stream hands out a place, and the reader is the only thing that remembers it,
- * so a batch that failed is read again from exactly where it was. The
- * checkpoint therefore only moves when a batch is finished with: handled, or
- * discarded after its retries.
+ * so a batch that failed is read again from exactly where it was.
+ *
+ * The place is all this holds. Which place the next read starts from is decided
+ * by what became of the batch and what the mapping is willing to keep trying,
+ * and that decision is made elsewhere.
  */
 export class SimLambdaStreamCheckpoint {
     #position;
@@ -20,21 +22,12 @@ export class SimLambdaStreamCheckpoint {
         return this.#position;
     }
     /**
-     * Move past a batch that is finished with.
+     * Move to where the next read starts.
+     *
+     * That is past a batch the mapping is finished with, and back to the record a
+     * batch it is not finished with is delivered again from.
      */
     advanceTo(position) {
         this.#position = position;
     }
-    /**
-     * Take a batch the function did not finish.
-     *
-     * A batch that failed whole is read again from where it was. One the function
-     * reported failing partway through moves the checkpoint to the record it
-     * named, so that record and everything after it goes over again, including
-     * the records after it that the function did handle. The records before it
-     * are finished with.
-     */
-    retry(outcome) {
-        this.#position = outcome.retryPosition(this.#position);
-    }
 }

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

@@ -20,7 +20,7 @@ interface SimLambdaStreamProgressProperties {
  */
 export declare class SimLambdaStreamProgress {
     private readonly checkpoint;
-    private readonly backoff;
+    private readonly retry;
     private readonly schedule;
     constructor(properties: SimLambdaStreamProgressProperties);
     /**
@@ -44,7 +44,10 @@ export declare class SimLambdaStreamProgress {
      */
     after(outcome: SimLambdaStreamBatchOutcome, batch: SimLambdaEventSourceStreamProgressBatch): void;
     /**
-     * Move past a batch the function took, and read on.
+     * Move past a batch that is finished with, and read on.
+     *
+     * A batch the function took is finished with, and so is one the mapping has
+     * given up on.
      */
     handled(batch: SimLambdaEventSourceStreamProgressBatch): void;
     /**
@@ -54,10 +57,11 @@ export declare class SimLambdaStreamProgress {
      * what AWS does when a stream mapping's error handling runs out. Parking the
      * shard instead would be a simulator invention.
      *
-     * A report naming a record moves the checkpoint before the wait, so what goes
-     * over again is the batch from that record on. The attempts are still counted
-     * against the same limit: a batch that keeps failing partway through has as
-     * many tries as one that keeps failing whole.
+     * 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;
 }

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

@@ -1,7 +1,7 @@
 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 { SimLambdaStreamRetryBackoff } from "./sim-lambda-stream-retry-backoff.js";
+import { SimLambdaStreamRetry } from "./sim-lambda-stream-retry.js";
 /**
  * How far along its stream one mapping has got, and what it does next.
  *
@@ -15,15 +15,20 @@ import { SimLambdaStreamRetryBackoff } from "./sim-lambda-stream-retry-backoff.j
  */
 export class SimLambdaStreamProgress {
     checkpoint;
-    backoff = new SimLambdaStreamRetryBackoff();
+    retry;
     schedule;
     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 } = properties.mapping;
+        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);
     }
     /**
@@ -59,10 +64,13 @@ export class SimLambdaStreamProgress {
         this.failed(outcome, batch);
     }
     /**
-     * Move past a batch the function took, and read on.
+     * Move past a batch that is finished with, and read on.
+     *
+     * A batch the function took is finished with, and so is one the mapping has
+     * given up on.
      */
     handled(batch) {
-        this.backoff.reset();
+        this.retry.reset();
         this.checkpoint.advanceTo(batch.next);
         if (!batch.drained) {
             this.schedule.now();
@@ -75,17 +83,19 @@ export class SimLambdaStreamProgress {
      * what AWS does when a stream mapping's error handling runs out. Parking the
      * shard instead would be a simulator invention.
      *
-     * A report naming a record moves the checkpoint before the wait, so what goes
-     * over again is the batch from that record on. The attempts are still counted
-     * against the same limit: a batch that keeps failing partway through has as
-     * many tries as one that keeps failing whole.
+     * 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) {
-        if (this.backoff.isExhausted) {
+        const again = this.retry.after(outcome, this.checkpoint.position);
+        if (again === undefined) {
             this.handled(batch);
             return;
         }
-        this.checkpoint.retry(outcome);
-        this.schedule.afterSeconds(this.backoff.nextSeconds());
+        this.checkpoint.advanceTo(again.position);
+        this.schedule.afterSeconds(again.afterSeconds);
     }
 }

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

@@ -0,0 +1,23 @@
+import type { SimLambdaKinesisStreamRecord } from "../stream/kinesis/sim-lambda-kinesis-streams.js";
+import type { SimLambdaEventSourceStreamRecord } from "../stream/sim-lambda-event-source-streams.js";
+/**
+ * One record of a delivered batch, as deciding what to do with a failed batch
+ * sees it.
+ *
+ * Two things about a record matter once its function has failed: the name the
+ * mapping can be sent back to, and the instant its age is measured from. Each
+ * stream service cuts both out of its own record shape, the way it already does
+ * for the sequence numbers a batch item failure report names.
+ */
+export interface SimLambdaStreamRecordTime {
+    readonly sequenceNumber: string | undefined;
+    readonly at: Date | undefined;
+}
+/**
+ * What a DynamoDB Streams batch's records are named by and dated from.
+ */
+export declare function simLambdaDynamoDbStreamRecordTimes(records: readonly SimLambdaEventSourceStreamRecord[]): readonly SimLambdaStreamRecordTime[];
+/**
+ * What a Kinesis batch's records are named by and dated from.
+ */
+export declare function simLambdaKinesisStreamRecordTimes(records: readonly SimLambdaKinesisStreamRecord[]): readonly SimLambdaStreamRecordTime[];

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

@@ -0,0 +1,18 @@
+/**
+ * What a DynamoDB Streams batch's records are named by and dated from.
+ */
+export function simLambdaDynamoDbStreamRecordTimes(records) {
+    return records.map((one) => ({
+        sequenceNumber: one.dynamodb?.SequenceNumber,
+        at: one.dynamodb?.ApproximateCreationDateTime,
+    }));
+}
+/**
+ * What a Kinesis batch's records are named by and dated from.
+ */
+export function simLambdaKinesisStreamRecordTimes(records) {
+    return records.map((one) => ({
+        sequenceNumber: one.SequenceNumber,
+        at: one.ApproximateArrivalTimestamp,
+    }));
+}

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

@@ -1,25 +1,24 @@
 /**
  * How long a mapping waits before handing a failed batch to its function
- * again, and when it stops trying.
+ * again, and how many waits it has left.
  *
- * Both are simulator constraints rather than AWS behaviour, and both are
- * deliberate.
- *
- * AWS documents no delay between attempts. A delay of zero here would be
- * scheduled at the instant the clock already reads, and advancing the clock
- * keeps dispatching whatever falls due inside the interval it is moving
+ * The delay is a simulator constraint rather than AWS behaviour, and it is
+ * deliberate. AWS documents no delay between attempts. A delay of zero here
+ * would be scheduled at the instant the clock already reads, and advancing the
+ * clock keeps dispatching whatever falls due inside the interval it is moving
  * through, so a batch the function always throws on would leave `advanceBy`
  * with work to do forever. The delay is therefore strictly positive and grows
- * with each attempt, which is also what a consumer under load actually wants.
+ * with each attempt, which is also what a consumer under load actually wants,
+ * and it is what lets a test walk through the attempts by advancing the clock.
  *
- * AWS retries a stream batch until the records age out of the stream, which is
- * a day. Waiting out a simulated day for a handler that is never going to
- * succeed is the same hang with more steps, so the attempts are counted
- * instead. What happens at the end is AWS's own behaviour: the records are
- * discarded and the mapping carries on with the stream.
+ * How many attempts there are belongs to the mapping rather than to this: a
+ * mapping that asked for a retry quota gets the quota it asked for, and one
+ * that asked for neither limit gets the simulator's own cap.
  */
 export declare class SimLambdaStreamRetryBackoff {
+    private readonly attemptLimit;
     private attempts;
+    constructor(attemptLimit: number);
     /**
      * Whether this batch has had all the attempts it gets.
      */

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

@@ -1,41 +1,48 @@
 /**
- * How many times one batch is delivered again before it is given up on.
+ * The longest wait, in seconds, the simulation's clock can be scheduled at.
+ *
+ * A `Date` holds about 275,000 years either side of the epoch, and a wait past
+ * that would be scheduled at an instant that is not a date at all. Doubling
+ * reaches it on the 44th attempt, which is further than any test can advance
+ * the clock, so this is a guard on the arithmetic rather than a wait a mapping
+ * meets.
  */
-const attemptLimit = 5;
+const longestWaitSeconds = 2 ** 42;
 /**
  * How long a mapping waits before handing a failed batch to its function
- * again, and when it stops trying.
- *
- * Both are simulator constraints rather than AWS behaviour, and both are
- * deliberate.
+ * again, and how many waits it has left.
  *
- * AWS documents no delay between attempts. A delay of zero here would be
- * scheduled at the instant the clock already reads, and advancing the clock
- * keeps dispatching whatever falls due inside the interval it is moving
+ * The delay is a simulator constraint rather than AWS behaviour, and it is
+ * deliberate. AWS documents no delay between attempts. A delay of zero here
+ * would be scheduled at the instant the clock already reads, and advancing the
+ * clock keeps dispatching whatever falls due inside the interval it is moving
  * through, so a batch the function always throws on would leave `advanceBy`
  * with work to do forever. The delay is therefore strictly positive and grows
- * with each attempt, which is also what a consumer under load actually wants.
+ * with each attempt, which is also what a consumer under load actually wants,
+ * and it is what lets a test walk through the attempts by advancing the clock.
  *
- * AWS retries a stream batch until the records age out of the stream, which is
- * a day. Waiting out a simulated day for a handler that is never going to
- * succeed is the same hang with more steps, so the attempts are counted
- * instead. What happens at the end is AWS's own behaviour: the records are
- * discarded and the mapping carries on with the stream.
+ * How many attempts there are belongs to the mapping rather than to this: a
+ * mapping that asked for a retry quota gets the quota it asked for, and one
+ * that asked for neither limit gets the simulator's own cap.
  */
 export class SimLambdaStreamRetryBackoff {
+    attemptLimit;
     attempts = 0;
+    constructor(attemptLimit) {
+        this.attemptLimit = attemptLimit;
+    }
     /**
      * Whether this batch has had all the attempts it gets.
      */
     get isExhausted() {
-        return this.attempts >= attemptLimit;
+        return this.attempts >= this.attemptLimit;
     }
     /**
      * How long to wait before the next attempt, in seconds.
      */
     nextSeconds() {
         this.attempts += 1;
-        return 2 ** (this.attempts - 1);
+        return Math.min(2 ** (this.attempts - 1), longestWaitSeconds);
     }
     /**
      * Start counting again, which a batch that is finished with does.

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

@@ -0,0 +1,64 @@
+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.
+ */
+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.
+ */
+export declare class SimLambdaStreamRetry {
+    private readonly limits;
+    private readonly clock;
+    private readonly backoff;
+    constructor(properties: SimLambdaStreamRetryProperties);
+    /**
+     * The next delivery of a failed batch, or nothing when the batch is finished
+     * with.
+     */
+    after(outcome: SimLambdaStreamBatchOutcome, readFrom: SimLambdaEventSourceStreamPosition): SimLambdaStreamRetryAttempt | undefined;
+    /**
+     * 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

@@ -0,0 +1,86 @@
+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.
+ */
+export class SimLambdaStreamRetry {
+    limits;
+    clock;
+    backoff;
+    constructor(properties) {
+        this.limits = properties.limits;
+        this.clock = properties.clock;
+        this.backoff = new SimLambdaStreamRetryBackoff(properties.limits.attemptLimit);
+    }
+    /**
+     * The next delivery of a failed batch, or nothing when the batch is finished
+     * with.
+     */
+    after(outcome, readFrom) {
+        if (this.backoff.isExhausted) {
+            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 };
+    }
+    /**
+     * Start counting again, which a batch that is finished with does.
+     */
+    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/queue/sim-lambda-sqs-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";
 /**
@@ -44,6 +45,11 @@ export declare class SimLambdaSqsEventSourceArn {
      * is none of them.
      */
     get startingPositionRules(): SimLambdaEventSourceStartingPositionRules;
+    /**
+     * The failed-batch limits a mapping on this queue may be created with, which
+     * is neither of them.
+     */
+    get retryLimitRules(): SimLambdaEventSourceRetryLimitRules;
     /**
      * The URL SQS requests name this queue by.
      */

package/dist/service/lambda/event-source/queue/sim-lambda-sqs-event-source-arn.js

@@ -1,7 +1,7 @@
 import { SimLambdaInvalidParameterValueException } from "../../error/sim-lambda.error.js";
 import { sqsQueueUrl } from "../../../sqs/queue/sim-sqs-queue-arn.js";
 import { SimLambdaEventSourcePollingPermission } from "../sim-lambda-event-source-polling-permission.js";
-import { sqsBatchRules, sqsPollingOperations, sqsStartingPositionRules, } from "./sim-lambda-sqs-event-source-rules.js";
+import { sqsBatchRules, sqsPollingOperations, sqsRetryLimitRules, sqsStartingPositionRules, } from "./sim-lambda-sqs-event-source-rules.js";
 const queueArnPattern = /^arn:aws:sqs:(?<region>[a-z0-9-]+):(?<account>\d{12}):(?<name>[\w-]{1,80})$/u;
 /**
  * The queue ARN an event source mapping is created for.
@@ -68,6 +68,13 @@ export class SimLambdaSqsEventSourceArn {
     get startingPositionRules() {
         return sqsStartingPositionRules;
     }
+    /**
+     * The failed-batch limits a mapping on this queue may be created with, which
+     * is neither of them.
+     */
+    get retryLimitRules() {
+        return sqsRetryLimitRules;
+    }
     /**
      * The URL SQS requests name this queue by.
      */

package/dist/service/lambda/event-source/queue/sim-lambda-sqs-event-source-rules.d.ts

@@ -1,4 +1,5 @@
 import { SimLambdaEventSourceBatchRules } from "../sim-lambda-event-source-batch-rules.js";
+import { SimLambdaNoRetryLimits } from "../sim-lambda-event-source-retry-limits.js";
 import { SimLambdaNoStartingPosition } from "../sim-lambda-event-source-starting-position.js";
 /**
  * What a function's execution role has to be allowed to do on a queue for
@@ -21,3 +22,8 @@ export declare const sqsBatchRules: SimLambdaEventSourceBatchRules;
  * front of the queue, and there is nowhere else it could start from.
  */
 export declare const sqsStartingPositionRules: SimLambdaNoStartingPosition;
+/**
+ * A queue keeps its own count of how often a message has been received, so
+ * neither of Lambda's failed-batch limits is a queue mapping's to keep.
+ */
+export declare const sqsRetryLimitRules: SimLambdaNoRetryLimits;