effect-dynamodb 1.34.1 → 1.36.0

package/dist/EventStore.js

@@ -15,7 +15,10 @@
  *   state record as the load via `loadState`)
  * - Head proofs (`append({ headProof })`, #164): an additional item or the
  *   inline snapshot proves the stream head in place of the version-contiguity
- *   `ConditionCheck`
+ *   `ConditionCheck`, or (`headProof: "none"`, #173) the caller owns the head
+ *   and no proof is written
+ * - A one-item append (its one event, nothing else) is a plain conditional
+ *   `PutItem` rather than a transaction (#173)
  * - Sealing (#166): `append(..., { seal: true })` makes its last event the
  *   stream's final one (`StreamSealed` for any later append), and
  *   `stream.appendOp(...)` carries one stream's append — sealing or not — in
@@ -45,11 +48,11 @@ import { Compression } from "@effect-dynamodb/schema/Compression.js";
 import { isPackedConfig } from "@effect-dynamodb/schema/DynamoModel.js";
 import * as DynamoSchema from "@effect-dynamodb/schema/DynamoSchema.js";
 import { normalizeTtlSeconds } from "@effect-dynamodb/schema/Entity.js";
-import { AdditionalItemConditionFailed, AppendTooLarge, DuplicateCommand, isAwsConditionalCheckFailed, isAwsTransactionCancelled, StreamSealed, TransactionCancelled, ValidationError, VersionConflict, } from "@effect-dynamodb/schema/Errors.js";
+import { AdditionalItemConditionFailed, AppendTooLarge, DuplicateCommand, isAwsConditionalCheckFailed, isAwsTransactionCancelled, isAwsValidationError, StreamSealed, TransactionCancelled, ValidationError, VersionConflict, } from "@effect-dynamodb/schema/Errors.js";
 import { isDispatchEligible, packedShape, packValue, unpackStoredSync, } from "@effect-dynamodb/schema/internal/PackedCodec.js";
 import * as KeyComposer from "@effect-dynamodb/schema/KeyComposer.js";
 import { Context, DateTime, Effect, Function, Option, Pipeable, Result, Schedule, Schema, } from "effect";
-import { DynamoClient } from "./DynamoClient.js";
+import * as Capacity from "./internal/Capacity.js";
 import { ProjectionRoutes } from "./internal/EventProjection.js";
 import { eq } from "./internal/Expr.js";
 import { itemBytes, transactItemBytes } from "./internal/ItemSize.js";
@@ -146,6 +149,37 @@ const PROJECTED_ENVELOPE_ATTRIBUTES = [
  * every deployed `"withoutMetadata"` index.
  */
 const SEALED_ATTRIBUTE = "__edd_sealed__";
+/**
+ * @internal The write token of an event sent as a single-item `PutItem`
+ * (#173): random per `append` call, so the put can recognise its own item.
+ * A `TransactWriteItems` is idempotent under the AWS SDK's retries (the SDK
+ * fills its `ClientRequestToken`, and DynamoDB answers a resend of a
+ * committed transaction with success), but a `PutItem` has no token: a
+ * resend after a commit whose response was lost fails its own
+ * `attribute_not_exists(pk)`, and `ALL_OLD` returns the writer's own event.
+ * The token tells that case (success) from another writer's event at the
+ * same version (a conflict), however alike their content.
+ */
+const WRITE_TOKEN_ATTRIBUTE = "__edd_wt__";
+/** @internal The write token's length in hex digits: 128 random bits. */
+const WRITE_TOKEN_LENGTH = 32;
+/** @internal A fresh write token, from the platform's Web Crypto (CSPRNG). */
+const makeWriteToken = Effect.sync(() => Array.from(globalThis.crypto.getRandomValues(new Uint8Array(WRITE_TOKEN_LENGTH / 2)), (byte) => byte.toString(16).padStart(2, "0")).join(""));
+/**
+ * @internal The event `Put` of a single-item append with `token` as its write
+ * token (see {@link WRITE_TOKEN_ATTRIBUTE}).
+ */
+const withWriteToken = (item, token) => ({
+    Put: {
+        ...item.Put,
+        Item: { ...item.Put.Item, [WRITE_TOKEN_ATTRIBUTE]: { S: token } },
+    },
+});
+/**
+ * @internal Whether an append's request is exactly one item, its one event
+ * `Put` — sent as a `PutItem` (#173) rather than a `TransactWriteItems`.
+ */
+const isSingleEventPut = (items, eventCount) => items.length === 1 && eventCount === 1 && items[0].Put !== undefined;
 /**
  * @internal The version a sealed item returned by a failed condition
  * (`ReturnValuesOnConditionCheckFailure: "ALL_OLD"`) seals the stream at: an
@@ -162,6 +196,51 @@ const sealedVersionOf = (item) => {
     const version = typeof raw.version === "number" ? raw.version : raw.asOfVersion;
     return typeof version === "number" ? version : undefined;
 };
+/**
+ * @internal A `PutItem` validation error that a transaction reports as its
+ * item's cancellation reason (`ValidationError`) rather than as a request
+ * error: a key whose type is not the table's or an index's ("Type mismatch
+ * for key", "Type mismatch for Index Key"). Observed on DynamoDB Local, where
+ * an oversized item, an empty or oversized index key are request errors of
+ * the transaction as of the `PutItem` — and named by the diagnosis on both —
+ * and an oversized table key is a cancellation reason the diagnosis names.
+ * The single-item fast path (#173) reports these as the transaction does.
+ */
+const ITEM_REASON_VALIDATION = /Type mismatch/i;
+/**
+ * @internal The cancellation reason code a one-item `TransactWriteItems`
+ * reports for its item where a `PutItem` fails with `cause` instead, or
+ * `undefined` when the transaction reports it as a request error too (or not
+ * at all). The single-item fast path (#173) turns these into the
+ * `TransactionCancelled` the transaction gives:
+ *
+ * - `ProvisionedThroughputExceededException` — `ProvisionedThroughputExceeded`
+ *   (a provisioned table's capacity);
+ * - `ThrottlingException` — `ThrottlingError`;
+ * - `ItemCollectionSizeLimitExceededException` —
+ *   `ItemCollectionSizeLimitExceeded` (an LSI's 10 GB item collection, which
+ *   a stream index is by default);
+ * - `TransactionConflictException` — `TransactionConflict`;
+ * - a key of the wrong type ({@link ITEM_REASON_VALIDATION}) —
+ *   `ValidationError`.
+ */
+const putItemReason = (cause) => {
+    const name = cause?.name;
+    switch (name) {
+        case "ProvisionedThroughputExceededException":
+            return "ProvisionedThroughputExceeded";
+        case "ThrottlingException":
+            return "ThrottlingError";
+        case "ItemCollectionSizeLimitExceededException":
+            return "ItemCollectionSizeLimitExceeded";
+        case "TransactionConflictException":
+            return "TransactionConflict";
+    }
+    return isAwsValidationError(cause) &&
+        ITEM_REASON_VALIDATION.test(cause.message ?? "")
+        ? "ValidationError"
+        : undefined;
+};
 /**
  * @internal What a cancelled append means for one stream, from the reasons of
  * its own items: `[0, guardCount)` the contiguity check,
@@ -221,6 +300,7 @@ const STREAM_OWNED_ATTRIBUTES = [
     "state",
     "commandId",
     SEALED_ATTRIBUTE,
+    WRITE_TOKEN_ATTRIBUTE,
     DEFAULT_TTL_ATTRIBUTE_NAME,
 ];
 /** @internal Every member a stream index entry may declare (`StreamIndexConfigKey`). */
@@ -501,20 +581,20 @@ const snapshotProofRefusal = (streamName, settings, operation) => settings !== u
             : `This stream's snapshot is mode "${settings.mode}"` +
                 `${settings.every === undefined ? "" : ` with every: ${settings.every}`}.`);
 /**
- * @internal Why a `headProof` is malformed — not `"snapshot"` nor
+ * @internal Why a `headProof` is malformed — not `"snapshot"`, `"none"` nor
  * `{ additionalItem: n }` with `n` a non-negative integer — or `undefined`
  * when it is well-formed.
  */
 const headProofShapeProblem = (headProof) => {
-    if (headProof === "snapshot")
+    if (headProof === "snapshot" || headProof === "none")
         return undefined;
     const n = typeof headProof === "object" && headProof !== null
         ? headProof.additionalItem
         : undefined;
     return typeof n === "number" && Number.isInteger(n) && n >= 0
         ? undefined
-        : `headProof must be "snapshot" or { additionalItem: n } with n a non-negative integer; ` +
-            `received ${JSON.stringify(headProof) ?? String(headProof)}. Nothing was written.`;
+        : `headProof must be "snapshot", "none" or { additionalItem: n } with n a non-negative ` +
+            `integer; received ${JSON.stringify(headProof) ?? String(headProof)}. Nothing was written.`;
 };
 /**
  * @internal Why an `eventTimestamps` value cannot be written for `count`
@@ -778,6 +858,12 @@ export const makeStream = (config) => {
      */
     const codecCheck = runtimeCodecCheck(`EventStore (first use of stream "${config.streamName}")`, streamCodecRequirements(config.streamName, storage));
     const checked = (op) => codecCheck === undefined ? op : (...args) => Effect.andThen(codecCheck, op(...args));
+    /**
+     * A stream method as a named operation for consumed-capacity reports
+     * (#174). Internal compositions call the unwrapped closures, so only the
+     * public method opens a scope.
+     */
+    const named = (name, op) => (...args) => Capacity.operation(`EventStream.${name}`, { target: config.streamName }, op(...args));
     /** The `[EDD-9076]` guard for queries of a stream whose `data` is packed. */
     const dataGuards = dataStoredAs === undefined
         ? []
@@ -1005,12 +1091,14 @@ export const makeStream = (config) => {
      */
     const encodeSnapshotState = (state, operation) => encodeToWire(snapshot.schema, state, operation, snapshotEntityType);
     /**
-     * Map a failed `TransactWriteItems` of an append to its verdict. Resolves to
+     * Send an append — see {@link AppendTransaction} for its layout. Resolves to
      * the race a guarded additional put lost (so the transaction is built and
      * written again), and fails with every other verdict.
+     *
+     * A request of one item, the append's one event, is a `PutItem` (#173): see
+     * {@link sendAppendPut}. Everything else is one `TransactWriteItems`.
      */
     const sendAppendTransaction = (client, tx, streamIdStr, commandId) => {
-        const sent = () => ({ _tag: "Transaction", items: tx.items, targets: tx.targets });
         const diagnosed = (diagnosis, original) => diagnosis._tag === "TooManyItems"
             ? new AppendTooLarge({
                 streamName: config.streamName,
@@ -1020,6 +1108,16 @@ export const makeStream = (config) => {
                 cause: original,
             })
             : appendLimitError(diagnosis, original, tx);
+        // The stream's own key attributes and the additional items', for the
+        // key-size diagnosis.
+        const keys = () => mergeKeyAttributes({
+            partition: ["pk", ...streamIndexes.map((idx) => idx.pk)],
+            sort: ["sk", ...streamIndexes.map((idx) => idx.sk)],
+        }, tx.additional.keys());
+        if (isSingleEventPut(tx.items, tx.eventCount)) {
+            return Effect.flatMap(makeWriteToken, (token) => sendAppendPut(client, tx, token, streamIdStr, keys, diagnosed));
+        }
+        const sent = () => ({ _tag: "Transaction", items: tx.items, targets: tx.targets });
         return client.transactWriteItems({ TransactItems: tx.items }).pipe(Effect.as(undefined), 
         // One operation per item (#133, #144): diagnosed BEFORE the conditional
         // mapping below — DynamoDB can report a repeated item as a conditional
@@ -1062,10 +1160,10 @@ export const makeStream = (config) => {
                 return Effect.fail(own);
             // The head proof (#164) stands in for the contiguity check, so its
             // own condition failing shares their verdict — ahead of the other
-            // additional items.
+            // additional items. `"none"` (#173) has no item to fail.
             const proofFailed = tx.headProof === "snapshot"
                 ? failedAt(tx.snapshotIndex)
-                : tx.headProof !== undefined &&
+                : typeof tx.headProof === "object" &&
                     opConditionFailed(tx.additional, rawReasons, tx.headProof.additionalItem, tx.guardCount + tx.eventCount);
             if (proofFailed) {
                 return Effect.fail(new VersionConflict({
@@ -1111,13 +1209,70 @@ export const makeStream = (config) => {
         // transaction sent, naming the event, sentinel, snapshot or additional
         // item at fault. Over 100 items is `AppendTooLarge`, with the EXPANDED
         // count.
+        diagnoseFailure({ sent, keys, rewrite: diagnosed }));
+    };
+    /**
+     * The single-item fast path (#173): an append whose request is its one
+     * event `Put` sends it as a `PutItem` — the same item, condition and
+     * `ALL_OLD`, plus a write token (see {@link WRITE_TOKEN_ATTRIBUTE}) — at
+     * 1 WCU per KB instead of a transaction's 2. One item commits atomically
+     * either way, and every outcome maps to the one the transaction gives for
+     * the same case:
+     *
+     * - a failed condition whose returned item carries this call's write token
+     *   is this call's own commit, met again by an SDK retry of a `PutItem`
+     *   whose response was lost: success, as the transaction's idempotent
+     *   retry is;
+     * - any other failed condition is judged by {@link streamAppendVerdict}
+     *   from the one reason it stands for: `StreamSealed` when the returned
+     *   item is marked, `VersionConflict` otherwise;
+     * - a rejection DynamoDB names (an item over 400 KB, a key too long or
+     *   empty) is diagnosed against the item sent and rewritten by the same
+     *   `rewrite`, so it names the event as the transaction's does;
+     * - a failure a transaction reports as its item's cancellation reason is
+     *   `TransactionCancelled` with that reason (see {@link putItemReason}):
+     *   DynamoDB fails a `PutItem` with a request error where it cancels a
+     *   transaction for its item;
+     * - anything else passes through, as it does from the transaction (the
+     *   other validation errors a one-item transaction gets are request
+     *   errors there too).
+     */
+    const sendAppendPut = (client, tx, token, streamIdStr, keys, diagnosed) => {
+        const item = withWriteToken(tx.items[0], token);
+        return client.putItem(item.Put).pipe(Effect.as(undefined), 
+        // Diagnosed first: what it names is terminal, and what it cannot
+        // explain is mapped below.
         diagnoseFailure({
-            sent,
-            keys: () => mergeKeyAttributes({
-                partition: ["pk", ...streamIndexes.map((idx) => idx.pk)],
-                sort: ["sk", ...streamIndexes.map((idx) => idx.sk)],
-            }, tx.additional.keys()),
+            sent: () => ({ _tag: "Item", item, target: () => tx.targets()[0] }),
+            keys,
             rewrite: diagnosed,
+        }), Effect.catch((error) => {
+            if (error._tag === "AppendTooLarge" || error._tag === "ValidationError") {
+                return Effect.fail(error);
+            }
+            const cause = error.cause;
+            if (isAwsConditionalCheckFailed(cause)) {
+                const returned = cause.Item;
+                if (returned?.[WRITE_TOKEN_ATTRIBUTE]?.S === token)
+                    return Effect.succeed(undefined);
+                const verdict = streamAppendVerdict([{ Code: "ConditionalCheckFailed", Item: returned }], {
+                    guardCount: 0,
+                    eventCount: 1,
+                    snapshotIndex: -1,
+                    streamName: config.streamName,
+                    streamId: streamIdStr,
+                    expectedVersion: tx.expectedVersion,
+                });
+                return Effect.fail(verdict ?? error);
+            }
+            const code = putItemReason(cause);
+            if (code === undefined)
+                return Effect.fail(error);
+            return Effect.fail(new TransactionCancelled({
+                operation: "PutItem",
+                reasons: [{ code, message: cause.message }],
+                cause,
+            }));
         }));
     };
     /**
@@ -1652,7 +1807,7 @@ export const makeStream = (config) => {
         if (parts === undefined)
             return { version: expectedVersion, events: [] };
         const { tableName, streamIdStr, contiguityCheck, eventItems, sentinelPut, snapshotPut } = parts;
-        const client = yield* DynamoClient;
+        const client = yield* Capacity.client;
         /**
          * Lay out the append's one transaction — see {@link AppendTransaction}:
          *   [0, C)                version-contiguity ConditionCheck (C is 0 or 1)
@@ -1834,14 +1989,21 @@ export const makeStream = (config) => {
             return { events: [], sentinel: undefined, snapshot: undefined, transactionBytes: 0 };
         }
         const putBytes = (item) => itemBytes(item.Put?.Item ?? {});
-        const owned = [
+        const laidOut = [
             ...(parts.contiguityCheck === undefined ? [] : [parts.contiguityCheck]),
             ...parts.eventItems,
             ...(parts.sentinelPut === undefined ? [] : [parts.sentinelPut]),
             ...(parts.snapshotPut === undefined ? [] : [parts.snapshotPut]),
         ];
+        // A single-item append is sent as a `PutItem` carrying a write token
+        // (#173), whose bytes are measured here as a placeholder of its length.
+        // A `{ additionalItem }` proof means the append carries that item, so
+        // it is a transaction.
+        const single = typeof options?.headProof !== "object" && isSingleEventPut(laidOut, parts.eventItems.length);
+        const owned = single ? [withWriteToken(laidOut[0], "0".repeat(WRITE_TOKEN_LENGTH))] : laidOut;
+        const eventItems = single ? owned : parts.eventItems;
         const measurement = {
-            events: parts.eventItems.map(putBytes),
+            events: eventItems.map(putBytes),
             sentinel: parts.sentinelPut === undefined ? undefined : putBytes(parts.sentinelPut),
             snapshot: parts.snapshotPut === undefined ? undefined : putBytes(parts.snapshotPut),
             transactionBytes: owned.reduce((sum, item) => sum + transactItemBytes(item), 0),
@@ -1940,7 +2102,7 @@ export const makeStream = (config) => {
     const writeSnapshot = (streamId, state, asOfVersion) => Effect.gen(function* () {
         if (snapshot === undefined)
             return yield* snapshotUnavailable("writeSnapshot");
-        const client = yield* DynamoClient;
+        const client = yield* Capacity.client;
         const { name: tableName } = yield* config.table.Tag;
         const now = DateTime.formatIso(yield* DateTime.now);
         // Packed per `snapshot.storedAs` (#147): the diagnosis below measures
@@ -1994,7 +2156,7 @@ export const makeStream = (config) => {
     })));
     /** The raw snapshot item, by its exact key, in one `GetItem`. */
     const getSnapshotItem = (streamId, consistentRead) => Effect.gen(function* () {
-        const client = yield* DynamoClient;
+        const client = yield* Capacity.client;
         const { name: tableName } = yield* config.table.Tag;
         const result = yield* client.getItem({
             TableName: tableName,
@@ -2008,7 +2170,7 @@ export const makeStream = (config) => {
     });
     /** The raw event item at `version`, by its exact key, in one `GetItem` (#166). */
     const getEventItem = (streamId, version, consistentRead) => Effect.gen(function* () {
-        const client = yield* DynamoClient;
+        const client = yield* Capacity.client;
         const { name: tableName } = yield* config.table.Tag;
         const result = yield* client.getItem({
             TableName: tableName,
@@ -2084,7 +2246,7 @@ export const makeStream = (config) => {
                 }
             }
         }
-        const client = yield* DynamoClient;
+        const client = yield* Capacity.client;
         const { name: tableName } = yield* config.table.Tag;
         // One reverse Query over `[first event SK, snapshot SK]`: the snapshot
         // sorts after every event and the command sentinels before them (see
@@ -2180,7 +2342,7 @@ export const makeStream = (config) => {
     // hasCommandSentinel (internal — see CommandSentinelProbe)
     // ---------------------------------------------------------------------------
     const hasCommandSentinel = (streamId, commandId) => Effect.gen(function* () {
-        const client = yield* DynamoClient;
+        const client = yield* Capacity.client;
         const { name: tableName } = yield* config.table.Tag;
         const result = yield* client.getItem({
             TableName: tableName,
@@ -2210,6 +2372,9 @@ export const makeStream = (config) => {
             packed: dataGuards,
             resolveTableName: config.table.Tag.useSync((tc) => tc.name),
             keyFields: ["pk", "sk"],
+            // Consumed capacity reports these queries under the stream name, as
+            // every `EventStream.*` operation does (#174).
+            operationTarget: config.streamName,
             // Bound to the event SK range so non-event items in the stream partition
             // (the snapshot) are excluded at the key-condition level. A caller-supplied
             // `Query.where` replaces this — the `__edd_e__` filter still applies.
@@ -2290,6 +2455,7 @@ export const makeStream = (config) => {
                 label: `EventStream "${config.streamName}" index "${idx.name}"`,
             },
             keyFields: [idx.pk, idx.sk, "pk", "sk"],
+            operationTarget: config.streamName,
             // A "keys" index holds no events: an LSI has DynamoDB fetch them
             // (`Select: ALL_ATTRIBUTES`), a GSI fetches each page's with
             // `BatchGetItem` on the table key.
@@ -2393,15 +2559,15 @@ export const makeStream = (config) => {
         snapshotConfig: snapshotSettings,
         storedAs: storage,
         indexes: indexSettings,
-        writeSnapshot: checked(writeSnapshot),
-        readSnapshot: checked(readSnapshot),
-        append: checked(append),
+        writeSnapshot: checked(named("writeSnapshot", writeSnapshot)),
+        readSnapshot: checked(named("readSnapshot", readSnapshot)),
+        append: checked(named("append", append)),
         appendOp,
-        read: checked(read),
-        readFrom: checked(readFrom),
-        currentVersion: checked(currentVersion),
-        readLatest: checked(readLatest),
-        readIndex: checked(readIndex),
+        read: checked(named("read", read)),
+        readFrom: checked(named("readFrom", readFrom)),
+        currentVersion: checked(named("currentVersion", currentVersion)),
+        readLatest: checked(named("readLatest", readLatest)),
+        readIndex: checked(named("readIndex", readIndex)),
         measureAppend: checked(measureAppend),
         measureSnapshot: checked(measureSnapshot),
         decodeStreamImage: checked(decodeStreamImage),
@@ -2429,7 +2595,8 @@ export const makeStream = (config) => {
  * ```
  */
 export const bind = (stream) => Effect.gen(function* () {
-    const ctx = yield* Effect.context();
+    // Detached: no current operation or parent span is pinned for later calls (#174).
+    const ctx = Capacity.detachContext(yield* Effect.context());
     // The stream meets values compressed with every codec its `storedAs`
     // names, so the registry captured here must have them (#147).
     const codecError = unregisteredCodecError("EventStore.bind", streamCodecRequirements(stream.streamName, stream.storedAs), Context.getOrUndefined(ctx, Compression));
@@ -2440,6 +2607,7 @@ export const bind = (stream) => Effect.gen(function* () {
     const headProbe = headAboveProbeOf(stream);
     return {
         [EventStreamTypeId]: EventStreamTypeId,
+        [Capacity.CapturedReporting]: Capacity.capturedSettings(ctx),
         pipe() {
             // eslint-disable-next-line prefer-rest-params
             return Pipeable.pipeArguments(this, arguments);
@@ -3007,6 +3175,17 @@ const makeCommandHandlerImpl = (decider, stream, options) => {
                 : stream.currentVersion(streamId, readOptions);
         };
         const attempt = Effect.gen(function* () {
+            // `headProof: "none"` (#173) is `append`'s alone for now: refused for an
+            // untyped caller before anything is read. Not retryable, as below.
+            if (headProof === "none") {
+                return yield* new ValidationError({
+                    entityType: stream.streamName,
+                    operation: "EventStore.commandHandler.headProof",
+                    cause: 'commandHandler does not accept headProof: "none": it is accepted by append only. ' +
+                        "Omit headProof to keep the contiguity check, or name a proof item. " +
+                        "Nothing was written.",
+                });
+            }
             // Backstop for JS callers and `any`-shaped call sites: silently degrading
             // to at-least-once would look like success right up until the day a
             // duplicate mattered. Not retryable — `while` below only retries
@@ -3143,7 +3322,7 @@ const makeCommandHandlerImpl = (decider, stream, options) => {
         // answer, never a cue to re-read and re-decide. A conflict naming another
         // stream (a nested `appendOp`, #166) is retried either way: the If-Match
         // was not wrong, and the retried attempt checks it again on its reload.
-        return schedule === undefined
+        const run = schedule === undefined
             ? attempt
             : Effect.retry(attempt, {
                 // `while` runs before the schedule, so the schedule only ever sees a
@@ -3158,6 +3337,10 @@ const makeCommandHandlerImpl = (decider, stream, options) => {
                 while: (error) => error instanceof VersionConflict &&
                     (expectedVersion === undefined || !isOwnConflict(error)),
             });
+        // One report per invocation: the load and the append (and retries) nest
+        // under it (#174). A bound stream's captured setting applies, as it does
+        // to the bound calls inside.
+        return Capacity.operation("EventStore.commandHandler", { target: stream.streamName }, run, stream[Capacity.CapturedReporting]);
     };
 };
 /**
@@ -3316,7 +3499,8 @@ export { removeRow, skipEvent, } from "./internal/ProjectionEngine.js";
  * ```
  */
 export const bindProjection = (projection) => Effect.gen(function* () {
-    const ctx = yield* Effect.context();
+    // Detached: no current operation or parent span is pinned for later calls (#174).
+    const ctx = Capacity.detachContext(yield* Effect.context());
     // The codec check `bind` makes, for every stream, against the registry captured here.
     const streams = isMultiProjection(projection)
         ? Object.values(projection.sources).map((source) => source.stream)