@kensio/yulin 1.21.2 → 1.21.4

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;

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

@@ -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
@@ -30,3 +31,9 @@ export const sqsBatchRules = new SimLambdaEventSourceBatchRules({
  * front of the queue, and there is nowhere else it could start from.
  */
 export const sqsStartingPositionRules = new SimLambdaNoStartingPosition("a queue");
+/**
+ * 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 const sqsRetryLimitRules = new SimLambdaNoRetryLimits("a queue", "a message the function never handles is left to the queue's own redrive " +
+    "policy");

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

@@ -1,5 +1,6 @@
 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";
 import type { SimLambdaEventSourceStart, SimLambdaEventSourceStartingPosition } from "./sim-lambda-event-source-starting-position.js";
 /**
  * Event source mapping ARNs address the mapping by its UUID.
@@ -29,6 +30,7 @@ interface SimLambdaEventSourceMappingProperties {
     readonly start?: SimLambdaEventSourceStart | undefined;
     readonly enabled?: boolean | undefined;
     readonly functionResponseTypes?: readonly SimLambdaFunctionResponseType[] | undefined;
+    readonly streamRetryLimits?: SimLambdaStreamRetryLimits | undefined;
     readonly createdAt: Date;
 }
 /**
@@ -36,7 +38,7 @@ interface SimLambdaEventSourceMappingProperties {
  * CreateEventSourceMapping, GetEventSourceMapping, ListEventSourceMappings and
  * DeleteEventSourceMapping responses all report it.
  */
-export interface SimLambdaEventSourceMappingConfiguration {
+export interface SimLambdaEventSourceMappingConfiguration extends Partial<SimLambdaStreamRetryLimitsConfiguration> {
     readonly UUID: string;
     readonly EventSourceMappingArn: SimLambdaEventSourceMappingArn;
     readonly EventSourceArn: string;
@@ -81,6 +83,14 @@ export declare class SimLambdaEventSourceMapping {
      */
     readonly start: SimLambdaEventSourceStart | undefined;
     readonly functionResponseTypes: readonly SimLambdaFunctionResponseType[];
+    /**
+     * When this mapping stops delivering a batch its function keeps failing, for
+     * a source that leaves the counting to the mapping.
+     *
+     * A queue mapping has none, because a message the function never handles is
+     * the queue's own problem once the batch comes back.
+     */
+    readonly streamRetryLimits: SimLambdaStreamRetryLimits | undefined;
     private readonly accountRegionScope;
     private readonly enabled;
     private readonly lastModified;

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

@@ -29,6 +29,14 @@ export class SimLambdaEventSourceMapping {
      */
     start;
     functionResponseTypes;
+    /**
+     * When this mapping stops delivering a batch its function keeps failing, for
+     * a source that leaves the counting to the mapping.
+     *
+     * A queue mapping has none, because a message the function never handles is
+     * the queue's own problem once the batch comes back.
+     */
+    streamRetryLimits;
     accountRegionScope;
     enabled;
     lastModified;
@@ -44,6 +52,7 @@ export class SimLambdaEventSourceMapping {
         // Copied rather than held, so a caller keeping the list it passed in
         // cannot change what this mapping does with a batch afterwards.
         this.functionResponseTypes = [...(properties.functionResponseTypes ?? [])];
+        this.streamRetryLimits = properties.streamRetryLimits;
         this.enabled = properties.enabled ?? true;
         this.lastModified = properties.createdAt;
     }
@@ -97,6 +106,10 @@ export class SimLambdaEventSourceMapping {
             // Partial batches are delivered as soon as anything is available, so the
             // batching window is always zero. Anything else is refused at creation.
             MaximumBatchingWindowInSeconds: 0,
+            // Real Lambda reports both failed-batch limits for a stream mapping and
+            // neither for a queue one, so a mapping with no limits to keep leaves
+            // them out rather than reporting a limit it does not have.
+            ...this.streamRetryLimits?.configuration(),
             FunctionResponseTypes: this.functionResponseTypes,
             State: this.#state,
             StateTransitionReason: "USER_INITIATED",

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

@@ -0,0 +1,39 @@
+import { type SimLambdaEventSourceRetryLimitsInput, SimLambdaStreamRetryLimits } from "./sim-lambda-stream-retry-limits.js";
+/**
+ * Whether the event source a mapping names has failed-batch limits at all.
+ *
+ * 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.
+ */
+export interface SimLambdaEventSourceRetryLimitRules {
+    /**
+     * The limits a mapping on this source keeps, or nothing for a source that has
+     * none, refusing a request that asks for limits this source does not have.
+     */
+    limitsIn(input: SimLambdaEventSourceRetryLimitsInput): SimLambdaStreamRetryLimits | undefined;
+}
+/**
+ * The rules for an event source that decides for itself when to give up.
+ */
+export declare class SimLambdaNoRetryLimits implements SimLambdaEventSourceRetryLimitRules {
+    private readonly sourceDescription;
+    private readonly insteadDescription;
+    constructor(sourceDescription: string, insteadDescription: string);
+    /**
+     * Refuse both limits, since this source is not the one counting.
+     */
+    limitsIn(input: SimLambdaEventSourceRetryLimitsInput): SimLambdaStreamRetryLimits | undefined;
+}
+/**
+ * The rules for a stream, which counts a failed batch's attempts itself.
+ */
+export declare class SimLambdaStreamRetryLimitRules implements SimLambdaEventSourceRetryLimitRules {
+    /**
+     * The limits a mapping on this stream keeps, which are Lambda's own defaults
+     * of no limit when the request named neither.
+     */
+    limitsIn(input: SimLambdaEventSourceRetryLimitsInput): SimLambdaStreamRetryLimits;
+}

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

@@ -0,0 +1,46 @@
+import { SimLambdaInvalidParameterValueException } from "../error/sim-lambda.error.js";
+import { SimLambdaStreamRetryLimits, } from "./sim-lambda-stream-retry-limits.js";
+/**
+ * The rules for an event source that decides for itself when to give up.
+ */
+export class SimLambdaNoRetryLimits {
+    sourceDescription;
+    insteadDescription;
+    constructor(sourceDescription, insteadDescription) {
+        this.sourceDescription = sourceDescription;
+        this.insteadDescription = insteadDescription;
+    }
+    /**
+     * Refuse both limits, since this source is not the one counting.
+     */
+    limitsIn(input) {
+        const named = namedLimit(input);
+        if (named === undefined) {
+            return undefined;
+        }
+        throw new SimLambdaInvalidParameterValueException(`${named} is not valid for ${this.sourceDescription}: ${this.insteadDescription}`);
+    }
+}
+/**
+ * The rules for a stream, which counts a failed batch's attempts itself.
+ */
+export class SimLambdaStreamRetryLimitRules {
+    /**
+     * The limits a mapping on this stream keeps, which are Lambda's own defaults
+     * of no limit when the request named neither.
+     */
+    limitsIn(input) {
+        return new SimLambdaStreamRetryLimits(input);
+    }
+}
+/**
+ * Which limit a request named, for a refusal to name it back.
+ */
+function namedLimit(input) {
+    if (input.maximumRetryAttempts !== undefined) {
+        return "MaximumRetryAttempts";
+    }
+    return input.maximumRecordAgeInSeconds === undefined
+        ? undefined
+        : "MaximumRecordAgeInSeconds";
+}

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.
      */