@atolis-hq/wake 0.2.97 → 0.3.0

package/dist/src/resources/application/resource-service.js

@@ -0,0 +1,83 @@
+import { createEventDraft, EventSourceKind, } from '../../kernel/index.js';
+import { ResourceEventType, } from '../contracts/events.js';
+import { resourceStream } from '../contracts/streams.js';
+import { ResourceCorrelationProvenance, ResourceCorrelationRole, } from '../contracts/vocabulary.js';
+import { ResourceRepository } from './resource-repository.js';
+export function createResourceService(journal, lookup) {
+    const repository = new ResourceRepository(journal);
+    return {
+        discover: (command, context) => discoverResource(repository, command, context),
+        async get(resourceId) {
+            return (await repository.load(resourceId)).resource?.view ?? null;
+        },
+        async findByExternalKey(externalKey) {
+            const id = await lookup.resourceIdForExternalKey(externalKey);
+            return id === null ? null : ((await repository.load(id)).resource?.view ?? null);
+        },
+        async correlations(resourceId) {
+            return (await repository.load(resourceId)).resource?.correlations ?? [];
+        },
+        correlationsForWork: (workItemId) => lookup.correlationsForWork(workItemId),
+        correlate: (resourceId, workItemId, role, context, provenance) => correlateResource(repository, resourceId, workItemId, role, context, provenance),
+        async retract(resourceId, workItemId, context) {
+            await appendResourceEvent(repository, resourceId, resourceDraft(resourceId, context, ResourceEventType.WorkCorrelationRetracted, {
+                workItemId,
+            }));
+        },
+    };
+}
+async function discoverResource(repository, command, context) {
+    await appendResourceEvent(repository, command.resourceId, resourceDraft(command.resourceId, context, ResourceEventType.ResourceDiscovered, {
+        kind: command.kind,
+        externalKey: command.externalKey,
+        capabilities: command.capabilities,
+        ...(command.revision === undefined ? {} : { revision: command.revision }),
+        ...(command.title === undefined ? {} : { title: command.title }),
+    }));
+    const resource = (await repository.load(command.resourceId)).resource;
+    if (resource === null)
+        throw new Error(`Resource ${command.resourceId} was not discovered`);
+    return resource.view;
+}
+// Provenance is an explicit fifth command argument; the repository dependency is the sixth implementation concern.
+async function correlateResource(repository, resourceId, workItemId, role, context, provenance = ResourceCorrelationProvenance.ProviderObserved) {
+    const loaded = await repository.load(resourceId);
+    if (loaded.resource === null)
+        throw new Error(`Resource ${resourceId} does not exist`);
+    const primary = loaded.resource.correlations.find((correlation) => correlation.role === ResourceCorrelationRole.Primary);
+    if (role === ResourceCorrelationRole.Primary &&
+        primary !== undefined &&
+        primary.workItemId !== workItemId) {
+        await appendResourceEvent(repository, resourceId, resourceDraft(resourceId, context, ResourceEventType.WorkCorrelationConflicted, {
+            workItemId,
+            existingWorkItemId: primary.workItemId,
+        }));
+        throw new Error(`Resource ${resourceId} already has a primary WorkItem correlation`);
+    }
+    await appendResourceEvent(repository, resourceId, resourceDraft(resourceId, context, ResourceEventType.WorkCorrelationEstablished, {
+        workItemId,
+        role,
+        provenance,
+    }));
+    const correlation = (await repository.load(resourceId)).resource?.correlations.find((candidate) => candidate.workItemId === workItemId && candidate.role === role);
+    if (correlation === undefined)
+        throw new Error('Resource correlation was not established');
+    return correlation;
+}
+async function appendResourceEvent(repository, resourceId, draft) {
+    const loaded = await repository.load(resourceId);
+    await repository.append(resourceId, loaded.sequence, [draft]);
+}
+function resourceDraft(resourceId, context, eventType, payload) {
+    return createEventDraft({
+        eventId: `${context.commandId}:${eventType}`,
+        eventType,
+        occurredAt: context.occurredAt,
+        correlationId: context.correlationId,
+        causationId: context.commandId,
+        actor: context.actor,
+        source: { kind: EventSourceKind.Internal, id: 'resource-service' },
+        stream: resourceStream(resourceId),
+        payload,
+    });
+}

package/dist/src/resources/contracts/commands.js

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

package/dist/src/resources/contracts/config.js

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+export const resourcesConfigSchema = z.object({}).strict();

package/dist/src/resources/contracts/events.js

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+import { brandedStringSchema, eventEnvelopeSchema, } from '../../kernel/index.js';
+import { workItemId } from '../../work/index.js';
+import { resourceCapability, resourceId, resourceKind, } from './identifiers.js';
+import { ResourceStreamKind } from './streams.js';
+import { ResourceCorrelationProvenance, ResourceCorrelationRole, } from './vocabulary.js';
+export const ResourceEventType = {
+    ResourceDiscovered: 'resources.resource-discovered',
+    ResourceRevisionObserved: 'resources.resource-revision-observed',
+    WorkCorrelationEstablished: 'resources.work-correlation-established',
+    WorkCorrelationRetracted: 'resources.work-correlation-retracted',
+    WorkCorrelationConflicted: 'resources.work-correlation-conflicted',
+};
+const streamSchema = z
+    .object({
+    kind: z.literal(ResourceStreamKind.Resource),
+    id: brandedStringSchema(resourceId),
+})
+    .strict();
+const revisionSchema = z.object({ revision: z.string() }).strict();
+const workItemIdSchema = brandedStringSchema(workItemId);
+const eventSchema = z.discriminatedUnion('eventType', [
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(ResourceEventType.ResourceDiscovered),
+        stream: streamSchema,
+        payload: z
+            .object({
+            kind: brandedStringSchema(resourceKind),
+            externalKey: z.object({ adapter: z.string(), key: z.string() }).strict(),
+            capabilities: z.array(brandedStringSchema(resourceCapability)),
+            revision: z.string().optional(),
+            title: z.string().optional(),
+        })
+            .strict(),
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(ResourceEventType.ResourceRevisionObserved),
+        stream: streamSchema,
+        payload: revisionSchema,
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(ResourceEventType.WorkCorrelationEstablished),
+        stream: streamSchema,
+        payload: z
+            .object({
+            workItemId: workItemIdSchema,
+            role: z.enum([ResourceCorrelationRole.Primary, ResourceCorrelationRole.Secondary]),
+            provenance: z.enum([
+                ResourceCorrelationProvenance.ProviderObserved,
+                ResourceCorrelationProvenance.AgentReported,
+                ResourceCorrelationProvenance.OperatorDeclared,
+            ]),
+        })
+            .strict(),
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(ResourceEventType.WorkCorrelationRetracted),
+        stream: streamSchema,
+        payload: z.object({ workItemId: workItemIdSchema }).strict(),
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(ResourceEventType.WorkCorrelationConflicted),
+        stream: streamSchema,
+        payload: z
+            .object({
+            workItemId: workItemIdSchema,
+            existingWorkItemId: workItemIdSchema,
+        })
+            .strict(),
+    }),
+]);
+export function decodeResourceEvent(event) {
+    const result = eventSchema.safeParse(event);
+    if (!result.success)
+        throw invalidResourceEvent(event, result.error);
+    return result.data;
+}
+export function selectResourceEvent(event) {
+    return event.eventType.startsWith('resources.') ? decodeResourceEvent(event) : null;
+}
+function invalidResourceEvent(event, cause) {
+    return new Error(`Invalid Resource event ${event.eventId} at global position ${event.globalPosition} (${event.eventType}): ${cause.message}`, { cause });
+}

package/dist/src/resources/contracts/identifiers.js

@@ -0,0 +1,15 @@
+export const resourceId = (value) => {
+    if (!/^resource-[0-9a-hjkmnp-tv-z]{26}$/.test(value))
+        throw new Error(`Invalid ResourceId: ${value}. Resource identity is minted, never derived.`);
+    return value;
+};
+export const resourceKind = (value) => {
+    if (!/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(value))
+        throw new Error(`Invalid Resource kind: ${value}`);
+    return value;
+};
+export const resourceCapability = (value) => {
+    if (!/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/.test(value))
+        throw new Error(`Invalid Resource capability: ${value}`);
+    return value;
+};

package/dist/src/resources/contracts/streams.js

@@ -0,0 +1,6 @@
+export const ResourceStreamKind = { Resource: 'resource' };
+export const resourceStream = (id) => ({
+    kind: ResourceStreamKind.Resource,
+    id,
+});
+export const isResourceStream = (stream) => stream.kind === ResourceStreamKind.Resource;

package/dist/src/resources/contracts/views.js

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

package/dist/src/resources/contracts/vocabulary.js

@@ -0,0 +1,67 @@
+import { defineClosedVocabulary } from '../../kernel/index.js';
+import { resourceCapability, resourceKind, } from './identifiers.js';
+export const BuiltInResourceKind = {
+    Repository: resourceKind('repository'),
+    Issue: resourceKind('issue'),
+    PullRequest: resourceKind('pull-request'),
+};
+export const BuiltInResourceCapability = {
+    Commentable: resourceCapability('commentable'),
+    Reviewable: resourceCapability('reviewable'),
+    Approvable: resourceCapability('approvable'),
+    Mergeable: resourceCapability('mergeable'),
+    Revisioned: resourceCapability('revisioned'),
+    Editable: resourceCapability('editable'),
+    // Provider can report which file paths a revision changed.
+    ChangedFiles: resourceCapability('changed-files'),
+};
+export const ResourceCorrelationRole = defineClosedVocabulary({
+    Primary: 'primary',
+    Secondary: 'secondary',
+});
+export const ResourceCorrelationProvenance = defineClosedVocabulary({
+    ProviderObserved: 'provider-observed',
+    AgentReported: 'agent-reported',
+    OperatorDeclared: 'operator-declared',
+});
+class OpenResourceVocabularyRegistry {
+    parse;
+    label;
+    values = new Set();
+    constructor(initial, parse, label) {
+        this.parse = parse;
+        this.label = label;
+        for (const value of initial)
+            this.register(value);
+    }
+    register(value) {
+        const parsed = this.parse(value);
+        if (this.values.has(parsed))
+            throw new Error(`${this.label} ${value} is already registered`);
+        this.values.add(parsed);
+    }
+    resolve(value) {
+        const parsed = this.parse(value);
+        if (!this.values.has(parsed))
+            throw new Error(`Unknown ${this.label}: ${value}`);
+        return parsed;
+    }
+    has(value) {
+        try {
+            return this.values.has(this.parse(value));
+        }
+        catch {
+            return false;
+        }
+    }
+}
+export class ResourceKindRegistry extends OpenResourceVocabularyRegistry {
+    constructor(initial = []) {
+        super(initial, resourceKind, 'Resource kind');
+    }
+}
+export class ResourceCapabilityRegistry extends OpenResourceVocabularyRegistry {
+    constructor(initial = []) {
+        super(initial, resourceCapability, 'Resource capability');
+    }
+}

package/dist/src/resources/domain/correlation.js

@@ -0,0 +1,8 @@
+import { WorkStreamKind } from '../../work/index.js';
+import { ResourceStreamKind } from '../contracts/streams.js';
+export const resourceRepresentsWork = {
+    owner: 'resources',
+    name: 'resources.represents-work',
+    fromKind: ResourceStreamKind.Resource,
+    toKind: WorkStreamKind.WorkItem,
+};

package/dist/src/resources/domain/resource.js

@@ -0,0 +1,58 @@
+import { ResourceEventType } from '../contracts/events.js';
+export function foldResource(events) {
+    const discovered = events.find((event) => event.eventType === ResourceEventType.ResourceDiscovered);
+    if (discovered === undefined)
+        return null;
+    const resource = discoveredResource(discovered);
+    const active = new Map();
+    for (const event of events)
+        applyResourceEvent(resource, active, event);
+    return { view: resource, correlations: [...active.values()] };
+}
+function discoveredResource(event) {
+    const revision = event.payload.revision === undefined ? {} : { revision: event.payload.revision };
+    const title = event.payload.title === undefined ? {} : { title: event.payload.title };
+    return {
+        resourceId: event.stream.id,
+        kind: event.payload.kind,
+        externalKey: event.payload.externalKey,
+        capabilities: event.payload.capabilities,
+        ...revision,
+        ...title,
+    };
+}
+function applyResourceEvent(resource, active, event) {
+    switch (event.eventType) {
+        case ResourceEventType.ResourceDiscovered:
+            break;
+        case ResourceEventType.ResourceRevisionObserved:
+            Object.assign(resource, { revision: event.payload.revision });
+            break;
+        case ResourceEventType.WorkCorrelationEstablished:
+            active.set(event.payload.workItemId, {
+                resourceId: resource.resourceId,
+                workItemId: event.payload.workItemId,
+                role: event.payload.role,
+                provenance: event.payload.provenance,
+                establishedByEventId: event.eventId,
+            });
+            break;
+        case ResourceEventType.WorkCorrelationConflicted:
+            Object.assign(resource, {
+                primaryCorrelationConflict: {
+                    attemptedWorkItemId: event.payload.workItemId,
+                    existingWorkItemId: event.payload.existingWorkItemId,
+                    eventId: event.eventId,
+                },
+            });
+            break;
+        case ResourceEventType.WorkCorrelationRetracted:
+            active.delete(event.payload.workItemId);
+            break;
+        default:
+            assertNever(event);
+    }
+}
+function assertNever(value) {
+    throw new Error(`Unhandled Resource event: ${JSON.stringify(value)}`);
+}

package/dist/src/resources/index.js

@@ -0,0 +1,14 @@
+export * from './application/lookup-projections.js';
+export * from './application/resource-lookup.js';
+export * from './application/resource-projections.js';
+export * from './application/resource-repository.js';
+export * from './application/resource-service.js';
+export * from './contracts/commands.js';
+export * from './contracts/config.js';
+export * from './contracts/events.js';
+export * from './contracts/identifiers.js';
+export * from './contracts/streams.js';
+export * from './contracts/views.js';
+export * from './contracts/vocabulary.js';
+export * from './domain/correlation.js';
+export * from './domain/resource.js';

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

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

package/dist/src/surfaces/api/contracts/board.js

@@ -0,0 +1,2 @@
+import { BoardConditionValue as BoardConditionValues } from './transport-values.js';
+export const BoardCondition = BoardConditionValues;

package/dist/src/surfaces/api/contracts/common.js

@@ -0,0 +1,46 @@
+export function encodeCursor(value) {
+    if (!Number.isSafeInteger(value.position) || value.position < 0)
+        throw new Error('Invalid cursor position');
+    return `c_${btoa(JSON.stringify(value)).replaceAll('+', '-').replaceAll('/', '_').replace(/=+$/, '')}`;
+}
+export function decodeCursor(value) {
+    if (!/^c_[A-Za-z0-9_-]+$/.test(value))
+        throw new Error('Invalid cursor');
+    try {
+        const encoded = value.slice(2).replaceAll('-', '+').replaceAll('_', '/');
+        const parsed = JSON.parse(atob(encoded.padEnd(Math.ceil(encoded.length / 4) * 4, '=')));
+        if (typeof parsed !== 'object' || parsed === null || !('position' in parsed))
+            throw new Error();
+        const position = parsed.position;
+        if (!Number.isSafeInteger(position) || position < 0)
+            throw new Error();
+        return { position: position };
+    }
+    catch {
+        throw new Error('Invalid cursor');
+    }
+}
+export function resourceResponse(data, asOf, position) {
+    assertUtcInstant(asOf);
+    return { data, meta: position === undefined ? { asOf } : { asOf, position } };
+}
+export function collectionResponse(items, asOf, page = {}, position) {
+    assertUtcInstant(asOf);
+    return {
+        items,
+        page: {
+            nextCursor: page.nextCursor ?? null,
+            hasMore: page.hasMore ?? false,
+            ...(page.total === undefined ? {} : { total: page.total }),
+        },
+        meta: position === undefined ? { asOf } : { asOf, position },
+    };
+}
+function assertUtcInstant(value) {
+    if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/.test(value) ||
+        !Number.isFinite(Date.parse(value)))
+        throw new Error('Response timestamps must be valid UTC RFC 3339 instants ending in Z');
+}
+export function workItemPath(workItemKey) {
+    return `/api/v1/work-items/${encodeURIComponent(workItemKey)}`;
+}

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

@@ -0,0 +1,5 @@
+import { defineClosedVocabulary } from '../../../kernel/index.js';
+export const ApiCommandStatus = defineClosedVocabulary({
+    Accepted: 'accepted',
+    Completed: 'completed',
+});

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

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

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

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

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

@@ -0,0 +1,13 @@
+export * from './activities.js';
+export * from './board.js';
+export * from './common.js';
+export * from './control-plane.js';
+export * from './events.js';
+export * from './execution.js';
+export * from './observability.js';
+export * from './orchestration.js';
+export * from './resources.js';
+export * from './system.js';
+export * from './status.js';
+export * from './transport-values.js';
+export * from './work.js';

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

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

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

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

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

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

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

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

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

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

package/dist/src/surfaces/api/contracts/transport-values.js

@@ -0,0 +1,39 @@
+const commandStatusShape = { accepted: true, completed: true };
+const commandStatuses = Object.keys(commandStatusShape);
+export const AcceptedCommandStatusValue = {
+    Accepted: commandStatuses[0],
+    Completed: commandStatuses[1],
+};
+const runResponseShape = { active: true };
+export const RunResponseField = { Active: Object.keys(runResponseShape)[0] };
+const resourceItemFieldShape = { adapter: true };
+export const ResourceItemField = { Adapter: Object.keys(resourceItemFieldShape)[0] };
+const boardConditionShape = {
+    ready: true,
+    active: true,
+    'needs-input': true,
+    error: true,
+    finished: true,
+};
+const boardConditions = Object.keys(boardConditionShape);
+export const BoardConditionValue = {
+    Ready: boardConditions[0],
+    Active: boardConditions[1],
+    NeedsInput: boardConditions[2],
+    Error: boardConditions[3],
+    Finished: boardConditions[4],
+};
+const boardCardFieldShape = { stage: true };
+export const BoardCardField = { Stage: Object.keys(boardCardFieldShape)[0] };
+const transcriptChannelShape = { input: true, agent: true };
+const transcriptChannels = Object.keys(transcriptChannelShape);
+export const TranscriptChannelValue = {
+    Input: transcriptChannels[0],
+    Agent: transcriptChannels[1],
+};
+const transcriptGroupKindShape = { session: true, run: true };
+const transcriptGroupKinds = Object.keys(transcriptGroupKindShape);
+export const TranscriptGroupKindValue = {
+    Session: transcriptGroupKinds[0],
+    Run: transcriptGroupKinds[1],
+};

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

@@ -0,0 +1,17 @@
+export function toWorkItemKey(workItemId) {
+    return `wk_${btoa(workItemId).replaceAll('+', '-').replaceAll('/', '_').replace(/=+$/, '')}`;
+}
+export function fromWorkItemKey(key) {
+    if (!/^wk_[A-Za-z0-9_-]+$/.test(key))
+        throw new Error('Invalid WorkItemKey');
+    try {
+        const encoded = key.slice(3).replaceAll('-', '+').replaceAll('_', '/');
+        const value = atob(encoded.padEnd(Math.ceil(encoded.length / 4) * 4, '='));
+        if (value === '')
+            throw new Error();
+        return value;
+    }
+    catch {
+        throw new Error('Invalid WorkItemKey');
+    }
+}

package/dist/src/surfaces/api/http-server.js

@@ -0,0 +1,121 @@
+import { createServer } from 'node:http';
+import { problemDetails } from './problem-details.js';
+import { BrowserRouteOutcome, routeBrowserRequest } from './router.js';
+export function createApiHttpServer(dispatcher, assets) {
+    return createServer((request, response) => {
+        void handleRequest(dispatcher, assets, request, response);
+    });
+}
+async function handleRequest(dispatcher, assets, request, response) {
+    try {
+        await dispatchRequest(dispatcher, assets, request, response);
+    }
+    catch (error) {
+        sendJson(response, errorResult(error));
+    }
+}
+async function dispatchRequest(dispatcher, assets, request, response) {
+    const url = new URL(request.url ?? '/', 'http://wake.local');
+    const method = request.method ?? 'GET';
+    const head = method === 'HEAD';
+    const result = await dispatcher.dispatch(method, `${url.pathname}${url.search}`, await jsonBody(request));
+    if (result !== undefined)
+        return sendJson(response, result, head);
+    await serveWebRequest(assets, method, url.pathname, response, head);
+}
+async function serveWebRequest(assets, method, pathname, response, head) {
+    const asset = method === 'GET' || head ? await assets?.get(pathname) : undefined;
+    if (asset !== undefined)
+        return send(response, { status: 200, ...asset, head });
+    if (routeBrowserRequest(method, pathname) === BrowserRouteOutcome.Spa) {
+        const index = await assets?.get('/index.html');
+        if (index !== undefined)
+            return send(response, {
+                status: 200,
+                ...index,
+                contentType: 'text/html; charset=utf-8',
+                head,
+            });
+    }
+    if (pathname.startsWith('/api/'))
+        return sendJson(response, {
+            status: 404,
+            body: problemDetails(404, 'Not Found', `No route for ${pathname}`),
+            contentType: 'application/problem+json',
+        }, head);
+    return send(response, {
+        status: 404,
+        contentType: 'text/plain; charset=utf-8',
+        body: Buffer.from('Not Found'),
+        head,
+    });
+}
+function errorResult(error) {
+    if (error instanceof MalformedJsonError)
+        return {
+            status: 400,
+            body: problemDetails(400, 'Bad Request', 'The request body is not valid JSON.', {
+                code: 'malformed-json',
+            }),
+            contentType: 'application/problem+json',
+        };
+    if (isUpstreamProviderError(error))
+        return {
+            status: 502,
+            body: problemDetails(502, 'Bad Gateway', 'Wake could not complete the request because an external provider call failed (e.g. GitHub rate-limited or was unreachable). Retrying shortly usually resolves this.', { code: 'upstream-provider-error' }),
+            contentType: 'application/problem+json',
+        };
+    return {
+        status: 500,
+        body: problemDetails(500, 'Internal Server Error', 'Wake could not complete the request.'),
+        contentType: 'application/problem+json',
+    };
+}
+// Duck-types an octokit RequestError (or any similarly-shaped upstream HTTP
+// client failure) by its `.status` field — the same detection already used
+// for GitHub 404s in integrations/github/provider.ts's verifyArtifact. A
+// synchronous command (like manual tick) that happens to run while an
+// external provider is rate-limited or unreachable should surface as a
+// distinguishable gateway failure, not an opaque "Internal Server Error"
+// indistinguishable from an actual Wake bug.
+function isUpstreamProviderError(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'status' in error &&
+        typeof error.status === 'number' &&
+        error.status >= 400);
+}
+async function jsonBody(request) {
+    if (request.method === 'GET' || request.method === 'HEAD')
+        return undefined;
+    const chunks = [];
+    for await (const chunk of request)
+        chunks.push(Buffer.from(chunk));
+    if (chunks.length === 0)
+        return undefined;
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    }
+    catch {
+        throw new MalformedJsonError();
+    }
+}
+class MalformedJsonError extends Error {
+}
+function sendJson(response, result, head = false) {
+    send(response, {
+        status: result.status,
+        contentType: result.contentType ?? 'application/json; charset=utf-8',
+        body: Buffer.from(JSON.stringify(result.body)),
+        ...(result.headers === undefined ? {} : { headers: result.headers }),
+        head,
+    });
+}
+function send(response, options) {
+    response.writeHead(options.status, {
+        'content-type': options.contentType,
+        'content-length': options.body.byteLength,
+        ...options.headers,
+    });
+    response.end(options.head ? undefined : options.body);
+}

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

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

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

@@ -0,0 +1,3 @@
+export function presentBoardCard(card) {
+    return card;
+}

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

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

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

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