@kensio/yulin 1.21.9 → 1.21.10

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

@@ -19,7 +19,7 @@ export declare class SimCfnLambdaEventSourceMappingProperties {
     private readonly parser;
     constructor(properties: SimCfnLambdaEventSourceMappingPropertiesProperties);
     /**
-     * The create input this Resource asks for, refusing what is not simulated.
+     * The create input this Resource asks for, recording what is left out of it.
      *
      * The event source ARN is read before anything else is judged, as the command
      * reads it first for the same reason: what a mapping may ask for depends on

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

@@ -1,6 +1,6 @@
 import { simLambdaStreamDestinationConfig } from "../../event-source/sim-lambda-stream-destination-config.js";
 import { SimCfnLambdaPropertyParser } from "../function/sim-cfn-lambda-property-parser.js";
-import { assertSimulatedEventSourceMappingProperties } from "./sim-cfn-lambda-event-source-mapping-property-rules.js";
+import { recordUnsimulatedEventSourceMappingProperties } from "./sim-cfn-lambda-event-source-mapping-property-rules.js";
 import { simCfnLambdaTargetFunctionName } from "../function/sim-cfn-lambda-target-function.js";
 /**
  * What a CloudFormation Unix time seconds value is multiplied by to reach the
@@ -24,7 +24,7 @@ export class SimCfnLambdaEventSourceMappingProperties {
         this.properties = properties.properties;
     }
     /**
-     * The create input this Resource asks for, refusing what is not simulated.
+     * The create input this Resource asks for, recording what is left out of it.
      *
      * The event source ARN is read before anything else is judged, as the command
      * reads it first for the same reason: what a mapping may ask for depends on
@@ -32,7 +32,7 @@ export class SimCfnLambdaEventSourceMappingProperties {
      */
     createInput() {
         const eventSourceArn = this.parser.requiredString(this.resource, this.properties["EventSourceArn"], "EventSourceArn");
-        assertSimulatedEventSourceMappingProperties(this.resource, this.properties);
+        recordUnsimulatedEventSourceMappingProperties(this.resource, this.properties);
         return {
             EventSourceArn: eventSourceArn,
             DestinationConfig: simLambdaStreamDestinationConfig(this.properties["DestinationConfig"]),
@@ -42,6 +42,7 @@ export class SimCfnLambdaEventSourceMappingProperties {
             MaximumBatchingWindowInSeconds: this.parser.optionalNumber(this.resource, this.properties["MaximumBatchingWindowInSeconds"], "MaximumBatchingWindowInSeconds"),
             MaximumRetryAttempts: this.parser.optionalNumber(this.resource, this.properties["MaximumRetryAttempts"], "MaximumRetryAttempts"),
             MaximumRecordAgeInSeconds: this.parser.optionalNumber(this.resource, this.properties["MaximumRecordAgeInSeconds"], "MaximumRecordAgeInSeconds"),
+            BisectBatchOnFunctionError: this.parser.optionalBoolean(this.resource, this.properties["BisectBatchOnFunctionError"], "BisectBatchOnFunctionError"),
             StartingPosition: this.parser.optionalString(this.resource, this.properties["StartingPosition"], "StartingPosition"),
             StartingPositionTimestamp: this.startingPositionTimestamp(),
             FunctionResponseTypes: this.functionResponseTypes(),

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

@@ -0,0 +1,30 @@
+/**
+ * The AWS::Lambda::EventSourceMapping properties this simulation acts on.
+ *
+ * The two starting position properties are here rather than among the
+ * unsimulated ones because whether a mapping may carry one is the event
+ * source's own rule: a stream has to be given a position and a queue is refused
+ * for naming one. That is decided by CreateEventSourceMapping, which knows
+ * which source the ARN names, so both are read and passed on. The two
+ * failed-batch limits are read for the same reason: a stream mapping keeps them
+ * and a queue mapping is refused for naming one.
+ */
+export declare const simulatedPropertyNames: ReadonlySet<string>;
+/**
+ * Real AWS::Lambda::EventSourceMapping properties this simulation does not act
+ * on, and what the mapping does in place of each.
+ *
+ * Every one of them changes what the function sees or when it sees it. That is
+ * what the record against the Resource is for. A mapping created without one
+ * still carries the records the template asked for to the function the
+ * template named, and the difference is there to be read.
+ */
+export declare const unsimulatedPropertyReasons: ReadonlyMap<string, string>;
+/**
+ * Why a property name this simulation has never heard of is recorded.
+ *
+ * A typo and a property AWS added after this simulation read the docs look
+ * identical from here. A mapping that deploys with the unread name reported is
+ * more use than a stack that fails over either.
+ */
+export declare const unknownPropertyReason: string;

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

@@ -0,0 +1,91 @@
+/**
+ * The AWS::Lambda::EventSourceMapping properties this simulation acts on.
+ *
+ * The two starting position properties are here rather than among the
+ * unsimulated ones because whether a mapping may carry one is the event
+ * source's own rule: a stream has to be given a position and a queue is refused
+ * for naming one. That is decided by CreateEventSourceMapping, which knows
+ * which source the ARN names, so both are read and passed on. The two
+ * failed-batch limits are read for the same reason: a stream mapping keeps them
+ * and a queue mapping is refused for naming one.
+ */
+export const simulatedPropertyNames = new Set([
+    "BatchSize",
+    "Enabled",
+    "EventSourceArn",
+    "FunctionName",
+    "FunctionResponseTypes",
+    "MaximumBatchingWindowInSeconds",
+    "MaximumRecordAgeInSeconds",
+    "MaximumRetryAttempts",
+    "BisectBatchOnFunctionError",
+    "DestinationConfig",
+    "StartingPosition",
+    "StartingPositionTimestamp",
+]);
+/**
+ * The event sources a mapping property can only be configuring, none of which
+ * this simulation has.
+ *
+ * A mapping naming one of these has an event source ARN to match, and that ARN
+ * is what the mapping is refused on. The property beside it is recorded.
+ */
+const absentEventSource = "the mapping polls the source its EventSourceArn names, and this " +
+    "simulation has SQS queues, DynamoDB streams and Kinesis streams";
+/**
+ * Real AWS::Lambda::EventSourceMapping properties this simulation does not act
+ * on, and what the mapping does in place of each.
+ *
+ * Every one of them changes what the function sees or when it sees it. That is
+ * what the record against the Resource is for. A mapping created without one
+ * still carries the records the template asked for to the function the
+ * template named, and the difference is there to be read.
+ */
+export const unsimulatedPropertyReasons = new Map([
+    ["AmazonManagedKafkaEventSourceConfig", absentEventSource],
+    ["DocumentDBEventSourceConfig", absentEventSource],
+    [
+        "FilterCriteria",
+        "every record on the event source is delivered to the function, unfiltered",
+    ],
+    [
+        "KmsKeyArn",
+        "the key encrypts filter criteria, and filter criteria are not simulated",
+    ],
+    ["MetricsConfig", "the mapping publishes no CloudWatch metrics"],
+    [
+        "ParallelizationFactor",
+        "polling concurrency is not simulated, and each shard of a stream is read " +
+            "by one reader",
+    ],
+    ["ProvisionedPollerConfig", "polling concurrency is not simulated"],
+    ["Queues", absentEventSource],
+    ["ScalingConfig", "polling concurrency is not simulated"],
+    ["SelfManagedEventSource", absentEventSource],
+    ["SelfManagedKafkaEventSourceConfig", absentEventSource],
+    [
+        "SourceAccessConfigurations",
+        "event source authentication is not simulated",
+    ],
+    [
+        "Tags",
+        "the mapping is created without them, and nothing reads them back or " +
+            "groups or bills by them",
+    ],
+    ["Topics", absentEventSource],
+    [
+        "TumblingWindowInSeconds",
+        "a batch carries no window state from the batch before it, and the " +
+            "function is handed no state to return",
+    ],
+]);
+/**
+ * Why a property name this simulation has never heard of is recorded.
+ *
+ * A typo and a property AWS added after this simulation read the docs look
+ * identical from here. A mapping that deploys with the unread name reported is
+ * more use than a stack that fails over either.
+ */
+export const unknownPropertyReason = "it is not an AWS::Lambda::EventSourceMapping property this simulation " +
+    "knows, whether because AWS added it or because the template misspelled " +
+    "something";

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

@@ -1,17 +1,12 @@
 import type { SimCfnResource } from "../../../cloudformation/resource/sim-cfn-resource.js";
 import type { SimCfnTemplateValueRecord } from "../../../cloudformation/template/value/sim-cfn-template-value.js";
 /**
- * Build the error a property of an AWS::Lambda::EventSourceMapping Resource is
- * refused with.
+ * Record everything about an AWS::Lambda::EventSourceMapping Resource that the
+ * mapping is created without.
  *
- * The wording matters: sim CloudFormation skips a Resource whose error reads as
- * an unsupported Resource type, and skipping is the wrong answer for a mapping
- * that cannot be created as the template asks. The stack would deploy with the
- * queue and the function and nothing between them.
+ * Nothing here fails the Resource. A mapping missing one of these settings
+ * still carries records from the source to the function, and a stack that
+ * refused it would take every other Resource down over one line of a template.
+ * What the mapping does instead is in `stack.ignoredProperties`.
  */
-export declare function eventSourceMappingPropertyError(logicalId: string, reason: string): Error;
-/**
- * Refuse everything about an AWS::Lambda::EventSourceMapping Resource that is
- * not simulated, and record what the mapping is created without.
- */
-export declare function assertSimulatedEventSourceMappingProperties(resource: SimCfnResource, properties: SimCfnTemplateValueRecord): void;
+export declare function recordUnsimulatedEventSourceMappingProperties(resource: SimCfnResource, properties: SimCfnTemplateValueRecord): void;

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

@@ -1,100 +1,20 @@
+import { simulatedPropertyNames, unknownPropertyReason, unsimulatedPropertyReasons, } from "./sim-cfn-lambda-event-source-mapping-property-names.js";
 /**
- * The AWS::Lambda::EventSourceMapping properties this simulation acts on.
+ * Record everything about an AWS::Lambda::EventSourceMapping Resource that the
+ * mapping is created without.
  *
- * The two starting position properties are here rather than among the
- * unsimulated ones because whether a mapping may carry one is the event
- * source's own rule: a stream has to be given a position and a queue is refused
- * for naming one. That is decided by CreateEventSourceMapping, which knows
- * which source the ARN names, so both are read and passed on. The two
- * failed-batch limits are read for the same reason: a stream mapping keeps them
- * and a queue mapping is refused for naming one.
+ * Nothing here fails the Resource. A mapping missing one of these settings
+ * still carries records from the source to the function, and a stack that
+ * refused it would take every other Resource down over one line of a template.
+ * What the mapping does instead is in `stack.ignoredProperties`.
  */
-const simulatedPropertyNames = new Set([
-    "BatchSize",
-    "Enabled",
-    "EventSourceArn",
-    "FunctionName",
-    "FunctionResponseTypes",
-    "MaximumBatchingWindowInSeconds",
-    "MaximumRecordAgeInSeconds",
-    "MaximumRetryAttempts",
-    "DestinationConfig",
-    "StartingPosition",
-    "StartingPositionTimestamp",
-]);
-/**
- * Real AWS::Lambda::EventSourceMapping properties this simulation does not
- * model.
- *
- * Every one of them changes what the function sees or when it sees it, so a
- * template asking for one fails the Resource rather than deploying a mapping
- * that quietly ignores it.
- */
-const unsimulatedPropertyNames = new Set([
-    "AmazonManagedKafkaEventSourceConfig",
-    "BisectBatchOnFunctionError",
-    "DocumentDBEventSourceConfig",
-    "FilterCriteria",
-    "KmsKeyArn",
-    "MetricsConfig",
-    "ParallelizationFactor",
-    "ProvisionedPollerConfig",
-    "Queues",
-    "ScalingConfig",
-    "SelfManagedEventSource",
-    "SelfManagedKafkaEventSourceConfig",
-    "SourceAccessConfigurations",
-    "Topics",
-    "TumblingWindowInSeconds",
-]);
-/**
- * Real AWS::Lambda::EventSourceMapping properties this simulation has nothing
- * to act on and no reason to fail a stack over.
- *
- * `Tags` is the whole list. The mapping is created without them and the
- * omission is recorded against the Resource. A mapping delivers the same
- * records with a tag and without one, and a CDK app calling
- * `Tags.of(app).add(...)` tags every mapping in it.
- */
-const ignoredPropertyReasons = new Map([
-    [
-        "Tags",
-        "AWS::Lambda::EventSourceMapping property Tags is not simulated, so the " +
-            "mapping is created without them. Nothing reads them back and nothing " +
-            "is grouped or billed by them.",
-    ],
-]);
-/**
- * Build the error a property of an AWS::Lambda::EventSourceMapping Resource is
- * refused with.
- *
- * The wording matters: sim CloudFormation skips a Resource whose error reads as
- * an unsupported Resource type, and skipping is the wrong answer for a mapping
- * that cannot be created as the template asks. The stack would deploy with the
- * queue and the function and nothing between them.
- */
-export function eventSourceMappingPropertyError(logicalId, reason) {
-    return new Error(`Invalid AWS::Lambda::EventSourceMapping Resource ${logicalId}: ${reason}`);
-}
-/**
- * Refuse everything about an AWS::Lambda::EventSourceMapping Resource that is
- * not simulated, and record what the mapping is created without.
- */
-export function assertSimulatedEventSourceMappingProperties(resource, properties) {
-    const logicalId = resource.logicalId;
+export function recordUnsimulatedEventSourceMappingProperties(resource, properties) {
     for (const name of Object.keys(properties)) {
-        const ignoredReason = ignoredPropertyReasons.get(name);
-        if (ignoredReason !== undefined) {
-            resource.ignoreProperty(name, ignoredReason);
+        if (simulatedPropertyNames.has(name)) {
             continue;
         }
-        if (unsimulatedPropertyNames.has(name)) {
-            throw eventSourceMappingPropertyError(logicalId, `${name} is a real AWS::Lambda::EventSourceMapping property that ` +
-                "this simulation does not simulate, so it is refused rather than " +
-                "ignored");
-        }
-        if (!simulatedPropertyNames.has(name)) {
-            throw eventSourceMappingPropertyError(logicalId, `${name} is not an AWS::Lambda::EventSourceMapping property`);
-        }
+        const reason = unsimulatedPropertyReasons.get(name) ?? unknownPropertyReason;
+        resource.ignoreProperty(name, `AWS::Lambda::EventSourceMapping property ${name} is not simulated: ` +
+            `${reason}.`);
     }
 }

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

@@ -68,6 +68,7 @@ export class SimLambdaEventSourceMappingInput {
             streamRetryLimits: eventSourceArn.retryLimitRules.limitsIn({
                 maximumRetryAttempts: input.MaximumRetryAttempts,
                 maximumRecordAgeInSeconds: input.MaximumRecordAgeInSeconds,
+                bisectBatchOnFunctionError: input.BisectBatchOnFunctionError,
             }),
         });
     }

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

@@ -12,11 +12,6 @@ const unsimulatedInputs = new Map([
     ["FilterCriteria", "event filtering is not simulated"],
     ["ScalingConfig", "polling concurrency is not simulated"],
     ["ProvisionedPollerConfig", "polling concurrency is not simulated"],
-    [
-        "BisectBatchOnFunctionError",
-        "batch bisection is not simulated, so a failing stream batch is retried " +
-            "whole",
-    ],
     [
         "ParallelizationFactor",
         "polling concurrency is not simulated, so each shard of a stream is read " +

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

@@ -66,7 +66,7 @@ export class SimLambdaKinesisShardPoller {
         const { progress } = this;
         // Reading is done as the function's execution role, as on real Lambda, so
         // simulated IAM decides whether this mapping may read its stream.
-        const batch = await this.shard.read(progress.position, this.mapping.batchSize);
+        const batch = await this.shard.read(progress.position, progress.batchSizeWithin(this.mapping.batchSize));
         await processSimLambdaStreamBatch({
             batch,
             progress,

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

@@ -15,7 +15,7 @@ export class SimLambdaDynamoDbStreamPolling {
         const { progress, stream, mapping, delivery } = this.properties;
         // Reading is done as the function's execution role, as on real Lambda, so
         // simulated IAM decides whether this mapping may read its stream.
-        const batch = await stream.read(simFunction.roleArn, progress.position, mapping.batchSize);
+        const batch = await stream.read(simFunction.roleArn, progress.position, progress.batchSizeWithin(mapping.batchSize));
         await processSimLambdaStreamBatch({
             batch,
             progress,

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-progress-state.d.ts

@@ -2,6 +2,7 @@ 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";
@@ -16,6 +17,7 @@ export declare class SimLambdaStreamProgressState {
     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

@@ -3,6 +3,7 @@ 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. */
@@ -11,6 +12,7 @@ export class SimLambdaStreamProgressState {
     failures;
     cursor;
     retry;
+    bisect;
     constructor(properties) {
         const { mapping, background } = properties;
         this.failures = new SimLambdaStreamFailureDestination(mapping);
@@ -22,6 +24,7 @@ export class SimLambdaStreamProgressState {
         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,

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

@@ -15,6 +15,11 @@ export declare class SimLambdaStreamProgress {
      * Where the next read starts.
      */
     get position(): SimLambdaEventSourceStreamPosition;
+    /**
+     * How many records the next read may take, which is the mapping's batch size
+     * until a batch is being bisected.
+     */
+    batchSizeWithin(batchSize: number): number;
     /**
      * Take a read that came back with nothing.
      *
@@ -23,9 +28,17 @@ export declare class SimLambdaStreamProgress {
      * than working out a new one each time.
      */
     caughtUp(batch: SimLambdaEventSourceStreamProgressBatch): void;
+    /**
+     * Drop the records at the front of a batch that are too old to hand over,
+     * answering with where the live ones start.
+     *
+     * Records that aged out are as finished with as records the function took, so
+     * a batch being split counts them off its remainder too.
+     */
     before(records: readonly SimLambdaStreamRecordTime[], batch: SimLambdaEventSourceStreamProgressBatch, simFunction: SimLambdaFunction): Promise<number>;
     /**
-     * Take what became of a batch: move past it, or wait and try it again.
+     * Take what became of a batch: move past it, split it, or wait and try it
+     * again.
      */
     after(outcome: SimLambdaStreamBatchOutcome, batch: SimLambdaEventSourceStreamProgressBatch, simFunction: SimLambdaFunction): Promise<void>;
     /**

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

@@ -17,6 +17,13 @@ export class SimLambdaStreamProgress {
     get position() {
         return this.state.cursor.position;
     }
+    /**
+     * How many records the next read may take, which is the mapping's batch size
+     * until a batch is being bisected.
+     */
+    batchSizeWithin(batchSize) {
+        return this.state.bisect.sizeWithin(batchSize);
+    }
     /**
      * Take a read that came back with nothing.
      *
@@ -27,21 +34,36 @@ export class SimLambdaStreamProgress {
     caughtUp(batch) {
         this.state.cursor.advanceTo(batch.next);
     }
+    /**
+     * Drop the records at the front of a batch that are too old to hand over,
+     * answering with where the live ones start.
+     *
+     * Records that aged out are as finished with as records the function took, so
+     * a batch being split counts them off its remainder too.
+     */
     async before(records, batch, simFunction) {
-        return await this.state.expiry.before(records, batch, simFunction);
+        const firstLive = await this.state.expiry.before(records, batch, simFunction);
+        this.state.bisect.finished(firstLive);
+        return firstLive;
     }
     /**
-     * Take what became of a batch: move past it, or wait and try it again.
+     * Take what became of a batch: move past it, split it, or wait and try it
+     * again.
      */
     async after(outcome, batch, simFunction) {
         this.state.failures.invoked(outcome);
         if (outcome.isHandled) {
+            this.state.bisect.finished(outcome.records.length);
             this.handled(batch);
             return;
         }
+        if (this.state.bisect.split(outcome)) {
+            this.state.retry.reset();
+        }
         const again = this.state.retry.after(outcome, this.position);
         const notification = this.state.failures.deliver(this.state.retry.discarded, batch, simFunction);
         if (again === undefined) {
+            this.state.bisect.finished(outcome.records.length);
             this.handled(batch);
         }
         else {

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

@@ -1,12 +1,13 @@
 import { type SimLambdaEventSourceRetryLimitsInput, SimLambdaStreamRetryLimits } from "./sim-lambda-stream-retry-limits.js";
 /**
- * Whether the event source a mapping names has failed-batch limits at all.
+ * Whether the event source a mapping names decides for itself what becomes of
+ * a failed batch.
  *
- * A stream does: a record stays on the stream whatever the function makes of
- * it, so the mapping is the only thing that decides when to stop trying. A
- * queue does not, because a message the function never handles goes to the
- * queue's own redrive policy, and real Lambda refuses a request that names
- * either limit for one.
+ * A stream leaves it to the mapping: a record stays on the stream whatever the
+ * function makes of it, so the mapping is the only thing that decides when to
+ * stop trying and whether to split the batch first. A queue does not, because a
+ * message the function never handles goes to the queue's own redrive policy,
+ * and real Lambda refuses a request that names any of the three for one.
  */
 export interface SimLambdaEventSourceRetryLimitRules {
     /**
@@ -23,7 +24,7 @@ export declare class SimLambdaNoRetryLimits implements SimLambdaEventSourceRetry
     private readonly insteadDescription;
     constructor(sourceDescription: string, insteadDescription: string);
     /**
-     * Refuse both limits, since this source is not the one counting.
+     * Refuse all three, since this source is not the one counting.
      */
     limitsIn(input: SimLambdaEventSourceRetryLimitsInput): SimLambdaStreamRetryLimits | undefined;
 }

package/dist/service/lambda/event-source/sim-lambda-event-source-retry-limits.js

@@ -11,7 +11,7 @@ export class SimLambdaNoRetryLimits {
         this.insteadDescription = insteadDescription;
     }
     /**
-     * Refuse both limits, since this source is not the one counting.
+     * Refuse all three, since this source is not the one counting.
      */
     limitsIn(input) {
         const named = namedLimit(input);
@@ -40,7 +40,10 @@ function namedLimit(input) {
     if (input.maximumRetryAttempts !== undefined) {
         return "MaximumRetryAttempts";
     }
-    return input.maximumRecordAgeInSeconds === undefined
+    if (input.maximumRecordAgeInSeconds !== undefined) {
+        return "MaximumRecordAgeInSeconds";
+    }
+    return input.bisectBatchOnFunctionError === undefined
         ? undefined
-        : "MaximumRecordAgeInSeconds";
+        : "BisectBatchOnFunctionError";
 }

package/dist/service/lambda/event-source/sim-lambda-stream-retry-limits.d.ts

@@ -9,6 +9,7 @@
 export interface SimLambdaEventSourceRetryLimitsInput {
     readonly maximumRetryAttempts?: number | undefined;
     readonly maximumRecordAgeInSeconds?: number | undefined;
+    readonly bisectBatchOnFunctionError?: boolean | undefined;
 }
 /**
  * The failed-batch limits a mapping reports back, as Lambda names them.
@@ -16,22 +17,29 @@ export interface SimLambdaEventSourceRetryLimitsInput {
 export interface SimLambdaStreamRetryLimitsConfiguration {
     readonly MaximumRetryAttempts: number;
     readonly MaximumRecordAgeInSeconds: number;
+    readonly BisectBatchOnFunctionError: boolean;
 }
 /**
- * When a stream mapping stops delivering a batch its function keeps failing.
+ * What a stream mapping does with a batch its function keeps failing.
  *
- * The two limits are one thing rather than two, because they end the same
- * lifecycle: a record leaves the mapping when it has had its retries or when it
- * is too old to be worth another, whichever comes first. Both are held as
- * Lambda states them, with `-1` for no limit, so a Get or a List reports back
- * exactly what was asked for.
+ * The three settings are one thing rather than three, because they run the same
+ * lifecycle. A failing batch is split around the record that broke it where the
+ * mapping was asked to bisect, and a record leaves the mapping when it has had
+ * its retries or when it is too old to be worth another, whichever comes first.
+ * The limits are held as Lambda states them, with `-1` for no limit, so a Get
+ * or a List reports back exactly what was asked for.
  */
 export declare class SimLambdaStreamRetryLimits {
     readonly maximumRetryAttempts: number;
     readonly maximumRecordAgeInSeconds: number;
+    /**
+     * Whether a batch the function threw on is split in half and delivered again
+     * as two batches.
+     */
+    readonly bisectBatchOnFunctionError: boolean;
     constructor(input?: SimLambdaEventSourceRetryLimitsInput);
     /**
-     * The two limits as a Get, a List or a create response reports them.
+     * The three settings as a Get, a List or a create response reports them.
      */
     configuration(): SimLambdaStreamRetryLimitsConfiguration;
     /**

package/dist/service/lambda/event-source/sim-lambda-stream-retry-limits.js

@@ -23,17 +23,23 @@ const maximumRecordAgeLimit = 604_800;
 const defaultAttemptLimit = 5;
 const millisecondsPerSecond = 1000;
 /**
- * When a stream mapping stops delivering a batch its function keeps failing.
+ * What a stream mapping does with a batch its function keeps failing.
  *
- * The two limits are one thing rather than two, because they end the same
- * lifecycle: a record leaves the mapping when it has had its retries or when it
- * is too old to be worth another, whichever comes first. Both are held as
- * Lambda states them, with `-1` for no limit, so a Get or a List reports back
- * exactly what was asked for.
+ * The three settings are one thing rather than three, because they run the same
+ * lifecycle. A failing batch is split around the record that broke it where the
+ * mapping was asked to bisect, and a record leaves the mapping when it has had
+ * its retries or when it is too old to be worth another, whichever comes first.
+ * The limits are held as Lambda states them, with `-1` for no limit, so a Get
+ * or a List reports back exactly what was asked for.
  */
 export class SimLambdaStreamRetryLimits {
     maximumRetryAttempts;
     maximumRecordAgeInSeconds;
+    /**
+     * Whether a batch the function threw on is split in half and delivered again
+     * as two batches.
+     */
+    bisectBatchOnFunctionError;
     constructor(input = {}) {
         this.maximumRetryAttempts = checkedLimit({
             value: input.maximumRetryAttempts,
@@ -47,14 +53,16 @@ export class SimLambdaStreamRetryLimits {
             maximum: maximumRecordAgeLimit,
             unit: "seconds",
         });
+        this.bisectBatchOnFunctionError = input.bisectBatchOnFunctionError ?? false;
     }
     /**
-     * The two limits as a Get, a List or a create response reports them.
+     * The three settings as a Get, a List or a create response reports them.
      */
     configuration() {
         return {
             MaximumRetryAttempts: this.maximumRetryAttempts,
             MaximumRecordAgeInSeconds: this.maximumRecordAgeInSeconds,
+            BisectBatchOnFunctionError: this.bisectBatchOnFunctionError,
         };
     }
     /**

package/docs/services/lambda/README.md

@@ -2033,6 +2033,41 @@ discarded, and the mapping reads on from behind it.
 10,000 retries, `-1` to 604,800 seconds) is a `ValidationException`. A queue mapping takes neither,
 because a message the handler never takes is left to the queue's own redrive policy.
 
+### Splitting a failed batch around the record that broke it
+
+`BisectBatchOnFunctionError` splits a batch the handler threw on in half, and delivers each half as
+its own batch. A half that fails is split again, down to a single record. That is how the records
+beside a poison record get through, and how the poison record ends up delivered on its own and
+discarded on its own.
+
+```json
+{
+  "StartingPosition": "TRIM_HORIZON",
+  "BatchSize": 100,
+  "MaximumRetryAttempts": 10,
+  "BisectBatchOnFunctionError": true
+}
+```
+
+A batch of four whose third record the handler cannot take is delivered as `1, 2, 3, 4`, then
+`1, 2`, then `3, 4`, then `3` on its own, and finally `4`. The record that broke every batch it was
+in leaves the mapping under the retry and record-age limits, and reaches the
+[failure destination](#sending-discarded-stream-batches-to-a-destination) naming one record rather
+than four.
+
+Splitting puts the retry count back to the start, so a batch always reaches a single record before
+the count decides anything. Once it is down to one record, the limits count as they do for any other
+failing batch. A batch the handler reported partial failures on is left whole, because the report
+already says which record to go back to.
+
+The halves carry the batch that failed and nothing else. A record written while the splitting is
+going on waits behind it and is delivered as part of the batch after it, and the mapping reads at its
+own batch size again once the whole of the split batch is through.
+
+`GetEventSourceMapping` and `ListEventSourceMappings` report the setting, and
+`AWS::Lambda::EventSourceMapping` takes it in a template. Both stream sources have it. A queue
+mapping is refused for naming it, the way real Lambda refuses one.
+
 ### Sending discarded stream batches to a destination
 
 DynamoDB Streams and Kinesis mappings accept `DestinationConfig.OnFailure` with a standard SQS
@@ -2324,8 +2359,15 @@ this, and deploys without hand-editing. The grant CDK writes alongside it is an
 the three stream actions on the stream ARN and `dynamodb:ListStreams` on every stream, exactly what
 the mapping's execution-role check is looking for.
 
-The properties a non-default `DynamoEventSource` adds are refused by name. Those are
-`FilterCriteria`, `ParallelizationFactor`, `BisectBatchOnFunctionError` and `TumblingWindowInSeconds`.
+`bisectBatchOnError` is simulated, and is covered under
+[Splitting a failed batch around the record that broke it](#splitting-a-failed-batch-around-the-record-that-broke-it).
+The other properties a non-default `DynamoEventSource` adds are recorded rather than acted on. Those
+are `FilterCriteria`, `ParallelizationFactor` and `TumblingWindowInSeconds`.
+The mapping deploys, delivers every record whole and unfiltered, and each property it was created
+without is listed in
+[`stack.ignoredProperties`](https://yulinsim.dev/services/cloudformation/#properties-a-resource-was-created-without "Properties a Resource was created without")
+with what the mapping does in its place. `CreateEventSourceMapping` still refuses the same
+properties, since a caller naming one is asking for behaviour by hand.
 
 A hand-written template or a SAM application usually gives the function the AWS managed policy
 `AWSLambdaDynamoDBExecutionRole` instead. Simulated IAM has no model for managed policy ARNs, so
@@ -4297,11 +4339,12 @@ Current documented limitations:
   function, and `S3ObjectVersion` on `UpdateFunctionCode`. A versioned location loads the object as
   it stands.
 - SQS queues, DynamoDB streams and Kinesis streams are the only event sources. Kafka, DocumentDB and
-  Kinesis enhanced fan-out consumers are refused outright, and so are `FilterCriteria`,
-  `ScalingConfig`, `BisectBatchOnFunctionError`, `ParallelizationFactor`,
-  `TumblingWindowInSeconds` and the other mapping inputs this simulation has no behaviour for. An
-  `AWS::Lambda::EventSourceMapping` carrying `Tags` is the exception, and deploys with the tags
-  dropped and the property recorded.
+  Kinesis enhanced fan-out consumers are refused outright. `CreateEventSourceMapping` also refuses
+  `FilterCriteria`, `ScalingConfig`, `ParallelizationFactor`, `TumblingWindowInSeconds` and the
+  other inputs this simulation has no behaviour for. An
+  `AWS::Lambda::EventSourceMapping` naming any of them deploys instead, and records each one against
+  the Resource (see
+  [Properties a Resource was created without](https://yulinsim.dev/services/cloudformation/#properties-a-resource-was-created-without "Properties a Resource was created without")).
 - A failed stream batch waits 1, 2, 4, 8 and 16 seconds between attempts, where AWS documents no
   delay. That is deliberate. A delay of zero falls due at the instant the clock already reads, and a
   handler that always throws would leave `advanceBy` with work falling due forever. A mapping that
@@ -4309,6 +4352,10 @@ Current documented limitations:
   discards the batch, where AWS goes on until the records age out a day later. A batch item failure
   report counts against the same retries, and never starts them again for the records it rewound
   to.
+- Splitting a batch under `BisectBatchOnFunctionError` puts the retry count back to the start, where
+  AWS counts a bisected batch's deliveries against the same quota. 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. The
+  splitting still ends on its own, because a batch halves at every step.
 - A handler writing into the table whose stream invoked it is refused with
   `SimLambdaStreamCascadeError` rather than being delivered its own writes forever. Real Lambda runs
   that loop.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kensio/yulin",
-  "version": "1.21.9",
+  "version": "1.21.10",
   "description": "AWS system behaviour simulation for isolated unit testing",
   "repository": "https://github.com/KensioSoftware/yulin",
   "homepage": "https://yulinsim.dev/",