@atolis-hq/wake 0.2.96 → 0.3.0

package/dist/src/bootstrap/self-update-application.js

@@ -0,0 +1,195 @@
+import { runSelfUpdate } from '../surfaces/index.js';
+import { UpdateMaintenancePhase } from './update-maintenance-lease.js';
+export function createSelfUpdateApplication(input) {
+    return {
+        async update(tag, force = false) {
+            if (!force && (await input.ledger.isBad(tag)))
+                return false;
+            return startUpdateAttempt(input, tag, force);
+        },
+        async updateLatest(force = false) {
+            const candidates = await input.source.candidateTags();
+            const [latestCandidate] = candidates;
+            if (latestCandidate === undefined) {
+                throw new Error('No source version tags available');
+            }
+            for (const tag of candidates) {
+                if (!force && (await input.ledger.isBad(tag))) {
+                    continue;
+                }
+                const updated = await this.update(tag, force);
+                if (updated) {
+                    return { tag, updated: true };
+                }
+                // If update returned false (same tag or skipped), try the next candidate
+                if (!force && (await input.ledger.read()) === tag) {
+                    // Already on this tag, no need to try others
+                    return { tag, updated: false };
+                }
+            }
+            // All candidates exhausted
+            return { tag: latestCandidate, updated: false };
+        },
+    };
+}
+async function startUpdateAttempt(input, tag, force) {
+    if (input.quiesce?.exclusive !== undefined)
+        return input.quiesce.exclusive(tag, force, (lease) => updateAttempt(input, tag, force, lease));
+    return updateAttempt(input, tag, force, await input.quiesce?.acquire(tag, force));
+}
+async function updateAttempt(input, tag, force, lease) {
+    const maintenanceTag = lease?.tag ?? tag;
+    const attemptId = lease?.attemptId;
+    const context = {};
+    try {
+        return await performUpdateAttempt(input, tag, force, lease, context);
+    }
+    catch (error) {
+        await recordUpdateFailure(input, maintenanceTag, attemptId, context.deployError ?? error, error);
+        throw error;
+    }
+}
+async function performUpdateAttempt(input, tag, force, lease, context) {
+    if (lease !== undefined && requiresMaintenanceRecovery(lease)) {
+        await resumePendingMaintenance(input, lease);
+        return false;
+    }
+    if (!isStartableMaintenanceLease(lease, tag))
+        return false;
+    await quiesceForUpdate(input);
+    await recoverPendingUpdate(input.ledger, input.source);
+    if (!force && (await input.ledger.read()) === tag) {
+        await input.quiesce?.clear(lease?.attemptId);
+        return false;
+    }
+    return runForwardUpdate(input, tag, lease?.attemptId, context);
+}
+function requiresMaintenanceRecovery(lease) {
+    return (lease.phase !== UpdateMaintenancePhase.Quiescing &&
+        lease.phase !== UpdateMaintenancePhase.Failed);
+}
+function isStartableMaintenanceLease(lease, tag) {
+    return (lease === undefined || (lease.phase === UpdateMaintenancePhase.Quiescing && lease.tag === tag));
+}
+async function quiesceForUpdate(input) {
+    if (input.quiesce === undefined)
+        return;
+    await quiesceActiveRuns(input.quiesce, input.drainTimeoutMs ?? 30_000, input.cancellationTimeoutMs ?? 30_000);
+}
+async function runForwardUpdate(input, tag, attemptId, context) {
+    if (!(await input.source.isClean()))
+        throw new Error('Self-update requires a clean source checkout');
+    await input.ledger.begin(tag);
+    await input.quiesce?.transition(UpdateMaintenancePhase.Updating, attemptId);
+    const updated = await runSelfUpdate({
+        tag,
+        force: true,
+        readLedger: input.ledger.read,
+        writeLedger: input.ledger.write,
+        update: async (nextTag) => {
+            await input.source.checkout(nextTag);
+            context.deployError = await deployRollout(input.rollout, nextTag);
+        },
+        health: async () => context.deployError === undefined && input.source.healthy(),
+        rollback: async (priorTag) => rollbackUpdate(input, priorTag, attemptId),
+    });
+    await input.quiesce?.clear(attemptId);
+    return updated;
+}
+async function deployRollout(rollout, tag) {
+    if (rollout === undefined)
+        return undefined;
+    try {
+        await rollout.deploy(tag);
+        return undefined;
+    }
+    catch (error) {
+        return error;
+    }
+}
+async function rollbackUpdate(input, priorTag, attemptId) {
+    await input.quiesce?.transition(UpdateMaintenancePhase.RollingBack, attemptId);
+    await input.source.checkout(priorTag);
+    await input.rollout?.rollback(priorTag);
+}
+async function recordUpdateFailure(input, tag, attemptId, rolloutError, originalError) {
+    try {
+        await input.quiesce?.fail(originalError, attemptId);
+    }
+    catch (persistenceError) {
+        await input.ledger.recordBad(tag);
+        throw new Error(`Could not persist failed maintenance lease: ${formatError(persistenceError)}. ` +
+            `Quiesce remains unresolved: ${formatError(originalError)}`, { cause: persistenceError });
+    }
+    await recordRolloutFailure(input.rollout, tag, rolloutError);
+    await input.ledger.recordBad(tag);
+}
+async function recordRolloutFailure(rollout, tag, error) {
+    if (rollout === undefined)
+        return;
+    try {
+        await rollout.recordFailure(tag, error);
+    }
+    catch {
+        // Best-effort: a failure-log write must never mask the original update failure.
+    }
+}
+/**
+ * A restart must never repeat a forward deploy. The persisted phase tells us
+ * that source/rollout work may already have begun, so recover the prior
+ * healthy revision while the durable lease continues to pause the runtime.
+ */
+async function resumePendingMaintenance(input, lease) {
+    if (lease.phase === UpdateMaintenancePhase.Quiescing)
+        return;
+    const priorTag = await input.ledger.recover();
+    if (priorTag === null)
+        throw new Error(`Self-update recovery has no prior healthy tag for ${lease.tag}`);
+    await input.source.checkout(priorTag);
+    await input.rollout?.rollback(priorTag);
+    if (!(await input.source.healthy()))
+        throw new Error(`Self-update recovery could not verify the prior tag ${priorTag}`);
+    await input.ledger.recordBad(lease.tag);
+    await input.quiesce?.clear(lease.attemptId);
+}
+async function quiesceActiveRuns(quiesce, drainTimeoutMs, cancellationTimeoutMs) {
+    let remaining = await waitForActiveRunsToDrain(quiesce, drainTimeoutMs);
+    if (remaining.length === 0)
+        return;
+    const cancellationIds = remaining
+        .filter((run) => run.maintenanceCancellable)
+        .map((run) => run.runId);
+    let cancellationError;
+    try {
+        await quiesce.requestMaintenanceCancellation(cancellationIds);
+    }
+    catch (error) {
+        cancellationError = error;
+    }
+    remaining = await waitForActiveRunsToDrain(quiesce, cancellationTimeoutMs);
+    if (remaining.length === 0)
+        return;
+    if (cancellationError !== undefined)
+        throw cancellationError;
+    throw new Error(`active Runs remain after maintenance cancellation: ${remaining.map((run) => run.runId).join(', ')}`);
+}
+function formatError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+async function waitForActiveRunsToDrain(quiesce, timeoutMs) {
+    const deadline = quiesce.now() + timeoutMs;
+    let activeRuns = await quiesce.activeRuns();
+    while (activeRuns.length > 0 && quiesce.now() < deadline) {
+        await quiesce.sleep(Math.min(100, deadline - quiesce.now()));
+        activeRuns = await quiesce.activeRuns();
+    }
+    return activeRuns;
+}
+async function recoverPendingUpdate(ledger, source) {
+    const priorTag = await ledger.recover();
+    if (priorTag === null)
+        return;
+    await source.checkout(priorTag);
+    if (!(await source.healthy()))
+        throw new Error(`Self-update recovery could not verify the prior tag ${priorTag}`);
+}

package/dist/src/bootstrap/self-update-failure-log.js

@@ -0,0 +1,33 @@
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+/**
+ * Persists the most recent self-update rollback so it can surface on the
+ * operator health screen instead of relying on a third-party notification —
+ * cleared the moment a later deploy succeeds.
+ */
+export function createSelfUpdateFailureLog(wakeRoot, now = () => new Date().toISOString()) {
+    const path = join(wakeRoot, '.wake', 'self-update-failure.json');
+    return {
+        async record(tag, error) {
+            const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
+            const failure = { tag, message, occurredAt: now() };
+            await mkdir(dirname(path), { recursive: true });
+            const temporary = `${path}.${process.pid}.tmp`;
+            await writeFile(temporary, `${JSON.stringify(failure)}\n`, 'utf8');
+            await rename(temporary, path);
+        },
+        async clear() {
+            await rm(path, { force: true });
+        },
+        async read() {
+            try {
+                return JSON.parse(await readFile(path, 'utf8'));
+            }
+            catch (error) {
+                if (error.code === 'ENOENT')
+                    return null;
+                throw error;
+            }
+        },
+    };
+}

package/dist/src/bootstrap/source-update-port.js

@@ -0,0 +1,47 @@
+import { execFile as nodeExecFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFile = promisify(nodeExecFile);
+export function createSourceUpdatePort(input) {
+    const execute = input.execute ?? runProcess;
+    return {
+        async isClean() {
+            return (await execute('git', ['status', '--porcelain'], input.repoRoot)).trim().length === 0;
+        },
+        async latestTag() {
+            const tag = (await execute('git', ['tag', '--sort=-v:refname'], input.repoRoot))
+                .split(/\r?\n/u)
+                .find((value) => value.trim().length > 0)
+                ?.trim();
+            if (tag === undefined)
+                throw new Error('No source version tag is available');
+            return tag;
+        },
+        async candidateTags() {
+            const output = await execute('git', ['tag', '--sort=-v:refname'], input.repoRoot);
+            return output
+                .split(/\r?\n/u)
+                .map((line) => line.trim())
+                .filter((line) => line.length > 0);
+        },
+        async checkout(tag) {
+            await execute('git', ['checkout', tag], input.repoRoot);
+        },
+        async healthy() {
+            try {
+                // Verify the checked-out code can be built (TypeScript compiles).
+                // This is the minimal meaningful health check: the code must at least compile.
+                const buildCommand = 'npm';
+                const buildArgs = ['exec', 'tsc', '--'];
+                await execute(buildCommand, [...buildArgs], input.repoRoot);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+    };
+}
+async function runProcess(command, args, cwd) {
+    const result = await execFile(command, args, { cwd, encoding: 'utf8' });
+    return result.stdout;
+}

package/dist/src/bootstrap/status-publish-activity.js

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import { ActivityExecutionKind, activityName, ActivityOutcomeKind, } from '../activities/index.js';
+import { DeliveryIntentEventType } from '../integrations/index.js';
+import { createEventDraft, EventActorKind, EventSourceKind, } from '../kernel/index.js';
+import { resourceStream } from '../resources/index.js';
+export function createStatusPublishActivity(journal) {
+    return {
+        name: activityName('status.publish'),
+        inputSchema: z.object({ body: z.string().min(1) }).strict(),
+        outcomeSchema: z.object({ kind: z.literal(ActivityOutcomeKind.Done) }).strict(),
+        outcomeKinds: [ActivityOutcomeKind.Done],
+        resources: [],
+        executionKind: ActivityExecutionKind.Deterministic,
+        handler: {
+            async execute(invocation) {
+                const resource = invocation.resources[0];
+                if (resource === undefined)
+                    throw new Error('status.publish requires an intake resource');
+                const sequence = (await journal.readStream(resourceStream(resource.resourceId))).length;
+                await journal.append(resourceStream(resource.resourceId), sequence, [
+                    createEventDraft({
+                        eventId: `${invocation.activationId}:status.publish`,
+                        eventType: DeliveryIntentEventType.StatusPublishRequested,
+                        occurredAt: new Date().toISOString(),
+                        correlationId: invocation.causationId,
+                        causationId: invocation.causationId,
+                        actor: { kind: EventActorKind.System, id: 'status.publish' },
+                        source: { kind: EventSourceKind.Internal, id: 'status.publish' },
+                        stream: resourceStream(resource.resourceId),
+                        payload: {
+                            workflowInstanceId: invocation.workflowInstanceId,
+                            activationId: invocation.activationId,
+                            resourceId: resource.resourceId,
+                            body: invocation.input.body,
+                        },
+                    }),
+                ]);
+                return { kind: ActivityOutcomeKind.Done };
+            },
+        },
+    };
+}

package/dist/src/bootstrap/surface-api-applications.js

@@ -0,0 +1,325 @@
+import { ControlStreamKind } from '../control-plane/index.js';
+import { ApiCommandStatus, fromWorkItemKey, presentBoardCard, presentResource, presentStatus, presentWorkflowInstance, redactConfiguration, } from '../surfaces/index.js';
+import { analyticsProjection } from './analytics-projection.js';
+import { boardConditionCounts, boardProjection, } from './board-projection.js';
+import { primaryExternalRef } from './external-ref.js';
+import { createSelfUpdateFailureLog } from './self-update-failure-log.js';
+import { createExecutionApplications } from './surface-api-execution-applications.js';
+import { projectionMeta, sampledMeta } from './surface-api-metadata.js';
+import { projectionPage } from './surface-api-projection-pages.js';
+import { createSurfaceWorkApplications } from './surface-api-work-applications.js';
+import { wakeVersion } from './version.js';
+export function createSurfaceApiApplications(root, now) {
+    return {
+        now,
+        board: createBoardApplications(root, now),
+        status: createStatusApplications(root, now),
+        controlPlane: createControlPlaneApplications(root, now),
+        work: createSurfaceWorkApplications(root, now),
+        resources: createResourceApplications(root, now),
+        orchestration: createOrchestrationApplications(root, now),
+        execution: createExecutionApplications(root, now),
+        events: createEventApplications(root, now),
+        observability: createObservabilityApplications(root, now),
+        system: createSystemApplications(root, now),
+    };
+}
+function createBoardApplications(root, now) {
+    return {
+        async list(query) {
+            const nowMs = Date.parse(now());
+            const stored = await root.projections.read(boardProjection.name, 'global');
+            const cards = Object.values(stored?.value.cards ?? {}).sort((left, right) => cardRecency(right).localeCompare(cardRecency(left)));
+            const offset = query.cursor?.position ?? 0;
+            const page = cards.slice(offset, offset + query.limit);
+            const items = await Promise.all(page.map(async (card) => {
+                const externalRef = await primaryExternalRef(root, card.workItemId);
+                const { activeRun, ...withoutActiveRun } = card;
+                return presentBoardCard({
+                    ...withoutActiveRun,
+                    totalDurationMs: card.totalDurationMs ?? 0,
+                    ...(externalRef === undefined ? {} : { externalRef }),
+                    ...(card.lastRunAt === undefined
+                        ? {}
+                        : { lastRunAgeMs: elapsedSince(card.lastRunAt, nowMs) }),
+                    ...(activeRun === undefined
+                        ? {}
+                        : {
+                            activeRun: {
+                                ...activeRun,
+                                elapsedMs: elapsedSince(activeRun.startedAt, nowMs),
+                            },
+                        }),
+                });
+            }));
+            return {
+                items,
+                total: cards.length,
+                ...(offset + query.limit < cards.length ? { nextPosition: offset + query.limit } : {}),
+                conditionCounts: boardConditionCounts(stored?.value ?? boardProjection.initial('global')),
+                meta: await projectionMeta(root.journal, stored === null ? [] : [stored], now()),
+            };
+        },
+    };
+}
+function createStatusApplications(root, now) {
+    return {
+        async get() {
+            const stored = await root.projections.read(boardProjection.name, 'global');
+            return {
+                data: presentStatus({
+                    conditionCounts: boardConditionCounts(stored?.value ?? boardProjection.initial('global')),
+                }),
+                meta: await projectionMeta(root.journal, stored === null ? [] : [stored], now()),
+            };
+        },
+    };
+}
+function createResourceApplications(root, now) {
+    return {
+        async list(query) {
+            const stored = (await root.projections.list('resources')).flatMap((entry) => (entry.value === null ? [] : [{ ...entry, value: entry.value }]));
+            return projectionPage(root.journal, stored, query, presentResource(root.resolveResourceLink), {
+                emptyAsOf: now(),
+            });
+        },
+    };
+}
+function createOrchestrationApplications(root, now) {
+    return {
+        async list(query) {
+            const stored = (await root.projections.list('orchestration')).flatMap((entry) => entry.value.view === null ? [] : [{ ...entry, value: entry.value.view }]);
+            const filtered = stored.filter((entry) => query.state === undefined || entry.value.status === query.state);
+            return projectionPage(root.journal, filtered, query, presentWorkflowInstance, {
+                emptyAsOf: now(),
+                provenance: stored,
+            });
+        },
+    };
+}
+function createEventApplications(root, now) {
+    return {
+        async list(query) {
+            const workItemKey = query.workItemKey;
+            const workItemId = workItemKey === undefined
+                ? undefined
+                : (() => {
+                    try {
+                        return fromWorkItemKey(workItemKey);
+                    }
+                    catch {
+                        return workItemKey;
+                    }
+                })();
+            const events = await recentEvents(root.journal, query.cursor?.position, query.limit + 1, (event) => workItemId === undefined ||
+                event.stream.id === workItemId ||
+                (typeof event.payload === 'object' &&
+                    event.payload !== null &&
+                    'workItemId' in event.payload &&
+                    event.payload.workItemId === workItemId));
+            const visible = events.slice(0, query.limit);
+            const newest = visible[0];
+            const oldest = visible.at(-1);
+            const meta = await projectionMeta(root.journal, newest === undefined
+                ? query.cursor === undefined
+                    ? []
+                    : [{ lastGlobalPosition: query.cursor.position }]
+                : [{ lastGlobalPosition: newest.globalPosition }], now());
+            return {
+                items: presentEvents(visible),
+                meta,
+                ...(events.length > query.limit && oldest !== undefined
+                    ? { nextPosition: oldest.globalPosition }
+                    : {}),
+                ...(newest === undefined && query.cursor === undefined
+                    ? {}
+                    : { continuationPosition: oldest?.globalPosition ?? query.cursor.position }),
+            };
+        },
+    };
+}
+async function recentEvents(journal, beforeGlobalPosition, limit, include) {
+    const batchSize = Math.max(limit, 200);
+    const selected = [];
+    let before = beforeGlobalPosition;
+    while (selected.length < limit) {
+        const batch = journal.readLatest === undefined
+            ? (await journal.readAll(0))
+                .filter((event) => before === undefined || event.globalPosition < before)
+                .slice(-batchSize)
+                .reverse()
+            : await journal.readLatest(before, batchSize);
+        if (batch.length === 0)
+            return selected;
+        for (const event of batch) {
+            if (include(event))
+                selected.push(event);
+            if (selected.length === limit)
+                return selected;
+        }
+        const oldest = batch.at(-1);
+        if (oldest === undefined || batch.length < batchSize)
+            return selected;
+        before = oldest.globalPosition;
+    }
+    return selected;
+}
+function createObservabilityApplications(root, now) {
+    return {
+        async metrics(query = { days: 7 }) {
+            const collectedAt = now();
+            const stored = await root.projections.read(analyticsProjection.name, 'global');
+            const analytics = stored?.value ?? analyticsProjection.initial('global');
+            const window = analyticsWindow(analytics, collectedAt, query.days);
+            return {
+                data: { collectedAt, window: window.range, values: window.values },
+                meta: await projectionMeta(root.journal, stored === null ? [] : [stored], collectedAt),
+            };
+        },
+    };
+}
+function createSystemApplications(root, now) {
+    return {
+        async health() {
+            const checkedAt = now();
+            const selfUpdateFailure = await createSelfUpdateFailureLog(root.paths.wakeRoot).read();
+            const checks = [
+                { name: 'journal', status: 'ok' },
+                { name: 'projections', status: 'ok' },
+                { name: 'checkpoints', status: 'ok' },
+                selfUpdateFailure === null
+                    ? { name: 'self-update', status: 'ok' }
+                    : {
+                        name: 'self-update',
+                        status: 'degraded',
+                        detail: `rolled back from ${selfUpdateFailure.tag} at ${selfUpdateFailure.occurredAt}: ${selfUpdateFailure.message}`,
+                    },
+            ];
+            return {
+                data: {
+                    status: checks.some((check) => check.status === 'degraded') ? 'degraded' : 'ok',
+                    version: wakeVersion,
+                    checkedAt,
+                    checks,
+                },
+                meta: sampledMeta(checkedAt),
+            };
+        },
+        async configuration() {
+            const sampledAt = now();
+            return {
+                data: { configuration: redactConfiguration(root.config) },
+                meta: sampledMeta(sampledAt),
+            };
+        },
+    };
+}
+function commandAccepted(command, acceptedAt) {
+    return {
+        commandId: 'control:' + command.idempotencyKey,
+        idempotencyKey: command.idempotencyKey,
+        acceptedAt,
+        status: ApiCommandStatus.Accepted,
+    };
+}
+function createControlPlaneApplications(root, now) {
+    const activeTicks = new Map();
+    const recentTicks = new Map();
+    let commandSequence = 0;
+    return {
+        status: () => readControlPlaneStatus(root, now),
+        async pause(command) {
+            await root.controlPlane.pause(command.idempotencyKey);
+            return commandAccepted(command, now());
+        },
+        async resume(command) {
+            await root.controlPlane.resume(command.idempotencyKey);
+            return commandAccepted(command, now());
+        },
+        tick(command) {
+            const completed = recentTicks.get(command.idempotencyKey);
+            if (completed !== undefined)
+                return Promise.resolve(completed);
+            const active = activeTicks.get(command.idempotencyKey);
+            if (active !== undefined)
+                return active;
+            const pending = performTick(root, now, command, ++commandSequence).then((result) => {
+                activeTicks.delete(command.idempotencyKey);
+                rememberRecentTick(recentTicks, command.idempotencyKey, result);
+                return result;
+            }, (error) => {
+                activeTicks.delete(command.idempotencyKey);
+                throw error;
+            });
+            activeTicks.set(command.idempotencyKey, pending);
+            return pending;
+        },
+    };
+}
+const recentAdvanceLimit = 100;
+function rememberRecentTick(commands, key, result) {
+    commands.set(key, result);
+    while (commands.size > recentAdvanceLimit) {
+        const oldest = commands.keys().next().value;
+        if (oldest === undefined)
+            return;
+        commands.delete(oldest);
+    }
+}
+async function performTick(root, now, command, sequence) {
+    const acceptedAt = now();
+    await root.runnerPipeline.run({ maxProgress: 1 });
+    return {
+        commandId: `tick:${acceptedAt}:${sequence}`,
+        idempotencyKey: command.idempotencyKey,
+        acceptedAt,
+        status: ApiCommandStatus.Completed,
+        result: await readControlPlaneStatus(root, now),
+    };
+}
+async function readControlPlaneStatus(root, now) {
+    const stored = await root.projections.read(ControlStreamKind.Global, 'global');
+    const meta = await projectionMeta(root.journal, stored === null ? [] : [stored], now());
+    return {
+        data: {
+            paused: stored?.value.pausedUntil !== null && stored?.value.pausedUntil !== undefined,
+            ...(stored?.value.pausedUntil == null ? {} : { pausedUntil: stored.value.pausedUntil }),
+            ...(stored?.value.reason === undefined ? {} : { reason: stored.value.reason }),
+            updatedAt: meta.asOf,
+        },
+        meta,
+    };
+}
+function cardRecency(card) {
+    return card.lastRunAt ?? card.dwellSince;
+}
+export function elapsedSince(timestamp, nowMs) {
+    return nowMs - Date.parse(timestamp);
+}
+function presentEvents(events) {
+    return events.map((event) => ({
+        id: event.eventId,
+        type: event.eventType,
+        occurredAt: event.occurredAt,
+        position: event.globalPosition,
+        stream: event.stream,
+        causationId: event.causationId,
+        correlationId: event.correlationId,
+        payload: event.payload,
+    }));
+}
+function analyticsWindow(analytics, collectedAt, days) {
+    const end = collectedAt.slice(0, 10);
+    const endDate = new Date(`${end}T00:00:00.000Z`);
+    const startDate = new Date(endDate);
+    startDate.setUTCDate(startDate.getUTCDate() - (days - 1));
+    const from = startDate.toISOString().slice(0, 10);
+    const values = Object.entries(analytics.days)
+        .filter(([day]) => day >= from && day <= end)
+        .reduce((totals, [, bucket]) => ({
+        events: totals.events + bucket.events,
+        workItems: totals.workItems + bucket.workItems,
+        runs: totals.runs + bucket.runs,
+    }), { events: 0, workItems: 0, runs: 0 });
+    return { range: { days, from, to: end }, values };
+}