@qlever-llc/trellis 0.5.1 → 0.6.0

package/esm/trellis/server.js

@@ -0,0 +1,536 @@
+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_resolveOperation, _TrellisServer_applyOperationUpdate;
+import { AsyncResult, err, isErr, ok, } from "@qlever-llc/result";
+import { ulid } from "ulid";
+import { parseSchema } from "./codec.js";
+import { AuthError, 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";
+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());
+        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");
+        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 {
+            handle: async (handler) => {
+                const startSubject = ctx.subject;
+                const controlSubject = `${ctx.subject}.control`;
+                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,
+                    });
+                    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`);
+                const startSub = this.nats.subscribe(startSubject);
+                const controlSub = this.nats.subscribe(controlSubject);
+                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;
+                        }
+                        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);
+                        const accepted = {
+                            kind: "accepted",
+                            ref: {
+                                id: operationId,
+                                service: this.name,
+                                operation: String(operation),
+                            },
+                            snapshot: runtime.snapshot,
+                        };
+                        msg.respond(JSON.stringify(accepted));
+                        void (async () => {
+                            const op = makeOperation(runtime);
+                            try {
+                                const handlerResult = await handler({
+                                    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 }));
+                            }
+                        })();
+                    }
+                })();
+                void (async () => {
+                    for await (const msg of controlSub) {
+                        const validated = await authenticate(msg, 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: now(),
+                                completedAt: now(),
+                            };
+                            runtime.terminal = true;
+                            runtime.sequence += 1;
+                            await this.saveOperationRecord(runtime);
+                            await publishEventToWatchers(runtime, {
+                                type: "cancelled",
+                                snapshot: runtime.snapshot,
+                            });
+                            await flushWaiters(runtime);
+                            msg.respond(JSON.stringify({
+                                kind: "snapshot",
+                                snapshot: runtime.snapshot,
+                            }));
+                            continue;
+                        }
+                        this.respondWithError(msg, new UnexpectedError({
+                            cause: new Error(`Unknown operation control action '${control.action}'`),
+                        }));
+                    }
+                })();
+                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_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);
+};

package/esm/trellis/server_logger.d.ts

@@ -0,0 +1,3 @@
+import type { LoggerLike } from "./globals.js";
+export declare const serverLogger: LoggerLike;
+//# sourceMappingURL=server_logger.d.ts.map

package/esm/trellis/server_logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server_logger.d.ts","sourceRoot":"","sources":["../../src/trellis/server_logger.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAI/C,eAAO,MAAM,YAAY,EAAE,UAGzB,CAAC"}

package/esm/trellis/server_logger.js

@@ -0,0 +1,7 @@
+import { pino } from "pino";
+import { getEnv } from "./env.js";
+const level = getEnv("PINO_LEVEL") || "info";
+export const serverLogger = pino({
+    level,
+    base: { library: "@qlever-llc/trellis" },
+});

package/esm/trellis/tasks.d.ts

@@ -1,9 +1,9 @@
-import { AsyncResult, type BaseError } from "@qlever-llc/trellis-result";
-import type { Logger } from "pino";
+import { AsyncResult, type BaseError } from "@qlever-llc/result";
+import { type LoggerLike } from "./globals.js";
 export declare class TrellisTasks {
     #private;
     constructor(opts: {
-        log?: Logger;
+        log?: LoggerLike;
     });
     add<E extends BaseError>(name: string, task: AsyncResult<void, E>): void;
     wait(): AsyncResult<void, BaseError>;

package/esm/trellis/tasks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tasks.d.ts","sourceRoot":"","sources":["../../src/trellis/tasks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,KAAK,SAAS,EAAU,MAAM,4BAA4B,CAAC;AACjF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAGnC,qBAAa,YAAY;;gBAKX,IAAI,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE;IAOlC,GAAG,CAAC,CAAC,SAAS,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC;IAejE,IAAI,IAAI,WAAW,CAAC,IAAI,EAAE,SAAS,CAAC;CAGrC"}
+{"version":3,"file":"tasks.d.ts","sourceRoot":"","sources":["../../src/trellis/tasks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,KAAK,SAAS,EAAU,MAAM,oBAAoB,CAAC;AACzE,OAAO,EAAU,KAAK,UAAU,EAAE,MAAM,cAAc,CAAC;AAEvD,qBAAa,YAAY;;gBAKX,IAAI,EAAE;QAAE,GAAG,CAAC,EAAE,UAAU,CAAA;KAAE;IAOtC,GAAG,CAAC,CAAC,SAAS,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC;IAejE,IAAI,IAAI,WAAW,CAAC,IAAI,EAAE,SAAS,CAAC;CAGrC"}

package/esm/trellis/tasks.js

@@ -10,7 +10,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _TrellisTasks_tasks, _TrellisTasks_log;
-import { AsyncResult, Result } from "@qlever-llc/trellis-result";
+import { AsyncResult, Result } from "@qlever-llc/result";
 import { logger } from "./globals.js";
 export class TrellisTasks {
     constructor(opts) {

package/esm/trellis/tracing.d.ts

@@ -1,5 +1,5 @@
 import "../_dnt.polyfills.js";
-export type { HeaderCarrier, NatsHeadersLike } from "@qlever-llc/trellis-telemetry";
-export { configureErrorTraceId, context, createMapCarrier, createNatsHeaderCarrier, extractTraceContext, getActiveSpan, getTrellisTracer as getTracer, injectTraceContext, SpanKind, SpanStatusCode, startClientSpan, startServerSpan, trace, withSpan, withSpanAsync } from "@qlever-llc/trellis-telemetry";
+export type { HeaderCarrier, NatsHeadersLike } from "../telemetry/mod.js";
+export { configureErrorTraceId, context, createMapCarrier, createNatsHeaderCarrier, extractTraceContext, getActiveSpan, getTrellisTracer as getTracer, injectTraceContext, SpanKind, SpanStatusCode, startClientSpan, startServerSpan, trace, withSpan, withSpanAsync } from "../telemetry/mod.js";
 export declare function initTracing(serviceName: string): void;
 //# sourceMappingURL=tracing.d.ts.map

package/esm/trellis/tracing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tracing.d.ts","sourceRoot":"","sources":["../../src/trellis/tracing.ts"],"names":[],"mappings":"AAEA,OAAO,sBAAsB,CAAC;AAE9B,YAAY,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AACpF,OAAO,EAAC,qBAAqB,EAC3B,OAAO,EACP,gBAAgB,EAChB,uBAAuB,EACvB,mBAAmB,EACnB,aAAa,EAAC,gBAAgB,IAAI,SAAS,EAC3C,kBAAkB,EAClB,QAAQ,EACR,cAAc,EAAC,eAAe,EAAE,eAAe,EAC/C,KAAK,EACL,QAAQ,EACR,aAAa,EACd,MAAM,+BAA+B,CAAC;AACvC,wBAAgB,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAErD"}
+{"version":3,"file":"tracing.d.ts","sourceRoot":"","sources":["../../src/trellis/tracing.ts"],"names":[],"mappings":"AAEA,OAAO,sBAAsB,CAAC;AAE9B,YAAY,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC1E,OAAO,EAAC,qBAAqB,EAC3B,OAAO,EACP,gBAAgB,EAChB,uBAAuB,EACvB,mBAAmB,EACnB,aAAa,EAAC,gBAAgB,IAAI,SAAS,EAC3C,kBAAkB,EAClB,QAAQ,EACR,cAAc,EAAC,eAAe,EAAE,eAAe,EAC/C,KAAK,EACL,QAAQ,EACR,aAAa,EACd,MAAM,qBAAqB,CAAC;AAC7B,wBAAgB,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAErD"}

package/esm/trellis/tracing.js

@@ -1,7 +1,7 @@
 // Keep this subpath for Trellis-specific tracing convenience without exposing
 // telemetry from the root `@qlever-llc/trellis` package surface.
 import "../_dnt.polyfills.js";
-export { configureErrorTraceId, context, createMapCarrier, createNatsHeaderCarrier, extractTraceContext, getActiveSpan, getTrellisTracer as getTracer, injectTraceContext, SpanKind, SpanStatusCode, startClientSpan, startServerSpan, trace, withSpan, withSpanAsync } from "@qlever-llc/trellis-telemetry";
+export { configureErrorTraceId, context, createMapCarrier, createNatsHeaderCarrier, extractTraceContext, getActiveSpan, getTrellisTracer as getTracer, injectTraceContext, SpanKind, SpanStatusCode, startClientSpan, startServerSpan, trace, withSpan, withSpanAsync } from "../telemetry/mod.js";
 export function initTracing(serviceName) {
-    void import("@qlever-llc/trellis-telemetry").then((mod) => mod.initTracing(serviceName));
+    void import("../telemetry/mod.js").then((mod) => mod.initTracing(serviceName));
 }