@kensio/yulin 1.21.21 → 1.21.23

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 ?? "",

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

@@ -1,6 +1,7 @@
 import type { SimLambdaFunction } from "../../function/sim-lambda-function.js";
 import type { SimSqsPollMessage } from "../../../sqs/poll/sim-sqs-poll-message.js";
-import type { SimLambdaEventSourceBatchOutcome, SimLambdaEventSourceBatchResponse } from "./sim-lambda-event-source-batch-response.js";
+import { SimLambdaEventSourceBatchOutcome, type SimLambdaEventSourceBatchResponse } from "./sim-lambda-event-source-batch-response.js";
+import type { SimLambdaFilterCriteria } from "../filter/sim-lambda-filter-criteria.js";
 /**
  * One record of an event source event.
  *
@@ -25,10 +26,16 @@ export interface SimLambdaEventSourceEvent {
  */
 export interface SimLambdaEventSourceEventBuilder {
     of(messages: readonly SimSqsPollMessage[]): SimLambdaEventSourceEvent;
+    /**
+     * What a mapping's filters read one message as, which is the source's own
+     * translation.
+     */
+    filterDocumentOf(message: SimSqsPollMessage): Record<string, unknown>;
 }
 interface SimLambdaEventSourceDeliveryProperties {
     readonly eventBuilder: SimLambdaEventSourceEventBuilder;
     readonly batchResponse: SimLambdaEventSourceBatchResponse;
+    readonly filterCriteria: SimLambdaFilterCriteria | undefined;
 }
 /**
  * Hands one batch to a function and reads what became of it.
@@ -43,10 +50,23 @@ interface SimLambdaEventSourceDeliveryProperties {
 export declare class SimLambdaEventSourceDelivery {
     private readonly eventBuilder;
     private readonly batchResponse;
+    private readonly filterCriteria;
     constructor(properties: SimLambdaEventSourceDeliveryProperties);
     /**
      * Deliver a batch, answering with what to delete and what to leave.
      */
     to(simFunction: SimLambdaFunction, messages: readonly SimSqsPollMessage[]): Promise<SimLambdaEventSourceBatchOutcome>;
+    /**
+     * One batch of matching messages, handed over and read back.
+     */
+    private invoked;
+    /**
+     * An outcome with the filtered-out messages counted as handled, which deletes
+     * them whatever the function said about the rest.
+     *
+     * A message the function never saw is in neither list the outcome carries,
+     * which is what picks it out of the batch that was read.
+     */
+    private alsoHandling;
 }
 export {};

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

@@ -1,3 +1,5 @@
+import { SimLambdaEventSourceBatchOutcome, } from "./sim-lambda-event-source-batch-response.js";
+import { simLambdaFilteredDelivery } from "../filter/sim-lambda-filtered-delivery.js";
 /**
  * Hands one batch to a function and reads what became of it.
  *
@@ -11,22 +13,50 @@
 export class SimLambdaEventSourceDelivery {
     eventBuilder;
     batchResponse;
+    filterCriteria;
     constructor(properties) {
         this.eventBuilder = properties.eventBuilder;
         this.batchResponse = properties.batchResponse;
+        this.filterCriteria = properties.filterCriteria;
     }
     /**
      * Deliver a batch, answering with what to delete and what to leave.
      */
     async to(simFunction, messages) {
+        return await simLambdaFilteredDelivery({
+            criteria: this.filterCriteria,
+            records: messages,
+            documentOf: (message) => this.eventBuilder.filterDocumentOf(message),
+            // A message the filters excluded is deleted from the queue without the
+            // function seeing it, the way real Lambda deletes one.
+            handled: () => new SimLambdaEventSourceBatchOutcome(messages, []),
+            invoke: async (delivered) => this.alsoHandling(messages, await this.invoked(simFunction, delivered)),
+        });
+    }
+    /**
+     * One batch of matching messages, handed over and read back.
+     */
+    async invoked(simFunction, delivered) {
         try {
-            return this.batchResponse.handled(messages, await simFunction.invoke(this.eventBuilder.of(messages)));
+            return this.batchResponse.handled(delivered, await simFunction.invoke(this.eventBuilder.of(delivered)));
         }
         catch {
             // As on real Lambda, the handler error goes to the function's logs and
             // not to whoever sent the message. What the sender sees is the batch
             // coming back to the source.
-            return this.batchResponse.failed(messages);
+            return this.batchResponse.failed(delivered);
         }
     }
+    /**
+     * An outcome with the filtered-out messages counted as handled, which deletes
+     * them whatever the function said about the rest.
+     *
+     * A message the function never saw is in neither list the outcome carries,
+     * which is what picks it out of the batch that was read.
+     */
+    alsoHandling(messages, outcome) {
+        const seen = new Set([...outcome.handled, ...outcome.returned]);
+        const excluded = messages.filter((message) => !seen.has(message));
+        return new SimLambdaEventSourceBatchOutcome([...outcome.handled, ...excluded], outcome.returned);
+    }
 }

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

@@ -12,5 +12,6 @@ export function makeSimLambdaSqsDelivery(properties) {
     return new SimLambdaEventSourceDelivery({
         eventBuilder: new SimLambdaSqsEventBuilder(properties.eventSourceArn),
         batchResponse: new SimLambdaSqsBatchResponse(properties.mapping.reportsBatchItemFailures),
+        filterCriteria: properties.mapping.filterCriteria,
     });
 }

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

@@ -50,6 +50,14 @@ export declare class SimLambdaSqsEventBuilder {
      * The event for a batch of messages.
      */
     of(messages: readonly SimSqsPollMessage[]): SimLambdaSqsEvent;
+    /**
+     * What a mapping's filters read one message as.
+     *
+     * Real Lambda filters an SQS message on its body alone, and reads the body as
+     * JSON where it holds JSON. Nothing else about the message is here, because a
+     * pattern naming anything else was refused when the mapping was created.
+     */
+    filterDocumentOf(message: SimSqsPollMessage): Record<string, unknown>;
     private record;
     private messageAttributes;
 }

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

@@ -1,3 +1,4 @@
+import { simLambdaFilterData } from "../filter/sim-lambda-filtered-records.js";
 /**
  * Builds the SQS event for one batch of polled messages.
  *
@@ -17,6 +18,16 @@ export class SimLambdaSqsEventBuilder {
     of(messages) {
         return { Records: messages.map((message) => this.record(message)) };
     }
+    /**
+     * What a mapping's filters read one message as.
+     *
+     * Real Lambda filters an SQS message on its body alone, and reads the body as
+     * JSON where it holds JSON. Nothing else about the message is here, because a
+     * pattern naming anything else was refused when the mapping was created.
+     */
+    filterDocumentOf(message) {
+        return { body: simLambdaFilterData(message.Body) };
+    }
     record(message) {
         return {
             messageId: message.MessageId,

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

@@ -1,6 +1,7 @@
 import type { SimLambdaStreamDestinationConfiguration } from "./sim-lambda-stream-destination-config.js";
 import type { SimLambdaDestinationTargets } from "../destination/sim-lambda-destination-targets.js";
 import type { SimAwsAccountRegionScope } from "../../aws/sim-aws-account-region-scope.js";
+import type { SimLambdaFilterCriteria, SimLambdaFilterCriteriaInput } from "./filter/sim-lambda-filter-criteria.js";
 import type { SimLambdaFunctionArn } from "../function/sim-lambda-function-configuration.js";
 import type { SimLambdaStreamRetryLimits, SimLambdaStreamRetryLimitsConfiguration } from "./sim-lambda-stream-retry-limits.js";
 import type { SimLambdaEventSourceStart, SimLambdaEventSourceStartingPosition } from "./sim-lambda-event-source-starting-position.js";
@@ -35,6 +36,7 @@ interface SimLambdaEventSourceMappingProperties {
     readonly streamRetryLimits?: SimLambdaStreamRetryLimits | undefined;
     readonly destinationConfig?: SimLambdaStreamDestinationConfiguration | undefined;
     readonly destinations?: SimLambdaDestinationTargets | undefined;
+    readonly filterCriteria?: SimLambdaFilterCriteria | undefined;
     readonly createdAt: Date;
 }
 /**
@@ -53,6 +55,7 @@ export interface SimLambdaEventSourceMappingConfiguration extends Partial<SimLam
     readonly StartingPositionTimestamp?: Date | undefined;
     readonly MaximumBatchingWindowInSeconds: number;
     readonly FunctionResponseTypes: readonly SimLambdaFunctionResponseType[];
+    readonly FilterCriteria?: SimLambdaFilterCriteriaInput | undefined;
     readonly State: SimLambdaEventSourceMappingState;
     readonly StateTransitionReason: string;
     readonly LastModified: Date;
@@ -89,6 +92,13 @@ export declare class SimLambdaEventSourceMapping {
      */
     readonly start: SimLambdaEventSourceStart | undefined;
     readonly functionResponseTypes: readonly SimLambdaFunctionResponseType[];
+    /**
+     * The filters a record has to match before it is delivered, if this mapping
+     * was created with any.
+     *
+     * A mapping with none delivers every record its source hands it.
+     */
+    readonly filterCriteria: SimLambdaFilterCriteria | undefined;
     /**
      * When this mapping stops delivering a batch its function keeps failing, for
      * a source that leaves the counting to the mapping.

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

@@ -31,6 +31,13 @@ export class SimLambdaEventSourceMapping {
      */
     start;
     functionResponseTypes;
+    /**
+     * The filters a record has to match before it is delivered, if this mapping
+     * was created with any.
+     *
+     * A mapping with none delivers every record its source hands it.
+     */
+    filterCriteria;
     /**
      * When this mapping stops delivering a batch its function keeps failing, for
      * a source that leaves the counting to the mapping.
@@ -59,6 +66,7 @@ export class SimLambdaEventSourceMapping {
         // cannot change what this mapping does with a batch afterwards.
         this.functionResponseTypes = [...(properties.functionResponseTypes ?? [])];
         this.streamRetryLimits = properties.streamRetryLimits;
+        this.filterCriteria = properties.filterCriteria;
         this.enabled = properties.enabled ?? true;
         this.lastModified = properties.createdAt;
     }
@@ -120,6 +128,9 @@ export class SimLambdaEventSourceMapping {
             // them out rather than reporting a limit it does not have.
             ...this.streamRetryLimits?.configuration(),
             FunctionResponseTypes: this.functionResponseTypes,
+            // A mapping created without filters reports none, as real Lambda does,
+            // rather than reporting an empty list of them.
+            FilterCriteria: this.filterCriteria?.configuration(),
             State: this.#state,
             StateTransitionReason: "USER_INITIATED",
             LastModified: this.lastModified,

package/dist/service/lambda/event-source/stream/sim-lambda-stream-cascade-guard.d.ts

@@ -1,4 +1,15 @@
 import type { SimLambdaEventSourceMapping } from "../sim-lambda-event-source-mapping.js";
+import type { SimLambdaStreamHalt } from "./sim-lambda-stream-halt.js";
+/**
+ * How many deliveries in a row may feed the source that invoked them before the
+ * simulation is refused.
+ *
+ * One write back is a handler doing its job, and the delivery it causes is the
+ * chance for that work to finish. A handler that settles takes two or three
+ * links of chain. A handler that loops takes every link there is, and the
+ * simulation has to say so before the test times out.
+ */
+export declare const simLambdaStreamCascadeLimit = 10;
 /**
  * The source a guard watches, said in the terms its own service uses.
  */
@@ -20,33 +31,49 @@ export interface SimLambdaStreamCascadeSource {
 interface SimLambdaStreamCascadeGuardProperties {
     readonly mapping: SimLambdaEventSourceMapping;
     readonly source: SimLambdaStreamCascadeSource;
+    /**
+     * What a refusal stops, since a mapping polling on from a checkpoint the
+     * refusal left where it was would deliver the same records again.
+     */
+    readonly halt: SimLambdaStreamHalt;
 }
 /**
- * Watches one mapping's deliveries for the function writing back into the
+ * Watches one mapping's deliveries for a chain of the function feeding the
  * source whose stream invoked it.
  *
  * The delivery runs inside its own asynchronous context, so a record written by
  * the handler is told apart from one written by anything else that happened to
  * be running at the same time. That distinction is the whole point: several
  * records written at once are an ordinary batch, and a handler feeding its own
- * source is a loop.
+ * source is the start of a chain.
+ *
+ * What the guard counts is the chain, and never the shape of one write. A
+ * handler that writes back and then finds its own work done writes nothing the
+ * second time round, the chain ends at one link, and the simulation settles. A
+ * handler that writes back every time takes the chain to
+ * `simLambdaStreamCascadeLimit` and is refused there.
  */
 export declare class SimLambdaStreamCascadeGuard {
     private readonly properties;
-    private cascaded;
+    private fedRecords;
+    private chained;
     constructor(properties: SimLambdaStreamCascadeGuardProperties);
     /**
-     * Run one delivery, refusing afterwards if the function fed its own source.
+     * Run one delivery, refusing afterwards if the chain has gone on long enough
+     * to say the simulation will never settle.
      *
      * The refusal comes after the delivery rather than during it, so the handler
-     * sees its own write succeed and the loop is reported to whoever is waiting
+     * sees its own write succeed and the chain is reported to whoever is waiting
      * for the simulation to settle.
      */
     around<Result>(delivery: () => Promise<Result>): Promise<Result>;
     /**
-     * Note a record written to the polled stream, answering with whether this
-     * mapping's own function wrote it.
+     * Note a record written to the polled stream, which counts only while this
+     * mapping's own function is the thing that is running.
+     *
+     * Counted rather than flagged, so a delivery can tell whether the count moved
+     * while it ran without the flag having to be put back afterwards.
      */
-    noteRecordWritten(): boolean;
+    noteRecordWritten(): void;
 }
 export {};