@atolis-hq/wake 0.2.97 → 0.3.0

package/dist/src/orchestration/application/accept-activity-outcome.js

@@ -0,0 +1,25 @@
+import { orchestrationActivityOutcome } from '../contracts/activity-outcome.js';
+import { acceptActivityOutcome as decideActivityOutcome } from '../domain/interpreter.js';
+export class AcceptActivityOutcome {
+    repository;
+    workflows;
+    reconcileChildCompletions;
+    constructor(repository, workflows, reconcileChildCompletions) {
+        this.repository = repository;
+        this.workflows = workflows;
+        this.reconcileChildCompletions = reconcileChildCompletions;
+    }
+    async execute(command, context) {
+        const loaded = await this.repository.loadRequired(command.workflowInstanceId);
+        const decision = decideActivityOutcome(this.workflows.definition(loaded.view.workflowName), loaded.view, {
+            ...command,
+            outcome: orchestrationActivityOutcome(command.outcome),
+            occurredAt: context.occurredAt,
+            causationId: context.commandId,
+        });
+        if (decision.kind === 'append')
+            await this.repository.append(command.workflowInstanceId, loaded.sequence, decision.events);
+        await this.reconcileChildCompletions(context);
+        return (await this.repository.loadRequired(command.workflowInstanceId)).view;
+    }
+}

package/dist/src/orchestration/application/accept-signal.js

@@ -0,0 +1,35 @@
+import { acceptSignal as decideSignal, waitForSignal as decideSignalWait, } from '../domain/interpreter.js';
+export class AcceptSignal {
+    repository;
+    workflows;
+    work;
+    constructor(repository, workflows, work) {
+        this.repository = repository;
+        this.workflows = workflows;
+        this.work = work;
+    }
+    async wait(workflowInstanceId, expectation, context) {
+        const loaded = await this.repository.loadRequired(workflowInstanceId);
+        const decision = decideSignalWait(loaded.view, expectation, {
+            occurredAt: context.occurredAt,
+            causationId: context.commandId,
+        });
+        if (decision.kind === 'ignored')
+            throw new Error(decision.reason);
+        await this.repository.append(workflowInstanceId, loaded.sequence, decision.events);
+        return (await this.repository.loadRequired(workflowInstanceId)).view;
+    }
+    async execute(workflowInstanceId, signal, context) {
+        const loaded = await this.repository.loadRequired(workflowInstanceId);
+        const item = await this.work.get(loaded.view.workItemId);
+        const decision = decideSignal(this.workflows.definition(loaded.view.workflowName), loaded.view, {
+            signal,
+            occurredAt: context.occurredAt,
+            causationId: context.commandId,
+            consent: item?.autoApprovalGranted ?? false,
+        });
+        if (decision.kind === 'append')
+            await this.repository.append(workflowInstanceId, loaded.sequence, decision.events);
+        return (await this.repository.loadRequired(workflowInstanceId)).view;
+    }
+}

package/dist/src/orchestration/application/advance-workflow.js

@@ -0,0 +1,160 @@
+import { EventSourceKind, createEventDraft } from '../../kernel/index.js';
+import { OrchestrationEventType } from '../contracts/events.js';
+import { commandName, workflowInstanceId, } from '../contracts/identifiers.js';
+import { workflowInstanceStream } from '../contracts/streams.js';
+import { WorkflowStatus } from '../contracts/vocabulary.js';
+import { requestOperatorRetry as decideOperatorRetry, requestSupplementalActivity as decideSupplementalActivity, } from '../domain/interpreter.js';
+import { isAuthorisedActor } from '../domain/supplemental-policy.js';
+export class OperatorRetryIneligibleError extends Error {
+    constructor(detail) {
+        super(detail);
+        this.name = 'OperatorRetryIneligibleError';
+    }
+}
+export class AdvanceWorkflow {
+    repository;
+    workflows;
+    constructor(repository, workflows) {
+        this.repository = repository;
+        this.workflows = workflows;
+    }
+    async requestSupplementalActivity(id, request, context) {
+        const loaded = await this.repository.loadRequired(id);
+        const configured = this.workflows.definition(loaded.view.workflowName).commands[commandName(request.command)];
+        if (configured === undefined)
+            throw new Error(`Unknown supplemental command: ${request.command}`);
+        if (!isAuthorisedActor(configured.allowedActors, context.actor.kind))
+            throw new Error(`Actor kind ${context.actor.kind} is not authorised for ${request.command}`);
+        const decision = decideSupplementalActivity(loaded.view, {
+            activity: configured.activity,
+            input: configured.with,
+            requestedBy: context.actor.id,
+        }, { occurredAt: context.occurredAt, causationId: context.commandId });
+        if (decision.kind === 'ignored')
+            throw new Error(decision.reason);
+        await this.repository.append(id, loaded.sequence, decision.events);
+        return (await this.repository.loadRequired(id)).view;
+    }
+    async markActivationStarted(id, activationId, context) {
+        const loaded = await this.repository.load(id);
+        if (loaded.view?.pendingActivation?.activationId !== activationId)
+            return loaded.view;
+        const event = createEventDraft({
+            eventId: `${context.commandId}:${OrchestrationEventType.ActivityStarted}`,
+            eventType: OrchestrationEventType.ActivityStarted,
+            occurredAt: context.occurredAt,
+            correlationId: context.correlationId,
+            causationId: context.commandId,
+            actor: context.actor,
+            source: { kind: EventSourceKind.Internal, id: 'orchestration-service' },
+            stream: workflowInstanceStream(workflowInstanceId(id)),
+            payload: { activationId },
+        });
+        await this.repository.append(id, loaded.sequence, [event]);
+        return (await this.repository.load(id)).view;
+    }
+    async block(id, reason, context) {
+        const loaded = await this.repository.load(id);
+        if (loaded.view === null || loaded.view.status === WorkflowStatus.Blocked)
+            return loaded.view;
+        const event = createEventDraft({
+            eventId: `${context.commandId}:${OrchestrationEventType.InstanceBlocked}`,
+            eventType: OrchestrationEventType.InstanceBlocked,
+            occurredAt: context.occurredAt,
+            correlationId: context.correlationId,
+            causationId: context.commandId,
+            actor: context.actor,
+            source: { kind: EventSourceKind.Internal, id: 'orchestration-service' },
+            stream: workflowInstanceStream(id),
+            payload: { reason },
+        });
+        await this.repository.append(id, loaded.sequence, [event]);
+        return (await this.repository.load(id)).view;
+    }
+    async resolveExecutionFailure(id, input, context) {
+        const loaded = await this.repository.load(id);
+        if (loaded.view === null ||
+            loaded.view.status === WorkflowStatus.Blocked ||
+            loaded.view.pendingActivation?.activationId !== input.activationId ||
+            loaded.view.acceptedOutcomes.includes(input.activationId))
+            return loaded.view;
+        const stream = workflowInstanceStream(id);
+        await this.repository.append(id, loaded.sequence, [
+            createEventDraft({
+                eventId: `${context.commandId}:${OrchestrationEventType.ActivityExecutionFailed}`,
+                eventType: OrchestrationEventType.ActivityExecutionFailed,
+                occurredAt: context.occurredAt,
+                correlationId: context.correlationId,
+                causationId: context.commandId,
+                actor: context.actor,
+                source: { kind: EventSourceKind.Internal, id: 'orchestration-service' },
+                stream,
+                payload: input,
+            }),
+            createEventDraft({
+                eventId: `${context.commandId}:${OrchestrationEventType.InstanceBlocked}`,
+                eventType: OrchestrationEventType.InstanceBlocked,
+                occurredAt: context.occurredAt,
+                correlationId: context.correlationId,
+                causationId: context.commandId,
+                actor: context.actor,
+                source: { kind: EventSourceKind.Internal, id: 'orchestration-service' },
+                stream,
+                payload: { reason: input.reason },
+            }),
+        ]);
+        return (await this.repository.load(id)).view;
+    }
+    async retryBlockedFailedStage(id, context) {
+        const loaded = await this.repository.load(id);
+        if (loaded.view === null)
+            throw new OperatorRetryIneligibleError('WorkflowInstance does not exist');
+        if (loaded.view.operatorRetryCommandIds.includes(context.commandId))
+            return loaded.view;
+        const decision = decideOperatorRetry(this.workflows.definition(loaded.view.workflowName), loaded.view, {
+            commandId: context.commandId,
+            occurredAt: context.occurredAt,
+            causationId: context.commandId,
+        });
+        if (decision.kind === 'ignored')
+            throw new OperatorRetryIneligibleError(decision.reason);
+        try {
+            await this.repository.append(id, loaded.sequence, decision.events);
+        }
+        catch (error) {
+            const reloaded = await this.repository.loadRequired(id);
+            if (reloaded.view.operatorRetryCommandIds.includes(context.commandId))
+                return reloaded.view;
+            throw error;
+        }
+        return (await this.repository.loadRequired(id)).view;
+    }
+    async get(id) {
+        return (await this.repository.load(id)).view;
+    }
+    async listPendingActivations(workItemId) {
+        return (await this.repository.list())
+            .filter((view) => view !== null &&
+            view.status === WorkflowStatus.Active &&
+            view.pendingActivation !== undefined &&
+            (workItemId === undefined || view.workItemId === workItemId))
+            .map((view) => ({ workflow: view, activation: view.pendingActivation }));
+    }
+    async listWaiting(signalKind) {
+        return (await this.repository.list()).filter((view) => view?.status === WorkflowStatus.Waiting &&
+            (signalKind === undefined || view.waitingFor?.signalKind === signalKind));
+    }
+    async listAll() {
+        return (await this.repository.list()).filter((view) => view !== null);
+    }
+    async listWatchMatches(eventType) {
+        return (await this.listAll()).flatMap((parent) => {
+            const definition = this.workflows.definition(parent.workflowName);
+            return definition.watches
+                .filter((watch) => watch.on?.events.includes(eventType) === true &&
+                watch.while.stages.includes(parent.currentStage) &&
+                watch.while.statuses.some((status) => status === parent.status))
+                .map((watch) => ({ parent, watch }));
+        });
+    }
+}

package/dist/src/orchestration/application/coordination-claims.js

@@ -0,0 +1,107 @@
+import { createEventDraft, EventSourceKind, WrongExpectedSequenceError, } from '../../kernel/index.js';
+import { selectOrchestrationEvent } from '../contracts/event-decoder.js';
+import { OrchestrationEventType } from '../contracts/events.js';
+import { isOrchestrationGroupStream, primaryOrchestrationGroupStream, } from '../contracts/streams.js';
+export class CoordinationClaims {
+    journal;
+    constructor(journal) {
+        this.journal = journal;
+    }
+    async claimPrimary(workItemId, workflowInstanceId, context) {
+        const stream = primaryOrchestrationGroupStream(workItemId);
+        for (;;) {
+            const events = await this.journal.readStream(stream);
+            const owner = primaryOwner(groupEvents(events));
+            if (owner !== undefined) {
+                if (owner === workflowInstanceId)
+                    return;
+                throw new Error(`WorkItem already has an active primary workflow owned by ${owner}`);
+            }
+            try {
+                await this.journal.append(stream, events.length, [
+                    createEventDraft({
+                        eventId: `${context.commandId}:${OrchestrationEventType.PrimaryClaimed}:${workItemId}`,
+                        eventType: OrchestrationEventType.PrimaryClaimed,
+                        occurredAt: context.occurredAt,
+                        correlationId: context.correlationId,
+                        causationId: context.commandId,
+                        actor: context.actor,
+                        source: { kind: EventSourceKind.Internal, id: 'orchestration-service' },
+                        stream,
+                        payload: { workItemId, workflowInstanceId },
+                    }),
+                ]);
+                return;
+            }
+            catch (error) {
+                if (!(error instanceof WrongExpectedSequenceError))
+                    throw error;
+            }
+        }
+    }
+    async primaryWorkflowInstanceId(workItemId) {
+        return primaryOwner(groupEvents(await this.journal.readStream(primaryOrchestrationGroupStream(workItemId))));
+    }
+    async claimWithinBudget(stream, request, context) {
+        for (;;) {
+            const events = await this.journal.readStream(stream);
+            if (claimedRequestIds(groupEvents(events)).has(request.requestId))
+                return true;
+            if (events.length >= request.maxPerGroup)
+                return false;
+            try {
+                await this.journal.append(stream, events.length, [
+                    createEventDraft({
+                        eventId: `${context.commandId}:${OrchestrationEventType.GroupClaimed}:${request.requestId}`,
+                        eventType: OrchestrationEventType.GroupClaimed,
+                        occurredAt: context.occurredAt,
+                        correlationId: context.correlationId,
+                        causationId: context.commandId,
+                        actor: context.actor,
+                        source: { kind: EventSourceKind.Internal, id: 'orchestration-service' },
+                        stream,
+                        payload: { key: stream.id, requestId: request.requestId },
+                    }),
+                ]);
+                return true;
+            }
+            catch (error) {
+                if (!(error instanceof WrongExpectedSequenceError))
+                    throw error;
+            }
+        }
+    }
+}
+function primaryOwner(events) {
+    for (const event of events) {
+        switch (event.eventType) {
+            case OrchestrationEventType.PrimaryClaimed:
+                return event.payload.workflowInstanceId;
+            case OrchestrationEventType.GroupClaimed:
+                break;
+            default:
+                assertNever(event);
+        }
+    }
+    return undefined;
+}
+function claimedRequestIds(events) {
+    return new Set(events.flatMap((event) => {
+        switch (event.eventType) {
+            case OrchestrationEventType.GroupClaimed:
+                return [event.payload.requestId];
+            case OrchestrationEventType.PrimaryClaimed:
+                return [];
+            default:
+                return assertNever(event);
+        }
+    }));
+}
+function groupEvents(events) {
+    return events
+        .map(selectOrchestrationEvent)
+        .filter((event) => event !== null && isOrchestrationGroupStream(event.stream));
+}
+function assertNever(value) {
+    throw new Error(`Unhandled Orchestration group event: ${JSON.stringify(value)}`);
+}

package/dist/src/orchestration/application/group-budget-recorder.js

@@ -0,0 +1,43 @@
+import { WrongExpectedSequenceError, } from '../../kernel/index.js';
+import { selectOrchestrationEvent } from '../contracts/event-decoder.js';
+import { OrchestrationEventType } from '../contracts/events.js';
+import { workflowInstanceId } from '../contracts/identifiers.js';
+import { workflowInstanceStream } from '../contracts/streams.js';
+import { coordinationDraft } from '../domain/coordination-events.js';
+import { stateDraft } from '../domain/decision-events.js';
+export class GroupBudgetRecorder {
+    journal;
+    constructor(journal) {
+        this.journal = journal;
+    }
+    async record(parent, metadata, maxPerGroup, context) {
+        const stream = workflowInstanceStream(workflowInstanceId(parent.workflowInstanceId));
+        const payload = { ...metadata, maxPerGroup };
+        for (;;) {
+            const events = await this.journal.readStream(stream);
+            if (events.some((event) => {
+                const owned = selectOrchestrationEvent(event);
+                return (owned?.eventType === OrchestrationEventType.GroupBudgetExhausted &&
+                    owned.payload.requestId === metadata.requestId);
+            }))
+                return;
+            try {
+                await this.journal.append(stream, events.length, [
+                    coordinationDraft({
+                        workflowInstanceId: parent.workflowInstanceId,
+                        eventIdPrefix: context.commandId,
+                        occurredAt: context.occurredAt,
+                        correlationId: parent.orchestrationGroupId,
+                        causationId: context.commandId,
+                    }, OrchestrationEventType.GroupBudgetExhausted, payload, 1),
+                    stateDraft(parent, { occurredAt: context.occurredAt, causationId: context.commandId }, OrchestrationEventType.InstanceBlocked, { reason: `watch group budget exhausted for ${metadata.watchId}` }, 2),
+                ]);
+                return;
+            }
+            catch (error) {
+                if (!(error instanceof WrongExpectedSequenceError))
+                    throw error;
+            }
+        }
+    }
+}

package/dist/src/orchestration/application/orchestration-projection.js

@@ -0,0 +1,20 @@
+import { selectWorkflowOrchestrationEvent } from '../contracts/event-decoder.js';
+import { isWorkflowInstanceStream } from '../contracts/streams.js';
+import { foldWorkflowInstance } from '../domain/workflow-instance.js';
+export const orchestrationProjection = {
+    name: 'orchestration',
+    select(event) {
+        const owned = selectWorkflowOrchestrationEvent(event);
+        return owned !== null && isWorkflowInstanceStream(owned.stream)
+            ? { key: owned.stream.id }
+            : null;
+    },
+    initial: () => ({ events: [], view: null }),
+    project(previous, event) {
+        const owned = selectWorkflowOrchestrationEvent(event);
+        if (owned === null || !isWorkflowInstanceStream(owned.stream))
+            return previous;
+        const events = [...previous.events, owned];
+        return { events, view: foldWorkflowInstance(events) };
+    },
+};

package/dist/src/orchestration/application/orchestration-repository.js

@@ -0,0 +1,36 @@
+import { decodeOrchestrationEvent, selectWorkflowOrchestrationEvent, } from '../contracts/event-decoder.js';
+import { workflowInstanceId } from '../contracts/identifiers.js';
+import { isWorkflowInstanceStream, workflowInstanceStream } from '../contracts/streams.js';
+import { foldWorkflowInstance } from '../domain/workflow-instance.js';
+export class OrchestrationRepository {
+    journal;
+    constructor(journal) {
+        this.journal = journal;
+    }
+    async load(id) {
+        const events = await this.journal.readStream(workflowInstanceStream(workflowInstanceId(id)));
+        const owned = events
+            .map(selectWorkflowOrchestrationEvent)
+            .filter((event) => event !== null && isWorkflowInstanceStream(event.stream));
+        return { sequence: events.length, view: foldWorkflowInstance(owned) };
+    }
+    async loadRequired(id) {
+        const loaded = await this.load(id);
+        if (loaded.view === null)
+            throw new Error('WorkflowInstance does not exist');
+        return { sequence: loaded.sequence, view: loaded.view };
+    }
+    async append(id, sequence, drafts) {
+        const events = await this.journal.append(workflowInstanceStream(workflowInstanceId(id)), sequence, drafts);
+        return events.map(decodeOrchestrationEvent).filter(isWorkflowEvent);
+    }
+    async list() {
+        const ids = new Set((await this.journal.readAll(0))
+            .filter((event) => isWorkflowInstanceStream(event.stream))
+            .map((event) => event.stream.id));
+        return Promise.all([...ids].map(async (id) => (await this.load(id)).view));
+    }
+}
+function isWorkflowEvent(event) {
+    return isWorkflowInstanceStream(event.stream);
+}

package/dist/src/orchestration/application/orchestration-service.js

@@ -0,0 +1,82 @@
+import { AcceptActivityOutcome } from './accept-activity-outcome.js';
+import { AcceptSignal } from './accept-signal.js';
+import { AdvanceWorkflow } from './advance-workflow.js';
+import { CoordinationClaims } from './coordination-claims.js';
+import { GroupBudgetRecorder } from './group-budget-recorder.js';
+import { OrchestrationRepository } from './orchestration-repository.js';
+import { RequestChild } from './request-child.js';
+import { StartWorkflow } from './start-workflow.js';
+export class OrchestrationService {
+    startWorkflow;
+    acceptActivityOutcome;
+    acceptWorkflowSignal;
+    advanceWorkflow;
+    childWorkflows;
+    constructor(journal, work, definitions) {
+        const repository = new OrchestrationRepository(journal);
+        const claims = new CoordinationClaims(journal);
+        this.startWorkflow = new StartWorkflow(repository, claims, work, definitions);
+        this.acceptWorkflowSignal = new AcceptSignal(repository, this.startWorkflow, work);
+        this.advanceWorkflow = new AdvanceWorkflow(repository, this.startWorkflow);
+        this.childWorkflows = new RequestChild(repository, claims, new GroupBudgetRecorder(journal), this.startWorkflow, this.advanceWorkflow);
+        this.acceptActivityOutcome = new AcceptActivityOutcome(repository, this.startWorkflow, (context) => this.childWorkflows.reconcileChildCompletions(context));
+    }
+    start(command, context) {
+        return this.startWorkflow.execute(command, context);
+    }
+    requestChild(request, context) {
+        return this.childWorkflows.execute(request, context);
+    }
+    rejectCausalActivation(request, context) {
+        return this.childWorkflows.rejectCausalActivation(request, context);
+    }
+    acceptOutcome(command, context) {
+        return this.acceptActivityOutcome.execute(command, context);
+    }
+    waitForSignal(workflowInstanceId, expectation, context) {
+        return this.acceptWorkflowSignal.wait(workflowInstanceId, expectation, context);
+    }
+    acceptSignal(workflowInstanceId, signal, context) {
+        return this.acceptWorkflowSignal.execute(workflowInstanceId, signal, context);
+    }
+    requestSupplementalActivity(workflowInstanceId, request, context) {
+        return this.advanceWorkflow.requestSupplementalActivity(workflowInstanceId, request, context);
+    }
+    markActivationStarted(workflowInstanceId, activationId, context) {
+        return this.advanceWorkflow.markActivationStarted(workflowInstanceId, activationId, context);
+    }
+    block(workflowInstanceId, reason, context) {
+        return this.advanceWorkflow.block(workflowInstanceId, reason, context);
+    }
+    resolveExecutionFailure(workflowInstanceId, input, context) {
+        return this.advanceWorkflow.resolveExecutionFailure(workflowInstanceId, input, context);
+    }
+    retryBlockedFailedStage(workflowInstanceId, context) {
+        return this.advanceWorkflow.retryBlockedFailedStage(workflowInstanceId, context);
+    }
+    get(id) {
+        return this.advanceWorkflow.get(id);
+    }
+    getPrimaryWorkflowInstanceId(workItemId) {
+        return this.childWorkflows.getPrimaryWorkflowInstanceId(workItemId);
+    }
+    listPendingActivations(workItemId) {
+        return this.advanceWorkflow.listPendingActivations(workItemId);
+    }
+    listWaiting(signalKind) {
+        return this.advanceWorkflow.listWaiting(signalKind);
+    }
+    listAll() {
+        return this.advanceWorkflow.listAll();
+    }
+    reconcileChildCompletions(context) {
+        return this.childWorkflows.reconcileChildCompletions(context);
+    }
+    isCausalRepeat(workflowInstanceId, triggerId, causalCycleId, requestId) {
+        return this.childWorkflows.isCausalRepeat(workflowInstanceId, triggerId, causalCycleId, requestId);
+    }
+    listWatchMatches(eventType) {
+        return this.advanceWorkflow.listWatchMatches(eventType);
+    }
+}
+export const createOrchestrationService = (journal, work, definitions) => new OrchestrationService(journal, work, definitions);

package/dist/src/orchestration/application/request-child.js

@@ -0,0 +1,118 @@
+import { OrchestrationEventType } from '../contracts/events.js';
+import { signalName } from '../contracts/identifiers.js';
+import { childOrchestrationGroupStream } from '../contracts/streams.js';
+import { WorkflowStatus } from '../contracts/vocabulary.js';
+import { childMetadata, childRequestId, coordinationMetadata } from '../domain/child-policy.js';
+import { coordinationDraft } from '../domain/coordination-events.js';
+import { stateDraft } from '../domain/decision-events.js';
+import { acceptSignal as decideSignal } from '../domain/interpreter.js';
+export class RequestChild {
+    repository;
+    claims;
+    groupBudgets;
+    workflows;
+    advance;
+    constructor(repository, claims, groupBudgets, workflows, advance) {
+        this.repository = repository;
+        this.claims = claims;
+        this.groupBudgets = groupBudgets;
+        this.workflows = workflows;
+        this.advance = advance;
+    }
+    async execute(request, context) {
+        const parent = await this.repository.loadRequired(request.parentWorkflowInstanceId);
+        const id = childRequestId(request);
+        if (request.requestId !== id)
+            throw new Error('Child request id must be stable for its parent, watch, and trigger');
+        const existing = await this.repository.load(id);
+        if (existing.view !== null)
+            return existing.view;
+        const group = childOrchestrationGroupStream(parent.view.orchestrationGroupId, request.watchId);
+        const metadata = coordinationMetadata(parent.view, request);
+        if (!(await this.claims.claimWithinBudget(group, request, context))) {
+            await this.groupBudgets.record(parent.view, metadata, request.maxPerGroup, context);
+            return { kind: 'group-budget-exhausted', requestId: request.requestId };
+        }
+        return this.workflows.execute({
+            workflowInstanceId: id,
+            workItemId: parent.view.workItemId,
+            workflowName: request.workflowName,
+            orchestrationGroupId: parent.view.orchestrationGroupId,
+            parentWorkflowInstanceId: request.parentWorkflowInstanceId,
+            watchId: request.watchId,
+            triggerId: request.triggerId,
+            causalCycleId: request.causalCycleId,
+            requestId: request.requestId,
+        }, context);
+    }
+    async rejectCausalActivation(request, context) {
+        const loaded = await this.repository.loadRequired(request.parentWorkflowInstanceId);
+        if (loaded.view.causalRejectionIds.includes(request.triggerId))
+            return loaded.view;
+        const metadata = coordinationMetadata(loaded.view, request);
+        await this.repository.append(loaded.view.workflowInstanceId, loaded.sequence, [
+            this.coordinationEvent(loaded.view, context, OrchestrationEventType.CausalActivationRejected, metadata, 1),
+            stateDraft(loaded.view, { occurredAt: context.occurredAt, causationId: context.commandId }, OrchestrationEventType.InstanceBlocked, { reason: 'causal activation rejected' }, 2),
+        ]);
+        return (await this.repository.loadRequired(loaded.view.workflowInstanceId)).view;
+    }
+    async reconcileChildCompletions(context) {
+        for (const child of await this.advance.listAll()) {
+            if (child.parentWorkflowInstanceId !== undefined && child.status === WorkflowStatus.Completed)
+                await this.complete(child, {
+                    ...context,
+                    commandId: `${context.commandId}:child:${child.workflowInstanceId}`,
+                });
+        }
+    }
+    async isCausalRepeat(workflowInstanceId, triggerId, causalCycleId, requestId) {
+        const parent = await this.repository.loadRequired(workflowInstanceId);
+        return (await this.advance.listAll()).some((view) => view.orchestrationGroupId === parent.view.orchestrationGroupId &&
+            view.parentWorkflowInstanceId !== undefined &&
+            view.requestId !== requestId &&
+            (view.triggerId === triggerId ||
+                (causalCycleId !== undefined && view.causalCycleId === causalCycleId)));
+    }
+    async getPrimaryWorkflowInstanceId(workItemId) {
+        return this.claims.primaryWorkflowInstanceId(workItemId);
+    }
+    async complete(child, context) {
+        const metadata = childMetadata(child);
+        const childLoaded = await this.repository.loadRequired(child.workflowInstanceId);
+        if (!childLoaded.view.childCompletionRecorded)
+            await this.repository.append(child.workflowInstanceId, childLoaded.sequence, [
+                this.coordinationEvent(child, context, OrchestrationEventType.ChildCompleted, metadata, 1),
+            ]);
+        const parent = await this.repository.loadRequired(metadata.parentWorkflowInstanceId);
+        if (parent.view.acceptedChildCompletionIds.includes(child.workflowInstanceId))
+            return;
+        const signal = {
+            kind: signalName(OrchestrationEventType.ChildCompleted),
+            actorId: 'orchestration',
+            actorDecision: { authorized: true, evidenceId: child.workflowInstanceId },
+            providerEventId: child.workflowInstanceId,
+            childWorkflowInstanceId: child.workflowInstanceId,
+            requestId: metadata.requestId,
+        };
+        const decision = decideSignal(this.workflows.definition(parent.view.workflowName), parent.view, {
+            signal,
+            occurredAt: context.occurredAt,
+            causationId: context.commandId,
+        });
+        if (decision.kind === 'ignored')
+            return;
+        await this.repository.append(parent.view.workflowInstanceId, parent.sequence, [
+            ...decision.events,
+            this.coordinationEvent(parent.view, context, OrchestrationEventType.ChildCompletionConsumed, metadata, 2),
+        ]);
+    }
+    coordinationEvent(state, context, eventType, payload, ordinal) {
+        return coordinationDraft({
+            workflowInstanceId: state.workflowInstanceId,
+            eventIdPrefix: context.commandId,
+            occurredAt: context.occurredAt,
+            correlationId: state.orchestrationGroupId,
+            causationId: context.commandId,
+        }, eventType, payload, ordinal);
+    }
+}

package/dist/src/orchestration/application/signal-reactor.js

@@ -0,0 +1,17 @@
+export function createSignalReactor(orchestration) {
+    return {
+        async accept(signal, context) {
+            const waiting = await orchestration.listWaiting(signal.kind);
+            const accepted = [];
+            for (const instance of waiting) {
+                if (instance === null)
+                    continue;
+                const before = instance.acceptedSignalIds.length;
+                const after = await orchestration.acceptSignal(instance.workflowInstanceId, signal, context);
+                if (after.acceptedSignalIds.length > before)
+                    accepted.push(after);
+            }
+            return accepted;
+        },
+    };
+}