@atolis-hq/wake 0.2.97 → 0.3.1

package/dist/src/bootstrap/update-ledger.js

@@ -0,0 +1,61 @@
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+export function createUpdateLedger(wakeRoot) {
+    const path = join(wakeRoot, '.wake', 'update-ledger.json');
+    return {
+        async read() {
+            return (await readState(path)).lastHealthyTag ?? null;
+        },
+        async begin(tag) {
+            const state = await readState(path);
+            await writeState(path, { ...state, pendingTag: tag });
+        },
+        async write(tag) {
+            const state = await readState(path);
+            await writeState(path, {
+                lastHealthyTag: tag,
+                ...(state.badTags === undefined ? {} : { badTags: state.badTags }),
+            });
+        },
+        async isBad(tag) {
+            return (await readState(path)).badTags?.includes(tag) ?? false;
+        },
+        async recordBad(tag) {
+            const state = await readState(path);
+            await writeState(path, { ...state, badTags: [...new Set([...(state.badTags ?? []), tag])] });
+        },
+        async recover() {
+            const state = await readState(path);
+            if (state.pendingTag === undefined)
+                return null;
+            await writeState(path, {
+                ...(state.lastHealthyTag === undefined ? {} : { lastHealthyTag: state.lastHealthyTag }),
+                ...(state.badTags === undefined ? {} : { badTags: state.badTags }),
+            });
+            return state.lastHealthyTag ?? null;
+        },
+    };
+}
+async function readState(path) {
+    try {
+        const value = JSON.parse(await readFile(path, 'utf8'));
+        return {
+            ...(typeof value.lastHealthyTag === 'string' ? { lastHealthyTag: value.lastHealthyTag } : {}),
+            ...(typeof value.pendingTag === 'string' ? { pendingTag: value.pendingTag } : {}),
+            ...(Array.isArray(value.badTags) && value.badTags.every((tag) => typeof tag === 'string')
+                ? { badTags: value.badTags }
+                : {}),
+        };
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return {};
+        throw error;
+    }
+}
+async function writeState(path, state) {
+    await mkdir(dirname(path), { recursive: true });
+    const temporary = `${path}.${process.pid}.tmp`;
+    await writeFile(temporary, `${JSON.stringify(state)}\n`, 'utf8');
+    await rename(temporary, path);
+}

package/dist/src/bootstrap/update-maintenance-lease.js

@@ -0,0 +1,176 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { defineClosedVocabulary } from '../kernel/index.js';
+import { acquireFileLock } from '../persistence/index.js';
+export const UpdateMaintenancePhase = defineClosedVocabulary({
+    Quiescing: 'quiescing',
+    Updating: 'updating',
+    RollingBack: 'rolling-back',
+    Failed: 'failed',
+});
+export function createUpdateMaintenanceLease(wakeRoot, now = () => new Date().toISOString(), createAttemptId = randomUUID, isProcessAlive) {
+    const path = join(wakeRoot, '.wake', 'update-maintenance.json');
+    const acquire = async (tag, retryFailed = false) => withLeaseLock(path, async () => {
+        const existing = await readState(path);
+        if (existing !== null &&
+            !(existing.phase === UpdateMaintenancePhase.Failed && (existing.tag !== tag || retryFailed)))
+            return existing;
+        const initial = {
+            attemptId: createAttemptId(),
+            tag,
+            phase: UpdateMaintenancePhase.Quiescing,
+            startedAt: now(),
+        };
+        await writeState(path, initial);
+        return initial;
+    });
+    return {
+        async read() {
+            return readState(path);
+        },
+        acquire,
+        async runExclusive(tag, retryFailed, operation) {
+            return withAttemptLock(path, isProcessAlive, async () => operation(await acquire(tag, retryFailed)));
+        },
+        async transition(phase, attemptId) {
+            return withLeaseLock(path, async () => {
+                const current = await requireState(path);
+                requireOwnership(current, attemptId);
+                if (!canTransition(current.phase, phase)) {
+                    throw new Error(`Invalid maintenance lease transition from ${current.phase} to ${phase}`);
+                }
+                const next = { ...current, phase };
+                await writeState(path, next);
+                return next;
+            });
+        },
+        async fail(error, attemptId) {
+            return withLeaseLock(path, async () => {
+                const current = await requireState(path);
+                requireOwnership(current, attemptId);
+                if (current.phase === UpdateMaintenancePhase.Failed)
+                    return current;
+                const next = {
+                    ...current,
+                    phase: UpdateMaintenancePhase.Failed,
+                    failure: error instanceof Error ? error.message : String(error),
+                };
+                await writeState(path, next);
+                return next;
+            });
+        },
+        async clear(attemptId) {
+            await withLeaseLock(path, async () => {
+                const current = await readState(path);
+                if (current === null) {
+                    if (attemptId !== undefined)
+                        throw new Error('No maintenance lease is active');
+                    return;
+                }
+                requireOwnership(current, attemptId);
+                await rm(path, { force: true });
+            });
+        },
+    };
+}
+function requireOwnership(state, attemptId) {
+    if (attemptId !== undefined && state.attemptId !== attemptId)
+        throw new Error(`Maintenance attempt ${attemptId} no longer owns the lease`);
+}
+function canTransition(from, to) {
+    return ((from === UpdateMaintenancePhase.Quiescing && to === UpdateMaintenancePhase.Updating) ||
+        (from === UpdateMaintenancePhase.Updating && to === UpdateMaintenancePhase.RollingBack));
+}
+async function requireState(path) {
+    const state = await readState(path);
+    if (state === null)
+        throw new Error('No maintenance lease is active');
+    return state;
+}
+async function readState(path) {
+    try {
+        return parseState(JSON.parse(await readFile(path, 'utf8')));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+function parseState(value) {
+    if (typeof value !== 'object' ||
+        value === null ||
+        typeof value.attemptId !== 'string' ||
+        typeof value.tag !== 'string' ||
+        !isPhase(value.phase) ||
+        typeof value.startedAt !== 'string' ||
+        ('failure' in value && typeof value.failure !== 'string')) {
+        throw new Error('Invalid maintenance lease state');
+    }
+    return value;
+}
+function isPhase(value) {
+    return (value === UpdateMaintenancePhase.Quiescing ||
+        value === UpdateMaintenancePhase.Updating ||
+        value === UpdateMaintenancePhase.RollingBack ||
+        value === UpdateMaintenancePhase.Failed);
+}
+async function writeState(path, state) {
+    await mkdir(dirname(path), { recursive: true });
+    const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    await writeFile(temporary, `${JSON.stringify(state)}\n`, 'utf8');
+    await rename(temporary, path);
+}
+async function withLeaseLock(path, operation) {
+    const lockPath = `${path}.lock`;
+    while (true) {
+        let lock;
+        try {
+            lock = await acquireFileLock(lockPath, { staleAfterMs: 60_000 });
+        }
+        catch (error) {
+            if (error.code !== 'EPERM')
+                throw error;
+            await new Promise((resolve) => setTimeout(resolve, 1));
+            continue;
+        }
+        if (lock.acquired) {
+            try {
+                return await operation();
+            }
+            finally {
+                await lock.release();
+            }
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1));
+    }
+}
+async function withAttemptLock(path, isProcessAlive, operation) {
+    const lockPath = `${path}.attempt.lock`;
+    while (true) {
+        let lock;
+        try {
+            lock = await acquireFileLock(lockPath, {
+                staleAfterMs: 60_000,
+                staleRequiresDeadProcess: true,
+                ...(isProcessAlive === undefined ? {} : { isProcessAlive }),
+            });
+        }
+        catch (error) {
+            if (error.code !== 'EPERM')
+                throw error;
+            await new Promise((resolve) => setTimeout(resolve, 1));
+            continue;
+        }
+        if (lock.acquired) {
+            try {
+                return await operation();
+            }
+            finally {
+                await lock.release();
+            }
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1));
+    }
+}

package/dist/src/{version.js → bootstrap/version.js}

@@ -2,7 +2,7 @@ import { execFileSync } from 'node:child_process';
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-const defaultRepoRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const defaultRepoRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
 function gitOutputFromRoot(repoRoot, args) {
     try {
         return execFileSync('git', args, {
@@ -24,104 +24,88 @@ function defaultReadTextFile(path) {
     }
 }
 function defaultListTextFiles(path) {
-    if (!existsSync(path)) {
+    if (!existsSync(path))
         return [];
-    }
     const files = [];
     for (const entry of readdirSync(path, { withFileTypes: true })) {
         const entryPath = resolve(path, entry.name);
-        if (entry.isDirectory()) {
+        if (entry.isDirectory())
             files.push(...defaultListTextFiles(entryPath));
-        }
         else if (entry.isFile()) {
             const content = defaultReadTextFile(entryPath);
-            if (content !== undefined) {
+            if (content !== undefined)
                 files.push({ path: entryPath, content });
-            }
         }
     }
     return files;
 }
 function currentHeadHash(repoRoot, readTextFile) {
     const head = readTextFile(resolve(repoRoot, '.git', 'HEAD'))?.trim();
-    if (head === undefined || head.length === 0) {
+    if (head === undefined || head.length === 0)
         return '';
-    }
-    if (!head.startsWith('ref: ')) {
+    if (!head.startsWith('ref: '))
         return head;
-    }
-    const refPath = head.slice('ref: '.length).trim();
-    return readTextFile(resolve(repoRoot, '.git', ...refPath.split('/')))?.trim() ?? '';
+    return (readTextFile(resolve(repoRoot, '.git', ...head.slice('ref: '.length).trim().split('/')))?.trim() ?? '');
 }
-function looseTagRefs(repoRoot, listTextFiles) {
+function exactTagFromGitFiles(repoRoot, readTextFile, listTextFiles) {
+    const headHash = currentHeadHash(repoRoot, readTextFile);
+    if (headHash.length === 0)
+        return '';
     const tagsRoot = resolve(repoRoot, '.git', 'refs', 'tags');
-    return listTextFiles(tagsRoot).map((file) => ({
-        name: file.path.replaceAll('\\', '/').slice(tagsRoot.replaceAll('\\', '/').length + 1),
+    const root = tagsRoot.replaceAll('\\', '/');
+    const looseTags = listTextFiles(tagsRoot).map((file) => ({
+        name: file.path.replaceAll('\\', '/').slice(root.length + 1),
         hash: file.content.trim(),
     }));
+    return ([...looseTags, ...packedTagRefs(repoRoot, readTextFile)].find((tag) => tag.hash === headHash)
+        ?.name ?? '');
 }
 function packedTagRefs(repoRoot, readTextFile) {
     const packedRefs = readTextFile(resolve(repoRoot, '.git', 'packed-refs'));
-    if (packedRefs === undefined) {
+    if (packedRefs === undefined)
         return [];
-    }
-    const refs = [];
-    let previousTag;
+    const tags = [];
+    let precedingTag;
     for (const line of packedRefs.split(/\r?\n/)) {
-        if (line.length === 0 || line.startsWith('#')) {
+        if (line.length === 0 || line.startsWith('#'))
             continue;
-        }
         if (line.startsWith('^')) {
-            if (previousTag !== undefined) {
-                previousTag.hash = line.slice(1).trim();
-            }
+            if (precedingTag !== undefined)
+                precedingTag.hash = line.slice(1).trim();
             continue;
         }
-        previousTag = undefined;
+        precedingTag = undefined;
         const [hash, ref] = line.split(' ');
         if (hash !== undefined && ref?.startsWith('refs/tags/') === true) {
-            previousTag = { name: ref.slice('refs/tags/'.length), hash };
-            refs.push(previousTag);
+            precedingTag = { name: ref.slice('refs/tags/'.length), hash };
+            tags.push(precedingTag);
         }
     }
-    return refs;
-}
-function exactTagFromGitFiles(repoRoot, readTextFile, listTextFiles) {
-    const headHash = currentHeadHash(repoRoot, readTextFile);
-    if (headHash.length === 0) {
-        return '';
-    }
-    const matchingTag = [
-        ...looseTagRefs(repoRoot, listTextFiles),
-        ...packedTagRefs(repoRoot, readTextFile),
-    ].find((tag) => tag.hash === headHash);
-    return matchingTag?.name ?? '';
+    return tags;
 }
+// Mirrors legacy src/version.ts: exact tag at HEAD, else latest tag + short hash, else
+// short hash, else a dev placeholder. Packaged installs get a literal value baked in at
+// build time by scripts/embed-version.mjs, so the git plumbing here only runs from source.
 export function resolveWakeVersion(options = {}) {
     const repoRoot = options.repoRoot ?? defaultRepoRoot;
     const gitOutput = options.gitOutput ?? ((args) => gitOutputFromRoot(repoRoot, args));
     const readTextFile = options.readTextFile ?? defaultReadTextFile;
     const listTextFiles = options.listTextFiles ?? defaultListTextFiles;
     const exactTag = gitOutput(['describe', '--tags', '--exact-match', 'HEAD']);
-    if (exactTag.length > 0) {
+    if (exactTag.length > 0)
         return exactTag;
-    }
     const exactFileTag = exactTagFromGitFiles(repoRoot, readTextFile, listTextFiles);
-    if (exactFileTag.length > 0) {
+    if (exactFileTag.length > 0)
         return exactFileTag;
-    }
     const latestTag = gitOutput(['describe', '--tags', '--abbrev=0']);
     const shortHash = gitOutput(['rev-parse', '--short', 'HEAD']);
-    if (latestTag.length > 0 && shortHash.length > 0) {
+    if (latestTag.length > 0 && shortHash.length > 0)
         return `${latestTag}+g${shortHash}`;
-    }
-    if (shortHash.length > 0) {
+    if (shortHash.length > 0)
         return `g${shortHash}`;
-    }
     const headHash = currentHeadHash(repoRoot, readTextFile);
-    if (headHash.length > 0) {
+    if (headHash.length > 0)
         return `g${headHash.slice(0, 7)}`;
-    }
     return '0.1.0-dev';
 }
-export const wakeVersion = "g17e7db1";
+export const wakeVersion = "g9e7311e";

package/dist/src/control-plane/application/advance-once.js

@@ -0,0 +1,184 @@
+import { RunStatus, WorkspaceMode } from '../../execution/index.js';
+import { correlationId, EventActorKind, } from '../../kernel/index.js';
+import { WorkflowStatus } from '../../orchestration/index.js';
+import { WorkStatus } from '../../work/index.js';
+import { ControlStreamKind } from '../contracts/streams.js';
+import { DispatchPolicy } from '../domain/dispatch-policy.js';
+export function createAdvanceOnce(orchestration, execution, resources, clock, dependencies) {
+    const runnerIneligibility = dependencies.runnerIneligibility ?? (async () => new Set());
+    const isDispatchPaused = dependencies.isDispatchPaused ?? (async () => false);
+    const workspaceRecovery = dependencies.workspaceRecovery;
+    const transcriptRetention = dependencies.transcriptRetention;
+    const dispatchPolicy = dependencies.dispatchPolicy ?? new DispatchPolicy({ maxDispatches: 1 });
+    const context = (cause) => ({
+        commandId: dependencies.ids.next('command'),
+        correlationId: correlationId(cause),
+        occurredAt: clock.now().toISOString(),
+        actor: { kind: EventActorKind.System, id: ControlStreamKind.Global },
+    });
+    return async (options) => {
+        if (options.maxProgress < 1)
+            return { kind: 'exhausted', progressCount: 0 };
+        if (await isDispatchPaused())
+            return { kind: 'paused' };
+        if (workspaceRecovery !== undefined) {
+            await workspaceRecovery.recover(await execution.list(), {
+                isPaused: isDispatchPaused,
+                retainWorkItem: async (workItemId) => {
+                    const work = await dependencies.work?.get(workItemId);
+                    return work?.state === WorkStatus.Open && work.deleted !== true;
+                },
+                onWorkspaceReclaimed: async (workItemId) => {
+                    if (await isDispatchPaused())
+                        return false;
+                    const work = await dependencies.work?.get(workItemId);
+                    if (work?.state !== WorkStatus.Closed)
+                        return true;
+                    try {
+                        return (await transcriptRetention?.markClosedWorkItem(workItemId)) ?? true;
+                    }
+                    catch {
+                        return false;
+                    }
+                },
+            });
+        }
+        if (await isDispatchPaused())
+            return { kind: 'paused' };
+        await execution.recoverActive?.(ControlStreamKind.Global);
+        if (await isDispatchPaused())
+            return { kind: 'paused' };
+        if (transcriptRetention !== undefined) {
+            for (const workItemId of (await dependencies.closedWorkItemIds?.()) ?? []) {
+                if (await isDispatchPaused())
+                    return { kind: 'paused' };
+                try {
+                    await transcriptRetention.markClosedWorkItem(workItemId);
+                }
+                catch {
+                    // Retention is operational filesystem maintenance, not Run lifecycle state.
+                }
+            }
+        }
+        if (await isDispatchPaused())
+            return { kind: 'paused' };
+        try {
+            await transcriptRetention?.sweep();
+        }
+        catch {
+            // Retention is operational filesystem maintenance, not Run lifecycle state.
+        }
+        if (await isDispatchPaused())
+            return { kind: 'paused' };
+        await orchestration.reconcileChildCompletions(context('child-completion-reconciliation'));
+        if (await isDispatchPaused())
+            return { kind: 'paused' };
+        const rawPending = await orchestration.listPendingActivations(options.workItemId);
+        const pending = (await Promise.all(rawPending.map(async (candidate) => {
+            const work = await dependencies.work?.get(candidate.workflow.workItemId);
+            return work?.frozen || work?.deleted ? null : candidate;
+        }))).filter((candidate) => candidate !== null);
+        const blocked = ((await orchestration.listAll?.()) ?? []).flatMap((workflow) => workflow.status === WorkflowStatus.Blocked &&
+            workflow.pendingActivation !== undefined &&
+            (options.workItemId === undefined || workflow.workItemId === options.workItemId)
+            ? [{ workflow, activation: workflow.pendingActivation }]
+            : []);
+        const recovery = await findUnresolvedTerminal([...pending, ...blocked], execution);
+        if (recovery !== undefined) {
+            if (await isDispatchPaused())
+                return { kind: 'paused' };
+            if (recovery.run.status === RunStatus.Succeeded) {
+                await orchestration.acceptOutcome({
+                    workflowInstanceId: recovery.item.workflow.workflowInstanceId,
+                    activationId: recovery.item.activation.activationId,
+                    outcome: recovery.run.outcome,
+                }, context(recovery.run.runId));
+                return {
+                    kind: 'progressed',
+                    activationId: recovery.item.activation.activationId,
+                    runId: recovery.run.runId,
+                };
+            }
+            await orchestration.resolveExecutionFailure?.(recovery.item.workflow.workflowInstanceId, {
+                activationId: recovery.item.activation.activationId,
+                runId: recovery.run.runId,
+                reason: recovery.run.failure?.message ?? 'execution failed',
+            }, context(recovery.run.runId));
+            return {
+                kind: WorkflowStatus.Blocked,
+                workflowInstanceId: recovery.item.workflow.workflowInstanceId,
+                reason: recovery.run.failure?.message ?? 'execution failed',
+            };
+        }
+        const allRuns = await execution.list();
+        const selectedCandidate = dispatchPolicy.select(await Promise.all(pending.map(async (item, requestedPosition) => ({
+            workItemId: item.workflow.workItemId,
+            activationId: item.activation.activationId,
+            requestedPosition,
+            hasActiveRun: (await execution.list(item.activation.activationId)).some((run) => run.status === RunStatus.Started) ||
+                allRuns.some((run) => run.status === RunStatus.Started &&
+                    run.workflowInstanceId === item.workflow.workflowInstanceId &&
+                    run.workspace?.mode === WorkspaceMode.Branch),
+            cancelled: false,
+        }))))[0];
+        const selected = selectedCandidate === undefined
+            ? undefined
+            : pending.find((item) => item.activation.activationId === selectedCandidate.activationId);
+        if (selected === undefined) {
+            const waiting = (await orchestration.listWaiting()).find((view) => view !== null);
+            return waiting === undefined
+                ? { kind: 'no-work' }
+                : { kind: WorkflowStatus.Waiting, workflowInstanceId: waiting.workflowInstanceId };
+        }
+        // Recheck at the dispatch boundary so maintenance cannot race a selected activation.
+        if (await isDispatchPaused())
+            return { kind: 'paused' };
+        await orchestration.markActivationStarted(selected.workflow.workflowInstanceId, selected.activation.activationId, context(selected.activation.activationId));
+        const correlated = await resources.correlationsForWork(selected.workflow.workItemId);
+        const resourceViews = (await Promise.all(correlated.map((entry) => resources.get(entry.resourceId)))).filter((resource) => resource !== null);
+        const ineligible = await runnerIneligibility();
+        const run = await execution.attempt(selected.activation, {
+            workItemId: selected.workflow.workItemId,
+            workflowInstanceId: selected.workflow.workflowInstanceId,
+            orchestrationGroupId: selected.workflow.orchestrationGroupId,
+            resources: resourceViews,
+            sessionPolicy: selected.workflow.parentWorkflowInstanceId === undefined ? 'resume-stage' : 'fresh',
+            awaitImmediateCompletion: true,
+            ...(ineligible.size === 0 ? {} : { ineligibleRunners: ineligible }),
+        });
+        if (run.status === RunStatus.Succeeded && run.outcome !== undefined) {
+            if (await isDispatchPaused())
+                return { kind: 'paused' };
+            await orchestration.acceptOutcome({
+                workflowInstanceId: selected.workflow.workflowInstanceId,
+                activationId: selected.activation.activationId,
+                outcome: run.outcome,
+            }, context(run.runId));
+        }
+        if (isExecutionFailureTerminal(run.status))
+            await orchestration.resolveExecutionFailure?.(selected.workflow.workflowInstanceId, {
+                activationId: selected.activation.activationId,
+                runId: run.runId,
+                reason: run.failure?.message ?? 'execution failed',
+            }, context(run.runId));
+        return run.status === RunStatus.Succeeded || run.status === RunStatus.Started
+            ? { kind: 'progressed', activationId: selected.activation.activationId, runId: run.runId }
+            : {
+                kind: WorkflowStatus.Blocked,
+                workflowInstanceId: selected.workflow.workflowInstanceId,
+                reason: run.failure?.message ?? 'execution failed',
+            };
+    };
+}
+async function findUnresolvedTerminal(pending, execution) {
+    for (const item of pending) {
+        const run = (await execution.list(item.activation.activationId)).find((candidate) => (candidate.status === RunStatus.Succeeded && candidate.outcome !== undefined) ||
+            isExecutionFailureTerminal(candidate.status));
+        if (run !== undefined && !item.workflow.acceptedOutcomes.includes(item.activation.activationId))
+            return { item, run };
+    }
+    return undefined;
+}
+function isExecutionFailureTerminal(status) {
+    return (status === RunStatus.Failed || status === RunStatus.Cancelled || status === RunStatus.Ambiguous);
+}

package/dist/src/control-plane/application/control-plane-projection.js

@@ -0,0 +1,42 @@
+import { ControlEventType, selectControlEvent } from '../contracts/events.js';
+import { ControlStreamKind } from '../contracts/streams.js';
+export function ineligibleRunners(view, now) {
+    const current = Date.parse(now);
+    return new Set(Object.entries(view.runnerPauses)
+        .filter(([, pause]) => pause.resumeAt === undefined || Date.parse(pause.resumeAt) > current)
+        .map(([runnerName]) => runnerName));
+}
+export const controlPlaneProjection = {
+    name: ControlStreamKind.Global,
+    select(event) {
+        return selectControlEvent(event) === null ? null : { key: 'global' };
+    },
+    initial: () => ({ pausedUntil: null, runnerPauses: {} }),
+    project(previous, envelope) {
+        const event = selectControlEvent(envelope);
+        if (event === null)
+            return previous;
+        switch (event.eventType) {
+            case ControlEventType.DispatchPaused:
+                return { ...previous, pausedUntil: event.payload.resumeAt, reason: event.payload.reason };
+            case ControlEventType.DispatchResumed:
+                return withoutDispatchPause(previous);
+            case ControlEventType.RunnerPaused:
+                return {
+                    ...previous,
+                    runnerPauses: { ...previous.runnerPauses, [event.payload.runnerName]: event.payload },
+                };
+            case ControlEventType.RunnerResumed: {
+                const { [event.payload.runnerName]: _, ...runnerPauses } = previous.runnerPauses;
+                return { ...previous, runnerPauses };
+            }
+        }
+    },
+};
+function withoutDispatchPause(previous) {
+    const { reason: _, ...rest } = previous;
+    return { ...rest, pausedUntil: null };
+}
+export const controlPlaneProjectionDefinitions = [
+    controlPlaneProjection,
+];

package/dist/src/control-plane/application/control-plane-service.js

@@ -0,0 +1,42 @@
+import { EventActorKind, correlationId, } from '../../kernel/index.js';
+import { ControlEventType, createControlEventDraft, selectControlEvent, } from '../contracts/events.js';
+import { controlPlaneStream } from '../contracts/streams.js';
+export function createControlPlaneService(input) {
+    return {
+        pause: (key) => change(input, key, 'pause'),
+        resume: (key) => change(input, key, 'resume'),
+        async isPaused() {
+            let paused = false;
+            for (const envelope of await input.journal.readStream(controlPlaneStream())) {
+                const event = selectControlEvent(envelope);
+                if (event?.eventType === ControlEventType.DispatchPaused)
+                    paused = true;
+                if (event?.eventType === ControlEventType.DispatchResumed)
+                    paused = false;
+            }
+            return paused;
+        },
+    };
+}
+async function change(input, idempotencyKey, operation) {
+    const stream = controlPlaneStream();
+    const events = await input.journal.readStream(stream);
+    const eventType = operation === 'pause' ? ControlEventType.DispatchPaused : ControlEventType.DispatchResumed;
+    const correlation = correlationId(`control:${operation}:${idempotencyKey}`);
+    if (events.some((event) => event.eventType === eventType && event.correlationId === correlation))
+        return;
+    const currentlyPaused = await createControlPlaneService(input).isPaused();
+    if ((operation === 'pause' && currentlyPaused) || (operation === 'resume' && !currentlyPaused))
+        return;
+    const occurredAt = input.clock.now().toISOString();
+    const context = {
+        commandId: input.ids.next('command'),
+        correlationId: correlation,
+        occurredAt,
+        actor: { kind: EventActorKind.Operator, id: 'web' },
+    };
+    const event = operation === 'pause'
+        ? createControlEventDraft(ControlEventType.DispatchPaused, { resumeAt: '9999-12-31T23:59:59.999Z', reason: 'paused by operator' }, context)
+        : createControlEventDraft(ControlEventType.DispatchResumed, { resumedAt: occurredAt }, context);
+    await input.journal.append(stream, events.length, [event]);
+}