borgmcp-server 0.1.4 → 0.1.5

package/README.md

@@ -6,22 +6,23 @@ HTTPS.
 
 ## Release status
 
-The current public preview remains `borgmcp-server@0.1.1`, published on npm.
+The current public preview is `borgmcp-server@0.1.4`, published on npm.
 Versions `0.1.2` and `0.1.3` were not published; their immutable tags are
 internal failed-release evidence and are not installation or dogfood targets.
-The current source is the unpublished `0.1.4` release candidate. It retains the
+Version `0.1.4` retains the
 reviewed owner-enrollment, idempotent multi-cube creation, and stable prior-seat
 reattachment baseline, and adds managed role creation and updates, fail-closed
 setup reinitialization, opt-in redacted debug logging, live-safe invitation
 minting, and atomic cube-scoped invitations with enforced observer posture.
-The candidate consumes the audited exact `borgmcp-shared@0.3.0` registry
-release.
+The published `0.1.4` package consumes the audited exact
+`borgmcp-shared@0.3.0` registry release. Current source consumes the audited
+exact `borgmcp-shared@0.4.0` release for the clean-slate protocol generation.
 
 Setup prepares local identity and storage and prints one-time recovery and
 owner-enrollment secrets; it creates no cube. Version `0.1.1` completed the
 documented exact-source, tagged-artifact, and protected-publication gates.
-Version `0.1.4` has no tag or publication authorization until its exact merged
-source and tagged artifact complete the gates in `docs/releasing.md`.
+Version `0.1.4` completed a fresh exact-source, tagged-artifact, tokenless OIDC
+publication, provenance, signature, and attestation gate chain.
 
 ## Requirements
 

package/THIRD_PARTY_NOTICES.md

@@ -21,6 +21,7 @@ refer to each installed package for its complete license text.
 | `@peculiar/utils` | 2.0.3 | MIT |
 | `@peculiar/x509` | 1.14.3 | MIT |
 | `asn1js` | 3.0.10 | BSD-3-Clause |
+| `borgmcp-shared` | 0.4.0 | Apache-2.0 |
 | `bytestreamjs` | 2.0.1 | BSD-3-Clause |
 | `pkijs` | 3.4.0 | BSD-3-Clause |
 | `pvtsutils` | 1.3.6 | MIT |

package/dist/coordination-api.d.ts

@@ -8,6 +8,7 @@ export interface CoordinationRequest {
     readonly principal: Principal;
     readonly body?: unknown;
     readonly cursor?: string;
+    readonly since?: string;
     readonly signal: AbortSignal;
 }
 export interface CoordinationResponse {
@@ -17,7 +18,7 @@ export interface CoordinationResponse {
 }
 export declare class CoordinationApi {
     #private;
-    constructor(runtime: StoreRuntime, authority: CredentialAuthority, debugLogger?: DebugLogger);
+    constructor(runtime: StoreRuntime, authority: CredentialAuthority, debugLogger?: DebugLogger, streamHeartbeatMs?: number);
     armReplayTransition(): {
         readonly reached: Promise<void>;
         readonly release: () => void;

package/dist/coordination-api.js

@@ -1,16 +1,20 @@
 import { randomUUID } from "node:crypto";
+import { ATTACH_PATH, ErrorCode, PROTOCOL_VERSION, ProtocolContractError, createProtocolEnvelope, decodeAttachRequestEnvelope, decodeProtocolEnvelope, } from "borgmcp-shared/protocol";
 import { assertServerDerivedPrincipal } from "./principal.js";
 import { disabledDebugLogger } from "./debug-log.js";
-import { CursorExpiredError, AttachConflictError, AccessDeniedError, CreateCubeConflictError, DefaultRoleRequiredError, RoleConflictError, RoleSectionConflictError, ScopedStoreError, StorageCapacityError, } from "./store.js";
+import { patchMessageTaxonomy, resolveMessageRouting, validateMessageTaxonomy, } from "./message-taxonomy.js";
+import { CursorExpiredError, AttachSessionRejectedError, AccessDeniedError, CreateCubeConflictError, DefaultRoleRequiredError, RoleConflictError, RoleSectionConflictError, ScopedStoreError, StorageCapacityError, } from "./store.js";
 export class CoordinationApi {
     #runtime;
     #authority;
     #debugLogger;
+    #streamHeartbeatMs;
     #replayBarrier;
-    constructor(runtime, authority, debugLogger = disabledDebugLogger) {
+    constructor(runtime, authority, debugLogger = disabledDebugLogger, streamHeartbeatMs = 5_000) {
         this.#runtime = runtime;
         this.#authority = authority;
         this.#debugLogger = debugLogger;
+        this.#streamHeartbeatMs = streamHeartbeatMs;
     }
     armReplayTransition() {
         let markReached;
@@ -28,36 +32,36 @@ export class CoordinationApi {
     async handle(request) {
         assertServerDerivedPrincipal(request.principal);
         const authentication = request.principal;
-        if (request.path === "/api/client/attach" && request.method === "POST") {
+        if (request.path === ATTACH_PATH && request.method === "POST") {
             const requestId = safeRequestId(request.body);
             try {
-                const envelope = decodeEnvelope(request.body);
-                exactKeys(envelope.payload, ["cube_id", "role_id", "retry_key"], ["prior_drone_id"]);
-                const priorDroneId = envelope.payload["prior_drone_id"] === undefined
-                    ? undefined
-                    : requiredUuid(envelope.payload, "prior_drone_id");
+                const envelope = decodeAttachRequestEnvelope(request.body);
+                const priorDroneId = envelope.payload.prior_drone_id;
                 const attachment = this.#authority.attachSeat(this.#runtime.forPrincipal(authentication), {
-                    cubeId: requiredUuid(envelope.payload, "cube_id"),
-                    roleId: requiredUuid(envelope.payload, "role_id"),
-                    retryKey: requiredUuid(envelope.payload, "retry_key"),
+                    cubeId: envelope.payload.cube_id,
+                    roleId: envelope.payload.role_id,
+                    sessionCredential: envelope.payload.session_credential,
                     ...(priorDroneId === undefined ? {} : { priorDroneId }),
                 });
-                return success(201, envelope.requestId, {
+                return success(attachment.result === "created" ? 201 : 200, envelope.request_id, {
+                    result: attachment.result,
                     cube: attachment.cube,
                     role: attachment.role,
                     drone: attachment.drone,
                     session: {
-                        token: attachment.credential,
+                        id: attachment.sessionId,
                         expires_at: attachment.expiresAt,
-                        generation: attachment.generation,
-                        posture: attachment.posture,
                     },
-                    reattached: attachment.reattached,
                 });
             }
             catch (error) {
-                if (error instanceof AttachConflictError) {
-                    return failure(409, "INVALID_INPUT", "The attach request conflicts.", requestId);
+                if (error instanceof ProtocolContractError) {
+                    return error.code === ErrorCode.UNSUPPORTED_PROTOCOL_VERSION
+                        ? failure(426, error.code, "Unsupported protocol version.", requestId)
+                        : failure(400, "INVALID_INPUT", "Invalid protocol request.", requestId);
+                }
+                if (error instanceof AttachSessionRejectedError) {
+                    return failure(401, ErrorCode.SESSION_REJECTED, error.message, requestId);
                 }
                 if (error instanceof ScopedStoreError) {
                     return failure(404, "NOT_FOUND", error.message, requestId);
@@ -77,6 +81,7 @@ export class CoordinationApi {
                 owner_id: cube.ownerId,
                 name: cube.name,
                 cube_directive: cube.directive,
+                message_taxonomy: cube.messageTaxonomy,
                 created_at: cube.createdAt,
                 updated_at: cube.updatedAt,
             }));
@@ -112,6 +117,11 @@ export class CoordinationApi {
                 if (error instanceof StorageCapacityError) {
                     return failure(507, "CAPACITY_EXCEEDED", error.message, requestId);
                 }
+                if (error instanceof ProtocolContractError) {
+                    return error.code === ErrorCode.UNSUPPORTED_PROTOCOL_VERSION
+                        ? failure(426, error.code, "Unsupported protocol version.", requestId)
+                        : failure(400, "INVALID_INPUT", "Invalid protocol request.", requestId);
+                }
                 if (error instanceof InputError || error instanceof TypeError || error instanceof RangeError) {
                     return failure(400, "INVALID_INPUT", "Invalid protocol request.", requestId);
                 }
@@ -120,7 +130,7 @@ export class CoordinationApi {
         }
         const roleMatch = /^\/api\/cubes\/([0-9a-f-]{36})\/roles\/([0-9a-f-]{36})(\/section-patch)?$/u
             .exec(request.path);
-        const match = /^\/api\/cubes\/([0-9a-f-]{36})(?:\/(roles|drones|logs|acks|decisions|stream))?$/u
+        const match = /^\/api\/cubes\/([0-9a-f-]{36})(?:\/(roles|drones|logs|acks|decisions|stream|taxonomy-patch))?$/u
             .exec(request.path);
         if (match === null && roleMatch === null) {
             return failure(404, "NOT_FOUND", "The requested resource was not found.");
@@ -144,11 +154,50 @@ export class CoordinationApi {
                         owner_id: cube.ownerId,
                         name: cube.name,
                         cube_directive: cube.directive,
+                        message_taxonomy: cube.messageTaxonomy,
                         created_at: cube.createdAt,
                         updated_at: cube.updatedAt,
                     },
                 });
             }
+            if (resource === undefined && request.method === "PATCH") {
+                const envelope = decodeEnvelope(request.body);
+                exactKeys(envelope.payload, [], ["cube_directive", "message_taxonomy"]);
+                if (Object.keys(envelope.payload).length === 0)
+                    throw new InputError();
+                const directive = optionalText(envelope.payload, "cube_directive", 100_000);
+                const messageTaxonomy = optionalMessageTaxonomy(envelope.payload["message_taxonomy"]);
+                const cube = store.updateCube(cubeId, {
+                    ...(directive === undefined ? {} : { directive }),
+                    ...(messageTaxonomy === undefined ? {} : { messageTaxonomy }),
+                });
+                return success(200, envelope.requestId, { cube: cubePayload(cube) });
+            }
+            if (resource === "taxonomy-patch" && request.method === "POST") {
+                const envelope = decodeEnvelope(request.body);
+                const action = envelope.payload["action"];
+                const cube = store.getCube(cubeId);
+                if (cube === null)
+                    throw new ScopedStoreError();
+                if (action === "remove") {
+                    exactKeys(envelope.payload, ["action", "class"]);
+                    const messageTaxonomy = patchMessageTaxonomy(cube.messageTaxonomy, {
+                        action,
+                        className: requiredString(envelope.payload, "class", 64),
+                    });
+                    return success(200, envelope.requestId, {
+                        cube: cubePayload(store.updateCube(cubeId, { messageTaxonomy })),
+                    });
+                }
+                if (action !== "add" && action !== "replace")
+                    throw new InputError();
+                exactKeys(envelope.payload, ["action", "class_def"]);
+                const classDef = validateMessageTaxonomy([envelope.payload["class_def"]])[0];
+                const messageTaxonomy = patchMessageTaxonomy(cube.messageTaxonomy, { action, classDef });
+                return success(200, envelope.requestId, {
+                    cube: cubePayload(store.updateCube(cubeId, { messageTaxonomy })),
+                });
+            }
             if (resource === "roles" && request.method === "GET") {
                 return success(200, "roles-read", { roles: store.listRoles(cubeId) });
             }
@@ -162,6 +211,7 @@ export class CoordinationApi {
                     "is_human_seat",
                     "can_broadcast",
                     "receives_all_direct",
+                    "role_class",
                 ]);
                 const role = store.createRole(cubeId, {
                     name: requiredRoleName(envelope.payload, "name"),
@@ -172,6 +222,9 @@ export class CoordinationApi {
                     isHumanSeat: optionalBoolean(envelope.payload["is_human_seat"]),
                     canBroadcast: optionalBoolean(envelope.payload["can_broadcast"]),
                     receivesAllDirect: optionalBoolean(envelope.payload["receives_all_direct"]),
+                    ...(envelope.payload["role_class"] === undefined
+                        ? {}
+                        : { roleClass: optionalRoleClass(envelope.payload["role_class"]) }),
                 });
                 return success(201, envelope.requestId, { role });
             }
@@ -186,6 +239,7 @@ export class CoordinationApi {
                     "is_human_seat",
                     "can_broadcast",
                     "receives_all_direct",
+                    "role_class",
                 ]);
                 if (Object.keys(envelope.payload).length === 0)
                     throw new InputError();
@@ -199,6 +253,7 @@ export class CoordinationApi {
                 const isHumanSeat = optionalBooleanValue(envelope.payload["is_human_seat"]);
                 const canBroadcast = optionalBooleanValue(envelope.payload["can_broadcast"]);
                 const receivesAllDirect = optionalBooleanValue(envelope.payload["receives_all_direct"]);
+                const roleClass = optionalRoleClass(envelope.payload["role_class"]);
                 const role = store.updateRole(cubeId, roleId, {
                     ...(name === undefined ? {} : { name }),
                     ...(shortDescription === undefined ? {} : { shortDescription }),
@@ -208,6 +263,7 @@ export class CoordinationApi {
                     ...(isHumanSeat === undefined ? {} : { isHumanSeat }),
                     ...(canBroadcast === undefined ? {} : { canBroadcast }),
                     ...(receivesAllDirect === undefined ? {} : { receivesAllDirect }),
+                    ...(roleClass === undefined ? {} : { roleClass }),
                 });
                 return success(200, envelope.requestId, { role });
             }
@@ -245,22 +301,38 @@ export class CoordinationApi {
                 });
             }
             if (resource === "drones" && request.method === "GET") {
-                return success(200, "drones-read", { drones: store.listDrones(cubeId) });
+                if (request.since === undefined) {
+                    return success(200, "drones-read", { drones: store.listDrones(cubeId) });
+                }
+                const since = decodeSince(request.since);
+                return success(200, "drones-read", store.listDronesSince(cubeId, since));
             }
             if (resource === "logs" && request.method === "POST") {
                 const envelope = decodeEnvelope(request.body);
-                exactKeys(envelope.payload, ["message"], ["visibility", "recipientDroneIds"]);
+                exactKeys(envelope.payload, ["message"], [
+                    "visibility", "recipientDroneIds", "class", "to",
+                ]);
                 const message = requiredString(envelope.payload, "message", 10_240);
                 const visibility = optionalVisibility(envelope.payload["visibility"]);
                 const recipientDroneIds = optionalUuidArray(envelope.payload["recipientDroneIds"]);
-                if (((visibility ?? "broadcast") === "broadcast" && recipientDroneIds !== undefined) ||
-                    (visibility === "direct" && (recipientDroneIds?.length ?? 0) === 0)) {
-                    throw new InputError();
-                }
-                const entry = store.appendLog(cubeId, {
+                const className = optionalString(envelope.payload, "class", 64);
+                const to = optionalStringArray(envelope.payload["to"]);
+                const cube = store.getCube(cubeId);
+                if (cube === null)
+                    throw new ScopedStoreError();
+                const resolved = resolveMessageRouting({
                     message,
                     ...(visibility === undefined ? {} : { visibility }),
                     ...(recipientDroneIds === undefined ? {} : { recipientDroneIds }),
+                    ...(className === undefined ? {} : { className }),
+                    ...(to === undefined ? {} : { to }),
+                }, cube.messageTaxonomy, store.listRoles(cubeId), store.listDrones(cubeId));
+                const entry = store.appendLog(cubeId, {
+                    message,
+                    visibility: resolved.visibility,
+                    ...(resolved.visibility === "direct"
+                        ? { recipientDroneIds: resolved.recipientDroneIds }
+                        : {}),
                 });
                 this.#debugLogger.emit({
                     event: "activity_append",
@@ -334,6 +406,9 @@ export class CoordinationApi {
             if (error instanceof CursorExpiredError) {
                 return failure(410, "CURSOR_EXPIRED", error.message);
             }
+            if (error instanceof AccessDeniedError) {
+                return failure(403, ErrorCode.ACCESS_DENIED, error.message);
+            }
             if (error instanceof ScopedStoreError) {
                 return failure(404, "NOT_FOUND", error.message);
             }
@@ -349,6 +424,11 @@ export class CoordinationApi {
             if (error instanceof StorageCapacityError) {
                 return failure(507, "CAPACITY_EXCEEDED", error.message, safeRequestId(request.body));
             }
+            if (error instanceof ProtocolContractError) {
+                return error.code === ErrorCode.UNSUPPORTED_PROTOCOL_VERSION
+                    ? failure(426, error.code, "Unsupported protocol version.", safeRequestId(request.body))
+                    : failure(400, "INVALID_INPUT", "Invalid protocol request.", safeRequestId(request.body));
+            }
             if (error instanceof InputError || error instanceof TypeError || error instanceof RangeError) {
                 return failure(400, "INVALID_INPUT", "Invalid protocol request.", safeRequestId(request.body));
             }
@@ -363,7 +443,10 @@ export class CoordinationApi {
         let unsubscribe = () => undefined;
         let subscribed = false;
         let deliveryCount = 0;
+        let heartbeat;
         const queue = new AsyncStringQueue(() => {
+            if (heartbeat !== undefined)
+                clearInterval(heartbeat);
             unsubscribe();
             session.release();
             if (subscribed) {
@@ -376,7 +459,9 @@ export class CoordinationApi {
                 });
             }
         }, () => { deliveryCount += 1; });
-        const pending = [];
+        let replayDirty = false;
+        const pendingNotifications = [];
+        let notificationIndex = 0;
         let live = false;
         try {
             unsubscribe = store.subscribeActivity(cubeId, (entry) => {
@@ -386,23 +471,15 @@ export class CoordinationApi {
                 }
                 if (live)
                     queue.push(encodeLogEvent(entry));
-                else if (pending.length >= 200)
-                    queue.close();
+                else if ("kind" in entry)
+                    pendingNotifications.push(entry);
                 else
-                    pending.push(entry);
+                    replayDirty = true;
             });
+            subscribed = true;
             signal.addEventListener("abort", () => queue.close(), { once: true });
-            const replayPage = store.readLog(cubeId, cursor, 200);
-            const replay = replayPage.entries;
-            this.#debugLogger.emit({
-                event: "cursor_replay",
-                mode: "sse",
-                cubeId,
-                cursorId: cursor?.id ?? null,
-                returnedCount: replay.length,
-                behindBy: replayPage.behind_by,
-                truncated: replayPage.has_more,
-            });
+            const firstPage = store.readLog(cubeId, cursor, 200);
+            this.#logReplayPage(cubeId, cursor, firstPage);
             const barrier = this.#replayBarrier;
             this.#replayBarrier = undefined;
             if (barrier !== undefined) {
@@ -410,29 +487,63 @@ export class CoordinationApi {
                 barrier.markReached();
                 await barrier.release;
             }
-            const seen = new Set(replay.map(cursorKey));
-            for (const entry of replay)
-                queue.push(encodeLogEvent(entry));
-            for (const entry of pending) {
-                if (!seen.has(cursorKey(entry)) && afterCursor(entry, cursor)) {
-                    seen.add(cursorKey(entry));
-                    queue.push(encodeLogEvent(entry));
+            void (async () => {
+                let page = firstPage;
+                let replayCursor = cursor;
+                let replayCount = 0;
+                try {
+                    for (;;) {
+                        for (const entry of page.entries) {
+                            if (!await queue.write(encodeLogEvent(entry)))
+                                return;
+                            replayCursor = { id: entry.id, created_at: entry.created_at };
+                            replayCount += 1;
+                        }
+                        if (page.has_more || replayDirty) {
+                            replayDirty = false;
+                            page = store.readLog(cubeId, replayCursor, 200);
+                            this.#logReplayPage(cubeId, replayCursor, page);
+                            continue;
+                        }
+                        while (notificationIndex < pendingNotifications.length) {
+                            if (!await queue.write(encodeLogEvent(pendingNotifications[notificationIndex])))
+                                return;
+                            notificationIndex += 1;
+                        }
+                        // Reserve room for the bookmark before making live callbacks visible.
+                        // Any append while waiting marks replay dirty and is fetched first.
+                        if (!await queue.waitForSpace())
+                            return;
+                        if (replayDirty || notificationIndex < pendingNotifications.length) {
+                            replayDirty = false;
+                            page = store.readLog(cubeId, replayCursor, 200);
+                            this.#logReplayPage(cubeId, replayCursor, page);
+                            continue;
+                        }
+                        queue.push(`event: bookmark\ndata: ${JSON.stringify({
+                            as_of: new Date().toISOString(),
+                            replay_complete: true,
+                        })}\n\n`);
+                        live = true;
+                        heartbeat = setInterval(() => {
+                            queue.tryPush(encodeHeartbeat());
+                        }, this.#streamHeartbeatMs);
+                        heartbeat.unref();
+                        this.#debugLogger.emit({
+                            event: "sse_subscribe",
+                            connectionId,
+                            cubeId,
+                            principal,
+                            replayCount,
+                            truncated: false,
+                        });
+                        return;
+                    }
                 }
-            }
-            queue.push(`event: bookmark\ndata: ${JSON.stringify({
-                as_of: new Date().toISOString(),
-                replay_complete: true,
-            })}\n\n`);
-            live = true;
-            subscribed = true;
-            this.#debugLogger.emit({
-                event: "sse_subscribe",
-                connectionId,
-                cubeId,
-                principal,
-                replayCount: replay.length,
-                truncated: replayPage.has_more,
-            });
+                catch {
+                    queue.close();
+                }
+            })();
             return { status: 200, stream: queue };
         }
         catch (error) {
@@ -444,12 +555,24 @@ export class CoordinationApi {
             throw error;
         }
     }
+    #logReplayPage(cubeId, cursor, page) {
+        this.#debugLogger.emit({
+            event: "cursor_replay",
+            mode: "sse",
+            cubeId,
+            cursorId: cursor?.id ?? null,
+            returnedCount: page.entries.length,
+            behindBy: page.behind_by,
+            truncated: page.has_more,
+        });
+    }
 }
 class InputError extends Error {
 }
 class AsyncStringQueue {
     #values = [];
     #waiters = [];
+    #spaceWaiters = [];
     #cleanup;
     #onDelivered;
     #closed = false;
@@ -464,13 +587,30 @@ class AsyncStringQueue {
             this.close();
             return;
         }
-        const waiter = this.#waiters.shift();
-        if (waiter === undefined)
-            this.#values.push(value);
-        else {
-            this.#onDelivered();
-            waiter({ value, done: false });
+        this.#enqueue(value);
+    }
+    tryPush(value) {
+        if (this.#closed || this.#values.length >= 200)
+            return false;
+        this.#enqueue(value);
+        return true;
+    }
+    async write(value) {
+        while (!this.#closed && this.#values.length >= 200) {
+            if (!await this.waitForSpace())
+                return false;
         }
+        if (this.#closed)
+            return false;
+        this.#enqueue(value);
+        return true;
+    }
+    waitForSpace() {
+        if (this.#closed)
+            return Promise.resolve(false);
+        if (this.#values.length < 200)
+            return Promise.resolve(true);
+        return new Promise((resolve) => this.#spaceWaiters.push(resolve));
     }
     close() {
         if (this.#closed)
@@ -479,12 +619,15 @@ class AsyncStringQueue {
         this.#cleanup();
         for (const waiter of this.#waiters.splice(0))
             waiter({ value: undefined, done: true });
+        for (const waiter of this.#spaceWaiters.splice(0))
+            waiter(false);
     }
     [Symbol.asyncIterator]() {
         return {
             next: async () => {
                 const value = this.#values.shift();
                 if (value !== undefined) {
+                    this.#spaceWaiters.shift()?.(true);
                     this.#onDelivered();
                     return { value, done: false };
                 }
@@ -498,17 +641,19 @@ class AsyncStringQueue {
             },
         };
     }
+    #enqueue(value) {
+        const waiter = this.#waiters.shift();
+        if (waiter === undefined)
+            this.#values.push(value);
+        else {
+            this.#onDelivered();
+            waiter({ value, done: false });
+        }
+    }
 }
 function decodeEnvelope(value) {
-    const record = object(value);
-    exactKeys(record, ["protocol_version", "request_id", "payload"]);
-    if (record["protocol_version"] !== "1")
-        throw new InputError();
-    const requestId = record["request_id"];
-    if (typeof requestId !== "string" || !/^[A-Za-z0-9._-]{8,128}$/u.test(requestId)) {
-        throw new InputError();
-    }
-    return { requestId, payload: object(record["payload"]) };
+    const envelope = decodeProtocolEnvelope(value, object);
+    return { requestId: envelope.request_id, payload: envelope.payload };
 }
 function object(value) {
     if (typeof value !== "object" || value === null || Array.isArray(value))
@@ -568,6 +713,28 @@ function optionalBooleanValue(value) {
         throw new InputError();
     return value;
 }
+function optionalRoleClass(value) {
+    if (value === undefined)
+        return undefined;
+    if (value !== "queen" && value !== "worker")
+        throw new InputError();
+    return value;
+}
+function optionalMessageTaxonomy(value) {
+    return value === undefined ? undefined : validateMessageTaxonomy(value);
+}
+function optionalStringArray(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) || value.length < 1 || value.length > 100 ||
+        value.some((entry) => typeof entry !== "string" || entry.length < 1 || entry.length > 120)) {
+        throw new InputError();
+    }
+    const entries = value;
+    if (new Set(entries).size !== entries.length)
+        throw new InputError();
+    return entries;
+}
 function requiredSectionHeading(record, key) {
     const value = requiredString(record, key, 60);
     const heading = value.trim();
@@ -632,6 +799,13 @@ function decodeOpaqueCursor(value) {
         throw new InputError();
     }
 }
+function decodeSince(value) {
+    if (uuidPattern.test(value))
+        return value.toLowerCase();
+    if (timestampPattern.test(value) && new Date(value).toISOString() === value)
+        return value;
+    throw new InputError();
+}
 function safeRequestId(value) {
     if (typeof value !== "object" || value === null || Array.isArray(value))
         return undefined;
@@ -641,30 +815,40 @@ function safeRequestId(value) {
         : undefined;
 }
 function success(status, requestId, payload) {
-    return { status, body: { protocol_version: "1", request_id: requestId, payload } };
+    return { status, body: createProtocolEnvelope(requestId, payload) };
 }
 function failure(status, code, message, requestId) {
     return {
         status,
         body: {
-            protocol_version: "1",
+            protocol_version: PROTOCOL_VERSION,
             ...(requestId === undefined ? {} : { request_id: requestId }),
             error: { code, message },
         },
     };
 }
 function encodeLogEvent(entry) {
+    if ("kind" in entry) {
+        return `event: log\nid: ${entry.id}\ndata: ${JSON.stringify({ entry })}\n\n`;
+    }
     return `event: log\nid: ${entry.id}\ndata: ${JSON.stringify({
         cursor: { id: entry.id, created_at: entry.created_at },
         entry,
     })}\n\n`;
 }
-function cursorKey(entry) {
-    return `${entry.created_at}\0${entry.id}`;
+function encodeHeartbeat() {
+    return `event: heartbeat\ndata: ${JSON.stringify({ ts: new Date().toISOString() })}\n\n`;
 }
-function afterCursor(entry, cursor) {
-    return cursor === null || entry.created_at > cursor.created_at ||
-        (entry.created_at === cursor.created_at && entry.id > cursor.id);
+function cubePayload(cube) {
+    return {
+        id: cube.id,
+        owner_id: cube.ownerId,
+        name: cube.name,
+        cube_directive: cube.directive,
+        message_taxonomy: cube.messageTaxonomy,
+        created_at: cube.createdAt,
+        updated_at: cube.updatedAt,
+    };
 }
 const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
 const timestampPattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u;