@kensio/yulin 1.2.0 → 1.3.0

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

@@ -0,0 +1,40 @@
+/**
+ * What a turn is taken on behalf of.
+ */
+export interface SimLambdaEventSourcePolls {
+    /**
+     * Poll once.
+     */
+    poll(): Promise<void>;
+    /**
+     * Poll again as soon as the simulation gets to it.
+     */
+    pollNow(): void;
+}
+/**
+ * One poll at a time, remembering a wake-up that arrived during one.
+ *
+ * A stream mapping cannot have two polls overlapping. Reading a stream record
+ * leaves it where it is, unlike receiving a message, so a second poll reading
+ * from the same checkpoint would hand the same records to the function again.
+ *
+ * Dropping the second poll instead is not safe either. The poll schedule clears
+ * its own flag when the task starts rather than when it finishes, so a write
+ * landing mid-poll does schedule a further poll, and a poll that returned
+ * without noting it would leave those records sitting until an unrelated later
+ * write happened to wake the mapping.
+ */
+export declare class SimLambdaEventSourcePollTurn {
+    private readonly poller;
+    private running;
+    private asked;
+    constructor(poller: SimLambdaEventSourcePolls);
+    /**
+     * Take a turn, or note that one was asked for while a turn is being taken.
+     *
+     * The poll asked for during a turn is scheduled once the turn is over rather
+     * than run here, so the two never overlap.
+     */
+    take(): Promise<void>;
+}
+//# sourceMappingURL=sim-lambda-event-source-poll-turn.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-event-source-poll-turn.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/poll/sim-lambda-event-source-poll-turn.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC;;OAEG;IACH,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEtB;;OAEG;IACH,OAAO,IAAI,IAAI,CAAC;CACjB;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,4BAA4B;IACvC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA4B;IACnD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,KAAK,CAAS;IAEtB,YAAY,MAAM,EAAE,yBAAyB,EAE5C;IAED;;;;;OAKG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAmB1B;CACF"}

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

@@ -0,0 +1,45 @@
+/**
+ * One poll at a time, remembering a wake-up that arrived during one.
+ *
+ * A stream mapping cannot have two polls overlapping. Reading a stream record
+ * leaves it where it is, unlike receiving a message, so a second poll reading
+ * from the same checkpoint would hand the same records to the function again.
+ *
+ * Dropping the second poll instead is not safe either. The poll schedule clears
+ * its own flag when the task starts rather than when it finishes, so a write
+ * landing mid-poll does schedule a further poll, and a poll that returned
+ * without noting it would leave those records sitting until an unrelated later
+ * write happened to wake the mapping.
+ */
+export class SimLambdaEventSourcePollTurn {
+    poller;
+    running = false;
+    asked = false;
+    constructor(poller) {
+        this.poller = poller;
+    }
+    /**
+     * Take a turn, or note that one was asked for while a turn is being taken.
+     *
+     * The poll asked for during a turn is scheduled once the turn is over rather
+     * than run here, so the two never overlap.
+     */
+    async take() {
+        if (this.running) {
+            this.asked = true;
+            return;
+        }
+        this.running = true;
+        try {
+            await this.poller.poll();
+        }
+        finally {
+            this.running = false;
+            if (this.asked) {
+                this.asked = false;
+                this.poller.pollNow();
+            }
+        }
+    }
+}
+//# sourceMappingURL=sim-lambda-event-source-poll-turn.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-event-source-poll-turn.js","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/poll/sim-lambda-event-source-poll-turn.ts"],"names":[],"mappings":"AAeA;;;;;;;;;;;;GAYG;AACH,MAAM,OAAO,4BAA4B;IACtB,MAAM,CAA4B;IAC3C,OAAO,GAAG,KAAK,CAAC;IAChB,KAAK,GAAG,KAAK,CAAC;IAEtB,YAAY,MAAiC;QAC3C,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,IAAI;QACR,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;YAElB,OAAO;QACT,CAAC;QAED,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QAEpB,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;QAC3B,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;YAErB,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;gBACf,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;gBACnB,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACxB,CAAC;QACH,CAAC;IACH,CAAC;CACF"}

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

@@ -3,12 +3,14 @@ import type { SimLambdaFunctionLookup } from "../../function/url/sim-lambda-func
 import type { SimLambdaEventSourceQueues } from "../queue/sim-lambda-event-source-queues.js";
 import type { SimLambdaEventSourceArn } from "../sim-lambda-event-source-arn.js";
 import type { SimLambdaEventSourceMapping } from "../sim-lambda-event-source-mapping.js";
+import type { SimLambdaEventSourceStreams } from "../stream/sim-lambda-event-source-streams.js";
 import type { SimLambdaEventSourcePoller } from "./sim-lambda-event-source-poller.js";
 export interface SimLambdaEventSourcePollerProperties {
     readonly mapping: SimLambdaEventSourceMapping;
     readonly eventSourceArn: SimLambdaEventSourceArn;
     readonly functions: SimLambdaFunctionLookup;
     readonly queues: SimLambdaEventSourceQueues;
+    readonly streams: SimLambdaEventSourceStreams;
     readonly background: BackgroundScheduler;
 }
 /**
@@ -16,10 +18,9 @@ export interface SimLambdaEventSourcePollerProperties {
  *
  * Which poller a mapping gets is decided here rather than by whoever starts
  * one, so adding a kind of source is a change here rather than a change to
- * everything a poller touches. There is one kind so far, so this hands the ARN
- * straight to the queue poller: the queue poller only accepts a queue ARN, so a
- * second kind of source fails to compile here rather than being polled as a
- * queue.
+ * everything a poller touches. Each poller only accepts the ARN of the source
+ * it polls, so a source given to the wrong one fails to compile here rather
+ * than being polled as something it is not.
  */
 export declare function makeSimLambdaEventSourcePoller(properties: SimLambdaEventSourcePollerProperties): SimLambdaEventSourcePoller;
 //# sourceMappingURL=sim-lambda-event-source-poller-factory.d.ts.map

package/dist/service/lambda/event-source/poll/sim-lambda-event-source-poller-factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sim-lambda-event-source-poller-factory.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/poll/sim-lambda-event-source-poller-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AACrF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kDAAkD,CAAC;AAChG,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,4CAA4C,CAAC;AAC7F,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,mCAAmC,CAAC;AACjF,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,uCAAuC,CAAC;AACzF,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,qCAAqC,CAAC;AAGtF,MAAM,WAAW,oCAAoC;IACnD,QAAQ,CAAC,OAAO,EAAE,2BAA2B,CAAC;IAC9C,QAAQ,CAAC,cAAc,EAAE,uBAAuB,CAAC;IACjD,QAAQ,CAAC,SAAS,EAAE,uBAAuB,CAAC;IAC5C,QAAQ,CAAC,MAAM,EAAE,0BAA0B,CAAC;IAC5C,QAAQ,CAAC,UAAU,EAAE,mBAAmB,CAAC;CAC1C;AAED;;;;;;;;;GASG;AACH,wBAAgB,8BAA8B,CAC5C,UAAU,EAAE,oCAAoC,GAC/C,0BAA0B,CAI5B"}
+{"version":3,"file":"sim-lambda-event-source-poller-factory.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/poll/sim-lambda-event-source-poller-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AACrF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kDAAkD,CAAC;AAChG,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,4CAA4C,CAAC;AAC7F,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,mCAAmC,CAAC;AACjF,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,uCAAuC,CAAC;AACzF,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,8CAA8C,CAAC;AAEhG,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,qCAAqC,CAAC;AAGtF,MAAM,WAAW,oCAAoC;IACnD,QAAQ,CAAC,OAAO,EAAE,2BAA2B,CAAC;IAC9C,QAAQ,CAAC,cAAc,EAAE,uBAAuB,CAAC;IACjD,QAAQ,CAAC,SAAS,EAAE,uBAAuB,CAAC;IAC5C,QAAQ,CAAC,MAAM,EAAE,0BAA0B,CAAC;IAC5C,QAAQ,CAAC,OAAO,EAAE,2BAA2B,CAAC;IAC9C,QAAQ,CAAC,UAAU,EAAE,mBAAmB,CAAC;CAC1C;AAED;;;;;;;;GAQG;AACH,wBAAgB,8BAA8B,CAC5C,UAAU,EAAE,oCAAoC,GAC/C,0BAA0B,CAkB5B"}

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

@@ -1,16 +1,29 @@
+import { SimLambdaDynamoDbStreamEventSourcePoller } from "./sim-lambda-dynamodb-stream-event-source-poller.js";
 import { SimLambdaSqsEventSourcePoller } from "./sim-lambda-sqs-event-source-poller.js";
 /**
  * The poller for the kind of event source a mapping names.
  *
  * Which poller a mapping gets is decided here rather than by whoever starts
  * one, so adding a kind of source is a change here rather than a change to
- * everything a poller touches. There is one kind so far, so this hands the ARN
- * straight to the queue poller: the queue poller only accepts a queue ARN, so a
- * second kind of source fails to compile here rather than being polled as a
- * queue.
+ * everything a poller touches. Each poller only accepts the ARN of the source
+ * it polls, so a source given to the wrong one fails to compile here rather
+ * than being polled as something it is not.
  */
 export function makeSimLambdaEventSourcePoller(properties) {
     const { eventSourceArn } = properties;
-    return new SimLambdaSqsEventSourcePoller({ ...properties, eventSourceArn });
+    switch (eventSourceArn.kind) {
+        case "sqs": {
+            return new SimLambdaSqsEventSourcePoller({
+                ...properties,
+                eventSourceArn,
+            });
+        }
+        case "dynamodb-stream": {
+            return new SimLambdaDynamoDbStreamEventSourcePoller({
+                ...properties,
+                eventSourceArn,
+            });
+        }
+    }
 }
 //# sourceMappingURL=sim-lambda-event-source-poller-factory.js.map

package/dist/service/lambda/event-source/poll/sim-lambda-event-source-poller-factory.js.map

@@ -1 +1 @@
-{"version":3,"file":"sim-lambda-event-source-poller-factory.js","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/poll/sim-lambda-event-source-poller-factory.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,6BAA6B,EAAE,MAAM,yCAAyC,CAAC;AAUxF;;;;;;;;;GASG;AACH,MAAM,UAAU,8BAA8B,CAC5C,UAAgD;IAEhD,MAAM,EAAE,cAAc,EAAE,GAAG,UAAU,CAAC;IAEtC,OAAO,IAAI,6BAA6B,CAAC,EAAE,GAAG,UAAU,EAAE,cAAc,EAAE,CAAC,CAAC;AAC9E,CAAC"}
+{"version":3,"file":"sim-lambda-event-source-poller-factory.js","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/poll/sim-lambda-event-source-poller-factory.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,wCAAwC,EAAE,MAAM,qDAAqD,CAAC;AAE/G,OAAO,EAAE,6BAA6B,EAAE,MAAM,yCAAyC,CAAC;AAWxF;;;;;;;;GAQG;AACH,MAAM,UAAU,8BAA8B,CAC5C,UAAgD;IAEhD,MAAM,EAAE,cAAc,EAAE,GAAG,UAAU,CAAC;IAEtC,QAAQ,cAAc,CAAC,IAAI,EAAE,CAAC;QAC5B,KAAK,KAAK,EAAE,CAAC;YACX,OAAO,IAAI,6BAA6B,CAAC;gBACvC,GAAG,UAAU;gBACb,cAAc;aACf,CAAC,CAAC;QACL,CAAC;QAED,KAAK,iBAAiB,EAAE,CAAC;YACvB,OAAO,IAAI,wCAAwC,CAAC;gBAClD,GAAG,UAAU;gBACb,cAAc;aACf,CAAC,CAAC;QACL,CAAC;IACH,CAAC;AACH,CAAC"}

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

@@ -0,0 +1,37 @@
+import type { SimLambdaEventSourceStreamPosition } from "../stream/sim-lambda-event-source-streams.js";
+/**
+ * What became of one batch of stream records handed to a function.
+ *
+ * A queue batch splits into the messages that were handled and the ones that
+ * go back, because each message is deleted or returned on its own. A stream
+ * batch does not split. The mapping holds one place on the shard, so the answer
+ * is one place: either the batch is finished with, or reading goes back to a
+ * record and everything from there is delivered again.
+ */
+export declare class SimLambdaStreamBatchOutcome {
+    readonly isHandled: boolean;
+    private readonly rewindTo;
+    private constructor();
+    /**
+     * A batch the function took in full.
+     */
+    static handled(): SimLambdaStreamBatchOutcome;
+    /**
+     * A batch the function did not take, which is read again from where it was.
+     */
+    static failed(): SimLambdaStreamBatchOutcome;
+    /**
+     * A batch the function reported failing partway through, which is read again
+     * from the record it named.
+     */
+    static failedFrom(sequenceNumber: string): SimLambdaStreamBatchOutcome;
+    /**
+     * Where the next read starts when the batch goes back.
+     *
+     * A batch that failed whole goes back to where it was read from, which is the
+     * place handed in. One the function reported on goes back to the record it
+     * named, which may be behind or ahead of that place.
+     */
+    retryPosition(readFrom: SimLambdaEventSourceStreamPosition): SimLambdaEventSourceStreamPosition;
+}
+//# sourceMappingURL=sim-lambda-stream-batch-outcome.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-stream-batch-outcome.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/poll/sim-lambda-stream-batch-outcome.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,8CAA8C,CAAC;AAEvG;;;;;;;;GAQG;AACH,qBAAa,2BAA2B;IACtC,SAAgB,SAAS,EAAE,OAAO,CAAC;IAEnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqB;IAE9C,OAAO,eAGN;IAED;;OAEG;IACH,MAAM,CAAC,OAAO,IAAI,2BAA2B,CAE5C;IAED;;OAEG;IACH,MAAM,CAAC,MAAM,IAAI,2BAA2B,CAE3C;IAED;;;OAGG;IACH,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,MAAM,GAAG,2BAA2B,CAErE;IAED;;;;;;OAMG;IACH,aAAa,CACX,QAAQ,EAAE,kCAAkC,GAC3C,kCAAkC,CAQpC;CACF"}

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

@@ -0,0 +1,51 @@
+/**
+ * What became of one batch of stream records handed to a function.
+ *
+ * A queue batch splits into the messages that were handled and the ones that
+ * go back, because each message is deleted or returned on its own. A stream
+ * batch does not split. The mapping holds one place on the shard, so the answer
+ * is one place: either the batch is finished with, or reading goes back to a
+ * record and everything from there is delivered again.
+ */
+export class SimLambdaStreamBatchOutcome {
+    isHandled;
+    rewindTo;
+    constructor(isHandled, rewindTo) {
+        this.isHandled = isHandled;
+        this.rewindTo = rewindTo;
+    }
+    /**
+     * A batch the function took in full.
+     */
+    static handled() {
+        return new SimLambdaStreamBatchOutcome(true, undefined);
+    }
+    /**
+     * A batch the function did not take, which is read again from where it was.
+     */
+    static failed() {
+        return new SimLambdaStreamBatchOutcome(false, undefined);
+    }
+    /**
+     * A batch the function reported failing partway through, which is read again
+     * from the record it named.
+     */
+    static failedFrom(sequenceNumber) {
+        return new SimLambdaStreamBatchOutcome(false, sequenceNumber);
+    }
+    /**
+     * Where the next read starts when the batch goes back.
+     *
+     * A batch that failed whole goes back to where it was read from, which is the
+     * place handed in. One the function reported on goes back to the record it
+     * named, which may be behind or ahead of that place.
+     */
+    retryPosition(readFrom) {
+        const sequenceNumber = this.rewindTo;
+        if (sequenceNumber === undefined) {
+            return readFrom;
+        }
+        return { kind: "sequence", sequenceNumber };
+    }
+}
+//# sourceMappingURL=sim-lambda-stream-batch-outcome.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-stream-batch-outcome.js","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/poll/sim-lambda-stream-batch-outcome.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,MAAM,OAAO,2BAA2B;IACtB,SAAS,CAAU;IAElB,QAAQ,CAAqB;IAE9C,YAAoB,SAAkB,EAAE,QAA4B;QAClE,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,OAAO;QACZ,OAAO,IAAI,2BAA2B,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;IAC1D,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,MAAM;QACX,OAAO,IAAI,2BAA2B,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;IAC3D,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,UAAU,CAAC,cAAsB;QACtC,OAAO,IAAI,2BAA2B,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC;IAChE,CAAC;IAED;;;;;;OAMG;IACH,aAAa,CACX,QAA4C;QAE5C,MAAM,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC;QAErC,IAAI,cAAc,KAAK,SAAS,EAAE,CAAC;YACjC,OAAO,QAAQ,CAAC;QAClB,CAAC;QAED,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,cAAc,EAAE,CAAC;IAC9C,CAAC;CACF"}

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

@@ -0,0 +1,29 @@
+import type { SimLambdaEventSourceStreamRecord } from "../stream/sim-lambda-event-source-streams.js";
+import { SimLambdaStreamBatchOutcome } from "./sim-lambda-stream-batch-outcome.js";
+/**
+ * Reads what a function said about the batch of stream records it was given.
+ *
+ * A sibling of the queue's batch response rather than a variation on it, and
+ * the rule is the one AWS states for a stream: the lowest sequence number the
+ * report names becomes the checkpoint, and everything from there is delivered
+ * again. Records after it that the function did handle are delivered again too,
+ * which is why a stream consumer has to be idempotent.
+ *
+ * A report naming a record that was not in the batch returns the whole batch,
+ * as it does for a queue: the alternative is to guess which record was meant,
+ * and guessing wrong on a stream skips records rather than repeating them.
+ */
+export declare class SimLambdaStreamBatchResponse {
+    private readonly batchItemFailures;
+    constructor(reportsBatchItemFailures: boolean);
+    /**
+     * What became of a batch the function returned from.
+     */
+    handled(records: readonly SimLambdaEventSourceStreamRecord[], result: unknown): SimLambdaStreamBatchOutcome;
+    /**
+     * What becomes of a batch the function threw on: the whole of it is read
+     * again.
+     */
+    failed(): SimLambdaStreamBatchOutcome;
+}
+//# sourceMappingURL=sim-lambda-stream-batch-response.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-stream-batch-response.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/poll/sim-lambda-stream-batch-response.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,8CAA8C,CAAC;AAErG,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAEnF;;;;;;;;;;;;GAYG;AACH,qBAAa,4BAA4B;IACvC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAA6B;IAE/D,YAAY,wBAAwB,EAAE,OAAO,EAI5C;IAED;;OAEG;IACH,OAAO,CACL,OAAO,EAAE,SAAS,gCAAgC,EAAE,EACpD,MAAM,EAAE,OAAO,GACd,2BAA2B,CAc7B;IAED;;;OAGG;IACH,MAAM,IAAI,2BAA2B,CAEpC;CACF"}

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

@@ -0,0 +1,71 @@
+import { SimLambdaBatchItemFailures } from "./sim-lambda-batch-item-failures.js";
+import { SimLambdaStreamBatchOutcome } from "./sim-lambda-stream-batch-outcome.js";
+/**
+ * Reads what a function said about the batch of stream records it was given.
+ *
+ * A sibling of the queue's batch response rather than a variation on it, and
+ * the rule is the one AWS states for a stream: the lowest sequence number the
+ * report names becomes the checkpoint, and everything from there is delivered
+ * again. Records after it that the function did handle are delivered again too,
+ * which is why a stream consumer has to be idempotent.
+ *
+ * A report naming a record that was not in the batch returns the whole batch,
+ * as it does for a queue: the alternative is to guess which record was meant,
+ * and guessing wrong on a stream skips records rather than repeating them.
+ */
+export class SimLambdaStreamBatchResponse {
+    batchItemFailures;
+    constructor(reportsBatchItemFailures) {
+        this.batchItemFailures = new SimLambdaBatchItemFailures(reportsBatchItemFailures);
+    }
+    /**
+     * What became of a batch the function returned from.
+     */
+    handled(records, result) {
+        const failedIds = this.batchItemFailures.idsIn(result);
+        if (failedIds === undefined) {
+            return SimLambdaStreamBatchOutcome.handled();
+        }
+        const rewindTo = rewindPoint(failedIds, sequenceNumbersOf(records));
+        if (rewindTo === undefined) {
+            return this.failed();
+        }
+        return SimLambdaStreamBatchOutcome.failedFrom(rewindTo);
+    }
+    /**
+     * What becomes of a batch the function threw on: the whole of it is read
+     * again.
+     */
+    failed() {
+        return SimLambdaStreamBatchOutcome.failed();
+    }
+}
+/**
+ * The sequence numbers a batch's records can be named by, in stream order.
+ *
+ * A record carrying none is left out rather than given an empty name, so a
+ * report entry with no identifier names nothing and the whole batch goes back.
+ */
+function sequenceNumbersOf(records) {
+    return records.flatMap((record) => {
+        const sequenceNumber = record.dynamodb?.SequenceNumber;
+        if (sequenceNumber === undefined || sequenceNumber === "") {
+            return [];
+        }
+        return [sequenceNumber];
+    });
+}
+/**
+ * The record a report sends the mapping back to, or undefined for a report it
+ * cannot be trusted.
+ *
+ * The batch is in stream order, so the first record the report names is the
+ * lowest sequence number it named.
+ */
+function rewindPoint(failedIds, sequenceNumbers) {
+    if (failedIds.some((failedId) => !sequenceNumbers.includes(failedId))) {
+        return undefined;
+    }
+    return sequenceNumbers.find((sequenceNumber) => failedIds.includes(sequenceNumber));
+}
+//# sourceMappingURL=sim-lambda-stream-batch-response.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-stream-batch-response.js","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/poll/sim-lambda-stream-batch-response.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,0BAA0B,EAAE,MAAM,qCAAqC,CAAC;AACjF,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAEnF;;;;;;;;;;;;GAYG;AACH,MAAM,OAAO,4BAA4B;IACtB,iBAAiB,CAA6B;IAE/D,YAAY,wBAAiC;QAC3C,IAAI,CAAC,iBAAiB,GAAG,IAAI,0BAA0B,CACrD,wBAAwB,CACzB,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,OAAO,CACL,OAAoD,EACpD,MAAe;QAEf,MAAM,SAAS,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAEvD,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YAC5B,OAAO,2BAA2B,CAAC,OAAO,EAAE,CAAC;QAC/C,CAAC;QAED,MAAM,QAAQ,GAAG,WAAW,CAAC,SAAS,EAAE,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAAC;QAEpE,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC3B,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC;QACvB,CAAC;QAED,OAAO,2BAA2B,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;IAC1D,CAAC;IAED;;;OAGG;IACH,MAAM;QACJ,OAAO,2BAA2B,CAAC,MAAM,EAAE,CAAC;IAC9C,CAAC;CACF;AAED;;;;;GAKG;AACH,SAAS,iBAAiB,CACxB,OAAoD;IAEpD,OAAO,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE;QAChC,MAAM,cAAc,GAAG,MAAM,CAAC,QAAQ,EAAE,cAAc,CAAC;QAEvD,IAAI,cAAc,KAAK,SAAS,IAAI,cAAc,KAAK,EAAE,EAAE,CAAC;YAC1D,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,OAAO,CAAC,cAAc,CAAC,CAAC;IAC1B,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;GAMG;AACH,SAAS,WAAW,CAClB,SAA4B,EAC5B,eAAkC;IAElC,IAAI,SAAS,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,eAAe,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC;QACtE,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,OAAO,eAAe,CAAC,IAAI,CAAC,CAAC,cAAc,EAAE,EAAE,CAC7C,SAAS,CAAC,QAAQ,CAAC,cAAc,CAAC,CACnC,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,36 @@
+import type { SimLambdaEventSourceStartingPosition } from "../sim-lambda-event-source-starting-position.js";
+import type { SimLambdaEventSourceStreamPosition } from "../stream/sim-lambda-event-source-streams.js";
+import type { SimLambdaStreamBatchOutcome } from "./sim-lambda-stream-batch-outcome.js";
+/**
+ * How far along its stream one mapping has got.
+ *
+ * This is the difference between a stream and a queue. A queue hands a message
+ * out and hides it, so a failed batch is the queue's problem afterwards. A
+ * stream hands out a place, and the reader is the only thing that remembers it,
+ * so a batch that failed is read again from exactly where it was. The
+ * checkpoint therefore only moves when a batch is finished with: handled, or
+ * discarded after its retries.
+ */
+export declare class SimLambdaStreamCheckpoint {
+    #private;
+    constructor(startingPosition: SimLambdaEventSourceStartingPosition);
+    /**
+     * Where the next read starts.
+     */
+    get position(): SimLambdaEventSourceStreamPosition;
+    /**
+     * Move past a batch that is finished with.
+     */
+    advanceTo(position: SimLambdaEventSourceStreamPosition): void;
+    /**
+     * Take a batch the function did not finish.
+     *
+     * A batch that failed whole is read again from where it was. One the function
+     * reported failing partway through moves the checkpoint to the record it
+     * named, so that record and everything after it goes over again, including
+     * the records after it that the function did handle. The records before it
+     * are finished with.
+     */
+    retry(outcome: SimLambdaStreamBatchOutcome): void;
+}
+//# sourceMappingURL=sim-lambda-stream-checkpoint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-stream-checkpoint.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/poll/sim-lambda-stream-checkpoint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oCAAoC,EAAE,MAAM,iDAAiD,CAAC;AAC5G,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,8CAA8C,CAAC;AACvG,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAExF;;;;;;;;;GASG;AACH,qBAAa,yBAAyB;;IAGpC,YAAY,gBAAgB,EAAE,oCAAoC,EAEjE;IAED;;OAEG;IACH,IAAI,QAAQ,IAAI,kCAAkC,CAEjD;IAED;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,kCAAkC,GAAG,IAAI,CAE5D;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,OAAO,EAAE,2BAA2B,GAAG,IAAI,CAEhD;CACF"}

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

@@ -0,0 +1,41 @@
+/**
+ * How far along its stream one mapping has got.
+ *
+ * This is the difference between a stream and a queue. A queue hands a message
+ * out and hides it, so a failed batch is the queue's problem afterwards. A
+ * stream hands out a place, and the reader is the only thing that remembers it,
+ * so a batch that failed is read again from exactly where it was. The
+ * checkpoint therefore only moves when a batch is finished with: handled, or
+ * discarded after its retries.
+ */
+export class SimLambdaStreamCheckpoint {
+    #position;
+    constructor(startingPosition) {
+        this.#position = { kind: "starting", startingPosition };
+    }
+    /**
+     * Where the next read starts.
+     */
+    get position() {
+        return this.#position;
+    }
+    /**
+     * Move past a batch that is finished with.
+     */
+    advanceTo(position) {
+        this.#position = position;
+    }
+    /**
+     * Take a batch the function did not finish.
+     *
+     * A batch that failed whole is read again from where it was. One the function
+     * reported failing partway through moves the checkpoint to the record it
+     * named, so that record and everything after it goes over again, including
+     * the records after it that the function did handle. The records before it
+     * are finished with.
+     */
+    retry(outcome) {
+        this.#position = outcome.retryPosition(this.#position);
+    }
+}
+//# sourceMappingURL=sim-lambda-stream-checkpoint.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-stream-checkpoint.js","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/poll/sim-lambda-stream-checkpoint.ts"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,MAAM,OAAO,yBAAyB;IACpC,SAAS,CAAqC;IAE9C,YAAY,gBAAsD;QAChE,IAAI,CAAC,SAAS,GAAG,EAAE,IAAI,EAAE,UAAU,EAAE,gBAAgB,EAAE,CAAC;IAC1D,CAAC;IAED;;OAEG;IACH,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED;;OAEG;IACH,SAAS,CAAC,QAA4C;QACpD,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;IAC5B,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,OAAoC;QACxC,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACzD,CAAC;CACF"}

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

@@ -0,0 +1,65 @@
+import type { BackgroundScheduler, BackgroundTask } from "../../../../util/background/background.js";
+import type { SimLambdaEventSourceMapping } from "../sim-lambda-event-source-mapping.js";
+import type { SimLambdaEventSourceStreamBatch, SimLambdaEventSourceStreamPosition } from "../stream/sim-lambda-event-source-streams.js";
+import type { SimLambdaStreamBatchOutcome } from "./sim-lambda-stream-batch-outcome.js";
+interface SimLambdaStreamProgressProperties {
+    readonly mapping: SimLambdaEventSourceMapping;
+    readonly background: BackgroundScheduler;
+    readonly poll: BackgroundTask;
+}
+/**
+ * How far along its stream one mapping has got, and what it does next.
+ *
+ * The two belong together because they are the same decision. A batch the
+ * function took moves the checkpoint and the mapping reads on; a batch it threw
+ * on leaves the checkpoint where it is and the mapping tries the same records
+ * again after a wait; a batch it reported failing partway through moves the
+ * checkpoint back to the record it named. Nothing behind a failing batch is
+ * read until it is through, which is what it means for a stream mapping to
+ * block its shard.
+ */
+export declare class SimLambdaStreamProgress {
+    private readonly checkpoint;
+    private readonly backoff;
+    private readonly schedule;
+    constructor(properties: SimLambdaStreamProgressProperties);
+    /**
+     * Poll as soon as the simulation gets to it.
+     */
+    pollNow(): void;
+    /**
+     * Where the next read starts.
+     */
+    get position(): SimLambdaEventSourceStreamPosition;
+    /**
+     * Take a read that came back with nothing.
+     *
+     * The place is still worth keeping: it is what a starting position of LATEST
+     * resolves to, so the mapping settles on one place to read on from rather
+     * than working out a new one each time.
+     */
+    caughtUp(batch: SimLambdaEventSourceStreamBatch): void;
+    /**
+     * Take what became of a batch: move past it, or wait and try it again.
+     */
+    after(outcome: SimLambdaStreamBatchOutcome, batch: SimLambdaEventSourceStreamBatch): void;
+    /**
+     * Move past a batch the function took, and read on.
+     */
+    handled(batch: SimLambdaEventSourceStreamBatch): void;
+    /**
+     * Wait and hand a failed batch over again, or give up on it.
+     *
+     * Giving up discards the records and carries on with the stream, which is
+     * what AWS does when a stream mapping's error handling runs out. Parking the
+     * shard instead would be a simulator invention.
+     *
+     * A report naming a record moves the checkpoint before the wait, so what goes
+     * over again is the batch from that record on. The attempts are still counted
+     * against the same limit: a batch that keeps failing partway through has as
+     * many tries as one that keeps failing whole.
+     */
+    failed(outcome: SimLambdaStreamBatchOutcome, batch: SimLambdaEventSourceStreamBatch): void;
+}
+export {};
+//# sourceMappingURL=sim-lambda-stream-progress.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-stream-progress.d.ts","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/poll/sim-lambda-stream-progress.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,cAAc,EACf,MAAM,2CAA2C,CAAC;AAEnD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,uCAAuC,CAAC;AACzF,OAAO,KAAK,EACV,+BAA+B,EAC/B,kCAAkC,EACnC,MAAM,8CAA8C,CAAC;AAEtD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAIxF,UAAU,iCAAiC;IACzC,QAAQ,CAAC,OAAO,EAAE,2BAA2B,CAAC;IAC9C,QAAQ,CAAC,UAAU,EAAE,mBAAmB,CAAC;IACzC,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;CAC/B;AAED;;;;;;;;;;GAUG;AACH,qBAAa,uBAAuB;IAClC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA4B;IACvD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqC;IAC7D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmC;IAE5D,YAAY,UAAU,EAAE,iCAAiC,EASxD;IAED;;OAEG;IACH,OAAO,IAAI,IAAI,CAEd;IAED;;OAEG;IACH,IAAI,QAAQ,IAAI,kCAAkC,CAEjD;IAED;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK,EAAE,+BAA+B,GAAG,IAAI,CAErD;IAED;;OAEG;IACH,KAAK,CACH,OAAO,EAAE,2BAA2B,EACpC,KAAK,EAAE,+BAA+B,GACrC,IAAI,CAQN;IAED;;OAEG;IACH,OAAO,CAAC,KAAK,EAAE,+BAA+B,GAAG,IAAI,CAOpD;IAED;;;;;;;;;;;OAWG;IACH,MAAM,CACJ,OAAO,EAAE,2BAA2B,EACpC,KAAK,EAAE,+BAA+B,GACrC,IAAI,CASN;CACF"}

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

@@ -0,0 +1,92 @@
+import { assertDefined } from "../../../../util/type-guard/defined.js";
+import { SimLambdaEventSourcePollSchedule } from "./sim-lambda-event-source-poll-schedule.js";
+import { SimLambdaStreamCheckpoint } from "./sim-lambda-stream-checkpoint.js";
+import { SimLambdaStreamRetryBackoff } from "./sim-lambda-stream-retry-backoff.js";
+/**
+ * How far along its stream one mapping has got, and what it does next.
+ *
+ * The two belong together because they are the same decision. A batch the
+ * function took moves the checkpoint and the mapping reads on; a batch it threw
+ * on leaves the checkpoint where it is and the mapping tries the same records
+ * again after a wait; a batch it reported failing partway through moves the
+ * checkpoint back to the record it named. Nothing behind a failing batch is
+ * read until it is through, which is what it means for a stream mapping to
+ * block its shard.
+ */
+export class SimLambdaStreamProgress {
+    checkpoint;
+    backoff = new SimLambdaStreamRetryBackoff();
+    schedule;
+    constructor(properties) {
+        // A stream mapping is refused at creation unless it names a starting
+        // position, so one that has got this far without one is the simulator
+        // having gone wrong rather than a request having been wrong.
+        const { startingPosition } = properties.mapping;
+        assertDefined(startingPosition, "DynamoDB stream mapping start position");
+        this.checkpoint = new SimLambdaStreamCheckpoint(startingPosition);
+        this.schedule = new SimLambdaEventSourcePollSchedule(properties);
+    }
+    /**
+     * Poll as soon as the simulation gets to it.
+     */
+    pollNow() {
+        this.schedule.now();
+    }
+    /**
+     * Where the next read starts.
+     */
+    get position() {
+        return this.checkpoint.position;
+    }
+    /**
+     * Take a read that came back with nothing.
+     *
+     * The place is still worth keeping: it is what a starting position of LATEST
+     * resolves to, so the mapping settles on one place to read on from rather
+     * than working out a new one each time.
+     */
+    caughtUp(batch) {
+        this.checkpoint.advanceTo(batch.next);
+    }
+    /**
+     * Take what became of a batch: move past it, or wait and try it again.
+     */
+    after(outcome, batch) {
+        if (outcome.isHandled) {
+            this.handled(batch);
+            return;
+        }
+        this.failed(outcome, batch);
+    }
+    /**
+     * Move past a batch the function took, and read on.
+     */
+    handled(batch) {
+        this.backoff.reset();
+        this.checkpoint.advanceTo(batch.next);
+        if (!batch.drained) {
+            this.schedule.now();
+        }
+    }
+    /**
+     * Wait and hand a failed batch over again, or give up on it.
+     *
+     * Giving up discards the records and carries on with the stream, which is
+     * what AWS does when a stream mapping's error handling runs out. Parking the
+     * shard instead would be a simulator invention.
+     *
+     * A report naming a record moves the checkpoint before the wait, so what goes
+     * over again is the batch from that record on. The attempts are still counted
+     * against the same limit: a batch that keeps failing partway through has as
+     * many tries as one that keeps failing whole.
+     */
+    failed(outcome, batch) {
+        if (this.backoff.isExhausted) {
+            this.handled(batch);
+            return;
+        }
+        this.checkpoint.retry(outcome);
+        this.schedule.afterSeconds(this.backoff.nextSeconds());
+    }
+}
+//# sourceMappingURL=sim-lambda-stream-progress.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-lambda-stream-progress.js","sourceRoot":"","sources":["../../../../../src/service/lambda/event-source/poll/sim-lambda-stream-progress.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAMvE,OAAO,EAAE,gCAAgC,EAAE,MAAM,4CAA4C,CAAC;AAE9F,OAAO,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AAC9E,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAQnF;;;;;;;;;;GAUG;AACH,MAAM,OAAO,uBAAuB;IACjB,UAAU,CAA4B;IACtC,OAAO,GAAG,IAAI,2BAA2B,EAAE,CAAC;IAC5C,QAAQ,CAAmC;IAE5D,YAAY,UAA6C;QACvD,qEAAqE;QACrE,sEAAsE;QACtE,6DAA6D;QAC7D,MAAM,EAAE,gBAAgB,EAAE,GAAG,UAAU,CAAC,OAAO,CAAC;QAChD,aAAa,CAAC,gBAAgB,EAAE,wCAAwC,CAAC,CAAC;QAE1E,IAAI,CAAC,UAAU,GAAG,IAAI,yBAAyB,CAAC,gBAAgB,CAAC,CAAC;QAClE,IAAI,CAAC,QAAQ,GAAG,IAAI,gCAAgC,CAAC,UAAU,CAAC,CAAC;IACnE,CAAC;IAED;;OAEG;IACH,OAAO;QACL,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;IACtB,CAAC;IAED;;OAEG;IACH,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC;IAClC,CAAC;IAED;;;;;;OAMG;IACH,QAAQ,CAAC,KAAsC;QAC7C,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACxC,CAAC;IAED;;OAEG;IACH,KAAK,CACH,OAAoC,EACpC,KAAsC;QAEtC,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;YACtB,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAEpB,OAAO;QACT,CAAC;QAED,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IAC9B,CAAC;IAED;;OAEG;IACH,OAAO,CAAC,KAAsC;QAC5C,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;QACrB,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAEtC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;YACnB,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;QACtB,CAAC;IACH,CAAC;IAED;;;;;;;;;;;OAWG;IACH,MAAM,CACJ,OAAoC,EACpC,KAAsC;QAEtC,IAAI,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC;YAC7B,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAEpB,OAAO;QACT,CAAC;QAED,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAC/B,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IACzD,CAAC;CACF"}