@atolis-hq/wake 0.2.97 → 0.3.0

package/dist/src/surfaces/api/presenters/execution.js

@@ -0,0 +1,59 @@
+import { ActivityOutcomeKind } from '../../../activities/index.js';
+import { agentTokenUsage, RunStatus, } from '../../../execution/index.js';
+const outcomeSentinels = {
+    [ActivityOutcomeKind.Done]: 'DONE',
+    [ActivityOutcomeKind.Rejected]: 'REJECTED',
+    [ActivityOutcomeKind.Blocked]: 'BLOCKED',
+    [ActivityOutcomeKind.Failed]: 'FAILED',
+    [ActivityOutcomeKind.Waiting]: 'WAITING',
+};
+// The response preserves optional run facts without introducing a second view model.
+// eslint-disable-next-line complexity
+export function presentRun(value) {
+    const usage = agentTokenUsage(value.agent?.metadata);
+    const sentinel = value.outcome?.kind !== undefined && isActivityOutcomeKind(value.outcome.kind)
+        ? outcomeSentinels[value.outcome.kind]
+        : value.status.toUpperCase();
+    return {
+        runId: value.runId,
+        activationId: value.activationId,
+        activity: value.activity,
+        ...(value.stage === undefined ? {} : { stage: value.stage }),
+        workflowInstanceId: value.workflowInstanceId,
+        orchestrationGroupId: value.orchestrationGroupId,
+        attempt: value.attempt,
+        status: value.status,
+        active: value.status === RunStatus.Started,
+        startedAt: value.startedAt,
+        ...(value.finishedAt === undefined ? {} : { finishedAt: value.finishedAt }),
+        ...(value.outcome === undefined ? {} : { outcome: value.outcome }),
+        ...(value.failure === undefined ? {} : { failure: { kind: value.failure.kind } }),
+        sentinel,
+        ...(value.runner?.name === undefined ? {} : { runnerName: value.runner.name }),
+        ...(value.runner?.model === undefined ? {} : { runnerModel: value.runner.model }),
+        totalTokens: usage.tokens,
+        ...tokenBreakdown(value.agent?.metadata),
+        totalCostUsd: usage.costUsd,
+    };
+}
+function tokenBreakdown(metadata) {
+    const numeric = (key) => {
+        const value = metadata?.[key];
+        return typeof value === 'number' ? value : undefined;
+    };
+    const inputTokens = numeric('inputTokens');
+    const outputTokens = numeric('outputTokens');
+    if (inputTokens === undefined || outputTokens === undefined)
+        return {};
+    const cacheReadTokens = numeric('cacheReadTokens');
+    const cacheWriteTokens = numeric('cacheWriteTokens');
+    return {
+        inputTokens,
+        outputTokens,
+        ...(cacheReadTokens === undefined ? {} : { cacheReadTokens }),
+        ...(cacheWriteTokens === undefined ? {} : { cacheWriteTokens }),
+    };
+}
+function isActivityOutcomeKind(kind) {
+    return Object.values(ActivityOutcomeKind).includes(kind);
+}

package/dist/src/surfaces/api/presenters/observability.js

@@ -0,0 +1 @@
+export { resourceResponse as presentMetrics } from '../contracts/common.js';

package/dist/src/surfaces/api/presenters/orchestration.js

@@ -0,0 +1,19 @@
+import { isOperatorRetryEligible, } from '../../../orchestration/index.js';
+import { toWorkItemKey } from '../contracts/work.js';
+export function presentWorkflowInstance(value) {
+    return {
+        workflowInstanceId: value.workflowInstanceId,
+        workItemKey: toWorkItemKey(value.workItemId),
+        workflowName: value.workflowName,
+        orchestrationGroupId: value.orchestrationGroupId,
+        ...(value.parentWorkflowInstanceId === undefined
+            ? {}
+            : { parentWorkflowInstanceId: value.parentWorkflowInstanceId }),
+        status: value.status,
+        currentStage: value.currentStage,
+        ...(isOperatorRetryEligible(value) ? { retryEligible: true } : {}),
+        ...(value.waitingFor === undefined
+            ? {}
+            : { waitingFor: { signalKind: value.waitingFor.signalKind } }),
+    };
+}

package/dist/src/surfaces/api/presenters/resources.js

@@ -0,0 +1,15 @@
+export function presentResource(resolveLink) {
+    return (value) => {
+        const externalUrl = resolveLink(value.externalKey);
+        return {
+            resourceId: value.resourceId,
+            adapter: value.externalKey.adapter,
+            kind: value.kind,
+            locatorLabel: `${value.kind} ${value.externalKey.key}`,
+            capabilities: value.capabilities,
+            ...(value.title === undefined ? {} : { title: value.title }),
+            ...(externalUrl === null ? {} : { externalUrl }),
+            ...(value.revision === undefined ? {} : { revision: value.revision }),
+        };
+    };
+}

package/dist/src/surfaces/api/presenters/status.js

@@ -0,0 +1,3 @@
+export function presentStatus(status) {
+    return status;
+}

package/dist/src/surfaces/api/presenters/system.js

@@ -0,0 +1,14 @@
+export { resourceResponse as presentSystem } from '../contracts/common.js';
+export function redactConfiguration(value) {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+        key,
+        /secret|token|password|credential|key/i.test(key) ? '[redacted]' : redactValue(item),
+    ]));
+}
+function redactValue(value) {
+    if (Array.isArray(value))
+        return value.map(redactValue);
+    if (typeof value === 'object' && value !== null)
+        return redactConfiguration(value);
+    return value;
+}

package/dist/src/surfaces/api/presenters/work.js

@@ -0,0 +1,16 @@
+import { toWorkItemKey } from '../contracts/work.js';
+/** The current Wake work identity is the canonical transport key; retain the mapping centrally. */
+export function presentWorkItem(work) {
+    return {
+        workItemKey: toWorkItemKey(work.workItemId),
+        workItemId: work.workItemId,
+        objective: work.objective,
+        state: work.state,
+        ...(work.frozen === undefined ? {} : { frozen: work.frozen }),
+        ...(work.deleted === undefined ? {} : { deleted: work.deleted }),
+        relatedWorkItems: work.relatedWorkItems.map((item) => ({
+            workItemKey: toWorkItemKey(item.workItemId),
+            relation: item.relation,
+        })),
+    };
+}

package/dist/src/surfaces/api/problem-details.js

@@ -0,0 +1,9 @@
+export function problemDetails(status, title, detail, extensions = {}) {
+    return {
+        type: `https://wake.atolis.dev/problems/${status}`,
+        title,
+        status,
+        ...(detail === undefined ? {} : { detail }),
+        ...extensions,
+    };
+}

package/dist/src/surfaces/api/router.js

@@ -0,0 +1,13 @@
+import { defineClosedVocabulary } from '../../kernel/index.js';
+export const BrowserRouteOutcome = defineClosedVocabulary({
+    Spa: 'spa',
+    NotFound: 'not-found',
+});
+/** Browser history fallback must never mask a missing API or static asset. */
+export function routeBrowserRequest(method, pathname) {
+    if (method !== 'GET' && method !== 'HEAD')
+        return BrowserRouteOutcome.NotFound;
+    if (pathname.startsWith('/api/') || /\/[^/]+\.[^/]+$/.test(pathname))
+        return BrowserRouteOutcome.NotFound;
+    return BrowserRouteOutcome.Spa;
+}

package/dist/src/surfaces/api/routes/activities.js

@@ -0,0 +1 @@
+export const activityRoutes = [];

package/dist/src/surfaces/api/routes/applications.js

@@ -0,0 +1 @@
+export {};

package/dist/src/surfaces/api/routes/commands.js

@@ -0,0 +1,82 @@
+import { normalizePage } from './pagination.js';
+import { accepted, ApiPathError, decodePathSegment, invalidPath, invalidQuery, invalidRequest, isObject, problem, unavailable, } from './responses.js';
+export async function dispatchCommand(applications, url, body) {
+    if (url.search !== '')
+        return invalidQuery('Command routes do not accept query parameters');
+    const request = commandRequest(body);
+    if ('status' in request)
+        return request;
+    const work = await dispatchWorkCommand(applications, url.pathname, request);
+    if (work !== undefined)
+        return work;
+    const control = await dispatchControlCommand(applications, url.pathname, request);
+    if (control !== undefined)
+        return control;
+    const runner = await dispatchRunnerCommand(applications, url.pathname, request);
+    return runner ?? problem(404, 'Not Found', `No command route for ${url.pathname}`);
+}
+async function dispatchWorkCommand(applications, pathname, request) {
+    const match = /^\/api\/v1\/work-items\/([^/]+)\/commands\/(freeze|unfreeze|delete|retry)$/.exec(pathname);
+    if (match === null)
+        return undefined;
+    const decoded = decodePathSegment(match[1]);
+    if (decoded instanceof ApiPathError)
+        return invalidPath(decoded.message);
+    const name = match[2];
+    const operation = applications.work[name];
+    if (operation === undefined)
+        return unavailable(name, (await applications.work.detail(decoded))?.data);
+    const status = name === 'freeze' || name === 'unfreeze' ? 200 : 202;
+    return accepted(await operation(decoded, request), applications.now(), status);
+}
+async function dispatchControlCommand(applications, pathname, request) {
+    const name = controlCommandName(pathname);
+    if (name === undefined)
+        return undefined;
+    const status = await applications.controlPlane.status();
+    if (name === 'tick' && status.data.paused)
+        return problem(409, 'Conflict', 'Ticks are paused', { code: 'paused', current: status.data });
+    const operation = applications.controlPlane[name];
+    return operation === undefined
+        ? unavailable(name, status.data)
+        : accepted(await operation(request), applications.now());
+}
+function controlCommandName(pathname) {
+    const prefix = '/api/v1/control-plane/commands/';
+    if (!pathname.startsWith(prefix))
+        return undefined;
+    const name = pathname.slice(prefix.length);
+    return name === 'pause' || name === 'resume' || name === 'tick' ? name : undefined;
+}
+async function dispatchRunnerCommand(applications, pathname, request) {
+    const match = /^\/api\/v1\/runners\/([^/]+)\/commands\/(pause|unpause)$/.exec(pathname);
+    if (match === null)
+        return undefined;
+    const runnerId = decodePathSegment(match[1]);
+    if (runnerId instanceof ApiPathError)
+        return invalidPath(runnerId.message);
+    const operation = match[2] === 'pause'
+        ? applications.execution.pauseRunner
+        : applications.execution.unpauseRunner;
+    if (operation !== undefined)
+        return accepted(await operation(runnerId, request), applications.now());
+    return unavailable(`runner-${match[2]}`, await currentRunner(applications, runnerId));
+}
+async function currentRunner(applications, runnerId) {
+    if (applications.execution.runners === undefined)
+        return undefined;
+    const page = normalizePage(await applications.execution.runners({ limit: 200 }));
+    return page.items.find((item) => item.runnerId === runnerId);
+}
+function commandRequest(body) {
+    if (!isObject(body))
+        return invalidRequest('idempotencyKey', 'A JSON object with an idempotency key is required');
+    if (Object.keys(body).some((key) => key !== 'idempotencyKey'))
+        return invalidRequest('', 'The command body contains unknown fields');
+    const value = body.idempotencyKey;
+    if (typeof value !== 'string' || value.trim() === '')
+        return invalidRequest('idempotencyKey', 'Must be a non-empty string');
+    return value.length <= 200
+        ? { idempotencyKey: value }
+        : invalidRequest('idempotencyKey', 'Must be at most 200 characters');
+}

package/dist/src/surfaces/api/routes/control-plane.js

@@ -0,0 +1,6 @@
+export const controlPlaneRoutes = [
+    '/api/v1/control-plane/status',
+    '/api/v1/control-plane/commands/pause',
+    '/api/v1/control-plane/commands/resume',
+    '/api/v1/control-plane/commands/tick',
+];

package/dist/src/surfaces/api/routes/events.js

@@ -0,0 +1 @@
+export const eventRoutes = ['/api/v1/events'];

package/dist/src/surfaces/api/routes/execution.js

@@ -0,0 +1,8 @@
+export const executionRoutes = [
+    '/api/v1/runs',
+    '/api/v1/runs/:runId',
+    '/api/v1/runs/:runId/transcript',
+    '/api/v1/runners',
+    '/api/v1/runners/:runnerId/commands/pause',
+    '/api/v1/runners/:runnerId/commands/unpause',
+];

package/dist/src/surfaces/api/routes/index.js

@@ -0,0 +1,18 @@
+import { dispatchCommand } from './commands.js';
+import { dispatchRead } from './read.js';
+import { problem } from './responses.js';
+export function createApiDispatcher(applications) {
+    return {
+        async dispatch(method, target, body) {
+            const url = new URL(target, 'http://wake.local');
+            if (!url.pathname.startsWith('/api/'))
+                return undefined;
+            const response = await dispatchRead(applications, method, url);
+            if (response !== undefined)
+                return response;
+            if (method === 'POST')
+                return dispatchCommand(applications, url, body);
+            return problem(404, 'Not Found', `No route for ${url.pathname}`);
+        },
+    };
+}

package/dist/src/surfaces/api/routes/observability.js

@@ -0,0 +1 @@
+export const observabilityRoutes = ['/api/v1/observability/metrics'];

package/dist/src/surfaces/api/routes/orchestration.js

@@ -0,0 +1 @@
+export const orchestrationRoutes = ['/api/v1/workflow-instances'];

package/dist/src/surfaces/api/routes/pagination.js

@@ -0,0 +1,78 @@
+import { collectionResponse, decodeCursor, encodeCursor } from '../contracts/index.js';
+import { invalidQuery, ok } from './responses.js';
+export function parseCollectionQuery(parameters, allowed) {
+    const invalidParameter = validateParameterNames(parameters, allowed);
+    if (invalidParameter !== undefined)
+        return invalidParameter;
+    const limit = parseLimit(parameters.get('limit'));
+    if (typeof limit !== 'number')
+        return limit;
+    const cursor = parseCursor(parameters.get('cursor'));
+    if ('status' in cursor)
+        return cursor;
+    const text = parseTextFilters(parameters);
+    return 'status' in text
+        ? text
+        : queryResult(limit, cursor.value, text.search, text.state, parameters.get('workItemKey') ?? undefined);
+}
+export function collection(page, query) {
+    const visible = page.items.slice(0, query.limit);
+    const hasMore = page.nextPosition !== undefined || page.items.length > query.limit;
+    const nextPosition = page.continuationPosition ??
+        page.nextPosition ??
+        (hasMore ? (query.cursor?.position ?? 0) + visible.length : undefined);
+    return ok(collectionResponse(visible, page.meta.asOf, {
+        nextCursor: nextPosition === undefined ? null : encodeCursor({ position: nextPosition }),
+        hasMore,
+        ...(page.total === undefined ? {} : { total: page.total }),
+    }, page.meta.position));
+}
+export function normalizePage(result) {
+    return result;
+}
+function validateParameterNames(parameters, allowed) {
+    for (const key of parameters.keys()) {
+        if (!allowed.has(key))
+            return invalidQuery(`Unknown query parameter: ${key}`, key);
+        if (parameters.getAll(key).length !== 1)
+            return invalidQuery(`Query parameter must occur once: ${key}`, key);
+    }
+    return undefined;
+}
+function parseLimit(value) {
+    const limit = value === null ? 50 : Number(value);
+    return /^[1-9]\d*$/.test(value ?? '50') && Number.isSafeInteger(limit) && limit <= 200
+        ? limit
+        : invalidQuery('limit must be an integer from 1 to 200', 'limit');
+}
+function parseCursor(value) {
+    if (value === null)
+        return {};
+    try {
+        return { value: decodeCursor(value) };
+    }
+    catch {
+        return invalidQuery('cursor is malformed or unsupported', 'cursor');
+    }
+}
+function parseTextFilters(parameters) {
+    const search = parameters.get('search')?.trim();
+    if (search !== undefined && search.length > 200)
+        return invalidQuery('search must be at most 200 characters', 'search');
+    const state = parameters.get('state')?.trim();
+    if (state !== undefined && (state === '' || state.length > 100))
+        return invalidQuery('state must be a non-empty value of at most 100 characters', 'state');
+    return {
+        ...(search === undefined || search === '' ? {} : { search }),
+        ...(state === undefined ? {} : { state }),
+    };
+}
+function queryResult(limit, cursor, search, state, workItemKey) {
+    return {
+        limit,
+        ...(cursor === undefined ? {} : { cursor }),
+        ...(search === undefined ? {} : { search }),
+        ...(state === undefined ? {} : { state }),
+        ...(workItemKey === undefined ? {} : { workItemKey }),
+    };
+}

package/dist/src/surfaces/api/routes/read.js

@@ -0,0 +1,135 @@
+import { collection, parseCollectionQuery } from './pagination.js';
+import { ApiPathError, decodePathSegment, found, invalidPath, invalidQuery, noQuery, ok, unavailable, } from './responses.js';
+const collectionRoutes = new Map([
+    ['/api/v1/work-items', new Set(['cursor', 'limit', 'search', 'state'])],
+    ['/api/v1/resources', new Set(['cursor', 'limit'])],
+    ['/api/v1/workflow-instances', new Set(['cursor', 'limit', 'state'])],
+    ['/api/v1/runs', new Set(['cursor', 'limit', 'state'])],
+    ['/api/v1/runners', new Set(['cursor', 'limit'])],
+    ['/api/v1/events', new Set(['cursor', 'limit', 'workItemKey'])],
+    ['/api/v1/board', new Set(['cursor', 'limit'])],
+]);
+export async function dispatchRead(applications, method, url) {
+    if (method !== 'GET' && method !== 'HEAD')
+        return undefined;
+    const resource = await readSingleton(applications, url);
+    if (resource !== undefined)
+        return resource;
+    const page = await readCollection(applications, url);
+    if (page !== undefined)
+        return page;
+    if (url.search !== '')
+        return invalidQuery('This resource does not accept query parameters');
+    return readDetail(applications, url.pathname);
+}
+async function readSingleton(applications, url) {
+    switch (url.pathname) {
+        case '/api/v1/control-plane/status':
+            return noQuery(url, async () => ok(await applications.controlPlane.status()));
+        case '/api/v1/observability/metrics':
+            return readMetrics(applications, url);
+        case '/api/v1/status':
+            return applications.status === undefined
+                ? unavailable('status')
+                : noQuery(url, async () => ok(await applications.status.get()));
+        case '/api/v1/system/health':
+            return noQuery(url, async () => ok(await applications.system.health()));
+        case '/api/v1/system/configuration':
+            return noQuery(url, async () => ok(await applications.system.configuration()));
+        default:
+            return undefined;
+    }
+}
+async function readMetrics(applications, url) {
+    const allowed = new Set(['days']);
+    for (const key of url.searchParams.keys()) {
+        if (!allowed.has(key) || url.searchParams.getAll(key).length !== 1)
+            return invalidQuery(`Unknown or repeated query parameter: ${key}`, key);
+    }
+    const raw = url.searchParams.get('days');
+    const days = raw === null ? 7 : Number(raw);
+    if (!/^[1-9]\d*$/.test(raw ?? '7') || !Number.isSafeInteger(days) || days > 31)
+        return invalidQuery('days must be an integer from 1 to 31', 'days');
+    return ok(await applications.observability.metrics({ days }));
+}
+async function readCollection(applications, url) {
+    const allowed = collectionRoutes.get(url.pathname);
+    if (allowed === undefined)
+        return undefined;
+    const query = parseCollectionQuery(url.searchParams, allowed);
+    if ('status' in query)
+        return query;
+    return collectionResult(applications, url.pathname, query);
+}
+async function collectionResult(applications, pathname, query) {
+    switch (pathname) {
+        case '/api/v1/work-items':
+            return collection(await applications.work.list(query), query);
+        case '/api/v1/resources':
+            return collection(await applications.resources.list(query), query);
+        case '/api/v1/workflow-instances':
+            return collection(await applications.orchestration.list(query), query);
+        case '/api/v1/runs':
+            return collection(await applications.execution.list(query), query);
+        case '/api/v1/runners':
+            return applications.execution.runners === undefined
+                ? unavailable('runners')
+                : collection(await applications.execution.runners(query), query);
+        case '/api/v1/board': {
+            if (applications.board === undefined)
+                return unavailable('board');
+            const board = await applications.board.list(query);
+            const response = collection(board, query);
+            return {
+                ...response,
+                body: { ...response.body, conditionCounts: board.conditionCounts },
+            };
+        }
+        default:
+            return collection(await applications.events.list(query), query);
+    }
+}
+async function readDetail(applications, pathname) {
+    const workTranscript = /^\/api\/v1\/work-items\/([^/]+)\/transcripts\/([^/]+)$/.exec(pathname);
+    if (workTranscript?.[1] !== undefined && workTranscript[2] !== undefined)
+        return readWorkTranscript(applications, workTranscript[1], workTranscript[2]);
+    const transcript = /^\/api\/v1\/runs\/([^/]+)\/transcript$/.exec(pathname)?.[1];
+    if (transcript !== undefined)
+        return readTranscript(applications, transcript);
+    const work = /^\/api\/v1\/work-items\/([^/]+)$/.exec(pathname)?.[1];
+    if (work !== undefined)
+        return readWork(applications, work);
+    const run = /^\/api\/v1\/runs\/([^/]+)$/.exec(pathname)?.[1];
+    return run === undefined ? undefined : readRun(applications, run);
+}
+async function readWorkTranscript(applications, keySegment, groupSegment) {
+    const key = decodePathSegment(keySegment);
+    const groupId = decodePathSegment(groupSegment);
+    if (key instanceof ApiPathError)
+        return invalidPath(key.message);
+    if (groupId instanceof ApiPathError)
+        return invalidPath(groupId.message);
+    if (applications.work.transcript === undefined)
+        return unavailable('transcript');
+    return found(await applications.work.transcript(key, groupId));
+}
+async function readTranscript(applications, segment) {
+    const runId = decodePathSegment(segment);
+    if (runId instanceof ApiPathError)
+        return invalidPath(runId.message);
+    if (applications.execution.transcript === undefined)
+        return unavailable('transcript', await applications.execution.get?.(runId));
+    return found(await applications.execution.transcript(runId));
+}
+async function readWork(applications, segment) {
+    const key = decodePathSegment(segment);
+    return key instanceof ApiPathError
+        ? invalidPath(key.message)
+        : found(await applications.work.detail(key));
+}
+async function readRun(applications, segment) {
+    const runId = decodePathSegment(segment);
+    return runId instanceof ApiPathError
+        ? invalidPath(runId.message)
+        : found(await applications.execution.get?.(runId));
+}

package/dist/src/surfaces/api/routes/resources.js

@@ -0,0 +1 @@
+export const resourceRoutes = ['/api/v1/resources'];

package/dist/src/surfaces/api/routes/responses.js

@@ -0,0 +1,67 @@
+import { resourceResponse, } from '../contracts/index.js';
+import { problemDetails } from '../problem-details.js';
+export async function noQuery(url, operation) {
+    return url.search === ''
+        ? operation()
+        : invalidQuery('This resource does not accept query parameters');
+}
+export function decodePathSegment(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return new ApiPathError('The route contains malformed percent encoding');
+    }
+}
+export class ApiPathError extends Error {
+}
+export function accepted(value, asOf, status = 202) {
+    if ('conflict' in value)
+        return problem(409, 'Conflict', value.detail ?? 'The command conflicts with current state', {
+            code: value.code,
+            retryable: value.retryable ?? false,
+            ...(value.current === undefined ? {} : { current: value.current }),
+        });
+    return {
+        status,
+        body: resourceResponse(value, 'acceptedAt' in value ? value.acceptedAt : asOf),
+    };
+}
+export function ok(body) {
+    return { status: 200, body };
+}
+export function found(value) {
+    return value === undefined ? problem(404, 'Not Found', 'Resource not found') : ok(value);
+}
+export function unavailable(commandName, current) {
+    return problem(409, 'Conflict', `The ${commandName} capability is unavailable`, {
+        code: 'command-unavailable',
+        retryable: false,
+        ...(current === undefined ? {} : { current }),
+    });
+}
+export function invalidPath(detail) {
+    return problem(400, 'Bad Request', detail, { code: 'invalid-path' });
+}
+export function invalidQuery(detail, path = '') {
+    return problem(422, 'Unprocessable Content', detail, {
+        code: 'invalid-query',
+        violations: [{ path, message: detail }],
+    });
+}
+export function invalidRequest(path, message) {
+    return problem(422, 'Unprocessable Content', 'The command request is invalid', {
+        code: 'invalid-request',
+        violations: [{ path, message }],
+    });
+}
+export function problem(status, title, detail, extensions = {}) {
+    return {
+        status,
+        body: problemDetails(status, title, detail, extensions),
+        contentType: 'application/problem+json',
+    };
+}
+export function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/src/surfaces/api/routes/system.js

@@ -0,0 +1 @@
+export const systemRoutes = ['/api/v1/system/health', '/api/v1/system/configuration'];

package/dist/src/surfaces/api/routes/work.js

@@ -0,0 +1,9 @@
+export const workRoutes = [
+    '/api/v1/work-items',
+    '/api/v1/work-items/:workItemKey',
+    '/api/v1/work-items/:workItemKey/transcripts/:groupId',
+    '/api/v1/work-items/:workItemKey/commands/freeze',
+    '/api/v1/work-items/:workItemKey/commands/unfreeze',
+    '/api/v1/work-items/:workItemKey/commands/delete',
+    '/api/v1/work-items/:workItemKey/commands/retry',
+];

package/dist/src/surfaces/cli/commands/api.js

@@ -0,0 +1 @@
+export const api = (application) => application.start();

package/dist/src/surfaces/cli/commands/audit.js

@@ -0,0 +1,10 @@
+/** Reads canonical journal facts, not a projection, so it remains useful during rebuilds. */
+export async function audit(journal, work, workItemId) {
+    await work.get(workItemId);
+    return (await journal.readAll(0))
+        .filter((event) => event.stream.id === workItemId)
+        .map((event) => ({
+        event,
+        causalLinks: { causationId: event.causationId, correlationId: event.correlationId },
+    }));
+}

package/dist/src/surfaces/cli/commands/correlate.js

@@ -0,0 +1,2 @@
+import { ResourceCorrelationRole } from '../../../resources/index.js';
+export const correlate = (application, resource, workItemId, context) => application.correlate(resource, workItemId, ResourceCorrelationRole.Primary, context);

package/dist/src/surfaces/cli/commands/doctor.js

@@ -0,0 +1,6 @@
+export async function runDoctor(input) {
+    if (input.rebuildProjections === true)
+        await input.projections.rebuild();
+    const [diagnostics, health] = await Promise.all([input.diagnose(), input.projections.health()]);
+    return { ...diagnostics, ...health };
+}