@kensio/yulin 1.21.3 → 1.21.4

package/dist/service/lambda/command/invoke/async/sim-lambda-async-invocation.js

@@ -1,5 +1,6 @@
 import { simLambdaEventTooOld, simLambdaRetryDueTime, } from "../../../function/event-invoke/sim-lambda-event-invoke-settings.js";
 import { simLambdaAbandonedOutcome, SimLambdaAsyncOutcomeDelivery, simLambdaSuccessOutcome, } from "./sim-lambda-async-outcome.js";
+import { simLambdaHandlerAttempt } from "./sim-lambda-handler-attempt.js";
 /**
  * One asynchronous invocation of a simulated Lambda function, from the first
  * attempt to wherever its result ends up.
@@ -22,19 +23,17 @@ export class SimLambdaAsyncInvocation {
      * Accept the invocation and let it run behind the caller.
      */
     start() {
-        this.properties.background.schedule(async () => {
-            await this.attempt();
-        });
+        this.properties.background.schedule(() => this.attempt());
     }
     async attempt() {
         const { simFunction, event } = this.properties;
         this.attemptCount += 1;
-        try {
-            await this.outcomes.deliver(simLambdaSuccessOutcome(await simFunction.invoke(event)), this.attemptCount);
-        }
-        catch (error) {
-            await this.failed(error);
+        const attempt = await simLambdaHandlerAttempt(simFunction, event);
+        if (!attempt.succeeded) {
+            await this.failed(attempt.error);
+            return;
         }
+        await this.outcomes.deliver(simLambdaSuccessOutcome(attempt.result), this.attemptCount);
     }
     /**
      * Retry the attempt that threw, or give up where the last one has been
@@ -46,11 +45,9 @@ export class SimLambdaAsyncInvocation {
             await this.abandon(error, "RetriesExhausted");
             return;
         }
-        background.scheduleAt(simLambdaRetryDueTime(background.now(), this.attemptCount), async () => {
-            await (simLambdaEventTooOld(this.startedAt, background.now(), settings)
-                ? this.abandon(error, "EventAgeExceeded")
-                : this.attempt());
-        });
+        background.scheduleAt(simLambdaRetryDueTime(background.now(), this.attemptCount), () => simLambdaEventTooOld(this.startedAt, background.now(), settings)
+            ? this.abandon(error, "EventAgeExceeded")
+            : this.attempt());
     }
     /**
      * Give up on the invocation, telling its failure destination why and

package/dist/service/lambda/command/invoke/async/sim-lambda-async-outcome.js

@@ -58,6 +58,7 @@ export class SimLambdaAsyncOutcomeDelivery {
         await destinations.deliver({
             destinationArn: SimLambdaDestinationArn.of(destination),
             sourceFunctionArn: simFunction.arn,
+            sourceFunctionRoleArn: simFunction.roleArn,
             record: makeSimLambdaDestinationRecord({
                 requestId: this.requestId,
                 functionArn: simFunction.arn,
@@ -82,6 +83,7 @@ export class SimLambdaAsyncOutcomeDelivery {
             targetArn: SimLambdaDestinationArn.of(settings.deadLetterArn),
             payload: event,
             sourceFunctionArn: simFunction.arn,
+            sourceFunctionRoleArn: simFunction.roleArn,
         });
     }
 }

package/dist/service/lambda/command/invoke/async/sim-lambda-handler-attempt.d.ts

@@ -0,0 +1,13 @@
+import type { SimLambdaFunction } from "../../../function/sim-lambda-function.js";
+export type SimLambdaHandlerAttempt = {
+    readonly succeeded: true;
+    readonly result: unknown;
+} | {
+    readonly succeeded: false;
+    readonly error: unknown;
+};
+/**
+ * Invoke a function handler while keeping its error separate from later
+ * destination delivery errors.
+ */
+export declare function simLambdaHandlerAttempt(simFunction: SimLambdaFunction, event: unknown): Promise<SimLambdaHandlerAttempt>;

package/dist/service/lambda/command/invoke/async/sim-lambda-handler-attempt.js

@@ -0,0 +1,12 @@
+/**
+ * Invoke a function handler while keeping its error separate from later
+ * destination delivery errors.
+ */
+export async function simLambdaHandlerAttempt(simFunction, event) {
+    try {
+        return { succeeded: true, result: await simFunction.invoke(event) };
+    }
+    catch (error) {
+        return { succeeded: false, error };
+    }
+}

package/dist/service/lambda/command/update-function-url-config/update-function-url-config.command.d.ts

@@ -2,6 +2,7 @@
  * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/lambda/command/UpdateFunctionUrlConfigCommand/
  */
 import type { SimResponseMetadata } from "../../../aws/metadata/response-metadata.type.js";
+import type { SimLambdaFunctionUrlCors } from "../../function/url/sim-lambda-function-url-cors.js";
 import type { SimLambdaFunctionUrlAuthType, SimLambdaFunctionUrlConfiguration, SimLambdaFunctionUrlInvokeMode } from "../../function/url/sim-lambda-function-url.js";
 /**
  * Minimal structural sim Lambda UpdateFunctionUrlConfig command.
@@ -19,6 +20,7 @@ export interface SimUpdateFunctionUrlConfigCommandInput {
     readonly FunctionName?: string | undefined;
     readonly AuthType?: SimLambdaFunctionUrlAuthType | undefined;
     readonly InvokeMode?: SimLambdaFunctionUrlInvokeMode | undefined;
+    readonly Cors?: SimLambdaFunctionUrlCors | undefined;
 }
 /**
  * Minimal structural sim Lambda UpdateFunctionUrlConfig output.

package/dist/service/lambda/command/update-function-url-config/update-function-url-config.handler.js

@@ -38,6 +38,7 @@ export class UpdateFunctionUrlConfigCommandHandler {
         functionUrl.update({
             authType: this.inputParser.parseOptionalAuthType(command.input.AuthType),
             invokeMode: this.inputParser.parseOptionalInvokeMode(command.input.InvokeMode),
+            cors: this.inputParser.parseOptionalCors(command.input.Cors),
         });
         return {
             $metadata: {},

package/dist/service/lambda/destination/deliver/sim-lambda-destination-bus.js

@@ -25,6 +25,6 @@ export class SimLambdaDestinationBus {
                     },
                 ],
             },
-        });
+        }, { caller: { kind: "arn", arn: request.sourceFunctionRoleArn } });
     }
 }

package/dist/service/lambda/destination/deliver/sim-lambda-destination-function.js

@@ -1,4 +1,3 @@
-import { SimLambdaError } from "../../error/sim-lambda.error.js";
 /**
  * A function a function is sending an asynchronous invocation result to, in
  * the Account and Region the destination ARN names.
@@ -9,16 +8,13 @@ export class SimLambdaDestinationFunction {
      */
     async deliver(scope, request) {
         const { destinationArn: arn } = request;
-        const target = scope
-            .lambda()
-            .getSimFunctionTarget(arn.functionName, arn.functionQualifier);
-        if (target === undefined) {
-            throw new SimLambdaError(`${arn.value} is not a simulated Lambda function.`);
-        }
-        // Invoked directly rather than through an Invoke command, because this is
-        // already inside the background task standing for the asynchronous
-        // invocation, and because a delivery failure has to reach the caller who
-        // advanced the clock rather than being swallowed a second time.
-        await target.simFunction.invoke(request.record);
+        await scope.lambda().invoke({
+            input: {
+                FunctionName: arn.functionName,
+                Qualifier: arn.functionQualifier,
+                InvocationType: "Event",
+                Payload: JSON.stringify(request.record),
+            },
+        }, { caller: { kind: "arn", arn: request.sourceFunctionRoleArn } });
     }
 }

package/dist/service/lambda/destination/deliver/sim-lambda-destination-queue.js

@@ -17,8 +17,9 @@ export class SimLambdaDestinationQueue {
         }
         // Sent through the ordinary SendMessage path, so what arrives is the same
         // thing an SDK caller would have sent.
-        await send.scope
-            .sqs()
-            .sendMessage({ input: { QueueUrl: queue.arn.url, MessageBody: send.body } }, { sourceArn: send.sourceFunctionArn });
+        await send.scope.sqs().sendMessage({ input: { QueueUrl: queue.arn.url, MessageBody: send.body } }, {
+            caller: { kind: "arn", arn: send.sourceFunctionRoleArn },
+            sourceArn: send.sourceFunctionArn,
+        });
     }
 }

package/dist/service/lambda/destination/deliver/sim-lambda-destination-send.d.ts

@@ -11,4 +11,6 @@ export interface SimLambdaDestinationSend {
      * The function this came from, supplied to IAM as `aws:SourceArn`.
      */
     readonly sourceFunctionArn: string;
+    /** The execution Role Lambda uses to send the document. */
+    readonly sourceFunctionRoleArn: string;
 }

package/dist/service/lambda/destination/deliver/sim-lambda-destination-topic.js

@@ -15,8 +15,9 @@ export class SimLambdaDestinationTopic {
         if (topic === undefined) {
             throw new SimLambdaError(`${send.arn.value} is not a simulated SNS topic.`);
         }
-        await send.scope
-            .sns()
-            .publish({ input: { TopicArn: topic.arn.value, Message: send.body } }, { sourceArn: send.sourceFunctionArn });
+        await send.scope.sns().publish({ input: { TopicArn: topic.arn.value, Message: send.body } }, {
+            caller: { kind: "arn", arn: send.sourceFunctionRoleArn },
+            sourceArn: send.sourceFunctionArn,
+        });
     }
 }

package/dist/service/lambda/destination/sim-aws-lambda-destinations.d.ts

@@ -11,12 +11,10 @@ interface SimAwsLambdaDestinationsProperties {
  * built: reaching another service while this one is being constructed is a
  * cycle with no bottom to it.
  *
- * Real Lambda delivers under the function's own execution role, and delivers
- * nothing when that role cannot write to the destination. The permission is
- * left unchecked here, so a delivery is made as the destination Account's own
- * root. A record that silently goes nowhere is the harder failure to find, and
- * a destination needs no resource policy on real AWS either, so nothing about
- * the destination itself has to be set up for a record to arrive.
+ * Every delivery uses the source function's execution Role as its caller. The
+ * destination service applies its ordinary IAM checks to that Role before it
+ * changes any state.
+ * @see https://docs.aws.amazon.com/lambda/latest/dg/invocation-async-retain-records.html
  */
 export declare class SimAwsLambdaDestinations implements SimLambdaDestinationTargets {
     private readonly simAws;

package/dist/service/lambda/destination/sim-aws-lambda-destinations.js

@@ -10,12 +10,10 @@ import { SimLambdaDestinationTopic } from "./deliver/sim-lambda-destination-topi
  * built: reaching another service while this one is being constructed is a
  * cycle with no bottom to it.
  *
- * Real Lambda delivers under the function's own execution role, and delivers
- * nothing when that role cannot write to the destination. The permission is
- * left unchecked here, so a delivery is made as the destination Account's own
- * root. A record that silently goes nowhere is the harder failure to find, and
- * a destination needs no resource policy on real AWS either, so nothing about
- * the destination itself has to be set up for a record to arrive.
+ * Every delivery uses the source function's execution Role as its caller. The
+ * destination service applies its ordinary IAM checks to that Role before it
+ * changes any state.
+ * @see https://docs.aws.amazon.com/lambda/latest/dg/invocation-async-retain-records.html
  */
 export class SimAwsLambdaDestinations {
     simAws;
@@ -58,6 +56,7 @@ export class SimAwsLambdaDestinations {
             arn: request.targetArn,
             body: JSON.stringify(request.payload),
             sourceFunctionArn: request.sourceFunctionArn,
+            sourceFunctionRoleArn: request.sourceFunctionRoleArn,
         };
         await (request.targetArn.service === "sqs"
             ? this.queue.deliver(send)
@@ -69,6 +68,7 @@ export class SimAwsLambdaDestinations {
             arn: request.destinationArn,
             body: JSON.stringify(request.record),
             sourceFunctionArn: request.sourceFunctionArn,
+            sourceFunctionRoleArn: request.sourceFunctionRoleArn,
         };
     }
     scopeOf(arn) {

package/dist/service/lambda/destination/sim-lambda-destination-targets.d.ts

@@ -11,6 +11,8 @@ export interface SimLambdaDestinationDeliveryRequest {
      * delivery is attributed to.
      */
     readonly sourceFunctionArn: string;
+    /** The execution Role Lambda uses to deliver this record. */
+    readonly sourceFunctionRoleArn: string;
 }
 /**
  * One asynchronous invocation's event on its way to a dead-letter target.
@@ -23,6 +25,7 @@ export interface SimLambdaDeadLetterRequest {
     readonly targetArn: SimLambdaDestinationArn;
     readonly payload: unknown;
     readonly sourceFunctionArn: string;
+    readonly sourceFunctionRoleArn: string;
 }
 /**
  * Everywhere a simulated function's asynchronous invocation results can go.

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

@@ -1,6 +1,6 @@
 import { SimLambdaStreamCascadeGuard } from "../../stream/sim-lambda-stream-cascade-guard.js";
 import { countSimLambdaKinesisIteratorAge } from "../sim-lambda-stream-iterator-age.js";
-import { simLambdaStreamSequenceNumbers } from "../sim-lambda-stream-sequence-numbers.js";
+import { simLambdaKinesisStreamRecordTimes } from "../sim-lambda-stream-record-times.js";
 import { SimLambdaStreamBatchResponse } from "../sim-lambda-stream-batch-response.js";
 import { SimLambdaKinesisStreamEventBuilder } from "./sim-lambda-kinesis-stream-event.js";
 /**
@@ -50,22 +50,17 @@ export class SimLambdaKinesisStreamDelivery {
         return this.cascade.noteRecordWritten();
     }
     async handled(simFunction, records) {
+        const times = simLambdaKinesisStreamRecordTimes(records);
         try {
-            return this.batchResponse.handled(sequenceNumbersOf(records), await simFunction.invoke(this.eventBuilder.of(records)));
+            return this.batchResponse.handled(times, await simFunction.invoke(this.eventBuilder.of(records)));
         }
         catch {
             // As on real Lambda, the handler error goes to the function's logs. What
             // the stream sees is the batch being tried again.
-            return this.batchResponse.failed();
+            return this.batchResponse.failed(times);
         }
         finally {
             countSimLambdaKinesisIteratorAge(simFunction, records);
         }
     }
 }
-/**
- * The sequence numbers this batch's records can be named by.
- */
-function sequenceNumbersOf(records) {
-    return simLambdaStreamSequenceNumbers(records.map((one) => one.SequenceNumber));
-}

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

@@ -1,7 +1,7 @@
 import { SimLambdaStreamCascadeGuard } from "../stream/sim-lambda-stream-cascade-guard.js";
 import { SimLambdaDynamoDbStreamEventBuilder } from "./sim-lambda-dynamodb-stream-event.js";
 import { countSimLambdaDynamoDbIteratorAge } from "./sim-lambda-stream-iterator-age.js";
-import { simLambdaStreamSequenceNumbers } from "./sim-lambda-stream-sequence-numbers.js";
+import { simLambdaDynamoDbStreamRecordTimes } from "./sim-lambda-stream-record-times.js";
 import { SimLambdaStreamBatchResponse } from "./sim-lambda-stream-batch-response.js";
 /**
  * Hands one batch of stream records to a function and says what became of it.
@@ -49,22 +49,17 @@ export class SimLambdaDynamoDbStreamDelivery {
         return this.cascade.noteRecordWritten();
     }
     async handled(simFunction, records) {
+        const times = simLambdaDynamoDbStreamRecordTimes(records);
         try {
-            return this.batchResponse.handled(sequenceNumbersOf(records), await simFunction.invoke(this.eventBuilder.of(records)));
+            return this.batchResponse.handled(times, await simFunction.invoke(this.eventBuilder.of(records)));
         }
         catch {
             // As on real Lambda, the handler error goes to the function's logs. What
             // the table sees is the batch being tried again.
-            return this.batchResponse.failed();
+            return this.batchResponse.failed(times);
         }
         finally {
             countSimLambdaDynamoDbIteratorAge(simFunction, records);
         }
     }
 }
-/**
- * The sequence numbers this batch's records can be named by.
- */
-function sequenceNumbersOf(records) {
-    return simLambdaStreamSequenceNumbers(records.map((one) => one.dynamodb?.SequenceNumber));
-}

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

@@ -1,4 +1,5 @@
 import type { SimLambdaEventSourceStreamPosition } from "../stream/sim-lambda-event-source-streams.js";
+import type { SimLambdaStreamRecordTime } from "./sim-lambda-stream-record-times.js";
 /**
  * What became of one batch of stream records handed to a function.
  *
@@ -7,24 +8,42 @@ import type { SimLambdaEventSourceStreamPosition } from "../stream/sim-lambda-ev
  * batch does not split. The mapping holds one place on the shard, so the answer
  * is one place: either the batch is finished with, or reading goes back to a
  * record and everything from there is delivered again.
+ *
+ * The batch's own records travel with the answer, because what happens to a
+ * batch that failed depends on them: they carry the names it can be sent back
+ * to and the instants its records are aged from.
  */
 export declare class SimLambdaStreamBatchOutcome {
     readonly isHandled: boolean;
+    /**
+     * The records the batch carried, in stream order.
+     */
+    readonly records: readonly SimLambdaStreamRecordTime[];
     private readonly rewindTo;
     private constructor();
     /**
      * A batch the function took in full.
      */
-    static handled(): SimLambdaStreamBatchOutcome;
+    static handled(records: readonly SimLambdaStreamRecordTime[]): SimLambdaStreamBatchOutcome;
     /**
      * A batch the function did not take, which is read again from where it was.
      */
-    static failed(): SimLambdaStreamBatchOutcome;
+    static failed(records: readonly SimLambdaStreamRecordTime[]): SimLambdaStreamBatchOutcome;
     /**
      * A batch the function reported failing partway through, which is read again
      * from the record it named.
      */
-    static failedFrom(sequenceNumber: string): SimLambdaStreamBatchOutcome;
+    static failedFrom(records: readonly SimLambdaStreamRecordTime[], sequenceNumber: string): SimLambdaStreamBatchOutcome;
+    /**
+     * Where in the batch the next delivery starts, as a position in the records
+     * the batch carried.
+     *
+     * A batch that failed whole starts at the first record. One the function
+     * reported on starts at the record it named, which the batch response has
+     * already checked was in the batch, so a name that is not there is the whole
+     * batch again rather than a guess.
+     */
+    get retryIndex(): number;
     /**
      * Where the next read starts when the batch goes back.
      *

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

@@ -6,32 +6,62 @@
  * batch does not split. The mapping holds one place on the shard, so the answer
  * is one place: either the batch is finished with, or reading goes back to a
  * record and everything from there is delivered again.
+ *
+ * The batch's own records travel with the answer, because what happens to a
+ * batch that failed depends on them: they carry the names it can be sent back
+ * to and the instants its records are aged from.
  */
 export class SimLambdaStreamBatchOutcome {
     isHandled;
+    /**
+     * The records the batch carried, in stream order.
+     */
+    records;
     rewindTo;
-    constructor(isHandled, rewindTo) {
-        this.isHandled = isHandled;
-        this.rewindTo = rewindTo;
+    constructor(properties) {
+        this.isHandled = properties.isHandled;
+        this.records = properties.records;
+        this.rewindTo = properties.rewindTo;
     }
     /**
      * A batch the function took in full.
      */
-    static handled() {
-        return new SimLambdaStreamBatchOutcome(true, undefined);
+    static handled(records) {
+        return new SimLambdaStreamBatchOutcome({ isHandled: true, records });
     }
     /**
      * A batch the function did not take, which is read again from where it was.
      */
-    static failed() {
-        return new SimLambdaStreamBatchOutcome(false, undefined);
+    static failed(records) {
+        return new SimLambdaStreamBatchOutcome({ isHandled: false, records });
     }
     /**
      * A batch the function reported failing partway through, which is read again
      * from the record it named.
      */
-    static failedFrom(sequenceNumber) {
-        return new SimLambdaStreamBatchOutcome(false, sequenceNumber);
+    static failedFrom(records, sequenceNumber) {
+        return new SimLambdaStreamBatchOutcome({
+            isHandled: false,
+            records,
+            rewindTo: sequenceNumber,
+        });
+    }
+    /**
+     * Where in the batch the next delivery starts, as a position in the records
+     * the batch carried.
+     *
+     * A batch that failed whole starts at the first record. One the function
+     * reported on starts at the record it named, which the batch response has
+     * already checked was in the batch, so a name that is not there is the whole
+     * batch again rather than a guess.
+     */
+    get retryIndex() {
+        const sequenceNumber = this.rewindTo;
+        if (sequenceNumber === undefined) {
+            return 0;
+        }
+        const index = this.records.findIndex((record) => record.sequenceNumber === sequenceNumber);
+        return index === -1 ? 0 : index;
     }
     /**
      * Where the next read starts when the batch goes back.

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