@qlever-llc/trellis 0.7.0-rc.5 → 0.7.0

package/esm/server.js

@@ -0,0 +1,807 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _TrellisServer_instances, _TrellisServer_version, _TrellisServer_log, _TrellisServer_operations, _TrellisServer_mountedOperationControls, _TrellisServer_transferSupport, _TrellisServer_resolveOperation, _TrellisServer_applyOperationUpdate, _TrellisServer_makeAcceptedOperation, _TrellisServer_acceptOperation, _TrellisServer_authenticateOperationMessage, _TrellisServer_ensureOperationControlLoop;
+import { Pointer } from "typebox/value";
+import { AsyncResult, err, isErr, ok, } from "@qlever-llc/result";
+import { ulid } from "ulid";
+import { parseSchema } from "./codec.js";
+import { AuthError, TransferError, UnexpectedError, } from "./errors/index.js";
+import { serverLogger } from "./server_logger.js";
+import { base64urlDecode, base64urlEncode, buildProofInput, buildRuntimeOperationSnapshot, isResultLike, isTerminalRuntimeOperationSnapshot, safeJson, sha256, toArrayBuffer, Trellis, } from "./trellis.js";
+function asStringPointerValue(operation, input, pointer, field) {
+    const value = Pointer.Get(input, pointer);
+    if (typeof value !== "string" || value.length === 0) {
+        return err(new TransferError({
+            operation: "transfer",
+            context: { reason: "invalid_input", operation, field, pointer },
+        }));
+    }
+    return ok(value);
+}
+function asOptionalStringPointerValue(input, pointer) {
+    if (!pointer) {
+        return ok(undefined);
+    }
+    const value = Pointer.Get(input, pointer);
+    if (value === undefined) {
+        return ok(undefined);
+    }
+    if (typeof value !== "string" || value.length === 0) {
+        return err(new TransferError({
+            operation: "transfer",
+            context: { reason: "invalid_input", field: pointer, pointer },
+        }));
+    }
+    return ok(value);
+}
+function asOptionalStringRecordPointerValue(input, pointer) {
+    if (!pointer) {
+        return ok(undefined);
+    }
+    const value = Pointer.Get(input, pointer);
+    if (value === undefined) {
+        return ok(undefined);
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return err(new TransferError({
+            operation: "transfer",
+            context: { reason: "invalid_input", field: pointer, pointer },
+        }));
+    }
+    const entries = Object.entries(value);
+    if (entries.some(([key, item]) => key.length === 0 || typeof item !== "string")) {
+        return err(new TransferError({
+            operation: "transfer",
+            context: { reason: "invalid_input", field: pointer, pointer },
+        }));
+    }
+    return ok(Object.fromEntries(entries));
+}
+export class TrellisServer extends Trellis {
+    constructor(name, nats, auth, opts) {
+        super(name, nats, auth, { ...opts, log: opts?.log ?? serverLogger });
+        _TrellisServer_instances.add(this);
+        _TrellisServer_version.set(this, void 0);
+        _TrellisServer_log.set(this, void 0);
+        _TrellisServer_operations.set(this, new Map());
+        _TrellisServer_mountedOperationControls.set(this, new Set());
+        _TrellisServer_transferSupport.set(this, void 0);
+        Object.defineProperty(this, "operations", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        __classPrivateFieldSet(this, _TrellisServer_version, opts?.version, "f");
+        __classPrivateFieldSet(this, _TrellisServer_log, (opts?.log ?? serverLogger).child({ lib: "trellis-server" }), "f");
+        __classPrivateFieldSet(this, _TrellisServer_transferSupport, opts?.transferSupport, "f");
+        this.operations = {
+            get: async (operationId) => {
+                const runtime = await __classPrivateFieldGet(this, _TrellisServer_instances, "m", _TrellisServer_resolveOperation).call(this, operationId);
+                if (!runtime) {
+                    return err(new UnexpectedError({
+                        cause: new Error(`Unknown operation '${operationId}'`),
+                    }));
+                }
+                return ok(runtime.snapshot);
+            },
+            started: async (operationId) => __classPrivateFieldGet(this, _TrellisServer_instances, "m", _TrellisServer_applyOperationUpdate).call(this, operationId, "running", {
+                event: { type: "started" },
+            }),
+            progress: async (operationId, progress) => __classPrivateFieldGet(this, _TrellisServer_instances, "m", _TrellisServer_applyOperationUpdate).call(this, operationId, "running", {
+                patch: { progress },
+                event: { type: "progress" },
+            }),
+            complete: async (operationId, output) => __classPrivateFieldGet(this, _TrellisServer_instances, "m", _TrellisServer_applyOperationUpdate).call(this, operationId, "completed", {
+                patch: { output },
+                event: { type: "completed" },
+            }),
+            fail: async (operationId, error) => __classPrivateFieldGet(this, _TrellisServer_instances, "m", _TrellisServer_applyOperationUpdate).call(this, operationId, "failed", {
+                patch: { error: { type: error.name, message: error.message } },
+                event: { type: "failed" },
+            }),
+            cancel: async (operationId) => __classPrivateFieldGet(this, _TrellisServer_instances, "m", _TrellisServer_applyOperationUpdate).call(this, operationId, "cancelled", {
+                event: { type: "cancelled" },
+            }),
+        };
+    }
+    static create(name, nats, auth, opts) {
+        return new TrellisServer(name, nats, auth, opts);
+    }
+    operation(operation) {
+        const ctx = this.api["operations"]?.[operation];
+        if (!ctx) {
+            throw new Error(`Unknown operation '${operation.toString()}'. Did you forget to include its API module?`);
+        }
+        return {
+            accept: async ({ sessionKey }) => {
+                __classPrivateFieldGet(this, _TrellisServer_instances, "m", _TrellisServer_ensureOperationControlLoop).call(this, String(operation), ctx);
+                if (ctx.transfer) {
+                    return err(new UnexpectedError({
+                        cause: new Error(`Operation '${String(operation)}' uses transfer-capable start semantics and cannot be accepted manually`),
+                    }));
+                }
+                return await __classPrivateFieldGet(this, _TrellisServer_instances, "m", _TrellisServer_acceptOperation).call(this, String(operation), sessionKey);
+            },
+            handle: async (handler) => {
+                const startSubject = ctx.subject;
+                const now = () => new Date().toISOString();
+                const publishFrame = async (reply, frame) => {
+                    await this.nats.publish(reply, JSON.stringify(frame));
+                };
+                const publishSnapshot = async (reply, snapshot) => {
+                    await publishFrame(reply, { kind: "snapshot", snapshot });
+                };
+                const publishEventToWatchers = async (runtime, event) => {
+                    const frame = { kind: "event", sequence: runtime.sequence, event };
+                    for (const reply of runtime.watchers) {
+                        await publishFrame(reply, frame);
+                    }
+                };
+                const flushWaiters = async (runtime) => {
+                    const frame = { kind: "snapshot", snapshot: runtime.snapshot };
+                    for (const reply of runtime.waiters) {
+                        await publishFrame(reply, frame);
+                    }
+                    runtime.waiters.clear();
+                };
+                const makeOperation = (runtime) => {
+                    const ensureActive = () => {
+                        if (runtime.terminal) {
+                            return err(new UnexpectedError({
+                                cause: new Error("operation already terminal"),
+                            }));
+                        }
+                        return null;
+                    };
+                    const transition = async (state, patch, event) => {
+                        runtime.sequence += 1;
+                        runtime.snapshot = buildRuntimeOperationSnapshot(runtime, state, patch);
+                        await this.saveOperationRecord(runtime);
+                        if (event) {
+                            await publishEventToWatchers(runtime, event);
+                        }
+                        return ok(runtime.snapshot);
+                    };
+                    return {
+                        id: runtime.id,
+                        started: async () => {
+                            const active = ensureActive();
+                            if (active)
+                                return active;
+                            return transition("running", undefined, {
+                                type: "started",
+                                snapshot: buildRuntimeOperationSnapshot(runtime, "running", {
+                                    revision: runtime.snapshot.revision + 1,
+                                }),
+                            });
+                        },
+                        progress: async (value) => {
+                            const active = ensureActive();
+                            if (active)
+                                return active;
+                            return transition("running", { progress: value }, {
+                                type: "progress",
+                                snapshot: buildRuntimeOperationSnapshot(runtime, "running", {
+                                    revision: runtime.snapshot.revision + 1,
+                                    progress: value,
+                                }),
+                            });
+                        },
+                        complete: async (value) => {
+                            const active = ensureActive();
+                            if (active)
+                                return active;
+                            const snapshot = buildRuntimeOperationSnapshot(runtime, "completed", {
+                                output: value,
+                                completedAt: now(),
+                            });
+                            runtime.sequence += 1;
+                            runtime.snapshot = snapshot;
+                            runtime.terminal = true;
+                            await this.saveOperationRecord(runtime);
+                            await publishEventToWatchers(runtime, {
+                                type: "completed",
+                                snapshot,
+                            });
+                            await flushWaiters(runtime);
+                            return ok(snapshot);
+                        },
+                        fail: async (error) => {
+                            const active = ensureActive();
+                            if (active)
+                                return active;
+                            const snapshot = buildRuntimeOperationSnapshot(runtime, "failed", {
+                                error: { type: error.name, message: error.message },
+                                completedAt: now(),
+                            });
+                            runtime.sequence += 1;
+                            runtime.snapshot = snapshot;
+                            runtime.terminal = true;
+                            await this.saveOperationRecord(runtime);
+                            await publishEventToWatchers(runtime, {
+                                type: "failed",
+                                snapshot,
+                            });
+                            await flushWaiters(runtime);
+                            return ok(snapshot);
+                        },
+                        cancel: async () => {
+                            const active = ensureActive();
+                            if (active)
+                                return active;
+                            const snapshot = buildRuntimeOperationSnapshot(runtime, "cancelled", {
+                                completedAt: now(),
+                            });
+                            runtime.sequence += 1;
+                            runtime.snapshot = snapshot;
+                            runtime.terminal = true;
+                            await this.saveOperationRecord(runtime);
+                            await publishEventToWatchers(runtime, {
+                                type: "cancelled",
+                                snapshot,
+                            });
+                            await flushWaiters(runtime);
+                            return ok(snapshot);
+                        },
+                        attach: async (job) => {
+                            const waited = await job.wait();
+                            const waitedValue = waited.take();
+                            if (isErr(waitedValue)) {
+                                return err(new UnexpectedError({ cause: waitedValue.error }));
+                            }
+                            const finalRuntime = await __classPrivateFieldGet(this, _TrellisServer_instances, "m", _TrellisServer_resolveOperation).call(this, runtime.id);
+                            if (!finalRuntime || !finalRuntime.terminal) {
+                                return err(new UnexpectedError({
+                                    cause: new Error("attached job completed without terminal operation state"),
+                                }));
+                            }
+                            return ok(finalRuntime.snapshot);
+                        },
+                    };
+                };
+                const authenticate = async (msg, parseInput = true) => {
+                    const jsonData = safeJson(msg).take();
+                    if (isErr(jsonData))
+                        return jsonData;
+                    let parsedInput;
+                    if (parseInput) {
+                        const parsedInputResult = parseSchema(ctx.input, jsonData).take();
+                        if (isErr(parsedInputResult)) {
+                            return err(parsedInputResult.error);
+                        }
+                        parsedInput = parsedInputResult;
+                    }
+                    else {
+                        parsedInput = jsonData;
+                    }
+                    const sessionKey = msg.headers?.get("session-key");
+                    const proof = msg.headers?.get("proof");
+                    if (!sessionKey) {
+                        return err(new AuthError({ reason: "missing_session_key" }));
+                    }
+                    if (!proof)
+                        return err(new AuthError({ reason: "missing_proof" }));
+                    const payloadBytes = msg.data ?? new Uint8Array();
+                    const payloadHash = await sha256(payloadBytes);
+                    const proofInput = buildProofInput(sessionKey, msg.subject, payloadHash);
+                    const digest = await sha256(proofInput);
+                    const verifyResult = await AsyncResult.try(async () => {
+                        const publicKeyRaw = base64urlDecode(sessionKey);
+                        const pub = await crypto.subtle.importKey("raw", toArrayBuffer(publicKeyRaw), { name: "Ed25519" }, true, ["verify"]);
+                        return crypto.subtle.verify({ name: "Ed25519" }, pub, toArrayBuffer(base64urlDecode(proof)), toArrayBuffer(digest));
+                    });
+                    const signatureOk = verifyResult.isOk() &&
+                        (await verifyResult).take() === true;
+                    if (!signatureOk) {
+                        return err(new AuthError({
+                            reason: "invalid_signature",
+                            context: { sessionKey },
+                        }));
+                    }
+                    const authResult = await this.requestAuthValidate({
+                        sessionKey,
+                        proof,
+                        subject: msg.subject,
+                        payloadHash: base64urlEncode(payloadHash),
+                        capabilities: ctx.callerCapabilities
+                            ? [...ctx.callerCapabilities]
+                            : undefined,
+                    });
+                    const auth = authResult.take();
+                    if (isErr(auth)) {
+                        return err(auth.error);
+                    }
+                    if (!auth.allowed) {
+                        return err(new AuthError({
+                            reason: "insufficient_permissions",
+                            context: {
+                                requiredCapabilities: ctx.callerCapabilities,
+                                userCapabilities: auth.caller.capabilities,
+                            },
+                        }));
+                    }
+                    if (typeof msg.reply !== "string" ||
+                        !msg.reply.startsWith(`${auth.inboxPrefix}.`)) {
+                        return err(new AuthError({
+                            reason: "reply_subject_mismatch",
+                            context: { expected: auth.inboxPrefix, actual: msg.reply },
+                        }));
+                    }
+                    return ok({
+                        input: parsedInput,
+                        caller: auth.caller,
+                        sessionKey,
+                        auth,
+                    });
+                };
+                __classPrivateFieldGet(this, _TrellisServer_log, "f").info({ operation: String(operation) }, `Mounting ${String(operation)} operation handler`);
+                __classPrivateFieldGet(this, _TrellisServer_instances, "m", _TrellisServer_ensureOperationControlLoop).call(this, String(operation), ctx);
+                const startSub = this.nats.subscribe(startSubject);
+                await this.nats.flush();
+                void (async () => {
+                    for await (const msg of startSub) {
+                        const validated = await authenticate(msg, true);
+                        const value = validated.take();
+                        if (isErr(value)) {
+                            this.respondWithError(msg, value.error);
+                            continue;
+                        }
+                        let transferSession;
+                        if (ctx.transfer) {
+                            if (!__classPrivateFieldGet(this, _TrellisServer_transferSupport, "f")) {
+                                this.respondWithError(msg, new UnexpectedError({
+                                    cause: new Error(`Operation '${String(operation)}' declared transfer support but no runtime transfer support is configured`),
+                                }));
+                                continue;
+                            }
+                            const key = asStringPointerValue(String(operation), value.input, ctx.transfer.key, "key").take();
+                            if (isErr(key)) {
+                                this.respondWithError(msg, key.error);
+                                continue;
+                            }
+                            const contentType = asOptionalStringPointerValue(value.input, ctx.transfer.contentType).take();
+                            if (isErr(contentType)) {
+                                this.respondWithError(msg, contentType.error);
+                                continue;
+                            }
+                            const metadata = asOptionalStringRecordPointerValue(value.input, ctx.transfer.metadata).take();
+                            if (isErr(metadata)) {
+                                this.respondWithError(msg, metadata.error);
+                                continue;
+                            }
+                            const openedTransfer = await __classPrivateFieldGet(this, _TrellisServer_transferSupport, "f").openOperationTransfer({
+                                sessionKey: value.sessionKey,
+                                store: ctx.transfer.store,
+                                key,
+                                expiresInMs: ctx.transfer.expiresInMs ?? 60_000,
+                                ...(ctx.transfer.maxBytes !== undefined
+                                    ? { maxBytes: ctx.transfer.maxBytes }
+                                    : {}),
+                                ...(contentType !== undefined ? { contentType } : {}),
+                                ...(metadata !== undefined ? { metadata } : {}),
+                            });
+                            const openedTransferValue = openedTransfer.take();
+                            if (isErr(openedTransferValue)) {
+                                this.respondWithError(msg, openedTransferValue.error);
+                                continue;
+                            }
+                            transferSession = openedTransferValue;
+                        }
+                        const operationId = ulid();
+                        const createdAt = now();
+                        const runtime = {
+                            id: operationId,
+                            service: this.name,
+                            operation: String(operation),
+                            ownerSessionKey: value.sessionKey,
+                            snapshot: {
+                                id: operationId,
+                                service: this.name,
+                                operation: String(operation),
+                                revision: 1,
+                                state: "pending",
+                                createdAt,
+                                updatedAt: createdAt,
+                            },
+                            sequence: 0,
+                            terminal: false,
+                            watchers: new Set(),
+                            waiters: new Set(),
+                        };
+                        __classPrivateFieldGet(this, _TrellisServer_operations, "f").set(operationId, runtime);
+                        await this.saveOperationRecord(runtime);
+                        if (transferSession) {
+                            void (async () => {
+                                for await (const progress of transferSession.transfer.updates()) {
+                                    runtime.sequence += 1;
+                                    runtime.snapshot = buildRuntimeOperationSnapshot(runtime, "running", { transfer: progress });
+                                    await this.saveOperationRecord(runtime);
+                                    await publishEventToWatchers(runtime, {
+                                        type: "transfer",
+                                        transfer: progress,
+                                        snapshot: runtime.snapshot,
+                                    });
+                                }
+                            })();
+                        }
+                        const accepted = {
+                            kind: "accepted",
+                            ref: {
+                                id: operationId,
+                                service: this.name,
+                                operation: String(operation),
+                            },
+                            snapshot: runtime.snapshot,
+                            ...(transferSession ? { transfer: transferSession.grant } : {}),
+                        };
+                        msg.respond(JSON.stringify(accepted));
+                        void (async () => {
+                            const op = makeOperation(runtime);
+                            try {
+                                const handlerResult = await handler(transferSession
+                                    ? {
+                                        input: value.input,
+                                        op,
+                                        caller: value.caller,
+                                        transfer: transferSession.transfer,
+                                    }
+                                    : {
+                                        input: value.input,
+                                        op,
+                                        caller: value.caller,
+                                    });
+                                const handlerOutcome = isResultLike(handlerResult)
+                                    ? handlerResult.take()
+                                    : handlerResult;
+                                if (isErr(handlerOutcome)) {
+                                    await op.fail(handlerOutcome.error);
+                                    return;
+                                }
+                                if (isTerminalRuntimeOperationSnapshot(handlerOutcome)) {
+                                    runtime.sequence = handlerOutcome.revision;
+                                    runtime.snapshot = handlerOutcome;
+                                    runtime.terminal = true;
+                                    await this.saveOperationRecord(runtime);
+                                    return;
+                                }
+                                if (!runtime.terminal) {
+                                    await op.complete(handlerOutcome);
+                                }
+                            }
+                            catch (cause) {
+                                await op.fail(new UnexpectedError({ cause }));
+                            }
+                        })();
+                    }
+                })();
+                return Promise.resolve();
+            },
+        };
+    }
+    async stop() {
+        if (!this.natsConnection.isClosed()) {
+            await this.natsConnection.drain();
+        }
+    }
+}
+_TrellisServer_version = new WeakMap(), _TrellisServer_log = new WeakMap(), _TrellisServer_operations = new WeakMap(), _TrellisServer_mountedOperationControls = new WeakMap(), _TrellisServer_transferSupport = new WeakMap(), _TrellisServer_instances = new WeakSet(), _TrellisServer_resolveOperation = async function _TrellisServer_resolveOperation(operationId) {
+    const existing = __classPrivateFieldGet(this, _TrellisServer_operations, "f").get(operationId);
+    if (existing)
+        return existing;
+    const durable = await this.loadOperationRecord(operationId);
+    if (!durable)
+        return null;
+    const runtime = {
+        id: durable.snapshot.id,
+        service: durable.snapshot.service,
+        operation: durable.snapshot.operation,
+        ownerSessionKey: durable.ownerSessionKey,
+        snapshot: durable.snapshot,
+        sequence: durable.sequence,
+        terminal: durable.snapshot.state === "completed" ||
+            durable.snapshot.state === "failed" ||
+            durable.snapshot.state === "cancelled",
+        watchers: new Set(),
+        waiters: new Set(),
+    };
+    __classPrivateFieldGet(this, _TrellisServer_operations, "f").set(operationId, runtime);
+    return runtime;
+}, _TrellisServer_applyOperationUpdate = async function _TrellisServer_applyOperationUpdate(operationId, state, opts) {
+    const runtime = await __classPrivateFieldGet(this, _TrellisServer_instances, "m", _TrellisServer_resolveOperation).call(this, operationId);
+    if (!runtime) {
+        return err(new UnexpectedError({
+            cause: new Error(`Unknown operation '${operationId}'`),
+        }));
+    }
+    if (runtime.terminal && state !== "cancelled") {
+        return err(new UnexpectedError({ cause: new Error("operation already terminal") }));
+    }
+    runtime.sequence += 1;
+    runtime.snapshot = buildRuntimeOperationSnapshot(runtime, state, opts.patch);
+    runtime.terminal = state === "completed" || state === "failed" ||
+        state === "cancelled";
+    await this.saveOperationRecord(runtime);
+    const frame = {
+        kind: "event",
+        sequence: runtime.sequence,
+        event: {
+            type: opts.event.type,
+            snapshot: runtime.snapshot,
+        },
+    };
+    for (const reply of runtime.watchers) {
+        await this.nats.publish(reply, JSON.stringify(frame));
+    }
+    if (runtime.terminal) {
+        const terminalFrame = { kind: "snapshot", snapshot: runtime.snapshot };
+        for (const reply of runtime.waiters) {
+            await this.nats.publish(reply, JSON.stringify(terminalFrame));
+        }
+        runtime.waiters.clear();
+    }
+    return ok(runtime.snapshot);
+}, _TrellisServer_makeAcceptedOperation = function _TrellisServer_makeAcceptedOperation(runtime) {
+    return {
+        id: runtime.id,
+        ref: {
+            id: runtime.id,
+            service: runtime.service,
+            operation: runtime.operation,
+        },
+        snapshot: runtime.snapshot,
+        started: async () => await this.operations.started(runtime.id),
+        progress: async (value) => await this.operations.progress(runtime.id, value),
+        complete: async (value) => await this.operations.complete(runtime.id, value),
+        fail: async (error) => await this.operations.fail(runtime.id, error),
+        cancel: async () => await this.operations.cancel(runtime.id),
+        attach: async (job) => {
+            const waited = await job.wait();
+            const waitedValue = waited.take();
+            if (isErr(waitedValue)) {
+                return err(new UnexpectedError({ cause: waitedValue.error }));
+            }
+            const finalRuntime = await __classPrivateFieldGet(this, _TrellisServer_instances, "m", _TrellisServer_resolveOperation).call(this, runtime.id);
+            if (!finalRuntime || !finalRuntime.terminal) {
+                return err(new UnexpectedError({
+                    cause: new Error("attached job completed without terminal operation state"),
+                }));
+            }
+            return ok(finalRuntime.snapshot);
+        },
+    };
+}, _TrellisServer_acceptOperation = async function _TrellisServer_acceptOperation(operation, sessionKey) {
+    const createdAt = new Date().toISOString();
+    const operationId = ulid();
+    const runtime = {
+        id: operationId,
+        service: this.name,
+        operation,
+        ownerSessionKey: sessionKey,
+        snapshot: {
+            id: operationId,
+            service: this.name,
+            operation,
+            revision: 1,
+            state: "pending",
+            createdAt,
+            updatedAt: createdAt,
+        },
+        sequence: 0,
+        terminal: false,
+        watchers: new Set(),
+        waiters: new Set(),
+    };
+    __classPrivateFieldGet(this, _TrellisServer_operations, "f").set(operationId, runtime);
+    await this.saveOperationRecord(runtime);
+    return ok(__classPrivateFieldGet(this, _TrellisServer_instances, "m", _TrellisServer_makeAcceptedOperation).call(this, runtime));
+}, _TrellisServer_authenticateOperationMessage = async function _TrellisServer_authenticateOperationMessage(msg, ctx, parseInput) {
+    const jsonData = safeJson(msg).take();
+    if (isErr(jsonData))
+        return jsonData;
+    let parsedInput;
+    if (parseInput) {
+        const parsedInputResult = parseSchema(ctx.input, jsonData).take();
+        if (isErr(parsedInputResult)) {
+            return err(parsedInputResult.error);
+        }
+        parsedInput = parsedInputResult;
+    }
+    else {
+        parsedInput = jsonData;
+    }
+    const sessionKey = msg.headers?.get("session-key");
+    const proof = msg.headers?.get("proof");
+    if (!sessionKey) {
+        return err(new AuthError({ reason: "missing_session_key" }));
+    }
+    if (!proof)
+        return err(new AuthError({ reason: "missing_proof" }));
+    const payloadBytes = msg.data ?? new Uint8Array();
+    const payloadHash = await sha256(payloadBytes);
+    const proofInput = buildProofInput(sessionKey, msg.subject, payloadHash);
+    const digest = await sha256(proofInput);
+    const verifyResult = await AsyncResult.try(async () => {
+        const publicKeyRaw = base64urlDecode(sessionKey);
+        const pub = await crypto.subtle.importKey("raw", toArrayBuffer(publicKeyRaw), { name: "Ed25519" }, true, ["verify"]);
+        return crypto.subtle.verify({ name: "Ed25519" }, pub, toArrayBuffer(base64urlDecode(proof)), toArrayBuffer(digest));
+    });
+    const signatureOk = verifyResult.isOk() &&
+        (await verifyResult).take() === true;
+    if (!signatureOk) {
+        return err(new AuthError({
+            reason: "invalid_signature",
+            context: { sessionKey },
+        }));
+    }
+    const authResult = await this.requestAuthValidate({
+        sessionKey,
+        proof,
+        subject: msg.subject,
+        payloadHash: base64urlEncode(payloadHash),
+        capabilities: ctx.callerCapabilities
+            ? [...ctx.callerCapabilities]
+            : undefined,
+    });
+    const auth = authResult.take();
+    if (isErr(auth)) {
+        return err(auth.error);
+    }
+    if (!auth.allowed) {
+        return err(new AuthError({
+            reason: "insufficient_permissions",
+            context: {
+                requiredCapabilities: ctx.callerCapabilities,
+                userCapabilities: auth.caller.capabilities,
+            },
+        }));
+    }
+    if (typeof msg.reply !== "string" ||
+        !msg.reply.startsWith(`${auth.inboxPrefix}.`)) {
+        return err(new AuthError({
+            reason: "reply_subject_mismatch",
+            context: { expected: auth.inboxPrefix, actual: msg.reply },
+        }));
+    }
+    return ok({
+        input: parsedInput,
+        caller: auth.caller,
+        sessionKey,
+        auth,
+    });
+}, _TrellisServer_ensureOperationControlLoop = function _TrellisServer_ensureOperationControlLoop(operation, ctx) {
+    const controlSubject = `${ctx.subject}.control`;
+    if (__classPrivateFieldGet(this, _TrellisServer_mountedOperationControls, "f").has(controlSubject)) {
+        return;
+    }
+    __classPrivateFieldGet(this, _TrellisServer_mountedOperationControls, "f").add(controlSubject);
+    const publishFrame = async (reply, frame) => {
+        await this.nats.publish(reply, JSON.stringify(frame));
+    };
+    const publishSnapshot = async (reply, snapshot) => {
+        await publishFrame(reply, { kind: "snapshot", snapshot });
+    };
+    const controlSub = this.nats.subscribe(controlSubject);
+    void (async () => {
+        for await (const msg of controlSub) {
+            const validated = await __classPrivateFieldGet(this, _TrellisServer_instances, "m", _TrellisServer_authenticateOperationMessage).call(this, msg, ctx, false);
+            const value = validated.take();
+            if (isErr(value)) {
+                this.respondWithError(msg, value.error);
+                continue;
+            }
+            const request = safeJson(msg).take();
+            if (isErr(request)) {
+                this.respondWithError(msg, request.error);
+                continue;
+            }
+            if (!request ||
+                typeof request !== "object" ||
+                typeof request.action !== "string" ||
+                typeof request.operationId !== "string") {
+                this.respondWithError(msg, new UnexpectedError({
+                    cause: new Error("Invalid operation control request"),
+                }));
+                continue;
+            }
+            const control = request;
+            const runtime = __classPrivateFieldGet(this, _TrellisServer_operations, "f").get(control.operationId);
+            const durableRecord = runtime
+                ? null
+                : await this.loadOperationRecord(control.operationId);
+            if (!runtime && !durableRecord) {
+                this.respondWithError(msg, new UnexpectedError({
+                    cause: new Error(`Unknown operation '${control.operationId}'`),
+                }));
+                continue;
+            }
+            const snapshot = runtime?.snapshot ?? durableRecord.snapshot;
+            const ownerSessionKey = runtime?.ownerSessionKey ?? durableRecord.ownerSessionKey;
+            if (ownerSessionKey !== value.sessionKey) {
+                this.respondWithError(msg, new AuthError({
+                    reason: "forbidden",
+                    context: { ownerSessionKey },
+                }));
+                continue;
+            }
+            if (control.action === "watch") {
+                if (msg.reply) {
+                    await publishSnapshot(msg.reply, snapshot);
+                    if (!runtime)
+                        continue;
+                    runtime.watchers.add(msg.reply);
+                }
+                continue;
+            }
+            if (control.action === "wait") {
+                if (snapshot.state === "completed" || snapshot.state === "failed" ||
+                    snapshot.state === "cancelled") {
+                    msg.respond(JSON.stringify({ kind: "snapshot", snapshot }));
+                }
+                else if (runtime && msg.reply) {
+                    runtime.waiters.add(msg.reply);
+                }
+                else if (msg.reply) {
+                    this.respondWithError(msg, new UnexpectedError({
+                        cause: new Error("operation is not running in this process"),
+                    }));
+                }
+                else {
+                    this.respondWithError(msg, new UnexpectedError({
+                        cause: new Error("missing reply subject for wait request"),
+                    }));
+                }
+                continue;
+            }
+            if (control.action === "get") {
+                msg.respond(JSON.stringify({ kind: "snapshot", snapshot }));
+                continue;
+            }
+            if (control.action === "cancel") {
+                if (!runtime) {
+                    msg.respond(JSON.stringify({ kind: "snapshot", snapshot }));
+                    continue;
+                }
+                runtime.snapshot = {
+                    ...runtime.snapshot,
+                    revision: runtime.snapshot.revision + 1,
+                    state: "cancelled",
+                    updatedAt: new Date().toISOString(),
+                    completedAt: new Date().toISOString(),
+                };
+                runtime.terminal = true;
+                runtime.sequence += 1;
+                await this.saveOperationRecord(runtime);
+                const frame = {
+                    kind: "event",
+                    sequence: runtime.sequence,
+                    event: {
+                        type: "cancelled",
+                        snapshot: runtime.snapshot,
+                    },
+                };
+                for (const reply of runtime.watchers) {
+                    await this.nats.publish(reply, JSON.stringify(frame));
+                }
+                for (const reply of runtime.waiters) {
+                    await this.nats.publish(reply, JSON.stringify({ kind: "snapshot", snapshot: runtime.snapshot }));
+                }
+                runtime.waiters.clear();
+                msg.respond(JSON.stringify({ kind: "snapshot", snapshot: runtime.snapshot }));
+                continue;
+            }
+            this.respondWithError(msg, new UnexpectedError({
+                cause: new Error(`Unknown operation control action '${control.action}' for '${operation}'`),
+            }));
+        }
+    })();
+};