effect-dynamodb 1.27.0 → 1.28.0

package/dist/internal/EventProjection.js

@@ -0,0 +1,695 @@
+/**
+ * EventStore projections (#151) — read models folded from a change feed that
+ * take their order from the event store, not from delivery.
+ *
+ * DynamoDB Streams orders records per item only, and a transaction's records
+ * carry no grouping or order, so a stream's events reach a consumer in any
+ * order. A projection groups a batch's events by row, sorts and
+ * deduplicates them, reads from the store only the versions the batch lacks
+ * (one strongly consistent `readFrom`), folds, and writes the read-model row
+ * once, conditioned on the checkpoint it read. See
+ * `docs/designs/eventstore-projections.md`.
+ *
+ * Re-exported from `EventStore`; this module only type-imports it.
+ *
+ * @internal
+ */
+import { ConcurrentModification, StreamRecordIdentifierMissing, ValidationError, } from "@effect-dynamodb/schema/Errors.js";
+import { DateTime, Effect, Option, Pipeable, Result, Schedule, Stream } from "effect";
+import * as Query from "../Query.js";
+import { asItem, condition as entityCondition, consistentRead as entityConsistentRead, } from "./EntityCombinators.js";
+import { imageEntityType } from "./Packed.js";
+const identify = (record, index, options) => {
+    const [itemIdentifier, member] = "identifier" in options
+        ? [options.identifier(record), "identifier"]
+        : options.source === "lambda"
+            ? [record.dynamodb?.SequenceNumber, "dynamodb.SequenceNumber"]
+            : [record.eventID, "eventID"];
+    return typeof itemIdentifier === "string" && itemIdentifier.length > 0
+        ? Effect.succeed(itemIdentifier)
+        : Effect.fail(new StreamRecordIdentifierMissing({ index, member }));
+};
+/**
+ * The partial batch response (`ReportBatchItemFailures`) for `failedRecords`:
+ * each identified by `dynamodb.SequenceNumber` for a Lambda event source
+ * mapping, by `eventID` for an EventBridge Pipe, or by your own `identifier`
+ * accessor.
+ *
+ * Lambda checkpoints at the lowest reported sequence number and redelivers
+ * every record from there, so reporting the earliest failed record of each
+ * row is enough. A record without an identifier fails with
+ * `StreamRecordIdentifierMissing` — an empty one would fail the whole batch
+ * silently — so fail the invocation, and the source redelivers the batch.
+ */
+export const batchResponse = (failedRecords, options) => Effect.forEach(failedRecords, (record, i) => identify(record, i, options)).pipe(Effect.map((ids) => ({ batchItemFailures: ids.map((itemIdentifier) => ({ itemIdentifier })) })));
+const markerIndex = (operation, streams) => {
+    const index = new Map();
+    for (const entry of streams) {
+        const existing = index.get(entry[1].eventMarker);
+        if (existing !== undefined) {
+            throw new Error(`[EDD-9082] ${operation}: "${existing[0]}" and "${entry[0]}" both store events as ` +
+                `"${entry[1].eventMarker}", so their images can't be told apart. Give the streams ` +
+                "distinct names.");
+        }
+        index.set(entry[1].eventMarker, entry);
+    }
+    return index;
+};
+/**
+ * One decoder for several streams' change-feed images. Name the streams in a
+ * record; `decode(image)` dispatches on the image's `__edd_e__` and returns
+ * `{ stream: <name>, event }`, or `Option.none()` for anything that is not one
+ * of their events (snapshots, idempotency sentinels, entities, other streams).
+ * The image is decoded by that stream's `decodeStreamImage`, so it accepts the
+ * same shapes (DynamoDB JSON with `B` as base64 or bytes, or unmarshalled).
+ *
+ * Two streams storing events under the same marker throw `[EDD-9082]`.
+ *
+ * @example
+ * ```ts
+ * const decode = EventStore.decoder({ Order: OrderEvents, Payment: PaymentEvents })
+ * const decoded = yield* decode(record.dynamodb.NewImage)
+ * if (Option.isSome(decoded) && decoded.value.stream === "Order") { ... }
+ * ```
+ */
+export const decoder = (streams) => {
+    const index = markerIndex("EventStore.decoder", Object.entries(streams));
+    return (image) => {
+        const entry = typeof image === "object" && image !== null && !Array.isArray(image)
+            ? index.get(imageEntityType(image) ?? "")
+            : undefined;
+        if (entry === undefined)
+            return Effect.succeed(Option.none());
+        const [name, stream] = entry;
+        return stream
+            .decodeStreamImage(image)
+            .pipe(Effect.map((event) => Option.map(event, (e) => ({ stream: name, event: e }))));
+    };
+};
+/**
+ * The filter pattern that selects the `INSERT`s of these streams' event items
+ * — `JSON.stringify` it into `FilterCriteria.Filters[].Pattern` of a Lambda
+ * event source mapping or an EventBridge Pipe. Snapshots, idempotency
+ * sentinels and other items are filtered out before the function runs.
+ */
+export const eventFilterPattern = (streams) => {
+    const list = Array.isArray(streams)
+        ? streams
+        : Object.values(streams);
+    const markers = [...new Set(list.map((s) => s.eventMarker))];
+    return { eventName: ["INSERT"], dynamodb: { NewImage: { __edd_e__: { S: markers } } } };
+};
+// ---------------------------------------------------------------------------
+// EventProjection
+// ---------------------------------------------------------------------------
+const EventProjectionTypeId = Symbol.for("effect-dynamodb/EventProjection");
+/** @internal See {@link EventProjection}'s decode member. */
+export const ProjectionDecode = Symbol.for("effect-dynamodb/EventProjection/Decode");
+/**
+ * The projection's own lost-race signal: another writer advanced the row
+ * between this call's read and its conditional write. Kept apart from a
+ * `ConcurrentModification` that `evolve` or the read model's own write path
+ * raises, which is not retried; mapped to `ConcurrentModification` when the
+ * retries run out.
+ */
+class LostRace {
+    key;
+    constructor(key) {
+        this.key = key;
+    }
+}
+/**
+ * The default lost-race policy: up to 12 retries, jittered and growing from
+ * 5 ms by 1.5× (about 1.3 s in all). Each round of a race has one winner, so
+ * `n` concurrent writers of one row can take `n` rounds.
+ */
+const defaultRetry = Schedule.max([
+    Schedule.jittered(Schedule.exponential("5 millis", 1.5)),
+    Schedule.recurs(12),
+]);
+/** The `retry` option as a schedule. */
+const retrySchedule = (retry) => (retry === undefined
+    ? defaultRetry
+    : typeof retry === "number"
+        ? Schedule.recurs(retry)
+        : retry);
+/** The model's declared fields, when its schema exposes them. */
+const modelFields = (model) => {
+    const fields = model.fields;
+    return typeof fields === "object" && fields !== null ? Object.keys(fields) : undefined;
+};
+/**
+ * Define a change-feed projection of `stream` into `readModel` — rows keyed by
+ * `key(streamId, event)` (one per stream instance when the key ignores the
+ * event), each folded from `initial(streamId, event)` through `evolve`, its
+ * checkpoint kept in `checkpoint`. See {@link EventProjection} for the
+ * operations.
+ *
+ * The read model must be a plain entity: `versioned` (the checkpoint is the
+ * version), `softDelete` (rows are never deleted) and `timeSeries` read
+ * models throw `[EDD-9081]`, as do a checkpoint the model has no field for and
+ * a non-integer offset.
+ *
+ * @example
+ * ```ts
+ * const OrderSummaryProjection = EventStore.projection({
+ *   stream: OrderEvents,
+ *   readModel: OrderSummaries,
+ *   key: (id) => ({ orderId: id.orderId }),
+ *   initial: (id) => ({ orderId: id.orderId, status: "open", total: 0, version: 0 }),
+ *   evolve: (state, event) => Effect.succeed(next(state, event.data)),
+ *   checkpoint: "version",
+ * })
+ * ```
+ */
+export const projection = (config) => {
+    const { stream, readModel } = config;
+    const label = `EventStore.projection("${stream.streamName}" → "${readModel.entityType}")`;
+    const refuse = (problem) => {
+        throw new Error(`[EDD-9081] ${label}: ${problem}`);
+    };
+    if (readModel.versioned) {
+        refuse("the read model is `versioned`. The projection's checkpoint is the row's version, and a " +
+            "versioned put adds its own lock — use a plain entity with a numeric checkpoint field.");
+    }
+    if (readModel.softDelete) {
+        refuse("the read model has `softDelete`; a projection never deletes its rows.");
+    }
+    if (readModel.timeSeries) {
+        refuse("the read model is a `timeSeries` entity, written by `append`, not `put`.");
+    }
+    const field = (typeof config.checkpoint === "string" ? config.checkpoint : config.checkpoint.field);
+    const offset = typeof config.checkpoint === "string" ? 0 : (config.checkpoint.offset ?? 0);
+    const fields = modelFields(readModel.model);
+    if (fields !== undefined && !fields.includes(field)) {
+        refuse(`the checkpoint field "${field}" is not a field of the read model.`);
+    }
+    if (!Number.isInteger(offset)) {
+        refuse(`the checkpoint offset ${offset} is not an integer.`);
+    }
+    const schedule = retrySchedule(config.retry);
+    const createdAtField = readModel.systemFields.createdAt;
+    /** A synchronous user callback, its throw this row's `ValidationError`. */
+    const call = (name, f) => Effect.try({
+        try: f,
+        catch: (cause) => new ValidationError({
+            entityType: readModel.entityType,
+            operation: `EventStore.projection.${name}`,
+            cause,
+        }),
+    });
+    /**
+     * The row, read strongly consistent — with its `Hidden` fields (the default
+     * decode drops them, and the whole-row `put` needs them back) and its
+     * `createdAt`; none when there is none.
+     */
+    const readRow = (key) => asItem(entityConsistentRead(readModel.get(key))).pipe(Effect.map((item) => {
+        let state = item;
+        if (fields !== undefined) {
+            state = {};
+            for (const f of fields)
+                if (item[f] !== undefined)
+                    state[f] = item[f];
+        }
+        return Option.some({
+            state: (readModel._attachPrototype?.(state) ?? state),
+            createdAt: createdAtField === null ? undefined : item[createdAtField],
+        });
+    }), Effect.catchTag("ItemNotFound", () => Effect.succeed(Option.none())));
+    /** The stream version a row is at — its checkpoint, offset removed. */
+    const versionOf = (row) => Option.isSome(row) ? Number(row.value.state[field]) - offset : 0;
+    /**
+     * Write the folded state at `version`, conditioned on the row still being at
+     * the version read (`create` when there was no row), carrying its
+     * `createdAt` over. A failed condition is a lost race, which the caller's
+     * retry re-reads after.
+     */
+    const writeRow = (streamId, key, state, version, row) => Effect.gen(function* () {
+        const checkpointed = { ...state, [field]: version + offset };
+        const written = config.toItem === undefined
+            ? checkpointed
+            : yield* call("toItem", () => config.toItem(checkpointed, { streamId, key }));
+        const item = { ...written, [field]: version + offset };
+        if (Option.isNone(row)) {
+            return yield* readModel.create(item).asEffect().pipe(Effect.catchTag("ConditionalCheckFailed", () => Effect.fail(new LostRace(key))));
+        }
+        // A whole-row `put` stamps a new `createdAt` unless it is given the row's.
+        const op = entityCondition(readModel.put(item), {
+            eq: { [field]: versionOf(row) + offset },
+        });
+        const createdAt = row.value.createdAt;
+        return yield* op
+            ._builder("model", {
+            condition: op._condition,
+            withVectors: op._withVectors,
+            putKind: op._putKind,
+            createdAt: DateTime.isDateTime(createdAt) ? DateTime.toUtc(createdAt) : undefined,
+        })
+            .pipe(Effect.catchTag("ConditionalCheckFailed", () => Effect.fail(new LostRace(key))));
+    });
+    /**
+     * Every version from `from` to the last of `events` was delivered: `events`
+     * themselves, or `delivered` (the batch's other events of the stream, which
+     * are not this row's).
+     */
+    const coveredFrom = (events, from, delivered) => {
+        const own = new Set(events.map((event) => event.version));
+        const last = events[events.length - 1].version;
+        for (let version = from; version <= last; version++) {
+            if (!own.has(version) && !delivered.has(version))
+                return false;
+        }
+        return true;
+    };
+    /** `events` is exactly `from, from + 1, …`. */
+    const contiguousFrom = (events, from) => events.every((event, i) => event.version === from + i);
+    /** Retry lost races under the policy; once it is spent, `ConcurrentModification`. */
+    const withRetry = (attempt) => Effect.retry(attempt, {
+        schedule,
+        while: (error) => error instanceof LostRace,
+    }).pipe(Effect.mapError((error) => error instanceof LostRace
+        ? new ConcurrentModification({
+            entityType: readModel.entityType,
+            key: error.key,
+            attributes: [field],
+            current: Option.none(),
+        })
+        : error));
+    // Unreachable for a stream written by `append` (a contiguity-checked
+    // transaction): the store holds every version below a delivered one.
+    const gapError = (streamId, from, to) => Effect.fail(new ValidationError({
+        entityType: stream.eventMarker,
+        operation: "EventStore.projection",
+        cause: `Stream ${JSON.stringify(streamId)} is missing events between versions ${from} and ` +
+            `${to}: a strongly consistent read did not return them. Was the stream written ` +
+            "outside `append`?",
+    }));
+    /** A key's identity: its fields, sorted, as JSON. */
+    const keyId = (key) => JSON.stringify(Object.entries(key).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
+    /** The row an event addresses — none when `key` says it addresses none. */
+    const keyOf = (streamId, event) => call("key", () => {
+        const key = config.key(streamId, event);
+        return Option.isOption(key) ? key : Option.some(key);
+    });
+    /**
+     * Fold `events` onto `row` (or a new row), skipping the events `terminal`
+     * rejects. `state` stays none while no event has been applied to a new row.
+     */
+    const foldRow = (streamId, row, events) => Effect.gen(function* () {
+        let state = row;
+        const applied = [];
+        const rejected = [];
+        for (const event of events) {
+            const base = Option.isSome(state)
+                ? state.value
+                : yield* call("initial", () => config.initial(streamId, event));
+            const result = yield* Effect.result(config.evolve(base, event));
+            if (Result.isSuccess(result)) {
+                state = Option.some(result.success);
+                applied.push(event);
+            }
+            else if (config.terminal?.(result.failure) === true) {
+                rejected.push({ event, error: result.failure });
+            }
+            else {
+                return yield* Effect.fail(result.failure);
+            }
+        }
+        return { state, applied, rejected };
+    });
+    /**
+     * One row. `events` are the batch's events for it, sorted and deduplicated;
+     * `undefined` for a catch-up to `top`. `delivered` holds the versions of
+     * every event of the stream instance in the batch — this row's, other rows'
+     * and those addressing no row — so a run they cover needs no read.
+     */
+    const applyRow = (streamIdStr, streamId, key, events, top, delivered = new Set()) => {
+        const id = keyId(key);
+        const attempt = Effect.gen(function* () {
+            const row = yield* readRow(key);
+            const at = versionOf(row);
+            const alreadyApplied = events?.filter((e) => e.version <= at) ?? [];
+            const pending = events?.filter((e) => e.version > at);
+            const done = (rejected) => ({
+                streamId: streamIdStr,
+                key,
+                applied: [],
+                rejected,
+                alreadyApplied,
+                state: Option.map(row, (r) => r.state),
+                version: at,
+            });
+            if (pending !== undefined ? pending.length === 0 : at >= top)
+                return done([]);
+            let run;
+            if (pending !== undefined && coveredFrom(pending, at + 1, delivered)) {
+                run = pending;
+            }
+            else {
+                // Every version from the checkpoint to the highest one wanted — the
+                // other rows' events among them — must be there; only this row's are
+                // folded. The read stops at that version.
+                const upTo = pending === undefined ? top : pending[pending.length - 1].version;
+                const read = (yield* stream.readFrom(streamId, at, {
+                    consistentRead: true,
+                    toVersion: upTo,
+                }));
+                if (!contiguousFrom(read, at + 1) || read.length < upTo - at) {
+                    return yield* gapError(streamIdStr, at + 1, upTo);
+                }
+                run = [];
+                for (const event of read) {
+                    const key = yield* keyOf(streamId, event);
+                    if (Option.isSome(key) && keyId(key.value) === id)
+                        run.push(event);
+                }
+            }
+            if (run.length === 0)
+                return done([]);
+            const folded = yield* foldRow(streamId, Option.map(row, (r) => r.state), run);
+            // Nothing but rejections for a row that does not exist: write nothing.
+            if (Option.isNone(folded.state))
+                return done(folded.rejected);
+            const version = run[run.length - 1].version;
+            const state = yield* writeRow(streamId, key, folded.state.value, version, row);
+            return {
+                streamId: streamIdStr,
+                key,
+                applied: folded.applied,
+                rejected: folded.rejected,
+                alreadyApplied,
+                state: Option.some(state),
+                version,
+            };
+        });
+        return withRetry(attempt);
+    };
+    const applyBatch = (events, options) => Effect.gen(function* () {
+        // By stream instance, in order of first delivery.
+        const streams = new Map();
+        events.forEach((event, position) => {
+            const group = streams.get(event.streamId);
+            if (group === undefined)
+                streams.set(event.streamId, [[position, event]]);
+            else
+                group.push([position, event]);
+        });
+        /** Positions of the events that address no row. */
+        const ignored = [];
+        // Then by row; each row's task is ordered by its first delivered event.
+        const tasks = [];
+        for (const [streamIdStr, group] of streams) {
+            const positions = group.map(([position]) => position);
+            // A stream id that does not parse, or a `key` that throws, fails the
+            // whole stream instance: its events can't be placed in rows.
+            const rows = yield* Effect.result(Effect.gen(function* () {
+                const streamId = yield* stream.parseStreamId(streamIdStr);
+                const byRow = new Map();
+                for (const [position, event] of group) {
+                    const addressed = yield* keyOf(streamId, event);
+                    if (Option.isNone(addressed)) {
+                        ignored.push(position);
+                        continue;
+                    }
+                    const key = addressed.value;
+                    const id = keyId(key);
+                    const row = byRow.get(id);
+                    if (row === undefined)
+                        byRow.set(id, { key, positions: [position], events: [event] });
+                    else {
+                        row.positions.push(position);
+                        row.events.push(event);
+                    }
+                }
+                return { streamId, rows: [...byRow.values()] };
+            }));
+            if (Result.isFailure(rows)) {
+                const error = rows.failure;
+                tasks.push({
+                    first: positions[0],
+                    run: Effect.succeed({
+                        _tag: "Failed",
+                        streamId: streamIdStr,
+                        key: undefined,
+                        positions,
+                        error,
+                    }),
+                });
+                continue;
+            }
+            const { streamId } = rows.success;
+            const delivered = new Set(group.map(([, event]) => event.version));
+            for (const row of rows.success.rows) {
+                // Sorted by version, one event per version (a redelivery is a duplicate).
+                const ordered = [...row.events]
+                    .sort((a, b) => a.version - b.version)
+                    .filter((e, i, sorted) => i === 0 || sorted[i - 1].version !== e.version);
+                tasks.push({
+                    first: row.positions[0],
+                    run: Effect.result(applyRow(streamIdStr, streamId, row.key, ordered, 0, delivered)).pipe(Effect.map((result) => Result.isSuccess(result)
+                        ? { _tag: "Applied", positions: row.positions, ...result.success }
+                        : {
+                            _tag: "Failed",
+                            streamId: streamIdStr,
+                            key: row.key,
+                            positions: row.positions,
+                            error: result.failure,
+                        })),
+                });
+            }
+        }
+        tasks.sort((a, b) => a.first - b.first);
+        const outcomes = yield* Effect.forEach(tasks, (task) => task.run, {
+            concurrency: options?.concurrency ?? 10,
+        });
+        return {
+            outcomes,
+            failedPositions: outcomes
+                .filter((o) => o._tag === "Failed")
+                .map((o) => o.positions[0])
+                .sort((a, b) => a - b),
+            ignored: ignored.sort((a, b) => a - b),
+        };
+    });
+    /**
+     * `applyBatch([event])`, the row's failure in the error channel — wrapped in
+     * an `Option` when `key` returns one (none: the event addresses no row).
+     */
+    const apply = (event) => Effect.gen(function* () {
+        const streamId = yield* stream.parseStreamId(event.streamId);
+        const key = yield* call("key", () => config.key(streamId, event));
+        const optional = Option.isOption(key);
+        if (optional && Option.isNone(key))
+            return Option.none();
+        const { outcomes } = yield* applyBatch([event]);
+        const outcome = outcomes[0];
+        if (outcome._tag === "Failed")
+            return yield* Effect.fail(outcome.error);
+        const { _tag, positions, ...applied } = outcome;
+        return optional ? Option.some(applied) : applied;
+    });
+    const joinStreamId = (streamId) => stream.streamIdFields.map((f) => streamId[f]).join("#");
+    const catchUp = (streamId) => Effect.gen(function* () {
+        // The latest event that addresses a row — usually the head, one page.
+        const pages = yield* Query.paginate(stream.query
+            .events(streamId)
+            .pipe(Query.reverse, Query.pageSize(25), (q) => Query.consistentRead(q)));
+        const latest = yield* pages.pipe(Stream.flatMap((page) => Stream.fromIterable(page)), Stream.mapEffect((event) => keyOf(streamId, event).pipe(Effect.map((key) => Option.map(key, (k) => [event, k])))), Stream.filter((found) => Option.isSome(found)), Stream.map((found) => Option.getOrThrow(found)), Stream.runHead);
+        if (Option.isNone(latest)) {
+            return { key: Option.none(), applied: [], rejected: [], state: Option.none(), version: 0 };
+        }
+        const [head, key] = latest.value;
+        const result = yield* applyRow(joinStreamId(streamId), streamId, key, undefined, head.version);
+        return {
+            key: Option.some(key),
+            applied: result.applied,
+            rejected: result.rejected,
+            state: result.state,
+            version: result.version,
+        };
+    });
+    const rebuild = (streamId) => Effect.gen(function* () {
+        const events = (yield* stream.read(streamId, { consistentRead: true }));
+        const rows = new Map();
+        for (const event of events) {
+            const addressed = yield* keyOf(streamId, event);
+            if (Option.isNone(addressed))
+                continue;
+            const key = addressed.value;
+            const id = keyId(key);
+            const row = rows.get(id);
+            if (row === undefined)
+                rows.set(id, { key, events: [event] });
+            else
+                row.events.push(event);
+        }
+        const rebuilt = yield* Effect.forEach([...rows.values()], ({ key, events: rowEvents }) => withRetry(Effect.gen(function* () {
+            const row = yield* readRow(key);
+            // From `initial`: the row's current state is ignored.
+            const folded = yield* foldRow(streamId, Option.none(), rowEvents);
+            if (Option.isNone(folded.state)) {
+                return {
+                    key,
+                    state: Option.map(row, (r) => r.state),
+                    version: versionOf(row),
+                    rejected: folded.rejected,
+                };
+            }
+            const version = rowEvents[rowEvents.length - 1].version;
+            const state = yield* writeRow(streamId, key, folded.state.value, version, row);
+            return { key, state: Option.some(state), version, rejected: folded.rejected };
+        })), { concurrency: 10 });
+        return { rows: rebuilt };
+    });
+    const processBatch = (records, options) => runBatch(`${label}.processBatch`, records, options, [
+        {
+            name: "projection",
+            stream: stream,
+            decode: (image) => stream.decodeStreamImage(image),
+            applyBatch,
+        },
+    ]).pipe(Effect.map(({ outcomes, unrouted: _, ...rest }) => ({
+        ...rest,
+        outcomes: outcomes.projection,
+    })));
+    return {
+        [EventProjectionTypeId]: EventProjectionTypeId,
+        pipe() {
+            // eslint-disable-next-line prefer-rest-params
+            return Pipeable.pipeArguments(this, arguments);
+        },
+        stream,
+        entityType: readModel.entityType,
+        [ProjectionDecode]: (image) => stream.decodeStreamImage(image),
+        applyBatch,
+        apply,
+        catchUp,
+        rebuild,
+        processBatch,
+    };
+};
+/** The default `image` accessor: the `NewImage` of an `INSERT`. */
+const insertImage = (record) => record.eventName !== undefined && record.eventName !== "INSERT"
+    ? undefined
+    : record.dynamodb?.NewImage;
+/**
+ * @internal Decode a batch once, route each event to the projections of its
+ * stream, apply each projection's events, and build one partial batch
+ * response — shared by {@link processBatch} and `projection.processBatch`.
+ */
+const runBatch = (operation, records, options, routes, 
+/** Streams decoded without a projection: their events are returned as `unrouted`. */
+decodeOnly = []) => {
+    return Effect.gen(function* () {
+        // One decode per stream, however many projections read it.
+        const streams = new Map();
+        for (const route of routes) {
+            const readers = streams.get(route.stream);
+            if (readers === undefined)
+                streams.set(route.stream, [route]);
+            else
+                readers.push(route);
+        }
+        const unroutedStreams = decodeOnly.filter(([, stream]) => !streams.has(stream));
+        /** A marker's stream: the projections that read it, or its name when it has none. */
+        const byMarker = markerIndex(operation, [
+            ...[...streams.keys()].map((stream) => [stream.streamName, stream]),
+            ...unroutedStreams,
+        ]);
+        const unroutedNames = new Map(unroutedStreams.map(([name, stream]) => [stream, name]));
+        const unrouted = [];
+        const image = options.image ?? insertImage;
+        /** Each projection's events, and the record each came from. */
+        const routed = new Map(routes.map((route) => [route.name, { events: [], recordOf: [] }]));
+        const decodeFailures = [];
+        const failed = new Set();
+        for (const [i, record] of records.entries()) {
+            const recordImage = image(record);
+            if (recordImage === undefined)
+                continue;
+            const entry = typeof recordImage === "object" && recordImage !== null && !Array.isArray(recordImage)
+                ? byMarker.get(imageEntityType(recordImage) ?? "")
+                : undefined;
+            // Not an event of any stream named: nothing to apply.
+            if (entry === undefined)
+                continue;
+            const readers = streams.get(entry[1]);
+            const decoded = yield* Effect.result(readers === undefined
+                ? entry[1].decodeStreamImage(recordImage)
+                : readers[0].decode(recordImage));
+            if (Result.isFailure(decoded)) {
+                decodeFailures.push({ record, error: decoded.failure });
+                if (options.onDecodeFailure !== "skip")
+                    failed.add(i);
+            }
+            else if (Option.isSome(decoded.success) && readers === undefined) {
+                unrouted.push({
+                    position: i,
+                    stream: unroutedNames.get(entry[1]),
+                    event: decoded.success.value,
+                });
+            }
+            else if (Option.isSome(decoded.success)) {
+                for (const route of readers) {
+                    const target = routed.get(route.name);
+                    target.events.push(decoded.success.value);
+                    target.recordOf.push(i);
+                }
+            }
+        }
+        const outcomes = {};
+        for (const route of routes) {
+            const { events, recordOf } = routed.get(route.name);
+            if (events.length === 0) {
+                outcomes[route.name] = [];
+                continue;
+            }
+            const batch = yield* route.applyBatch(events, options.concurrency === undefined ? undefined : { concurrency: options.concurrency });
+            for (const position of batch.failedPositions)
+                failed.add(recordOf[position]);
+            // Positions index the records, not the decoded events.
+            outcomes[route.name] = batch.outcomes.map((outcome) => ({
+                ...outcome,
+                positions: outcome.positions.map((position) => recordOf[position]),
+            }));
+        }
+        const failedRecords = [...failed].sort((a, b) => a - b).map((i) => records[i]);
+        const response = yield* batchResponse(failedRecords, ("identifier" in options && options.identifier !== undefined
+            ? { identifier: options.identifier }
+            : { source: options.source }));
+        return { unrouted, outcomes, decodeFailures, failedRecords, response };
+    });
+};
+/**
+ * Process one change-feed batch for several projections — the usual shape
+ * when one table's feed carries several streams. Each record is decoded once
+ * and routed to every projection of its stream; records of other streams and
+ * items are skipped, as acknowledged. Each projection applies its events
+ * (see {@link EventProjection.applyBatch}), and one partial batch response
+ * names the earliest record of every failed row across all of them, plus the
+ * records that failed to decode (unless `onDecodeFailure: "skip"`). Outcome
+ * `positions` index `records`.
+ *
+ * Records are read as `StreamRecord`s, identified per `source`, or through
+ * `image` / `identifier` accessors for a shape of your own (a Pipe input
+ * template's). A failed record without an identifier fails the call with
+ * `StreamRecordIdentifierMissing`. `streams` names streams to decode without a
+ * projection: their events come back as `unrouted`. Two streams storing
+ * events under one marker die with `[EDD-9082]`.
+ *
+ * @example
+ * ```ts
+ * const result = yield* EventStore.processBatch(event.Records, {
+ *   projections: { summaries: OrderSummaryProjection, balances: BalanceProjection },
+ *   source: "lambda",
+ * })
+ * return result.response
+ * ```
+ */
+export const processBatch = (records, options) => runBatch("EventStore.processBatch", records, options, Object.entries(options.projections).map(([name, projection]) => ({
+    name,
+    stream: projection.stream,
+    decode: (image) => projection[ProjectionDecode](image),
+    applyBatch: (events, applyOptions) => projection.applyBatch(events, applyOptions),
+})), Object.entries((options.streams ?? {})));
+//# sourceMappingURL=EventProjection.js.map