@atolis-hq/wake 0.1.0

package/dist/src/core/projection-updater.js

@@ -0,0 +1,438 @@
+import { CORRELATION_PRIMARY_CONFLICT_EVENT, CORRELATION_REGISTERED_EVENT, CORRELATION_RETRACTED_EVENT, UNRESOLVED_WORK_ITEM_KEY, parseIssueStateRecord, } from '../domain/schema.js';
+import { doneRunnerSentinel, stageFromLabels } from '../domain/stages.js';
+import { builtInDefaultWorkflowDefinition, defaultWorkflowName, workflowStageVocabulary, } from '../domain/workflows.js';
+import { createEventEnvelope } from '../lib/event-log.js';
+function stringArrayFromPayload(value) {
+    return Array.isArray(value)
+        ? value.filter((entry) => typeof entry === 'string')
+        : [];
+}
+function configuredStagesForLabels(config) {
+    if (config === undefined) {
+        return workflowStageVocabulary(builtInDefaultWorkflowDefinition);
+    }
+    const workflow = config.workflows[defaultWorkflowName(config)];
+    return workflow === undefined ? undefined : workflowStageVocabulary(workflow);
+}
+function createProjectionFromIssueEvent(event, config) {
+    const issue = event.sourceEventType === 'ticket.upsert'
+        ? event.payload.ticket
+        : event.payload.issue;
+    if (issue === undefined || typeof issue !== 'object' || issue === null) {
+        return null;
+    }
+    const labels = Array.isArray(issue.labels)
+        ? (issue.labels)
+        : [];
+    return parseIssueStateRecord({
+        schemaVersion: 1,
+        workItemKey: event.workItemKey,
+        origin: event.sourceSystem,
+        issue,
+        wake: {
+            stage: stageFromLabels(labels, configuredStagesForLabels(config)) ?? 'queue',
+            stageHistory: [],
+            recentEventIds: [event.eventId],
+            syncedAt: event.ingestedAt,
+        },
+        context: {},
+    });
+}
+async function applyEvent(current, event, ctx, config) {
+    // The shared sentinel for events whose resource failed mint qualification
+    // (tick-runner.ts's resolveInboundEvent, spec D1'). These are durable and
+    // inspectable via the event log but must never materialize a projection —
+    // otherwise every unqualified ticket.upsert/fake.issue.upsert would create
+    // one here on its first sighting (current === null), the same as a real
+    // mint, defeating the entire point of the gate. `current` is always null
+    // for this key (readIssueState(UNRESOLVED_WORK_ITEM_KEY) never has a file
+    // to read), so returning it unchanged is equivalent to "no projection".
+    if (event.workItemKey === UNRESOLVED_WORK_ITEM_KEY) {
+        return current;
+    }
+    if (event.sourceEventType === 'fake.issue.upsert' ||
+        event.sourceEventType === 'ticket.upsert') {
+        const next = createProjectionFromIssueEvent(event, config);
+        if (next === null) {
+            return current;
+        }
+        if (current === null) {
+            return next;
+        }
+        const nextStageFromLabels = stageFromLabels(next.issue.labels, configuredStagesForLabels(config));
+        const shouldReconcileStage = nextStageFromLabels !== undefined && nextStageFromLabels !== current.wake.stage;
+        return parseIssueStateRecord({
+            ...current,
+            origin: current.origin,
+            issue: next.issue,
+            wake: {
+                ...current.wake,
+                ...(shouldReconcileStage ? { stage: nextStageFromLabels } : {}),
+                syncedAt: event.ingestedAt,
+                stageHistory: shouldReconcileStage
+                    ? [
+                        ...current.wake.stageHistory,
+                        {
+                            stage: nextStageFromLabels,
+                            changedAt: event.occurredAt,
+                            reason: 'github-label-sync',
+                        },
+                    ]
+                    : current.wake.stageHistory,
+                recentEventIds: [...current.wake.recentEventIds, event.eventId].slice(-10),
+            },
+        });
+    }
+    if (current === null) {
+        return null;
+    }
+    if (event.sourceEventType === 'fake.issue.comment.created' ||
+        event.sourceEventType === 'ticket.comment.created' ||
+        event.sourceEventType === 'ticket.comment.updated' ||
+        event.sourceEventType === 'pr.comment.created' ||
+        event.sourceEventType === 'pr.review.created' ||
+        event.sourceEventType === 'pr.review-comment.created') {
+        const comment = event.payload.comment;
+        if (comment === undefined || typeof comment !== 'object' || comment === null) {
+            return current;
+        }
+        const isBotAuthored = Boolean(event.derivedHints?.botAuthoredComment);
+        const nextComment = {
+            ...comment,
+            isBotAuthored,
+        };
+        const existingComments = current.comments.filter((entry) => entry.id !== String(comment.id));
+        return parseIssueStateRecord({
+            ...current,
+            comments: [...existingComments, nextComment],
+            latestComment: nextComment,
+            wake: {
+                ...current.wake,
+                syncedAt: event.ingestedAt,
+                recentEventIds: [...current.wake.recentEventIds, event.eventId].slice(-10),
+            },
+        });
+    }
+    if (event.sourceEventType === 'wake.run.claimed') {
+        const payload = event.payload;
+        if (payload.claimedStage === undefined) {
+            return parseIssueStateRecord({
+                ...current,
+                wake: {
+                    ...current.wake,
+                    syncedAt: event.ingestedAt,
+                    recentEventIds: [...current.wake.recentEventIds, event.eventId].slice(-10),
+                },
+            });
+        }
+        return parseIssueStateRecord({
+            ...current,
+            wake: {
+                ...current.wake,
+                stage: payload.claimedStage,
+                lastRunId: event.sourceRefs.runId ?? current.wake.lastRunId,
+                syncedAt: event.ingestedAt,
+                stageHistory: [
+                    ...current.wake.stageHistory,
+                    {
+                        stage: payload.claimedStage,
+                        changedAt: event.occurredAt,
+                        reason: `run:${payload.action ?? 'unknown'}:claimed`,
+                    },
+                ],
+                recentEventIds: [...current.wake.recentEventIds, event.eventId].slice(-10),
+            },
+        });
+    }
+    if (event.sourceEventType === 'wake.run.completed') {
+        const payload = event.payload;
+        // Clear the session when the stage moves forward (new action needed) or the
+        // run failed outright. Keep it for BLOCKED so the same action can resume
+        // the in-progress session after a human replies.
+        const isForwardProgression = payload.nextStage !== undefined &&
+            payload.nextStage !== current.wake.stage;
+        const stageChanged = payload.nextStage !== undefined && payload.nextStage !== current.wake.stage;
+        const isFailed = payload.sentinel === 'FAILED';
+        const shouldClearSession = isForwardProgression || isFailed;
+        return parseIssueStateRecord({
+            ...current,
+            context: {
+                ...current.context,
+                lastFailureClass: payload.failureClass,
+                ...(payload.handledCommentId === undefined
+                    ? {}
+                    : { lastHandledCommentId: payload.handledCommentId }),
+                ...(payload.sentinel === undefined
+                    ? {}
+                    : { lastRunSentinel: payload.sentinel }),
+                ...(payload.action === undefined
+                    ? {}
+                    : { lastRunAction: payload.action }),
+                ...(payload.sentinel === doneRunnerSentinel && payload.action !== undefined
+                    ? { lastCompletedAction: payload.action }
+                    : {}),
+                // Remembered so the approval path knows which action to resume or
+                // skip when a human posts /approved.
+                ...(payload.sentinel === 'AWAITING_APPROVAL' && payload.action !== undefined
+                    ? { pendingApprovalAction: payload.action }
+                    : {}),
+            },
+            wake: {
+                ...current.wake,
+                stage: payload.nextStage ?? current.wake.stage,
+                lastRunId: payload.runId ?? current.wake.lastRunId,
+                sessionId: shouldClearSession
+                    ? undefined
+                    : (payload.sessionId ?? current.wake.sessionId),
+                sessionCli: shouldClearSession
+                    ? undefined
+                    : (payload.sessionCli ?? current.wake.sessionCli),
+                workspacePath: payload.workspacePath ?? current.wake.workspacePath,
+                blockReason: payload.blockReason ?? current.wake.blockReason,
+                syncedAt: event.ingestedAt,
+                stageHistory: stageChanged
+                    ? [
+                        ...current.wake.stageHistory,
+                        {
+                            stage: payload.nextStage,
+                            changedAt: event.occurredAt,
+                            reason: payload.reason ?? event.sourceEventType,
+                        },
+                    ]
+                    : current.wake.stageHistory,
+                recentEventIds: [...current.wake.recentEventIds, event.eventId].slice(-10),
+            },
+        });
+    }
+    if (event.sourceEventType === 'ticket.reply.published') {
+        const commentId = event.sourceRefs.commentId;
+        if (commentId === undefined) {
+            return parseIssueStateRecord({
+                ...current,
+                wake: {
+                    ...current.wake,
+                    syncedAt: event.ingestedAt,
+                    recentEventIds: [...current.wake.recentEventIds, event.eventId].slice(-10),
+                },
+            });
+        }
+        return parseIssueStateRecord({
+            ...current,
+            wake: {
+                ...current.wake,
+                expectedEcho: {
+                    ...current.wake.expectedEcho,
+                    commentIds: Array.from(new Set([...current.wake.expectedEcho.commentIds, commentId])),
+                },
+                syncedAt: event.ingestedAt,
+                recentEventIds: [...current.wake.recentEventIds, event.eventId].slice(-10),
+            },
+        });
+    }
+    if (event.sourceEventType === 'wake.workspace.cleaned') {
+        return parseIssueStateRecord({
+            ...current,
+            wake: {
+                ...current.wake,
+                workspacePath: undefined,
+                syncedAt: event.ingestedAt,
+                recentEventIds: [...current.wake.recentEventIds, event.eventId].slice(-10),
+            },
+        });
+    }
+    if (event.sourceEventType === 'ticket.labels.updated') {
+        const labels = stringArrayFromPayload(event.payload.labels);
+        return parseIssueStateRecord({
+            ...current,
+            issue: {
+                ...current.issue,
+                labels,
+            },
+            wake: {
+                ...current.wake,
+                expectedEcho: {
+                    ...current.wake.expectedEcho,
+                    labels,
+                },
+                syncedAt: event.ingestedAt,
+                recentEventIds: [...current.wake.recentEventIds, event.eventId].slice(-10),
+            },
+        });
+    }
+    // Purely an audit record; must never affect projection state, so a full
+    // event replay produces byte-identical output whether or not this
+    // synthesized event happens to be included in the batch being folded
+    // (it's created as a fold side effect, not iterated over on the original
+    // pass, but is naturally present on a later full replay).
+    if (event.sourceEventType === CORRELATION_PRIMARY_CONFLICT_EVENT) {
+        return current;
+    }
+    if (event.sourceEventType === CORRELATION_REGISTERED_EVENT) {
+        const payload = event.payload;
+        // ADR 0001 §6 is a *downgrade* rule, and only a downgrade rule: "a second
+        // `primary` registration on a claimed URI is downgraded to `secondary` and
+        // a warning event appended." It says nothing about promoting a requested
+        // `secondary`, and §5 lists `relation` as a payload input — so a requested
+        // `secondary` must stay `secondary`. Folding a requested `secondary` up to
+        // `primary` would silently rewrite the declaration the event made, and the
+        // downgrade rule is a corruption guard, not a merge rule — it exists to
+        // stop a second claim on a URI, not to promote unclaimed ones.
+        //
+        // (No shipped caller declares `secondary` yet — `wake correlate` hardcodes
+        // `primary`. The rule follows the spec's payload contract, which is the
+        // standard here; an emitter is #82's scope.)
+        //
+        //   requested primary + held by ANOTHER work item -> secondary + conflict
+        //   requested primary + unclaimed / held by THIS   -> primary, indexed
+        //   requested secondary                            -> secondary, unindexed
+        //
+        // A requested-secondary never touching the index is by design, not an
+        // orphan: the index is primary-only (ADR §5 — the resolver stamps the
+        // *primary* work item's canonical key), so a secondary has nothing to
+        // register. Promotion still requires the incumbent to retract first —
+        // never let a second registration silently steal a uri.
+        const incumbent = await ctx.resourceIndex.resolve(payload.resourceUri);
+        const heldByAnotherWorkItem = incumbent !== undefined && incumbent !== current.workItemKey;
+        const relation = payload.relation === 'primary' && !heldByAnotherWorkItem ? 'primary' : 'secondary';
+        if (relation === 'primary') {
+            await ctx.resourceIndex.register(payload.resourceUri, current.workItemKey);
+        }
+        else {
+            if (payload.relation === 'primary') {
+                await ctx.appendEvent(createEventEnvelope({
+                    eventId: `${event.eventId}-primary-conflict`,
+                    workItemKey: current.workItemKey,
+                    streamScope: 'work-item',
+                    direction: 'internal',
+                    sourceSystem: 'wake',
+                    sourceEventType: CORRELATION_PRIMARY_CONFLICT_EVENT,
+                    sourceRefs: event.sourceRefs,
+                    occurredAt: event.occurredAt,
+                    ingestedAt: event.ingestedAt,
+                    trigger: 'context-only',
+                    payload: {
+                        resourceUri: payload.resourceUri,
+                        incumbentWorkItemKey: incumbent,
+                    },
+                }));
+            }
+            // Coherent inverse of the retraction gate below: a registration that
+            // folds to non-primary must never leave the index stranded crediting
+            // this work item. This is reachable as a genuine *self-demotion* — a
+            // work item that holds a uri primary and then registers it `secondary`
+            // — where leaving the index pointing at us would contradict our own
+            // correlatedResources[] entry. Gated on actual index ownership, so the
+            // ordinary requested-secondary-on-an-unclaimed-uri case (owner
+            // undefined) correctly leaves the index untouched (finding B).
+            const owner = await ctx.resourceIndex.resolve(payload.resourceUri);
+            if (owner === current.workItemKey) {
+                await ctx.resourceIndex.retract(payload.resourceUri);
+            }
+        }
+        const entry = {
+            resourceUri: payload.resourceUri,
+            role: payload.role,
+            relation,
+            provenance: payload.provenance,
+            ...(payload.registeredBy === undefined ? {} : { registeredBy: payload.registeredBy }),
+            registeredAt: event.occurredAt,
+        };
+        const currentCorrelatedResources = current.correlatedResources;
+        const existingIndex = currentCorrelatedResources.findIndex((resource) => resource.resourceUri === payload.resourceUri);
+        const correlatedResources = existingIndex === -1
+            ? [...currentCorrelatedResources, entry]
+            : currentCorrelatedResources.map((resource, index) => index === existingIndex ? entry : resource);
+        return parseIssueStateRecord({
+            ...current,
+            correlatedResources,
+            wake: {
+                ...current.wake,
+                syncedAt: event.ingestedAt,
+                recentEventIds: [...current.wake.recentEventIds, event.eventId].slice(-10),
+            },
+        });
+    }
+    if (event.sourceEventType === CORRELATION_RETRACTED_EVENT) {
+        const payload = event.payload;
+        const currentCorrelatedResources = current.correlatedResources;
+        // Retract whenever the index currently credits this work item —
+        // regardless of the locally stored relation — so the registration and
+        // retraction gates are coherent inverses across a demotion. Gating this
+        // on `existing?.relation === 'primary'` (the locally folded relation at
+        // *registration* time) can strand the index pointing at a work item that
+        // no longer holds the resource once that relation has drifted, which is
+        // exactly the identity-critical path `resolve()` depends on (finding B).
+        const owner = await ctx.resourceIndex.resolve(payload.resourceUri);
+        if (owner === current.workItemKey) {
+            await ctx.resourceIndex.retract(payload.resourceUri);
+        }
+        return parseIssueStateRecord({
+            ...current,
+            correlatedResources: currentCorrelatedResources.filter((resource) => resource.resourceUri !== payload.resourceUri),
+            wake: {
+                ...current.wake,
+                syncedAt: event.ingestedAt,
+                recentEventIds: [...current.wake.recentEventIds, event.eventId].slice(-10),
+            },
+        });
+    }
+    return parseIssueStateRecord({
+        ...current,
+        wake: {
+            ...current.wake,
+            syncedAt: event.ingestedAt,
+            recentEventIds: [...current.wake.recentEventIds, event.eventId].slice(-10),
+        },
+    });
+}
+export function createProjectionUpdater(deps) {
+    const applyEventCtx = {
+        resourceIndex: deps.resourceIndex,
+        appendEvent: (event) => deps.stateStore.appendEventEnvelope(event),
+    };
+    return {
+        async rebuildFromEvents(events) {
+            // Correlation-index-affecting events (wake.correlation.registered in
+            // particular) must be folded in *globally* ordered time, not grouped by
+            // workItemKey and folded per-group. resourceIndex is shared/global
+            // across all work items, so whichever group happens to be visited first
+            // (Map insertion order — i.e. whichever work item's earliest event
+            // happens to appear first in the input array) would otherwise decide
+            // who wins a primary claim, independent of when the registration events
+            // actually occurred. That makes a full replay (this function, called
+            // with every event) diverge from the live/incremental fold (this
+            // function, called with one new event at a time as it happens) for any
+            // two work items whose creation order and registration order disagree
+            // — silently handing resumption for a resource to the wrong work item
+            // after `rm -rf state/` + replay. Sorting once, globally, by
+            // (ingestedAt, eventId) and folding in that single pass keeps replay
+            // and live agreeing by construction, for both the index and the
+            // per-work-item projection fold (a global sort is still a valid order
+            // for each individual work item's own events, since it's a stable
+            // sort over a total order that's consistent with each event's own
+            // ingestedAt).
+            // Sort is stable (ES2019+), so events sharing an ingestedAt keep their
+            // input order — which is append/arrival order, the same order the live
+            // fold saw them in. Do not add a tie-break on eventId: ids are not
+            // chronological, so that would reorder same-timestamp events within a
+            // work item against the order they actually happened.
+            const ordered = [...events].sort((left, right) => left.ingestedAt.localeCompare(right.ingestedAt));
+            const projections = new Map();
+            const touchedWorkItemKeys = [];
+            for (const event of ordered) {
+                if (!projections.has(event.workItemKey)) {
+                    touchedWorkItemKeys.push(event.workItemKey);
+                    projections.set(event.workItemKey, await deps.stateStore.readIssueState(event.workItemKey));
+                }
+                const current = projections.get(event.workItemKey) ?? null;
+                projections.set(event.workItemKey, await applyEvent(current, event, applyEventCtx, deps.config));
+            }
+            for (const workItemKey of touchedWorkItemKeys) {
+                const projection = projections.get(workItemKey) ?? null;
+                if (projection !== null) {
+                    await deps.stateStore.writeIssueState(projection);
+                }
+            }
+        },
+    };
+}

package/dist/src/core/quota-backoff.js

@@ -0,0 +1,69 @@
+function applyTimeOfDay(input) {
+    let hours = input.hours;
+    if (hours === 12) {
+        hours = 0;
+    }
+    if (input.meridiem === 'pm') {
+        hours += 12;
+    }
+    const reset = new Date(input.now);
+    if (input.useUtc) {
+        reset.setUTCHours(hours, input.minutes, 0, 0);
+        if (reset.getTime() <= input.now.getTime()) {
+            reset.setUTCDate(reset.getUTCDate() + 1);
+        }
+    }
+    else {
+        reset.setHours(hours, input.minutes, 0, 0);
+        if (reset.getTime() <= input.now.getTime()) {
+            reset.setDate(reset.getDate() + 1);
+        }
+    }
+    return reset.toISOString();
+}
+// CLIs report quota resets in prose, e.g. Claude's "resets 1:10am (UTC)" or
+// Codex's "try again at 2:29 PM" (no zone marker at all). Only trust a time as
+// UTC when the message says so explicitly; an unlabeled time is the CLI
+// provider's local clock, not ours, but treating it as this machine's local
+// time is the closest honest guess without a zone — better than silently
+// assuming UTC and pausing for the wrong duration.
+const utcResetPattern = /(?:resets?|try again at)\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)\s*(?:\(utc\)|utc)/i;
+const localResetPattern = /(?:resets?|try again at)\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)\b/i;
+// A cap on the exponential-backoff guess used when no reset time is reported
+// (see below). Kept well under a working day so a stuck-forever pause is
+// never possible even if the guess is wrong - worst case, Wake retries hourly.
+const maxEstimatedPauseMs = 60 * 60_000;
+export function resolveQuotaPauseUntil(input) {
+    const utcMatch = utcResetPattern.exec(input.result);
+    if (utcMatch !== null) {
+        return {
+            pausedUntil: applyTimeOfDay({
+                hours: Number(utcMatch[1]),
+                minutes: Number(utcMatch[2] ?? 0),
+                meridiem: utcMatch[3]?.toLowerCase(),
+                now: input.now,
+                useUtc: true,
+            }),
+            source: 'reported',
+        };
+    }
+    const localMatch = localResetPattern.exec(input.result);
+    if (localMatch !== null) {
+        return {
+            pausedUntil: applyTimeOfDay({
+                hours: Number(localMatch[1]),
+                minutes: Number(localMatch[2] ?? 0),
+                meridiem: localMatch[3]?.toLowerCase(),
+                now: input.now,
+                useUtc: false,
+            }),
+            source: 'reported',
+        };
+    }
+    const boundedFailureCount = Math.max(1, Math.min(input.failureCount, 6));
+    const delayMs = Math.min(15 * 60_000 * (2 ** (boundedFailureCount - 1)), maxEstimatedPauseMs);
+    return {
+        pausedUntil: new Date(input.now.getTime() + delayMs).toISOString(),
+        source: 'estimated',
+    };
+}

package/dist/src/core/sink-router.js

@@ -0,0 +1,85 @@
+export function createWorkSourceFanIn(sources) {
+    return {
+        async pollEvents(input) {
+            const batches = await Promise.all(sources.map((source) => source.pollEvents(input)));
+            return batches.flat();
+        },
+    };
+}
+function intentKind(event) {
+    if (event.sourceEventType !== 'wake.publish.intent.requested') {
+        return null;
+    }
+    return typeof event.payload.kind === 'string' ? event.payload.kind : null;
+}
+function isTerminalStageIntent(event) {
+    const stage = event.derivedHints?.stage;
+    return stage === 'done' || event.payload.sentinel === 'BLOCKED';
+}
+function subscriptionMatches(event, subscription) {
+    if (subscription === intentKind(event)) {
+        return true;
+    }
+    return subscription === 'stage.terminal' && isTerminalStageIntent(event);
+}
+function sinkNameForResourceUri(resourceUri, fallback) {
+    const [provider, kind] = resourceUri.split(':');
+    if (provider === undefined || kind === undefined) {
+        return fallback;
+    }
+    return kind === 'pr' || kind === 'pr-review-thread' ? `${provider}-pr` : fallback;
+}
+function withSinkRef(event, sink) {
+    return {
+        ...event,
+        sourceRefs: {
+            ...event.sourceRefs,
+            sink: event.sourceRefs.sink ?? sink,
+        },
+    };
+}
+export function createOutboundSinkRouter(input) {
+    const sinksByName = new Map(input.sinks.map((sink) => [sink.sink, sink]));
+    return {
+        async deliverIntent({ event }) {
+            const targetSinks = new Set();
+            const origin = typeof event.payload.origin === 'string' ? event.payload.origin : undefined;
+            const sourceOrigin = event.sourceRefs.sink ?? origin;
+            if (event.sourceEventType === 'wake.labels.requested') {
+                const projectionOrigin = typeof event.payload.origin === 'string'
+                    ? event.payload.origin
+                    : undefined;
+                if (projectionOrigin !== undefined) {
+                    targetSinks.add(projectionOrigin);
+                }
+            }
+            const kind = intentKind(event);
+            const resourceUri = event.sourceRefs.resourceUri;
+            if (event.sourceEventType === 'wake.publish.intent.requested' &&
+                sourceOrigin !== undefined) {
+                const resourceSink = resourceUri === undefined ? sourceOrigin : sinkNameForResourceUri(resourceUri, sourceOrigin);
+                // A resource-derived sink name (e.g. a PR surface) may not be
+                // registered — the source that owns it can be disabled independently
+                // of the origin sink. Falling back to sourceOrigin here, rather than
+                // silently skipping an unregistered sink below, is what keeps a reply
+                // from being dropped-but-marked-delivered when that happens.
+                targetSinks.add(sinksByName.has(resourceSink) ? resourceSink : sourceOrigin);
+            }
+            for (const [sinkName, sinkConfig] of Object.entries(input.config.sinks ?? {})) {
+                if (sinkConfig.subscribe.some((subscription) => subscriptionMatches(event, subscription))) {
+                    targetSinks.add(sinkName);
+                }
+            }
+            const deliveryEvents = [];
+            for (const sinkName of targetSinks) {
+                const sink = sinksByName.get(sinkName);
+                if (sink === undefined) {
+                    continue;
+                }
+                const sinkDeliveryEvents = await sink.deliverIntent({ event });
+                deliveryEvents.push(...sinkDeliveryEvents.map((deliveryEvent) => withSinkRef(deliveryEvent, sinkName)));
+            }
+            return deliveryEvents;
+        },
+    };
+}