@kensio/yulin 1.21.21 → 1.21.23

package/dist/service/lambda/command/event-source-mapping/create-event-source-mapping-input.d.ts

@@ -2,6 +2,7 @@ import { type SimLambdaStreamDestinationConfiguration } from "../../event-source
 import type { SimAwsAccountRegionScope } from "../../../aws/sim-aws-account-region-scope.js";
 import { type SimLambdaEventSourceArn } from "../../event-source/sim-lambda-event-source-arn.js";
 import type { SimLambdaFunctionResponseType } from "../../event-source/sim-lambda-event-source-mapping.js";
+import { SimLambdaFilterCriteria } from "../../event-source/filter/sim-lambda-filter-criteria.js";
 import type { SimLambdaStreamRetryLimits } from "../../event-source/sim-lambda-stream-retry-limits.js";
 import type { SimLambdaEventSourceStart } from "../../event-source/sim-lambda-event-source-starting-position.js";
 import type { SimCreateEventSourceMappingCommandInput } from "./event-source-mapping.command.js";
@@ -36,6 +37,10 @@ export declare class SimLambdaEventSourceMappingInput {
      * the counting to the mapping.
      */
     readonly streamRetryLimits: SimLambdaStreamRetryLimits | undefined;
+    /**
+     * The filters this mapping delivers through, if it was created with any.
+     */
+    readonly filterCriteria: SimLambdaFilterCriteria | undefined;
     private constructor();
     /**
      * Read a CreateEventSourceMapping request, refusing what this simulation

package/dist/service/lambda/command/event-source-mapping/create-event-source-mapping-input.js

@@ -1,5 +1,6 @@
 import { simLambdaStreamDestinationConfig, } from "../../event-source/sim-lambda-stream-destination-config.js";
 import { simLambdaEventSourceArnOf, } from "../../event-source/sim-lambda-event-source-arn.js";
+import { SimLambdaFilterCriteria } from "../../event-source/filter/sim-lambda-filter-criteria.js";
 import { SimLambdaInvalidParameterValueException } from "../../error/sim-lambda.error.js";
 import { simLambdaFunctionReferenceOf } from "../../function/sim-lambda-function-reference.js";
 import { functionResponseTypesIn, requiredString, } from "./create-event-source-mapping-values.js";
@@ -35,6 +36,10 @@ export class SimLambdaEventSourceMappingInput {
      * the counting to the mapping.
      */
     streamRetryLimits;
+    /**
+     * The filters this mapping delivers through, if it was created with any.
+     */
+    filterCriteria;
     constructor(properties) {
         this.eventSourceArn = properties.eventSourceArn;
         this.functionName = properties.functionName;
@@ -45,6 +50,7 @@ export class SimLambdaEventSourceMappingInput {
         this.functionResponseTypes = properties.functionResponseTypes;
         this.destinationConfig = properties.destinationConfig;
         this.streamRetryLimits = properties.streamRetryLimits;
+        this.filterCriteria = properties.filterCriteria;
     }
     /**
      * Read a CreateEventSourceMapping request, refusing what this simulation
@@ -65,6 +71,7 @@ export class SimLambdaEventSourceMappingInput {
             }),
             enabled: input.Enabled ?? true,
             functionResponseTypes: functionResponseTypesIn(input),
+            filterCriteria: SimLambdaFilterCriteria.of(input.FilterCriteria, eventSourceArn.kind),
             streamRetryLimits: eventSourceArn.retryLimitRules.limitsIn({
                 maximumRetryAttempts: input.MaximumRetryAttempts,
                 maximumRecordAgeInSeconds: input.MaximumRecordAgeInSeconds,

package/dist/service/lambda/command/event-source-mapping/create-event-source-mapping-refusals.js

@@ -9,7 +9,6 @@ import { SimLambdaInvalidParameterValueException } from "../../error/sim-lambda.
  * would not have.
  */
 const unsimulatedInputs = new Map([
-    ["FilterCriteria", "event filtering is not simulated"],
     ["ScalingConfig", "polling concurrency is not simulated"],
     ["ProvisionedPollerConfig", "polling concurrency is not simulated"],
     [

package/dist/service/lambda/command/event-source-mapping/create-event-source-mapping.handler.js

@@ -81,6 +81,7 @@ export class CreateEventSourceMappingCommandHandler {
             enabled: input.enabled,
             functionResponseTypes: input.functionResponseTypes,
             streamRetryLimits: input.streamRetryLimits,
+            filterCriteria: input.filterCriteria,
             destinationConfig: input.destinationConfig,
             destinations: this.properties.destinations,
             createdAt: this.properties.background.now(),

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

@@ -1,3 +1,4 @@
+import type { SimLambdaFilterCriteriaInput } from "../../event-source/filter/sim-lambda-filter-criteria.js";
 /**
  * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/lambda/command/CreateEventSourceMappingCommand/
  *
@@ -31,7 +32,7 @@ export interface SimCreateEventSourceMappingCommandInput {
     readonly BatchSize?: number | undefined;
     readonly MaximumBatchingWindowInSeconds?: number | undefined;
     readonly FunctionResponseTypes?: readonly string[] | undefined;
-    readonly FilterCriteria?: object | undefined;
+    readonly FilterCriteria?: SimLambdaFilterCriteriaInput | undefined;
     readonly ScalingConfig?: object | undefined;
     readonly DestinationConfig?: object | undefined;
     readonly SelfManagedEventSource?: object | undefined;

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

@@ -1,7 +1 @@
-/**
- * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/lambda/command/CreateEventSourceMappingCommand/
- *
- * The event source mapping commands share their output shape, because every one
- * of them reports the mapping it acted on, so they share one module.
- */
 export {};

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

@@ -0,0 +1,48 @@
+/**
+ * The `FilterCriteria` a CreateEventSourceMapping request carries, as the
+ * command takes it.
+ */
+export interface SimLambdaFilterCriteriaInput {
+    readonly Filters?: readonly {
+        readonly Pattern?: string | undefined;
+    }[] | undefined;
+}
+/**
+ * Read a `FilterCriteria` value of unknown shape, as a template carries one.
+ *
+ * The same shape check for an SDK request and a CloudFormation Resource, so a
+ * mapping a template deployed filters the way an SDK caller's would.
+ */
+export declare function simLambdaFilterCriteriaInput(value: unknown): SimLambdaFilterCriteriaInput | undefined;
+/**
+ * The filters a mapping delivers through, read from what a request asked for.
+ *
+ * A record is delivered when any one of the filters matches it, which is how
+ * real Lambda ORs a list of patterns together. A mapping with no criteria has
+ * none of these, and delivers everything.
+ *
+ * The patterns are EventBridge event patterns. Lambda documents its filter
+ * rules as EventBridge's own syntax, so simulated EventBridge's matcher is what
+ * evaluates them, down to the operators it refuses.
+ */
+export declare class SimLambdaFilterCriteria {
+    private readonly patterns;
+    private constructor();
+    /**
+     * Read the criteria a request carries, refusing a pattern this simulation
+     * cannot evaluate.
+     *
+     * The refusal comes before the mapping exists, because a mapping created
+     * with a filter it cannot apply would deliver the wrong records rather than
+     * none.
+     */
+    static of(criteria: SimLambdaFilterCriteriaInput | undefined, eventSourceKind: string): SimLambdaFilterCriteria | undefined;
+    /**
+     * The criteria as Create, Get and List report them back.
+     */
+    configuration(): SimLambdaFilterCriteriaInput;
+    /**
+     * Whether a record, as a pattern reads it, passes any of these filters.
+     */
+    matches(document: Record<string, unknown>): boolean;
+}

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

@@ -0,0 +1,129 @@
+import { SimEventPattern } from "../../../eventbridge/pattern/sim-event-pattern.js";
+import { SimLambdaInvalidParameterValueException } from "../../error/sim-lambda.error.js";
+import { isRecord } from "../../../../util/type-guard/record.js";
+/**
+ * The one key an SQS mapping may filter on.
+ *
+ * Real Lambda filters an SQS message on its body alone, where a stream mapping
+ * filters on the whole record. A pattern naming anything else is refused here,
+ * since accepting one would match nothing and read as a pattern that was
+ * simply too specific.
+ */
+const sqsFilterKey = "body";
+/**
+ * Read a `FilterCriteria` value of unknown shape, as a template carries one.
+ *
+ * The same shape check for an SDK request and a CloudFormation Resource, so a
+ * mapping a template deployed filters the way an SDK caller's would.
+ */
+export function simLambdaFilterCriteriaInput(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const filters = isRecord(value) ? value["Filters"] : undefined;
+    if (!Array.isArray(filters)) {
+        throw new SimLambdaInvalidParameterValueException(`FilterCriteria carries a Filters list, and this one carries ${JSON.stringify(value)}`);
+    }
+    return { Filters: filters.map((filter) => ({ Pattern: patternIn(filter) })) };
+}
+/**
+ * The pattern one filter of a list carries.
+ */
+function patternIn(filter) {
+    const pattern = isRecord(filter) ? filter["Pattern"] : undefined;
+    if (pattern !== undefined && typeof pattern !== "string") {
+        throw new SimLambdaInvalidParameterValueException("A filter in FilterCriteria carries a Pattern string, and this one " +
+            `carries ${JSON.stringify(pattern)}`);
+    }
+    return pattern;
+}
+/**
+ * The filters a mapping delivers through, read from what a request asked for.
+ *
+ * A record is delivered when any one of the filters matches it, which is how
+ * real Lambda ORs a list of patterns together. A mapping with no criteria has
+ * none of these, and delivers everything.
+ *
+ * The patterns are EventBridge event patterns. Lambda documents its filter
+ * rules as EventBridge's own syntax, so simulated EventBridge's matcher is what
+ * evaluates them, down to the operators it refuses.
+ */
+export class SimLambdaFilterCriteria {
+    patterns;
+    constructor(patterns) {
+        this.patterns = patterns;
+    }
+    /**
+     * Read the criteria a request carries, refusing a pattern this simulation
+     * cannot evaluate.
+     *
+     * The refusal comes before the mapping exists, because a mapping created
+     * with a filter it cannot apply would deliver the wrong records rather than
+     * none.
+     */
+    static of(criteria, eventSourceKind) {
+        const filters = criteria?.Filters ?? [];
+        if (filters.length === 0) {
+            return undefined;
+        }
+        return new this(filters.map((filter) => patternOf(filter.Pattern, eventSourceKind)));
+    }
+    /**
+     * The criteria as Create, Get and List report them back.
+     */
+    configuration() {
+        return {
+            Filters: this.patterns.map((pattern) => ({ Pattern: pattern.source })),
+        };
+    }
+    /**
+     * Whether a record, as a pattern reads it, passes any of these filters.
+     */
+    matches(document) {
+        return this.patterns.some((pattern) => pattern.matches(document));
+    }
+}
+/**
+ * One filter's pattern, refused as a Lambda parameter rather than as an
+ * EventBridge one.
+ *
+ * The matcher is EventBridge's and says so when it refuses a pattern, and the
+ * caller here sent a Lambda request. The reason survives and the exception type
+ * changes.
+ */
+function patternOf(source, eventSourceKind) {
+    if (source === undefined || source === "") {
+        throw new SimLambdaInvalidParameterValueException("A filter in FilterCriteria carries a Pattern, and this one carries " +
+            "none");
+    }
+    refuseUnfilterableKeys(source, eventSourceKind);
+    try {
+        return SimEventPattern.of(source);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new SimLambdaInvalidParameterValueException(`FilterCriteria pattern ${source} cannot be evaluated. ${reason}`);
+    }
+}
+/**
+ * Refuse a pattern naming a key the event source does not filter on.
+ */
+function refuseUnfilterableKeys(source, eventSourceKind) {
+    if (eventSourceKind !== "sqs") {
+        return;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(source);
+    }
+    catch {
+        // An unparseable pattern is the matcher's refusal to make, in its own
+        // words, and it is about to make it.
+        return;
+    }
+    const named = isRecord(parsed) ? Object.keys(parsed) : [];
+    const unfilterable = named.filter((key) => key !== sqsFilterKey);
+    if (unfilterable.length > 0) {
+        throw new SimLambdaInvalidParameterValueException(`FilterCriteria on an SQS event source mapping filters on ${sqsFilterKey} alone, and this pattern names ${unfilterable.join(", ")}`);
+    }
+}

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

@@ -0,0 +1,27 @@
+import type { SimLambdaFilterCriteria } from "./sim-lambda-filter-criteria.js";
+interface SimLambdaFilteredDeliveryProperties<RecordType, Outcome> {
+    readonly criteria: SimLambdaFilterCriteria | undefined;
+    readonly records: readonly RecordType[];
+    /**
+     * What a pattern reads one record as, which is the source's translation.
+     */
+    readonly documentOf: (record: RecordType) => Record<string, unknown>;
+    /**
+     * What becomes of a batch the filters emptied.
+     */
+    readonly handled: () => Outcome;
+    /**
+     * Hand the records that matched to the function.
+     */
+    readonly invoke: (delivered: readonly RecordType[]) => Promise<Outcome>;
+}
+/**
+ * Deliver the records of a batch a mapping's filters let through.
+ *
+ * A batch the filters emptied is finished with and the function is never
+ * invoked, which is the one rule every source shares. What being finished with
+ * means is the source's own, and so is what a pattern reads a record as, so
+ * both are handed in.
+ */
+export declare function simLambdaFilteredDelivery<RecordType, Outcome>(properties: SimLambdaFilteredDeliveryProperties<RecordType, Outcome>): Promise<Outcome>;
+export {};

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

@@ -0,0 +1,15 @@
+import { simLambdaFilteredRecords } from "./sim-lambda-filtered-records.js";
+/**
+ * Deliver the records of a batch a mapping's filters let through.
+ *
+ * A batch the filters emptied is finished with and the function is never
+ * invoked, which is the one rule every source shares. What being finished with
+ * means is the source's own, and so is what a pattern reads a record as, so
+ * both are handed in.
+ */
+export async function simLambdaFilteredDelivery(properties) {
+    const delivered = simLambdaFilteredRecords(properties.criteria, properties.records, properties.documentOf);
+    return delivered.length === 0
+        ? properties.handled()
+        : await properties.invoke(delivered);
+}

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