@kensio/yulin 1.21.20 → 1.21.22

package/dist/service/lambda/event-source/filter/sim-lambda-filtered-records.d.ts

@@ -0,0 +1,24 @@
+import type { SimLambdaFilterCriteria } from "./sim-lambda-filter-criteria.js";
+/**
+ * The records of a batch a mapping's filters let through.
+ *
+ * A mapping with no criteria delivers the batch it read. One with criteria
+ * delivers the records that match, and treats the rest as handled: a stream
+ * moves its checkpoint past them and a queue deletes them, which is what real
+ * Lambda does with a record it filtered out.
+ *
+ * What a pattern reads is the record as the function would have received it,
+ * with the source's own data field decoded. That translation is the source's,
+ * so it is handed in.
+ */
+export declare function simLambdaFilteredRecords<RecordType>(criteria: SimLambdaFilterCriteria | undefined, records: readonly RecordType[], documentOf: (record: RecordType) => Record<string, unknown>): readonly RecordType[];
+/**
+ * The JSON a data field holds, or the text it is when it holds no JSON.
+ *
+ * Real Lambda filters a record's data only when both the data and the pattern
+ * for it are JSON. Text that parses is handed to the pattern as the object it
+ * parses to, and text that does not is handed over as itself, which a pattern
+ * written for an object then fails to match. Either way the record is dropped
+ * exactly where AWS drops it.
+ */
+export declare function simLambdaFilterData(text: string): unknown;

package/dist/service/lambda/event-source/filter/sim-lambda-filtered-records.js

@@ -0,0 +1,35 @@
+/**
+ * The records of a batch a mapping's filters let through.
+ *
+ * A mapping with no criteria delivers the batch it read. One with criteria
+ * delivers the records that match, and treats the rest as handled: a stream
+ * moves its checkpoint past them and a queue deletes them, which is what real
+ * Lambda does with a record it filtered out.
+ *
+ * What a pattern reads is the record as the function would have received it,
+ * with the source's own data field decoded. That translation is the source's,
+ * so it is handed in.
+ */
+export function simLambdaFilteredRecords(criteria, records, documentOf) {
+    if (criteria === undefined) {
+        return records;
+    }
+    return records.filter((record) => criteria.matches(documentOf(record)));
+}
+/**
+ * The JSON a data field holds, or the text it is when it holds no JSON.
+ *
+ * Real Lambda filters a record's data only when both the data and the pattern
+ * for it are JSON. Text that parses is handed to the pattern as the object it
+ * parses to, and text that does not is handed over as itself, which a pattern
+ * written for an object then fails to match. Either way the record is dropped
+ * exactly where AWS drops it.
+ */
+export function simLambdaFilterData(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}

package/dist/service/lambda/event-source/poll/kinesis/sim-lambda-kinesis-shard-poller.d.ts

@@ -31,22 +31,25 @@ export declare class SimLambdaKinesisShardPoller implements SimLambdaEventSource
     private readonly delivery;
     private readonly progress;
     private readonly turn;
-    private stopped;
     constructor(properties: SimLambdaKinesisShardPollerProperties);
     /** Poll this shard as soon as the simulation gets to it. */
     pollNow(): void;
     /** Stop polling this shard. */
     stop(): void;
     /**
-     * Note a record put onto the stream, answering with whether this mapping's
-     * own function put it.
+     * Note a record put onto the stream, which counts only while this shard is
+     * mid-delivery.
      */
-    noteRecordWritten(): boolean;
+    noteRecordWritten(): void;
     /**
      * Read one batch off this shard, deliver it, and decide what happens next.
      *
      * Only ever called through the turn, which is what keeps two polls from
      * reading the same records.
+     *
+     * A refused shard polls no further. Its checkpoint stayed where the refused
+     * delivery found it, and reading on from there would deliver those records
+     * again.
      */
     poll(): Promise<void>;
 }

package/dist/service/lambda/event-source/poll/kinesis/sim-lambda-kinesis-shard-poller.js

@@ -23,7 +23,6 @@ export class SimLambdaKinesisShardPoller {
     delivery;
     progress;
     turn = new SimLambdaEventSourcePollTurn(this);
-    stopped = false;
     constructor(properties) {
         this.mapping = properties.mapping;
         this.functions = properties.functions;
@@ -43,23 +42,27 @@ export class SimLambdaKinesisShardPoller {
     }
     /** Stop polling this shard. */
     stop() {
-        this.stopped = true;
+        this.delivery.stop();
     }
     /**
-     * Note a record put onto the stream, answering with whether this mapping's
-     * own function put it.
+     * Note a record put onto the stream, which counts only while this shard is
+     * mid-delivery.
      */
     noteRecordWritten() {
-        return this.delivery.noteRecordWritten();
+        this.delivery.noteRecordWritten();
     }
     /**
      * Read one batch off this shard, deliver it, and decide what happens next.
      *
      * Only ever called through the turn, which is what keeps two polls from
      * reading the same records.
+     *
+     * A refused shard polls no further. Its checkpoint stayed where the refused
+     * delivery found it, and reading on from there would deliver those records
+     * again.
      */
     async poll() {
-        const simFunction = simLambdaEventSourceFunction(this.functions, this.mapping, this.stopped);
+        const simFunction = simLambdaEventSourceFunction(this.functions, this.mapping, this.delivery.stopped);
         if (simFunction === undefined) {
             return;
         }

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

@@ -2,7 +2,7 @@ import type { SimLambdaFunction } from "../../../function/sim-lambda-function.js
 import type { SimLambdaEventSourceMapping } from "../../sim-lambda-event-source-mapping.js";
 import type { SimLambdaKinesisEventSourceArn } from "../../stream/kinesis/sim-lambda-kinesis-event-source-arn.js";
 import type { SimLambdaKinesisStreamRecord } from "../../stream/kinesis/sim-lambda-kinesis-streams.js";
-import type { SimLambdaStreamBatchOutcome } from "../sim-lambda-stream-batch-outcome.js";
+import { SimLambdaStreamBatchOutcome } from "../sim-lambda-stream-batch-outcome.js";
 interface SimLambdaKinesisStreamDeliveryProperties {
     readonly mapping: SimLambdaEventSourceMapping;
     readonly eventSourceArn: SimLambdaKinesisEventSourceArn;
@@ -24,16 +24,28 @@ export declare class SimLambdaKinesisStreamDelivery {
     private readonly eventBuilder;
     private readonly batchResponse;
     private readonly cascade;
+    private readonly halt;
+    private readonly filterCriteria;
     constructor(properties: SimLambdaKinesisStreamDeliveryProperties);
     /**
      * Deliver a batch, answering with what became of it.
      */
     to(simFunction: SimLambdaFunction, records: readonly SimLambdaKinesisStreamRecord[]): Promise<SimLambdaStreamBatchOutcome>;
     /**
-     * Note a record put onto the polled stream, answering with whether this
-     * mapping's own function put it.
+     * Whether this shard has finished polling, which stopping it and refusing it
+     * both settle.
      */
-    noteRecordWritten(): boolean;
+    get stopped(): boolean;
+    /**
+     * Finish this shard, as stopping the mapping does.
+     */
+    stop(): void;
+    /**
+     * Note a record put onto the polled stream, which counts only while this
+     * mapping's own function is running.
+     */
+    noteRecordWritten(): void;
     private handled;
+    private invoked;
 }
 export {};

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

@@ -1,6 +1,9 @@
+import { simLambdaFilteredDelivery } from "../../filter/sim-lambda-filtered-delivery.js";
 import { SimLambdaStreamCascadeGuard } from "../../stream/sim-lambda-stream-cascade-guard.js";
+import { SimLambdaStreamHalt } from "../../stream/sim-lambda-stream-halt.js";
 import { countSimLambdaKinesisIteratorAge } from "../sim-lambda-stream-iterator-age.js";
-import { simLambdaKinesisStreamRecordTimes } from "../sim-lambda-stream-record-times.js";
+import { simLambdaKinesisStreamRecordTimes, } from "../sim-lambda-stream-record-times.js";
+import { SimLambdaStreamBatchOutcome } from "../sim-lambda-stream-batch-outcome.js";
 import { SimLambdaStreamBatchResponse } from "../sim-lambda-stream-batch-response.js";
 import { SimLambdaKinesisStreamEventBuilder } from "./sim-lambda-kinesis-stream-event.js";
 /**
@@ -18,8 +21,11 @@ export class SimLambdaKinesisStreamDelivery {
     eventBuilder;
     batchResponse;
     cascade;
+    halt = new SimLambdaStreamHalt();
+    filterCriteria;
     constructor(properties) {
         const { eventSourceArn } = properties;
+        this.filterCriteria = properties.mapping.filterCriteria;
         this.eventBuilder = new SimLambdaKinesisStreamEventBuilder({
             eventSourceArn,
             shardId: properties.shardId,
@@ -28,6 +34,7 @@ export class SimLambdaKinesisStreamDelivery {
         this.batchResponse = new SimLambdaStreamBatchResponse(properties.mapping.reportsBatchItemFailures);
         this.cascade = new SimLambdaStreamCascadeGuard({
             mapping: properties.mapping,
+            halt: this.halt,
             source: {
                 streamArn: eventSourceArn.value,
                 wroteTo: `put a record onto the stream ${eventSourceArn.streamName}`,
@@ -43,16 +50,40 @@ export class SimLambdaKinesisStreamDelivery {
         return await this.cascade.around(async () => await this.handled(simFunction, records));
     }
     /**
-     * Note a record put onto the polled stream, answering with whether this
-     * mapping's own function put it.
+     * Whether this shard has finished polling, which stopping it and refusing it
+     * both settle.
+     */
+    get stopped() {
+        return this.halt.stopped;
+    }
+    /**
+     * Finish this shard, as stopping the mapping does.
+     */
+    stop() {
+        this.halt.stop();
+    }
+    /**
+     * Note a record put onto the polled stream, which counts only while this
+     * mapping's own function is running.
      */
     noteRecordWritten() {
-        return this.cascade.noteRecordWritten();
+        this.cascade.noteRecordWritten();
     }
     async handled(simFunction, records) {
         const times = simLambdaKinesisStreamRecordTimes(records);
+        return await simLambdaFilteredDelivery({
+            criteria: this.filterCriteria,
+            records,
+            documentOf: (record) => this.eventBuilder.filterDocumentOf(record),
+            // A batch the filters emptied is finished with even though the function
+            // never saw it, as a filtered record advances a real checkpoint too.
+            handled: () => SimLambdaStreamBatchOutcome.handled(times),
+            invoke: async (delivered) => await this.invoked(simFunction, delivered, times, records),
+        });
+    }
+    async invoked(simFunction, delivered, times, records) {
         try {
-            return this.batchResponse.handled(times, await simFunction.invoke(this.eventBuilder.of(records)));
+            return this.batchResponse.handled(times, await simFunction.invoke(this.eventBuilder.of(delivered)));
         }
         catch {
             // As on real Lambda, the handler error goes to the function's logs. What

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

@@ -51,9 +51,10 @@ export declare class SimLambdaKinesisStreamEventSourcePoller implements SimLambd
      * Take a record arriving on the stream as something to poll for.
      *
      * A record put while this mapping's own function is running is the function
-     * writing back into its own source stream. That never settles, so the mapping
-     * stops here and the delivery refuses once it is over. Only the shard that is
-     * mid-delivery answers, since only it is inside the delivery.
+     * writing back into its own source stream. The delivery it brings on is what
+     * settles the work or carries the chain on, so the mapping polls for it
+     * either way and the guard counts the chain. Every shard is told, and only
+     * the one that is mid-delivery counts it.
      */
     recordsAvailable(): void;
     /**

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

@@ -58,15 +58,14 @@ export class SimLambdaKinesisStreamEventSourcePoller {
      * Take a record arriving on the stream as something to poll for.
      *
      * A record put while this mapping's own function is running is the function
-     * writing back into its own source stream. That never settles, so the mapping
-     * stops here and the delivery refuses once it is over. Only the shard that is
-     * mid-delivery answers, since only it is inside the delivery.
+     * writing back into its own source stream. The delivery it brings on is what
+     * settles the work or carries the chain on, so the mapping polls for it
+     * either way and the guard counts the chain. Every shard is told, and only
+     * the one that is mid-delivery counts it.
      */
     recordsAvailable() {
-        const cascading = this.shardPollers.made.some((shardPoller) => shardPoller.noteRecordWritten());
-        if (cascading) {
-            this.stop();
-            return;
+        for (const shardPoller of this.shardPollers.made) {
+            shardPoller.noteRecordWritten();
         }
         this.schedule.now();
     }

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

@@ -1,6 +1,6 @@
 import type { SimLambdaKinesisEventSourceArn } from "../../stream/kinesis/sim-lambda-kinesis-event-source-arn.js";
 import type { SimLambdaKinesisStreamRecord } from "../../stream/kinesis/sim-lambda-kinesis-streams.js";
-import type { SimLambdaKinesisStreamEvent } from "./sim-lambda-kinesis-stream-event.types.js";
+import type { SimLambdaKinesisStreamEvent, SimLambdaKinesisStreamEventRecord } from "./sim-lambda-kinesis-stream-event.types.js";
 interface SimLambdaKinesisStreamEventBuilderProperties {
     readonly eventSourceArn: SimLambdaKinesisEventSourceArn;
     readonly shardId: string;
@@ -27,6 +27,15 @@ export declare class SimLambdaKinesisStreamEventBuilder {
      * The event for a batch of records.
      */
     of(records: readonly SimLambdaKinesisStreamRecord[]): SimLambdaKinesisStreamEvent;
+    /**
+     * What a mapping's filters read one record as.
+     *
+     * The event record carries the payload base64 encoded under `kinesis`, and a
+     * Lambda filter pattern addresses it as JSON under a top-level `data`. Both
+     * are here, so a pattern can name the payload the way AWS documents it and
+     * the record's metadata the way the event carries it.
+     */
+    filterDocumentOf(record: SimLambdaKinesisStreamRecord): Record<string, unknown>;
     /**
      * The identifier one record is named by in the event.
      *
@@ -35,6 +44,9 @@ export declare class SimLambdaKinesisStreamEventBuilder {
      * one shard.
      */
     eventIdOf(record: SimLambdaKinesisStreamRecord): string;
-    private record;
+    /**
+     * The event record one polled record becomes.
+     */
+    recordOf(record: SimLambdaKinesisStreamRecord): SimLambdaKinesisStreamEventRecord;
 }
 export {};

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

@@ -1,3 +1,4 @@
+import { simLambdaFilterData } from "../../filter/sim-lambda-filtered-records.js";
 const millisecondsPerSecond = 1000;
 /**
  * The schema version every Kinesis event record carries.
@@ -31,7 +32,22 @@ export class SimLambdaKinesisStreamEventBuilder {
      * The event for a batch of records.
      */
     of(records) {
-        return { Records: records.map((record) => this.record(record)) };
+        return { Records: records.map((record) => this.recordOf(record)) };
+    }
+    /**
+     * What a mapping's filters read one record as.
+     *
+     * The event record carries the payload base64 encoded under `kinesis`, and a
+     * Lambda filter pattern addresses it as JSON under a top-level `data`. Both
+     * are here, so a pattern can name the payload the way AWS documents it and
+     * the record's metadata the way the event carries it.
+     */
+    filterDocumentOf(record) {
+        const eventRecord = this.recordOf(record);
+        return {
+            ...eventRecord,
+            data: simLambdaFilterData(Buffer.from(eventRecord.kinesis.data, "base64").toString("utf8")),
+        };
     }
     /**
      * The identifier one record is named by in the event.
@@ -43,7 +59,10 @@ export class SimLambdaKinesisStreamEventBuilder {
     eventIdOf(record) {
         return `${this.shardId}:${record.SequenceNumber ?? ""}`;
     }
-    record(record) {
+    /**
+     * The event record one polled record becomes.
+     */
+    recordOf(record) {
         return {
             eventID: this.eventIdOf(record),
             eventName: "aws:kinesis:record",

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

@@ -2,7 +2,7 @@ import type { SimLambdaFunction } from "../../function/sim-lambda-function.js";
 import type { SimLambdaEventSourceMapping } from "../sim-lambda-event-source-mapping.js";
 import type { SimLambdaDynamoDbStreamEventSourceArn } from "../stream/sim-lambda-dynamodb-stream-event-source-arn.js";
 import type { SimLambdaEventSourceStreamRecord } from "../stream/sim-lambda-event-source-streams.js";
-import type { SimLambdaStreamBatchOutcome } from "./sim-lambda-stream-batch-outcome.js";
+import { SimLambdaStreamBatchOutcome } from "./sim-lambda-stream-batch-outcome.js";
 interface SimLambdaDynamoDbStreamDeliveryProperties {
     readonly mapping: SimLambdaEventSourceMapping;
     readonly eventSourceArn: SimLambdaDynamoDbStreamEventSourceArn;
@@ -19,23 +19,36 @@ interface SimLambdaDynamoDbStreamDeliveryProperties {
  * what the function said, so the batch response decides it.
  *
  * What the function did with the table while it ran is part of the same
- * question, so the cascade guard belongs here too: a handler writing back into
- * its own source table is refused rather than handled.
+ * question, so the cascade guard belongs here too. It counts the deliveries a
+ * handler's own writes bring on, and refuses the mapping once that chain is
+ * long enough to say the simulation will never settle.
  */
 export declare class SimLambdaDynamoDbStreamDelivery {
     private readonly eventBuilder;
     private readonly batchResponse;
     private readonly cascade;
+    private readonly halt;
+    private readonly filterCriteria;
     constructor(properties: SimLambdaDynamoDbStreamDeliveryProperties);
     /**
      * Deliver a batch, answering with what became of it.
      */
     to(simFunction: SimLambdaFunction, records: readonly SimLambdaEventSourceStreamRecord[]): Promise<SimLambdaStreamBatchOutcome>;
     /**
-     * Note a record written to the polled stream, answering with whether this
-     * mapping's own function wrote it.
+     * Whether this mapping has finished polling, which deleting it and refusing
+     * it both settle.
      */
-    noteRecordWritten(): boolean;
+    get stopped(): boolean;
+    /**
+     * Finish this mapping, as deleting it does.
+     */
+    stop(): void;
+    /**
+     * Note a record written to the polled stream, which counts only while this
+     * mapping's own function is running.
+     */
+    noteRecordWritten(): void;
     private handled;
+    private invoked;
 }
 export {};

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

@@ -1,7 +1,10 @@
+import { simLambdaFilteredDelivery } from "../filter/sim-lambda-filtered-delivery.js";
 import { SimLambdaStreamCascadeGuard } from "../stream/sim-lambda-stream-cascade-guard.js";
+import { SimLambdaStreamHalt } from "../stream/sim-lambda-stream-halt.js";
 import { SimLambdaDynamoDbStreamEventBuilder } from "./sim-lambda-dynamodb-stream-event.js";
 import { countSimLambdaDynamoDbIteratorAge } from "./sim-lambda-stream-iterator-age.js";
-import { simLambdaDynamoDbStreamRecordTimes } from "./sim-lambda-stream-record-times.js";
+import { simLambdaDynamoDbStreamRecordTimes, } from "./sim-lambda-stream-record-times.js";
+import { SimLambdaStreamBatchOutcome } from "./sim-lambda-stream-batch-outcome.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.
@@ -15,18 +18,23 @@ import { SimLambdaStreamBatchResponse } from "./sim-lambda-stream-batch-response
  * what the function said, so the batch response decides it.
  *
  * What the function did with the table while it ran is part of the same
- * question, so the cascade guard belongs here too: a handler writing back into
- * its own source table is refused rather than handled.
+ * question, so the cascade guard belongs here too. It counts the deliveries a
+ * handler's own writes bring on, and refuses the mapping once that chain is
+ * long enough to say the simulation will never settle.
  */
 export class SimLambdaDynamoDbStreamDelivery {
     eventBuilder;
     batchResponse;
     cascade;
+    halt = new SimLambdaStreamHalt();
+    filterCriteria;
     constructor(properties) {
+        this.filterCriteria = properties.mapping.filterCriteria;
         this.eventBuilder = new SimLambdaDynamoDbStreamEventBuilder(properties.eventSourceArn);
         this.batchResponse = new SimLambdaStreamBatchResponse(properties.mapping.reportsBatchItemFailures);
         this.cascade = new SimLambdaStreamCascadeGuard({
             mapping: properties.mapping,
+            halt: this.halt,
             source: {
                 streamArn: properties.eventSourceArn.value,
                 wroteTo: `wrote to the table ${properties.eventSourceArn.tableName}`,
@@ -42,16 +50,42 @@ export class SimLambdaDynamoDbStreamDelivery {
         return await this.cascade.around(async () => await this.handled(simFunction, records));
     }
     /**
-     * Note a record written to the polled stream, answering with whether this
-     * mapping's own function wrote it.
+     * Whether this mapping has finished polling, which deleting it and refusing
+     * it both settle.
+     */
+    get stopped() {
+        return this.halt.stopped;
+    }
+    /**
+     * Finish this mapping, as deleting it does.
+     */
+    stop() {
+        this.halt.stop();
+    }
+    /**
+     * Note a record written to the polled stream, which counts only while this
+     * mapping's own function is running.
      */
     noteRecordWritten() {
-        return this.cascade.noteRecordWritten();
+        this.cascade.noteRecordWritten();
     }
     async handled(simFunction, records) {
         const times = simLambdaDynamoDbStreamRecordTimes(records);
+        return await simLambdaFilteredDelivery({
+            criteria: this.filterCriteria,
+            records,
+            // A pattern reads the record as the function would have received it, so
+            // the event builder makes what it matches against.
+            documentOf: (record) => ({ ...this.eventBuilder.recordOf(record) }),
+            // A batch the filters emptied is finished with even though the function
+            // never saw it, as a filtered record advances a real checkpoint too.
+            handled: () => SimLambdaStreamBatchOutcome.handled(times),
+            invoke: async (delivered) => await this.invoked(simFunction, delivered, times, records),
+        });
+    }
+    async invoked(simFunction, delivered, times, records) {
         try {
-            return this.batchResponse.handled(times, await simFunction.invoke(this.eventBuilder.of(records)));
+            return this.batchResponse.handled(times, await simFunction.invoke(this.eventBuilder.of(delivered)));
         }
         catch {
             // As on real Lambda, the handler error goes to the function's logs. What

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

@@ -31,7 +31,6 @@ export declare class SimLambdaDynamoDbStreamEventSourcePoller implements SimLamb
     private readonly polling;
     private readonly progress;
     private readonly turn;
-    private stopped;
     constructor(properties: SimLambdaDynamoDbStreamEventSourcePollerProperties);
     /**
      * Watch the stream this mapping polls.
@@ -56,8 +55,9 @@ export declare class SimLambdaDynamoDbStreamEventSourcePoller implements SimLamb
      * Take a record arriving on the stream as something to poll for.
      *
      * A record written while this mapping's own function is running is the
-     * function writing back into its own source table. That never settles, so the
-     * mapping stops here and the delivery refuses once it is over.
+     * function writing back into its own source table. The delivery it brings on
+     * is what settles the work or carries the chain on, so the mapping polls for
+     * it either way and the guard counts the chain.
      */
     recordsAvailable(): void;
     /**
@@ -65,6 +65,10 @@ export declare class SimLambdaDynamoDbStreamEventSourcePoller implements SimLamb
      *
      * Only ever called through the turn, which is what keeps two polls from
      * reading the same records.
+     *
+     * A refused mapping polls no further. Its checkpoint stayed where the refused
+     * delivery found it, and reading on from there would deliver those records
+     * again.
      */
     poll(): Promise<void>;
 }

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

@@ -22,7 +22,6 @@ export class SimLambdaDynamoDbStreamEventSourcePoller {
     polling;
     progress;
     turn = new SimLambdaEventSourcePollTurn(this);
-    stopped = false;
     constructor(properties) {
         const { eventSourceArn, mapping } = properties;
         this.stream = new SimLambdaDynamoDbPolledStream(properties.streams, eventSourceArn.value);
@@ -67,21 +66,19 @@ export class SimLambdaDynamoDbStreamEventSourcePoller {
      * Stop polling, as deleting the mapping does.
      */
     stop() {
-        this.stopped = true;
+        this.delivery.stop();
         this.stream.unwatch(this);
     }
     /**
      * Take a record arriving on the stream as something to poll for.
      *
      * A record written while this mapping's own function is running is the
-     * function writing back into its own source table. That never settles, so the
-     * mapping stops here and the delivery refuses once it is over.
+     * function writing back into its own source table. The delivery it brings on
+     * is what settles the work or carries the chain on, so the mapping polls for
+     * it either way and the guard counts the chain.
      */
     recordsAvailable() {
-        if (this.delivery.noteRecordWritten()) {
-            this.stopped = true;
-            return;
-        }
+        this.delivery.noteRecordWritten();
         this.progress.pollNow();
     }
     /**
@@ -89,8 +86,12 @@ export class SimLambdaDynamoDbStreamEventSourcePoller {
      *
      * Only ever called through the turn, which is what keeps two polls from
      * reading the same records.
+     *
+     * A refused mapping polls no further. Its checkpoint stayed where the refused
+     * delivery found it, and reading on from there would deliver those records
+     * again.
      */
     async poll() {
-        await this.polling.poll(this.stopped);
+        await this.polling.poll(this.delivery.stopped);
     }
 }

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

@@ -1,5 +1,5 @@
 import type { SimLambdaDynamoDbStreamEventSourceArn } from "../stream/sim-lambda-dynamodb-stream-event-source-arn.js";
-import type { SimLambdaDynamoDbStreamEvent } from "./sim-lambda-dynamodb-stream-event.types.js";
+import type { SimLambdaDynamoDbStreamEvent, SimLambdaDynamoDbStreamEventRecord } from "./sim-lambda-dynamodb-stream-event.types.js";
 import type { SimLambdaEventSourceStreamRecord } from "../stream/sim-lambda-event-source-streams.js";
 /**
  * Builds the DynamoDB stream event for one batch of polled records.
@@ -16,5 +16,9 @@ export declare class SimLambdaDynamoDbStreamEventBuilder {
      * The event for a batch of records.
      */
     of(records: readonly SimLambdaEventSourceStreamRecord[]): SimLambdaDynamoDbStreamEvent;
-    private record;
+    /**
+     * The event record one polled record becomes, which is also what a mapping's
+     * filters are matched against.
+     */
+    recordOf(record: SimLambdaEventSourceStreamRecord): SimLambdaDynamoDbStreamEventRecord;
 }

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

@@ -17,9 +17,13 @@ export class SimLambdaDynamoDbStreamEventBuilder {
      * The event for a batch of records.
      */
     of(records) {
-        return { Records: records.map((record) => this.record(record)) };
+        return { Records: records.map((record) => this.recordOf(record)) };
     }
-    record(record) {
+    /**
+     * The event record one polled record becomes, which is also what a mapping's
+     * filters are matched against.
+     */
+    recordOf(record) {
         const identity = record.userIdentity;
         return {
             eventID: record.eventID ?? "",