@kensio/yulin 1.21.8 → 1.21.10

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

@@ -0,0 +1,13 @@
+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 { SimLambdaStreamDiscard } from "./sim-lambda-stream-failure-record.js";
+import type { SimLambdaStreamRecordTime } from "./sim-lambda-stream-record-times.js";
+/** Identifies the expired prefix at the time a batch is polled. */
+export declare class SimLambdaStreamBatchAge {
+    private readonly limits;
+    private readonly clock;
+    constructor(limits: SimLambdaStreamRetryLimits, clock: SimClock);
+    discarded(records: readonly SimLambdaStreamRecordTime[]): SimLambdaStreamDiscard | undefined;
+    firstLivePosition(records: readonly SimLambdaStreamRecordTime[], count: number): SimLambdaEventSourceStreamPosition;
+}

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

@@ -0,0 +1,27 @@
+import { assertDefined } from "../../../../util/type-guard/defined.js";
+/** Identifies the expired prefix at the time a batch is polled. */
+export class SimLambdaStreamBatchAge {
+    limits;
+    clock;
+    constructor(limits, clock) {
+        this.limits = limits;
+        this.clock = clock;
+    }
+    discarded(records) {
+        const at = this.clock.now();
+        const firstLive = records.findIndex((record) => !this.limits.hasAgedOut(record.at, at));
+        const count = firstLive === -1 ? records.length : firstLive;
+        if (count === 0)
+            return undefined;
+        return {
+            records: records.slice(0, count),
+            condition: "RecordAgeExceeded",
+            at,
+        };
+    }
+    firstLivePosition(records, count) {
+        const sequenceNumber = records.at(count)?.sequenceNumber;
+        assertDefined(sequenceNumber, "live stream record sequence number");
+        return { kind: "sequence", sequenceNumber };
+    }
+}

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

@@ -0,0 +1,15 @@
+import type { SimLambdaStreamFailureRecord } from "./sim-lambda-stream-failure-record.js";
+import type { SimLambdaStreamRecordTime } from "./sim-lambda-stream-record-times.js";
+export interface SimLambdaStreamBatchInfo {
+    readonly shardId: string;
+    readonly streamArn: string;
+    readonly startSequenceNumber: string;
+    readonly endSequenceNumber: string;
+    readonly approximateArrivalOfFirstRecord: string;
+    readonly approximateArrivalOfLastRecord: string;
+    readonly batchSize: number;
+}
+/** Identify the discarded records by shard and sequence-number bounds. */
+export declare function simLambdaStreamBatchInfo(records: readonly SimLambdaStreamRecordTime[], streamArn: string, shardId: string | undefined): SimLambdaStreamBatchInfo;
+/** Identify the discarded records by shard and sequence-number bounds. */
+export declare function streamFailureBatchInfo(arn: string, info: SimLambdaStreamBatchInfo): Pick<SimLambdaStreamFailureRecord, "DDBStreamBatchInfo" | "KinesisBatchInfo">;

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

@@ -0,0 +1,26 @@
+import { assertDefined } from "../../../../util/type-guard/defined.js";
+/** Identify the discarded records by shard and sequence-number bounds. */
+export function simLambdaStreamBatchInfo(records, streamArn, shardId) {
+    const first = records.at(0);
+    const last = records.at(-1);
+    assertDefined(shardId, "discarded stream batch shard ID");
+    assertDefined(first?.sequenceNumber, "discarded batch start sequence number");
+    assertDefined(last?.sequenceNumber, "discarded batch end sequence number");
+    assertDefined(first.at, "discarded batch first arrival time");
+    assertDefined(last.at, "discarded batch last arrival time");
+    return {
+        shardId,
+        streamArn,
+        startSequenceNumber: first.sequenceNumber,
+        endSequenceNumber: last.sequenceNumber,
+        approximateArrivalOfFirstRecord: first.at.toISOString(),
+        approximateArrivalOfLastRecord: last.at.toISOString(),
+        batchSize: records.length,
+    };
+}
+/** Identify the discarded records by shard and sequence-number bounds. */
+export function streamFailureBatchInfo(arn, info) {
+    if (arn.startsWith("arn:aws:dynamodb:"))
+        return { DDBStreamBatchInfo: info };
+    return { KinesisBatchInfo: info };
+}

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

@@ -14,6 +14,7 @@ import type { SimLambdaStreamRecordTime } from "./sim-lambda-stream-record-times
  * to and the instants its records are aged from.
  */
 export declare class SimLambdaStreamBatchOutcome {
+    readonly functionError: boolean;
     readonly isHandled: boolean;
     /**
      * The records the batch carried, in stream order.

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

@@ -12,6 +12,7 @@
  * to and the instants its records are aged from.
  */
 export class SimLambdaStreamBatchOutcome {
+    functionError;
     isHandled;
     /**
      * The records the batch carried, in stream order.
@@ -19,6 +20,7 @@ export class SimLambdaStreamBatchOutcome {
     records;
     rewindTo;
     constructor(properties) {
+        this.functionError = properties.functionError ?? false;
         this.isHandled = properties.isHandled;
         this.records = properties.records;
         this.rewindTo = properties.rewindTo;
@@ -33,7 +35,11 @@ export class SimLambdaStreamBatchOutcome {
      * A batch the function did not take, which is read again from where it was.
      */
     static failed(records) {
-        return new SimLambdaStreamBatchOutcome({ isHandled: false, records });
+        return new SimLambdaStreamBatchOutcome({
+            isHandled: false,
+            records,
+            functionError: true,
+        });
     }
     /**
      * A batch the function reported failing partway through, which is read again

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

@@ -0,0 +1,17 @@
+import type { SimLambdaFunction } from "../../function/sim-lambda-function.js";
+import type { SimLambdaEventSourceStreamProgressBatch } from "../stream/sim-lambda-event-source-streams.js";
+import type { SimLambdaStreamBatchOutcome } from "./sim-lambda-stream-batch-outcome.js";
+import type { SimLambdaStreamProgress } from "./sim-lambda-stream-progress.js";
+import type { SimLambdaStreamRecordTime } from "./sim-lambda-stream-record-times.js";
+interface StreamBatchProcessing<RecordType> {
+    readonly batch: SimLambdaEventSourceStreamProgressBatch & {
+        readonly records: readonly RecordType[];
+    };
+    readonly simFunction: SimLambdaFunction;
+    readonly progress: SimLambdaStreamProgress;
+    readonly times: (records: readonly RecordType[]) => readonly SimLambdaStreamRecordTime[];
+    readonly deliver: (records: readonly RecordType[]) => Promise<SimLambdaStreamBatchOutcome>;
+}
+/** Check record age, invoke live records, and apply the batch outcome. */
+export declare function processSimLambdaStreamBatch<RecordType>(properties: StreamBatchProcessing<RecordType>): Promise<void>;
+export {};

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

@@ -0,0 +1,12 @@
+/** Check record age, invoke live records, and apply the batch outcome. */
+export async function processSimLambdaStreamBatch(properties) {
+    const { batch, progress, simFunction } = properties;
+    if (batch.records.length === 0) {
+        progress.caughtUp(batch);
+        return;
+    }
+    const firstLive = await progress.before(properties.times(batch.records), batch, simFunction);
+    if (firstLive === batch.records.length)
+        return;
+    await progress.after(await properties.deliver(batch.records.slice(firstLive)), batch, simFunction);
+}

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

@@ -0,0 +1,53 @@
+import type { SimLambdaStreamBatchOutcome } from "./sim-lambda-stream-batch-outcome.js";
+/**
+ * How much of a failing batch the next delivery may carry.
+ *
+ * A mapping asked to bisect halves a batch its function threw on, and halves
+ * again on each further error, until a failing batch holds one record. That is
+ * how the record that broke the batch ends up delivered on its own, and how the
+ * records beside it get through.
+ *
+ * A split is progress rather than another attempt at the same work, so it puts
+ * the retry count back to the start. Without that the simulator's own cap of
+ * five attempts would discard a batch of a hundred long before it was down to
+ * one record. A batch halves at every step, so the splitting ends on its own,
+ * and the single record it ends on is then counted and discarded as any failing
+ * batch is.
+ *
+ * Two numbers say what the next read may take. The half is how many records a
+ * delivery may carry, and the remainder is how many records of the batch being
+ * split are still to get through. Reading the lower of the two is what keeps a
+ * record written while the splitting is going on out of it: the halves are the
+ * batch that failed, and a record that arrived afterwards belongs to the batch
+ * after it. The mapping's own batch size comes back once the whole of the split
+ * batch is through.
+ */
+export declare class SimLambdaStreamBisect {
+    #private;
+    private readonly enabled;
+    constructor(enabled: boolean);
+    /**
+     * How many records the next read may take, within the mapping's batch size.
+     */
+    sizeWithin(batchSize: number): number;
+    /**
+     * Split a batch the function threw on, answering with whether it split.
+     *
+     * A batch the function reported partial failures on is left alone. Lambda
+     * bisects around an error the handler raised, and a report already says which
+     * record to go back to.
+     */
+    split(outcome: SimLambdaStreamBatchOutcome): boolean;
+    /**
+     * Take records of the batch being split that the mapping is finished with,
+     * whether the function handled them, they were discarded, or they aged out.
+     *
+     * The whole of the split batch being through is what puts the mapping back on
+     * full batches.
+     */
+    finished(count: number): void;
+    /**
+     * Read whole batches again.
+     */
+    reset(): void;
+}

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

@@ -0,0 +1,79 @@
+/**
+ * How much of a failing batch the next delivery may carry.
+ *
+ * A mapping asked to bisect halves a batch its function threw on, and halves
+ * again on each further error, until a failing batch holds one record. That is
+ * how the record that broke the batch ends up delivered on its own, and how the
+ * records beside it get through.
+ *
+ * A split is progress rather than another attempt at the same work, so it puts
+ * the retry count back to the start. Without that the simulator's own cap of
+ * five attempts would discard a batch of a hundred long before it was down to
+ * one record. A batch halves at every step, so the splitting ends on its own,
+ * and the single record it ends on is then counted and discarded as any failing
+ * batch is.
+ *
+ * Two numbers say what the next read may take. The half is how many records a
+ * delivery may carry, and the remainder is how many records of the batch being
+ * split are still to get through. Reading the lower of the two is what keeps a
+ * record written while the splitting is going on out of it: the halves are the
+ * batch that failed, and a record that arrived afterwards belongs to the batch
+ * after it. The mapping's own batch size comes back once the whole of the split
+ * batch is through.
+ */
+export class SimLambdaStreamBisect {
+    enabled;
+    #half;
+    #remaining = 0;
+    constructor(enabled) {
+        this.enabled = enabled;
+    }
+    /**
+     * How many records the next read may take, within the mapping's batch size.
+     */
+    sizeWithin(batchSize) {
+        const half = this.#half;
+        return half === undefined
+            ? batchSize
+            : Math.min(half, this.#remaining, batchSize);
+    }
+    /**
+     * Split a batch the function threw on, answering with whether it split.
+     *
+     * A batch the function reported partial failures on is left alone. Lambda
+     * bisects around an error the handler raised, and a report already says which
+     * record to go back to.
+     */
+    split(outcome) {
+        const count = outcome.records.length;
+        if (!this.enabled || !outcome.functionError || count < 2) {
+            return false;
+        }
+        this.#half = Math.ceil(count / 2);
+        this.#remaining = count;
+        return true;
+    }
+    /**
+     * Take records of the batch being split that the mapping is finished with,
+     * whether the function handled them, they were discarded, or they aged out.
+     *
+     * The whole of the split batch being through is what puts the mapping back on
+     * full batches.
+     */
+    finished(count) {
+        if (this.#half === undefined || count <= 0) {
+            return;
+        }
+        this.#remaining -= count;
+        if (this.#remaining <= 0) {
+            this.reset();
+        }
+    }
+    /**
+     * Read whole batches again.
+     */
+    reset() {
+        this.#half = undefined;
+        this.#remaining = 0;
+    }
+}

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

@@ -0,0 +1,15 @@
+import type { PollSchedule } from "../../../../util/background/poll-schedule.js";
+import type { SimLambdaEventSourceStart } from "../sim-lambda-event-source-starting-position.js";
+import type { SimLambdaEventSourceStreamPosition, SimLambdaEventSourceStreamProgressBatch } from "../stream/sim-lambda-event-source-streams.js";
+import type { SimLambdaStreamRetryAttempt } from "./sim-lambda-stream-retry.js";
+/** Keep the next read position and schedule consistent when a batch finishes or retries. */
+export declare class SimLambdaStreamCursor {
+    private readonly schedule;
+    private readonly checkpoint;
+    constructor(start: SimLambdaEventSourceStart, schedule: PollSchedule);
+    get position(): SimLambdaEventSourceStreamPosition;
+    advanceTo(position: SimLambdaEventSourceStreamPosition): void;
+    pollNow(): void;
+    handled(batch: SimLambdaEventSourceStreamProgressBatch): void;
+    resume(attempt: SimLambdaStreamRetryAttempt): void;
+}

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

@@ -0,0 +1,28 @@
+import { SimLambdaStreamCheckpoint } from "./sim-lambda-stream-checkpoint.js";
+/** Keep the next read position and schedule consistent when a batch finishes or retries. */
+export class SimLambdaStreamCursor {
+    schedule;
+    checkpoint;
+    constructor(start, schedule) {
+        this.schedule = schedule;
+        this.checkpoint = new SimLambdaStreamCheckpoint(start);
+    }
+    get position() {
+        return this.checkpoint.position;
+    }
+    advanceTo(position) {
+        this.checkpoint.advanceTo(position);
+    }
+    pollNow() {
+        this.schedule.now();
+    }
+    handled(batch) {
+        this.advanceTo(batch.next);
+        if (!batch.drained)
+            this.pollNow();
+    }
+    resume(attempt) {
+        this.advanceTo(attempt.position);
+        this.schedule.afterSeconds(attempt.afterSeconds);
+    }
+}

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

@@ -0,0 +1,19 @@
+import type { SimLambdaStreamBatchAge } from "./sim-lambda-stream-batch-age.js";
+import type { SimLambdaStreamRecordTime } from "./sim-lambda-stream-record-times.js";
+import type { SimLambdaFunction } from "../../function/sim-lambda-function.js";
+import type { SimLambdaStreamFailureDestination } from "./sim-lambda-stream-failure-destination.js";
+import type { SimLambdaEventSourceStreamProgressBatch } from "../stream/sim-lambda-event-source-streams.js";
+import type { SimLambdaStreamCursor } from "./sim-lambda-stream-cursor.js";
+interface StreamExpiryProperties {
+    readonly age: SimLambdaStreamBatchAge;
+    readonly cursor: SimLambdaStreamCursor;
+    readonly failures: SimLambdaStreamFailureDestination;
+    readonly handled: (batch: SimLambdaEventSourceStreamProgressBatch) => void;
+}
+/** Advance past expired records and notify their destination before processing live records. */
+export declare class SimLambdaStreamExpiry {
+    private readonly properties;
+    constructor(properties: StreamExpiryProperties);
+    before(records: readonly SimLambdaStreamRecordTime[], batch: SimLambdaEventSourceStreamProgressBatch, simFunction: SimLambdaFunction): Promise<number>;
+}
+export {};

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

@@ -0,0 +1,23 @@
+/** Advance past expired records and notify their destination before processing live records. */
+export class SimLambdaStreamExpiry {
+    properties;
+    constructor(properties) {
+        this.properties = properties;
+    }
+    async before(records, batch, simFunction) {
+        const { age, cursor, failures, handled } = this.properties;
+        const discard = age.discarded(records);
+        if (discard === undefined)
+            return 0;
+        const discardedCount = discard.records.length;
+        const notification = failures.deliver(discard, batch, simFunction);
+        if (discardedCount === records.length) {
+            handled(batch);
+        }
+        else {
+            cursor.advanceTo(age.firstLivePosition(records, discardedCount));
+        }
+        await notification;
+        return discardedCount;
+    }
+}

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

@@ -0,0 +1,3 @@
+import type { SimLambdaStreamFailureRecord, StreamFailureRecordProperties } from "./sim-lambda-stream-failure-record.js";
+/** Build invocation metadata for a stream failure notification. */
+export declare function streamFailureContext(properties: StreamFailureRecordProperties): Pick<SimLambdaStreamFailureRecord, "requestContext" | "responseContext">;

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

@@ -0,0 +1,19 @@
+import { randomUUID } from "node:crypto";
+/** Build invocation metadata for a stream failure notification. */
+export function streamFailureContext(properties) {
+    return {
+        requestContext: {
+            requestId: randomUUID(),
+            functionArn: properties.mapping.functionArn,
+            condition: properties.discard.condition,
+            approximateInvokeCount: properties.invokeCount,
+        },
+        ...(properties.invokeCount > 0 && {
+            responseContext: {
+                statusCode: 200,
+                executedVersion: properties.simFunction.version,
+                ...(properties.functionError && { functionError: "Unhandled" }),
+            },
+        }),
+    };
+}

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

@@ -0,0 +1,15 @@
+import type { SimLambdaStreamBatchOutcome } from "./sim-lambda-stream-batch-outcome.js";
+import type { SimLambdaFunction } from "../../function/sim-lambda-function.js";
+import type { SimLambdaEventSourceMapping } from "../sim-lambda-event-source-mapping.js";
+import type { SimLambdaEventSourceStreamProgressBatch } from "../stream/sim-lambda-event-source-streams.js";
+import { type SimLambdaStreamDiscard } from "./sim-lambda-stream-failure-record.js";
+/** Count invocations and send discarded batch metadata through the destination service. */
+export declare class SimLambdaStreamFailureDestination {
+    private readonly mapping;
+    private invokeCount;
+    private functionError;
+    constructor(mapping: SimLambdaEventSourceMapping);
+    invoked(outcome: SimLambdaStreamBatchOutcome): void;
+    reset(): void;
+    deliver(discard: SimLambdaStreamDiscard | undefined, batch: SimLambdaEventSourceStreamProgressBatch, simFunction: SimLambdaFunction): Promise<void>;
+}

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

@@ -0,0 +1,38 @@
+import { SimLambdaDestinationArn } from "../../destination/sim-lambda-destination-arn.js";
+import { simLambdaStreamFailureRecord, } from "./sim-lambda-stream-failure-record.js";
+/** Count invocations and send discarded batch metadata through the destination service. */
+export class SimLambdaStreamFailureDestination {
+    mapping;
+    invokeCount = 0;
+    functionError = false;
+    constructor(mapping) {
+        this.mapping = mapping;
+    }
+    invoked(outcome) {
+        this.invokeCount += 1;
+        this.functionError = outcome.functionError;
+    }
+    reset() {
+        this.invokeCount = 0;
+    }
+    async deliver(discard, batch, simFunction) {
+        const mapping = this.mapping;
+        const arn = mapping.failureDestinationArn;
+        if (discard === undefined || arn === undefined || arn === "")
+            return;
+        const record = simLambdaStreamFailureRecord({
+            mapping,
+            simFunction,
+            discard,
+            invokeCount: this.invokeCount,
+            shardId: batch.shardId,
+            functionError: this.functionError,
+        });
+        await mapping.destinations.deliver({
+            destinationArn: SimLambdaDestinationArn.of(arn),
+            sourceFunctionArn: mapping.functionArn,
+            sourceFunctionRoleArn: simFunction.roleArn,
+            record,
+        });
+    }
+}

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

@@ -0,0 +1,41 @@
+import { type SimLambdaStreamBatchInfo } from "./sim-lambda-stream-batch-info.js";
+import type { SimLambdaFunction } from "../../function/sim-lambda-function.js";
+import type { SimLambdaEventSourceMapping } from "../sim-lambda-event-source-mapping.js";
+import type { SimLambdaStreamRecordTime } from "./sim-lambda-stream-record-times.js";
+export type SimLambdaStreamFailureCondition = "RetryAttemptsExhausted" | "RecordAgeExceeded";
+export interface SimLambdaStreamDiscard {
+    readonly records: readonly SimLambdaStreamRecordTime[];
+    readonly condition: SimLambdaStreamFailureCondition;
+    readonly at: Date;
+}
+export interface SimLambdaStreamFailureRecord {
+    readonly version: string;
+    readonly timestamp: string;
+    readonly requestContext: {
+        readonly requestId: string;
+        readonly functionArn: string;
+        readonly condition: SimLambdaStreamFailureCondition;
+        readonly approximateInvokeCount: number;
+    };
+    readonly responseContext?: {
+        readonly statusCode: number;
+        readonly executedVersion: string;
+        readonly functionError?: string;
+    };
+    readonly DDBStreamBatchInfo?: SimLambdaStreamBatchInfo;
+    readonly KinesisBatchInfo?: SimLambdaStreamBatchInfo;
+}
+export interface StreamFailureRecordProperties {
+    readonly mapping: SimLambdaEventSourceMapping;
+    readonly simFunction: SimLambdaFunction;
+    readonly shardId: string | undefined;
+    readonly discard: SimLambdaStreamDiscard;
+    readonly invokeCount: number;
+    readonly functionError: boolean;
+}
+/**
+ * SQS and SNS receive metadata identifying the discarded records.
+ * @see https://docs.aws.amazon.com/lambda/latest/dg/services-dynamodb-errors.html
+ * @see https://docs.aws.amazon.com/lambda/latest/dg/kinesis-on-failure-destination.html
+ */
+export declare function simLambdaStreamFailureRecord(properties: StreamFailureRecordProperties): SimLambdaStreamFailureRecord;

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

@@ -0,0 +1,17 @@
+import { streamFailureContext } from "./sim-lambda-stream-failure-context.js";
+import { simLambdaStreamBatchInfo, streamFailureBatchInfo, } from "./sim-lambda-stream-batch-info.js";
+/**
+ * SQS and SNS receive metadata identifying the discarded records.
+ * @see https://docs.aws.amazon.com/lambda/latest/dg/services-dynamodb-errors.html
+ * @see https://docs.aws.amazon.com/lambda/latest/dg/kinesis-on-failure-destination.html
+ */
+export function simLambdaStreamFailureRecord(properties) {
+    const { mapping, discard, shardId } = properties;
+    const info = simLambdaStreamBatchInfo(discard.records, mapping.eventSourceArn, shardId);
+    return {
+        version: "1.0",
+        timestamp: discard.at.toISOString(),
+        ...streamFailureContext(properties),
+        ...streamFailureBatchInfo(mapping.eventSourceArn, info),
+    };
+}

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

@@ -0,0 +1,23 @@
+import { SimLambdaStreamExpiry } from "./sim-lambda-stream-expiry.js";
+import { SimLambdaStreamFailureDestination } from "./sim-lambda-stream-failure-destination.js";
+import { SimLambdaStreamCursor } from "./sim-lambda-stream-cursor.js";
+import { SimLambdaStreamRetry } from "./sim-lambda-stream-retry.js";
+import { SimLambdaStreamBisect } from "./sim-lambda-stream-bisect.js";
+import type { BackgroundScheduler, BackgroundTask } from "../../../../util/background/background.js";
+import type { SimLambdaEventSourceMapping } from "../sim-lambda-event-source-mapping.js";
+import type { SimLambdaEventSourceStreamProgressBatch } from "../stream/sim-lambda-event-source-streams.js";
+export interface SimLambdaStreamProgressProperties {
+    readonly mapping: SimLambdaEventSourceMapping;
+    readonly background: BackgroundScheduler;
+    readonly poll: BackgroundTask;
+}
+/** Own the per-shard retry state and its expiry and destination collaborators. */
+export declare class SimLambdaStreamProgressState {
+    readonly expiry: SimLambdaStreamExpiry;
+    readonly failures: SimLambdaStreamFailureDestination;
+    readonly cursor: SimLambdaStreamCursor;
+    readonly retry: SimLambdaStreamRetry;
+    readonly bisect: SimLambdaStreamBisect;
+    constructor(properties: SimLambdaStreamProgressProperties);
+    handled(batch: SimLambdaEventSourceStreamProgressBatch): void;
+}

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

@@ -0,0 +1,42 @@
+import { SimLambdaStreamExpiry } from "./sim-lambda-stream-expiry.js";
+import { SimLambdaStreamBatchAge } from "./sim-lambda-stream-batch-age.js";
+import { SimLambdaStreamFailureDestination } from "./sim-lambda-stream-failure-destination.js";
+import { SimLambdaStreamCursor } from "./sim-lambda-stream-cursor.js";
+import { SimLambdaStreamRetry } from "./sim-lambda-stream-retry.js";
+import { SimLambdaStreamBisect } from "./sim-lambda-stream-bisect.js";
+import { PollSchedule } from "../../../../util/background/poll-schedule.js";
+import { assertDefined } from "../../../../util/type-guard/defined.js";
+/** Own the per-shard retry state and its expiry and destination collaborators. */
+export class SimLambdaStreamProgressState {
+    expiry;
+    failures;
+    cursor;
+    retry;
+    bisect;
+    constructor(properties) {
+        const { mapping, background } = properties;
+        this.failures = new SimLambdaStreamFailureDestination(mapping);
+        // A stream mapping is refused at creation unless it names a starting
+        // position, so one that has got this far without one is the simulator
+        // having gone wrong rather than a request having been wrong.
+        const { start, streamRetryLimits } = mapping;
+        assertDefined(start, "stream mapping start position");
+        assertDefined(streamRetryLimits, "stream mapping retry limits");
+        this.cursor = new SimLambdaStreamCursor(start, new PollSchedule(properties));
+        this.retry = new SimLambdaStreamRetry(streamRetryLimits, background);
+        this.bisect = new SimLambdaStreamBisect(streamRetryLimits.bisectBatchOnFunctionError);
+        this.expiry = new SimLambdaStreamExpiry({
+            age: new SimLambdaStreamBatchAge(streamRetryLimits, background),
+            cursor: this.cursor,
+            failures: this.failures,
+            handled: (batch) => {
+                this.handled(batch);
+            },
+        });
+    }
+    handled(batch) {
+        this.failures.reset();
+        this.retry.reset();
+        this.cursor.handled(batch);
+    }
+}