@kensio/yulin 1.21.3 → 1.21.5

package/dist/service/lambda/command/function-url/function-url-cors-constraints.js

@@ -0,0 +1,49 @@
+/**
+ * The bounds Lambda publishes for each list member of a `Cors` block.
+ */
+export const corsListConstraints = [
+    {
+        member: "AllowHeaders",
+        field: "cors.allowHeaders",
+        maxItems: 100,
+        minLength: 0,
+        maxLength: 1024,
+    },
+    {
+        member: "AllowMethods",
+        field: "cors.allowMethods",
+        maxItems: 6,
+        minLength: 0,
+        maxLength: 6,
+    },
+    {
+        member: "AllowOrigins",
+        field: "cors.allowOrigins",
+        maxItems: 100,
+        minLength: 1,
+        maxLength: 253,
+    },
+    {
+        member: "ExposeHeaders",
+        field: "cors.exposeHeaders",
+        maxItems: 100,
+        minLength: 0,
+        maxLength: 1024,
+    },
+];
+/**
+ * The bound a list broke, worded as Lambda words it, or nothing when the list
+ * is within every bound.
+ */
+export function corsListViolation(values, constraint) {
+    const { maxItems, minLength, maxLength } = constraint;
+    if (values.length > maxItems) {
+        return `Member must have length less than or equal to ${String(maxItems)}`;
+    }
+    const outOfRange = values.some((value) => value.length < minLength || value.length > maxLength);
+    return outOfRange
+        ? "Member must satisfy constraint: [Member must have length less than " +
+            `or equal to ${String(maxLength)}, Member must have length greater ` +
+            `than or equal to ${String(minLength)}]`
+        : undefined;
+}

package/dist/service/lambda/command/function-url/function-url-cors-input.d.ts

@@ -0,0 +1,25 @@
+import type { SimLambdaFunctionUrlCors } from "../../function/url/sim-lambda-function-url-cors.js";
+/**
+ * Validates the `Cors` block of Function URL config command input.
+ *
+ * Every check here is against a bound real Lambda publishes. A configuration
+ * this accepts is one the API would have taken. Nothing else is checked,
+ * because a refusal the real service would not make costs a working
+ * deployment.
+ *
+ * The check runs before the Function URL is created or updated, leaving a
+ * refused configuration with the URL as it was.
+ */
+export declare class FunctionUrlCorsInputParser {
+    /**
+     * Parse an optional `Cors` block, which every Function URL config command
+     * allows a caller to leave out.
+     */
+    parseOptional(cors: SimLambdaFunctionUrlCors | undefined): SimLambdaFunctionUrlCors | undefined;
+    private checkMaxAge;
+    private maxAgeViolation;
+    /**
+     * Fail the way Lambda fails a request that broke one bound.
+     */
+    private refuse;
+}

package/dist/service/lambda/command/function-url/function-url-cors-input.js

@@ -0,0 +1,57 @@
+import { SimLambdaValidationException } from "../../error/sim-lambda.error.js";
+import { corsListConstraints, corsListViolation, } from "./function-url-cors-constraints.js";
+const maxAgeSeconds = 86_400;
+/**
+ * Validates the `Cors` block of Function URL config command input.
+ *
+ * Every check here is against a bound real Lambda publishes. A configuration
+ * this accepts is one the API would have taken. Nothing else is checked,
+ * because a refusal the real service would not make costs a working
+ * deployment.
+ *
+ * The check runs before the Function URL is created or updated, leaving a
+ * refused configuration with the URL as it was.
+ */
+export class FunctionUrlCorsInputParser {
+    /**
+     * Parse an optional `Cors` block, which every Function URL config command
+     * allows a caller to leave out.
+     */
+    parseOptional(cors) {
+        if (cors === undefined) {
+            return undefined;
+        }
+        for (const constraint of corsListConstraints) {
+            const values = cors[constraint.member];
+            if (values !== undefined) {
+                this.refuse(`[${values.join(", ")}]`, constraint.field, corsListViolation(values, constraint));
+            }
+        }
+        this.checkMaxAge(cors.MaxAge);
+        return cors;
+    }
+    checkMaxAge(maxAge) {
+        if (maxAge === undefined) {
+            return;
+        }
+        this.refuse(String(maxAge), "cors.maxAge", this.maxAgeViolation(maxAge));
+    }
+    maxAgeViolation(maxAge) {
+        if (maxAge > maxAgeSeconds) {
+            return `Member must have value less than or equal to ${String(maxAgeSeconds)}`;
+        }
+        return maxAge < 0
+            ? "Member must have value greater than or equal to 0"
+            : undefined;
+    }
+    /**
+     * Fail the way Lambda fails a request that broke one bound.
+     */
+    refuse(value, field, violation) {
+        if (violation === undefined) {
+            return;
+        }
+        throw new SimLambdaValidationException(`1 validation error detected: Value '${value}' at '${field}' failed ` +
+            `to satisfy constraint: ${violation}`);
+    }
+}

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

@@ -1,3 +1,4 @@
+import type { SimLambdaFunctionUrlCors } from "../../function/url/sim-lambda-function-url-cors.js";
 import type { SimLambdaFunctionUrlAuthType, SimLambdaFunctionUrlInvokeMode } from "../../function/url/sim-lambda-function-url.js";
 /**
  * Validates the enumerated values in Function URL config command input.
@@ -7,6 +8,7 @@ import type { SimLambdaFunctionUrlAuthType, SimLambdaFunctionUrlInvokeMode } fro
  * runtime and reported the way real Lambda reports a bad enum member.
  */
 export declare class FunctionUrlInputParser {
+    private readonly corsParser;
     /**
      * Parse a required AuthType, as CreateFunctionUrlConfig requires one.
      */
@@ -19,5 +21,10 @@ export declare class FunctionUrlInputParser {
      * Parse an optional InvokeMode, which defaults to BUFFERED on real Lambda.
      */
     parseOptionalInvokeMode(value: string | undefined): SimLambdaFunctionUrlInvokeMode | undefined;
+    /**
+     * Parse an optional `Cors` block, which every Function URL config command
+     * allows a caller to leave out.
+     */
+    parseOptionalCors(value: SimLambdaFunctionUrlCors | undefined): SimLambdaFunctionUrlCors | undefined;
     private parseAuthType;
 }

package/dist/service/lambda/command/function-url/function-url-input.js

@@ -1,4 +1,5 @@
 import { SimLambdaValidationException } from "../../error/sim-lambda.error.js";
+import { FunctionUrlCorsInputParser } from "./function-url-cors-input.js";
 const authTypes = ["NONE", "AWS_IAM"];
 const invokeModes = ["BUFFERED", "RESPONSE_STREAM"];
 /**
@@ -9,6 +10,7 @@ const invokeModes = ["BUFFERED", "RESPONSE_STREAM"];
  * runtime and reported the way real Lambda reports a bad enum member.
  */
 export class FunctionUrlInputParser {
+    corsParser = new FunctionUrlCorsInputParser();
     /**
      * Parse a required AuthType, as CreateFunctionUrlConfig requires one.
      */
@@ -39,6 +41,13 @@ export class FunctionUrlInputParser {
         }
         return value;
     }
+    /**
+     * Parse an optional `Cors` block, which every Function URL config command
+     * allows a caller to leave out.
+     */
+    parseOptionalCors(value) {
+        return this.corsParser.parseOptional(value);
+    }
     parseAuthType(value) {
         if (!authTypes.includes(value)) {
             throw new SimLambdaValidationException(`1 validation error detected: Value '${value}' at 'authType' failed to satisfy constraint: Member must satisfy enum value set: [${authTypes.join(", ")}]`);

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.