effect-dynamodb 1.28.0 → 1.30.0

package/dist/internal/EventProjection.js

@@ -14,11 +14,17 @@
  *
  * @internal
  */
-import { ConcurrentModification, StreamRecordIdentifierMissing, ValidationError, } from "@effect-dynamodb/schema/Errors.js";
-import { DateTime, Effect, Option, Pipeable, Result, Schedule, Stream } from "effect";
+import { StreamRecordIdentifierMissing, } from "@effect-dynamodb/schema/Errors.js";
+import { Duration, Effect, Option, Pipeable, Result, 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";
+import { addressed, keyId, makeEngine, modelFields, retrySchedule, } from "./ProjectionEngine.js";
+/** @internal `revision`, resolved. */
+export const resolveRevision = (revision) => revision === undefined
+    ? undefined
+    : typeof revision === "string"
+        ? { field: revision, initial: 1 }
+        : { field: revision.field, initial: revision.initial ?? 1 };
 const identify = (record, index, options) => {
     const [itemIdentifier, member] = "identifier" in options
         ? [options.identifier(record), "identifier"]
@@ -103,41 +109,56 @@ export const eventFilterPattern = (streams) => {
 // 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.
+ * @internal How a projection takes part in a multi-projection batch: one
+ * route per source stream — its decode (under the bound context for a bound
+ * projection) and its `applyBatch`.
  */
-class LostRace {
-    key;
-    constructor(key) {
-        this.key = key;
+export const ProjectionRoutes = Symbol.for("effect-dynamodb/EventProjection/Routes");
+/** @internal Refusals shared by `projection` and `multiProjection` (`[EDD-9081]`). */
+export const refuseReadModel = (label, readModel, options) => {
+    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 " +
+            "(and `revision` for a write counter).");
+    }
+    if (readModel.softDelete) {
+        refuse("the read model has `softDelete`; projections remove rows with `removal` tombstones.");
+    }
+    if (readModel.timeSeries) {
+        refuse("the read model is a `timeSeries` entity, written by `append`, not `put`.");
+    }
+    const declared = modelFields(readModel.model);
+    for (const f of options.fields) {
+        if (declared !== undefined && !declared.includes(f)) {
+            refuse(`"${f}" is not a field of the read model.`);
+        }
+    }
+    const multiItem = readModel
+        ._multiItemWriteFeatures;
+    if ((options.removal || options.outbox) && multiItem !== undefined && multiItem.length > 0) {
+        refuse(`\`${options.removal ? "removal" : "outbox"}\` writes the row's item itself, which a read ` +
+            `model with ${multiItem.join(", ")} can't take (its extra items would not be maintained).`);
+    }
+    if (options.outbox && options.revision === undefined) {
+        refuse("`outbox` orders a row's effects by its `revision`: declare one.");
     }
-}
-/**
- * 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;
 };
+/** @internal An outbox config, resolved. */
+export const resolveOutbox = (outbox) => outbox === undefined
+    ? undefined
+    : {
+        schema: outbox.schema,
+        effects: outbox.effects,
+        table: outbox.table,
+        pk: outbox.keys?.pk ?? "pk",
+        sk: outbox.keys?.sk ?? "sk",
+        index: outbox.index,
+        claimFor: Duration.fromInputUnsafe(outbox.claimFor ?? "30 seconds"),
+    };
 /**
  * Define a change-feed projection of `stream` into `readModel` — rows keyed by
  * `key(streamId, event)` (one per stream instance when the key ignores the
@@ -146,9 +167,10 @@ const modelFields = (model) => {
  * 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.
+ * version), `softDelete` (removal is `removal` tombstones) and `timeSeries`
+ * read models throw `[EDD-9081]`, as do a field the model lacks, a
+ * non-integer offset, `removal` / `outbox` on a read model with `unique`
+ * constraints, and `outbox` without `revision`.
  *
  * @example
  * ```ts
@@ -165,225 +187,69 @@ const modelFields = (model) => {
 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.`);
-    }
+    const revision = resolveRevision(config.revision);
+    refuseReadModel(label, readModel, {
+        fields: [field, ...(revision === undefined ? [] : [revision.field])],
+        removal: config.removal !== undefined,
+        outbox: config.outbox !== undefined,
+        revision: revision?.field,
+    });
     if (!Number.isInteger(offset)) {
-        refuse(`the checkpoint offset ${offset} is not an integer.`);
+        throw new Error(`[EDD-9081] ${label}: 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;
+    const source = {
+        name: "projection",
+        stream: stream,
+        key: config.key,
+        evolve: (state, event) => config.evolve(state, event),
+        mode: "fold",
+        terminal: config.terminal,
     };
-    /** `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);
+    const engine = makeEngine({
+        label,
+        readModel: readModel,
+        sources: [source],
+        initial: (_key, context) => config.initial(context.streamId, context.event),
+        checkpoints: { kind: "scalar", field, offset },
+        revision,
+        toItem: config.toItem,
+        toItemContext: (key, work) => ({ streamId: work[0]?.streamId, key }),
+        retry: retrySchedule(config.retry),
+        removal: config.removal === undefined
+            ? undefined
+            : {
+                ttl: config.removal.ttl === undefined
+                    ? undefined
+                    : Duration.fromInputUnsafe(config.removal.ttl),
+            },
+        outbox: resolveOutbox(config.outbox),
     });
-    /**
-     * 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 keyOf = (streamId, event) => engine.call("key", () => addressed(config.key(streamId, event)));
+    /** A row's engine result, as this projection reports it. */
+    const appliedOf = (streamIdStr, result) => {
+        const instance = result.instances[0];
+        return {
+            streamId: streamIdStr,
+            key: result.key,
+            applied: (instance?.applied ?? []),
+            rejected: (instance?.rejected ?? []),
+            alreadyApplied: (instance?.alreadyApplied ?? []),
+            state: result.state,
+            version: instance?.version ?? 0,
+            removed: result.removed,
+            enqueued: result.enqueued,
+            undelivered: Option.none(),
+        };
     };
+    /** After a write with effects, drain the row when the caller passed `deliver`. */
+    const deliverAfter = (applied, deliver) => deliver === undefined || config.outbox === undefined || applied.enqueued === 0
+        ? Effect.succeed(applied)
+        : engine.drain(applied.key, deliver).pipe(Effect.map((drained) => ({
+            ...applied,
+            undelivered: drained.undelivered,
+        })));
     const applyBatch = (events, options) => Effect.gen(function* () {
         // By stream instance, in order of first delivery.
         const streams = new Map();
@@ -403,19 +269,19 @@ export const projection = (config) => {
             // 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 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)) {
+                    const key = yield* keyOf(streamId, event);
+                    if (Option.isNone(key)) {
                         ignored.push(position);
                         continue;
                     }
-                    const key = addressed.value;
-                    const id = keyId(key);
+                    const id = keyId(key.value);
                     const row = byRow.get(id);
-                    if (row === undefined)
-                        byRow.set(id, { key, positions: [position], events: [event] });
+                    if (row === undefined) {
+                        byRow.set(id, { key: key.value, positions: [position], events: [event] });
+                    }
                     else {
                         row.positions.push(position);
                         row.events.push(event);
@@ -444,9 +310,17 @@ export const projection = (config) => {
                 const ordered = [...row.events]
                     .sort((a, b) => a.version - b.version)
                     .filter((e, i, sorted) => i === 0 || sorted[i - 1].version !== e.version);
+                const work = {
+                    source,
+                    streamIdStr,
+                    streamId,
+                    events: ordered,
+                    top: 0,
+                    delivered,
+                };
                 tasks.push({
                     first: row.positions[0],
-                    run: Effect.result(applyRow(streamIdStr, streamId, row.key, ordered, 0, delivered)).pipe(Effect.map((result) => Result.isSuccess(result)
+                    run: Effect.result(engine.applyRow(row.key, [work]).pipe(Effect.flatMap((result) => deliverAfter(appliedOf(streamIdStr, result), options?.deliver)))).pipe(Effect.map((result) => Result.isSuccess(result)
                         ? { _tag: "Applied", positions: row.positions, ...result.success }
                         : {
                             _tag: "Failed",
@@ -476,8 +350,8 @@ export const projection = (config) => {
      * 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 streamId = (yield* stream.parseStreamId(event.streamId));
+        const key = yield* engine.call("key", () => config.key(streamId, event));
         const optional = Option.isOption(key);
         if (optional && Option.isNone(key))
             return Option.none();
@@ -496,48 +370,69 @@ export const projection = (config) => {
             .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 };
+            return {
+                key: Option.none(),
+                applied: [],
+                rejected: [],
+                state: Option.none(),
+                version: 0,
+                removed: false,
+            };
         }
         const [head, key] = latest.value;
-        const result = yield* applyRow(joinStreamId(streamId), streamId, key, undefined, head.version);
+        const result = (yield* engine.applyRow(key, [
+            {
+                source,
+                streamIdStr: joinStreamId(streamId),
+                streamId,
+                events: undefined,
+                top: head.version,
+                delivered: new Set(),
+            },
+        ]));
+        const applied = appliedOf(joinStreamId(streamId), result);
         return {
             key: Option.some(key),
-            applied: result.applied,
-            rejected: result.rejected,
-            state: result.state,
-            version: result.version,
+            applied: applied.applied,
+            rejected: applied.rejected,
+            state: applied.state,
+            version: applied.version,
+            removed: applied.removed,
         };
     });
     const rebuild = (streamId) => Effect.gen(function* () {
         const events = (yield* stream.read(streamId, { consistentRead: true }));
+        const delivered = new Set(events.map((e) => e.version));
         const rows = new Map();
         for (const event of events) {
-            const addressed = yield* keyOf(streamId, event);
-            if (Option.isNone(addressed))
+            const key = yield* keyOf(streamId, event);
+            if (Option.isNone(key))
                 continue;
-            const key = addressed.value;
-            const id = keyId(key);
+            const id = keyId(key.value);
             const row = rows.get(id);
             if (row === undefined)
-                rows.set(id, { key, events: [event] });
+                rows.set(id, { key: key.value, 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 };
+        const rebuilt = yield* Effect.forEach([...rows.values()], ({ key, events: rowEvents }) => engine.applyRow(key, [
+            {
+                source,
+                streamIdStr: joinStreamId(streamId),
+                streamId,
+                events: rowEvents,
+                top: rowEvents[rowEvents.length - 1].version,
+                delivered,
+            },
+        ], { fromScratch: true }).pipe(Effect.map((result) => {
+            const applied = appliedOf(joinStreamId(streamId), result);
+            return {
+                key,
+                state: applied.state,
+                version: applied.version,
+                rejected: applied.rejected,
+                removed: applied.removed,
+            };
         })), { concurrency: 10 });
         return { rows: rebuilt };
     });
@@ -546,12 +441,13 @@ export const projection = (config) => {
             name: "projection",
             stream: stream,
             decode: (image) => stream.decodeStreamImage(image),
-            applyBatch,
+            applyBatch: (events, applyOptions) => applyBatch(events, applyOptions),
         },
     ]).pipe(Effect.map(({ outcomes, unrouted: _, ...rest }) => ({
         ...rest,
         outcomes: outcomes.projection,
     })));
+    const outboxRequired = (operation) => Effect.die(new Error(`[EDD-9081] ${label}.${operation}: the projection declares no \`outbox\`.`));
     return {
         [EventProjectionTypeId]: EventProjectionTypeId,
         pipe() {
@@ -560,12 +456,21 @@ export const projection = (config) => {
         },
         stream,
         entityType: readModel.entityType,
-        [ProjectionDecode]: (image) => stream.decodeStreamImage(image),
+        [ProjectionRoutes]: (name) => [
+            {
+                name,
+                stream: stream,
+                decode: (image) => stream.decodeStreamImage(image),
+                applyBatch: (events, applyOptions) => applyBatch(events, applyOptions),
+            },
+        ],
         applyBatch,
         apply,
         catchUp,
         rebuild,
         processBatch,
+        drain: (key, deliver) => config.outbox === undefined ? outboxRequired("drain") : engine.drain(key, deliver),
+        drainPending: (deliver) => config.outbox === undefined ? outboxRequired("drainPending") : engine.drainPending(deliver),
     };
 };
 /** The default `image` accessor: the `NewImage` of an `INSERT`. */
@@ -577,7 +482,7 @@ const insertImage = (record) => record.eventName !== undefined && record.eventNa
  * 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, 
+export const runBatch = (operation, records, options, routes, 
 /** Streams decoded without a projection: their events are returned as `unrouted`. */
 decodeOnly = []) => {
     return Effect.gen(function* () {
@@ -590,13 +495,22 @@ decodeOnly = []) => {
             else
                 readers.push(route);
         }
-        const unroutedStreams = decodeOnly.filter(([, stream]) => !streams.has(stream));
+        // `streams` may name a stream a projection reads too: it is decoded once,
+        // applied, and returned as `unrouted` as well.
+        // The same stream bound or unbound shares its event schema; a different
+        // stream with the same marker stays a conflict (`[EDD-9082]`).
+        const schemaOf = (stream) => stream.eventSchema;
+        const routedSchemas = new Map([...streams.keys()].map((stream) => [stream.eventMarker, schemaOf(stream)]));
+        const decodeOnlyStreams = decodeOnly.filter(([, stream]) => !streams.has(stream) &&
+            !(routedSchemas.has(stream.eventMarker) &&
+                routedSchemas.get(stream.eventMarker) === schemaOf(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,
+            ...decodeOnlyStreams,
         ]);
-        const unroutedNames = new Map(unroutedStreams.map(([name, stream]) => [stream, name]));
+        /** The names `streams` gives, by event marker. */
+        const unroutedNames = new Map(decodeOnly.map(([name, stream]) => [stream.eventMarker, name]));
         const unrouted = [];
         const image = options.image ?? insertImage;
         /** Each projection's events, and the record each came from. */
@@ -622,29 +536,33 @@ decodeOnly = []) => {
                 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 name = unroutedNames.get(entry[1].eventMarker);
+                if (name !== undefined) {
+                    unrouted.push({ position: i, stream: name, event: decoded.success.value });
+                }
+                for (const route of readers ?? []) {
                     const target = routed.get(route.name);
-                    target.events.push(decoded.success.value);
+                    target.events.push(route.tag === undefined
+                        ? decoded.success.value
+                        : { stream: route.tag, event: decoded.success.value });
                     target.recordOf.push(i);
                 }
             }
         }
         const outcomes = {};
-        for (const route of routes) {
+        // One `applyBatch` per projection, however many of its sources routed here.
+        const projections = [...new Map(routes.map((route) => [route.name, route])).values()];
+        for (const route of projections) {
             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 });
+            const batch = yield* route.applyBatch(events, {
+                ...(options.concurrency === undefined ? {} : { concurrency: options.concurrency }),
+                ...(options.deliver === undefined ? {} : { deliver: options.deliver }),
+            });
             for (const position of batch.failedPositions)
                 failed.add(recordOf[position]);
             // Positions index the records, not the decoded events.
@@ -686,10 +604,5 @@ decodeOnly = []) => {
  * 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 ?? {})));
+export const processBatch = (records, options) => runBatch("EventStore.processBatch", records, options, Object.entries(options.projections).flatMap(([name, projection]) => projection[ProjectionRoutes](name)), Object.entries((options.streams ?? {})));
 //# sourceMappingURL=EventProjection.js.map