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

package/script/js/packages/trellis/store.js

@@ -0,0 +1,377 @@
+"use strict";
+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 _TypedStore_instances, _TypedStore_store, _TypedStore_options, _TypedStore_putInternal, _TypedStoreEntry_store;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypedStoreEntry = exports.TypedStore = void 0;
+exports.bytesFromStoreStream = bytesFromStoreStream;
+const obj_1 = require("@nats-io/obj");
+const result_1 = require("@qlever-llc/result");
+const index_ts_1 = require("./errors/index.js");
+const INTERNAL_CONTENT_TYPE_METADATA_KEY = "__trellis_content_type";
+const DEFAULT_STORE_WAIT_POLL_INTERVAL_MS = 250;
+function metadataWithContentType(options) {
+    if (!options?.metadata && !options?.contentType) {
+        return undefined;
+    }
+    return {
+        ...(options?.metadata ?? {}),
+        ...(options?.contentType ? { [INTERNAL_CONTENT_TYPE_METADATA_KEY]: options.contentType } : {}),
+    };
+}
+function storeInfoFromObjectInfo(info) {
+    const { [INTERNAL_CONTENT_TYPE_METADATA_KEY]: contentType, ...metadata } = info.metadata ?? {};
+    return {
+        key: info.name,
+        size: info.size,
+        updatedAt: info.mtime,
+        ...(info.digest ? { digest: info.digest } : {}),
+        ...(contentType ? { contentType } : {}),
+        metadata,
+    };
+}
+function streamFromBytes(data) {
+    return new ReadableStream({
+        start(controller) {
+            controller.enqueue(data);
+            controller.close();
+        },
+    });
+}
+function streamFromAsyncIterable(iterable) {
+    const iterator = iterable[Symbol.asyncIterator]();
+    return new ReadableStream({
+        async pull(controller) {
+            const next = await iterator.next();
+            if (next.done) {
+                controller.close();
+                return;
+            }
+            controller.enqueue(next.value);
+        },
+        async cancel(reason) {
+            await iterator.return?.(reason);
+        },
+    });
+}
+function enforceMaxObjectBytes(stream, maxObjectBytes) {
+    if (maxObjectBytes === undefined) {
+        return stream;
+    }
+    const reader = stream.getReader();
+    let totalBytes = 0;
+    return new ReadableStream({
+        async pull(controller) {
+            const next = await reader.read();
+            if (next.done) {
+                controller.close();
+                return;
+            }
+            totalBytes += next.value.length;
+            if (totalBytes > maxObjectBytes) {
+                controller.error(new index_ts_1.StoreError({
+                    operation: "put",
+                    context: {
+                        reason: "max_object_bytes_exceeded",
+                        maxObjectBytes,
+                        attemptedBytes: totalBytes,
+                    },
+                }));
+                await reader.cancel();
+                return;
+            }
+            controller.enqueue(next.value);
+        },
+        async cancel(reason) {
+            await reader.cancel(reason);
+        },
+    });
+}
+async function bytesFromStream(stream) {
+    const reader = stream.getReader();
+    const chunks = [];
+    let totalLength = 0;
+    while (true) {
+        const next = await reader.read();
+        if (next.done) {
+            break;
+        }
+        chunks.push(next.value);
+        totalLength += next.value.length;
+    }
+    const merged = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+        merged.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return merged;
+}
+function isNotFoundStoreError(error) {
+    return error.getContext().reason === "not_found";
+}
+function abortedStoreError(key, cause) {
+    return new index_ts_1.StoreError({ operation: "waitFor", cause, context: { key, reason: "aborted" } });
+}
+async function sleepWithSignal(ms, signal) {
+    if (signal?.aborted) {
+        throw signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+    }
+    await new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(() => {
+            cleanup();
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            cleanup();
+            reject(signal?.reason ?? new DOMException("The operation was aborted", "AbortError"));
+        };
+        const cleanup = () => {
+            clearTimeout(timeoutId);
+            signal?.removeEventListener("abort", onAbort);
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+function streamFromBody(body) {
+    return body instanceof ReadableStream ? body : streamFromAsyncIterable(body);
+}
+async function unwrapObjectInfo(store, key) {
+    try {
+        const info = await store.info(key);
+        if (info === null || info.deleted) {
+            return result_1.Result.err(new index_ts_1.StoreError({ operation: "get", context: { key, reason: "not_found" } }));
+        }
+        return result_1.Result.ok(info);
+    }
+    catch (cause) {
+        return result_1.Result.err(new index_ts_1.StoreError({ operation: "get", cause, context: { key } }));
+    }
+}
+class TypedStore {
+    constructor(store, options) {
+        _TypedStore_instances.add(this);
+        _TypedStore_store.set(this, void 0);
+        _TypedStore_options.set(this, void 0);
+        __classPrivateFieldSet(this, _TypedStore_store, store, "f");
+        __classPrivateFieldSet(this, _TypedStore_options, {
+            ttlMs: options.ttlMs ?? 0,
+            ...(options.maxObjectBytes !== undefined ? { maxObjectBytes: options.maxObjectBytes } : {}),
+            ...(options.maxTotalBytes !== undefined ? { maxTotalBytes: options.maxTotalBytes } : {}),
+            ...(options.bindOnly !== undefined ? { bindOnly: options.bindOnly } : {}),
+        }, "f");
+    }
+    static async open(nats, name, options = {}) {
+        try {
+            const objm = new obj_1.Objm(nats);
+            const store = options.bindOnly
+                ? await objm.open(name)
+                : await objm.create(name, {
+                    ...(options.ttlMs && options.ttlMs > 0 ? { ttl: options.ttlMs * 1_000_000 } : {}),
+                    ...(options.maxTotalBytes !== undefined ? { max_bytes: options.maxTotalBytes } : {}),
+                });
+            return result_1.Result.ok(new TypedStore(store, options));
+        }
+        catch (cause) {
+            return result_1.Result.err(new index_ts_1.StoreError({ operation: "open", cause, context: { name } }));
+        }
+    }
+    async create(key, body, options) {
+        const existing = await unwrapObjectInfo(__classPrivateFieldGet(this, _TypedStore_store, "f"), key);
+        if (existing.isOk()) {
+            return result_1.Result.err(new index_ts_1.StoreError({ operation: "create", context: { key, reason: "already_exists" } }));
+        }
+        return __classPrivateFieldGet(this, _TypedStore_instances, "m", _TypedStore_putInternal).call(this, "create", key, body, options);
+    }
+    async put(key, body, options) {
+        return __classPrivateFieldGet(this, _TypedStore_instances, "m", _TypedStore_putInternal).call(this, "put", key, body, options);
+    }
+    async get(key) {
+        const info = await unwrapObjectInfo(__classPrivateFieldGet(this, _TypedStore_store, "f"), key);
+        return info.map((objectInfo) => new TypedStoreEntry(__classPrivateFieldGet(this, _TypedStore_store, "f"), storeInfoFromObjectInfo(objectInfo)));
+    }
+    /**
+     * Waits for an object key to appear in the store and returns the resulting entry.
+     */
+    async waitFor(key, options = {}) {
+        const startedAt = Date.now();
+        const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_STORE_WAIT_POLL_INTERVAL_MS;
+        while (true) {
+            if (options.signal?.aborted) {
+                return result_1.Result.err(abortedStoreError(key, options.signal.reason));
+            }
+            const entry = await this.get(key);
+            if (entry.isOk()) {
+                return entry;
+            }
+            if (!isNotFoundStoreError(entry.error)) {
+                return entry;
+            }
+            const remainingTimeoutMs = options.timeoutMs === undefined
+                ? undefined
+                : options.timeoutMs - (Date.now() - startedAt);
+            if (remainingTimeoutMs !== undefined && remainingTimeoutMs <= 0) {
+                return result_1.Result.err(new index_ts_1.StoreError({
+                    operation: "waitFor",
+                    context: { key, reason: "timeout", timeoutMs: options.timeoutMs },
+                }));
+            }
+            try {
+                await sleepWithSignal(remainingTimeoutMs === undefined ? pollIntervalMs : Math.min(pollIntervalMs, remainingTimeoutMs), options.signal);
+            }
+            catch (cause) {
+                return result_1.Result.err(abortedStoreError(key, cause));
+            }
+        }
+    }
+    async delete(key) {
+        try {
+            await __classPrivateFieldGet(this, _TypedStore_store, "f").delete(key);
+            return result_1.Result.ok(undefined);
+        }
+        catch (cause) {
+            return result_1.Result.err(new index_ts_1.StoreError({ operation: "delete", cause, context: { key } }));
+        }
+    }
+    async list(prefix = "") {
+        try {
+            const objects = await __classPrivateFieldGet(this, _TypedStore_store, "f").list();
+            const filtered = objects
+                .filter((info) => !info.deleted && info.name.startsWith(prefix))
+                .map(storeInfoFromObjectInfo);
+            async function* iterate() {
+                for (const info of filtered) {
+                    yield info;
+                }
+            }
+            return result_1.Result.ok(iterate());
+        }
+        catch (cause) {
+            return result_1.Result.err(new index_ts_1.StoreError({ operation: "list", cause, context: { prefix } }));
+        }
+    }
+    async status() {
+        try {
+            const status = await __classPrivateFieldGet(this, _TypedStore_store, "f").status();
+            return result_1.Result.ok(storeStatusFromObjectStoreStatus(status, __classPrivateFieldGet(this, _TypedStore_options, "f")));
+        }
+        catch (cause) {
+            return result_1.Result.err(new index_ts_1.StoreError({ operation: "status", cause }));
+        }
+    }
+}
+exports.TypedStore = TypedStore;
+_TypedStore_store = new WeakMap(), _TypedStore_options = new WeakMap(), _TypedStore_instances = new WeakSet(), _TypedStore_putInternal = async function _TypedStore_putInternal(operation, key, body, options) {
+    try {
+        const metadata = metadataWithContentType(options);
+        if (body instanceof Uint8Array) {
+            if (__classPrivateFieldGet(this, _TypedStore_options, "f").maxObjectBytes !== undefined && body.length > __classPrivateFieldGet(this, _TypedStore_options, "f").maxObjectBytes) {
+                return result_1.Result.err(new index_ts_1.StoreError({
+                    operation,
+                    context: {
+                        key,
+                        reason: "max_object_bytes_exceeded",
+                        maxObjectBytes: __classPrivateFieldGet(this, _TypedStore_options, "f").maxObjectBytes,
+                        attemptedBytes: body.length,
+                    },
+                }));
+            }
+            await __classPrivateFieldGet(this, _TypedStore_store, "f").putBlob({ name: key, ...(metadata ? { metadata } : {}) }, body);
+            return result_1.Result.ok(undefined);
+        }
+        const limitedStream = enforceMaxObjectBytes(streamFromBody(body), __classPrivateFieldGet(this, _TypedStore_options, "f").maxObjectBytes);
+        await __classPrivateFieldGet(this, _TypedStore_store, "f").put({ name: key, ...(metadata ? { metadata } : {}) }, limitedStream);
+        return result_1.Result.ok(undefined);
+    }
+    catch (cause) {
+        return result_1.Result.err(new index_ts_1.StoreError({ operation, cause, context: { key } }));
+    }
+};
+function storeStatusFromObjectStoreStatus(status, options) {
+    return {
+        size: status.size,
+        sealed: status.sealed,
+        ttlMs: status.ttl > 0 ? Math.floor(status.ttl / 1_000_000) : options.ttlMs,
+        ...(options.maxObjectBytes !== undefined ? { maxObjectBytes: options.maxObjectBytes } : {}),
+        ...(options.maxTotalBytes !== undefined ? { maxTotalBytes: options.maxTotalBytes } : {}),
+    };
+}
+class TypedStoreEntry {
+    constructor(store, info) {
+        Object.defineProperty(this, "key", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "info", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        _TypedStoreEntry_store.set(this, void 0);
+        __classPrivateFieldSet(this, _TypedStoreEntry_store, store, "f");
+        this.key = info.key;
+        this.info = info;
+    }
+    async stream() {
+        try {
+            const result = await __classPrivateFieldGet(this, _TypedStoreEntry_store, "f").get(this.key);
+            if (result === null) {
+                return result_1.Result.err(new index_ts_1.StoreError({ operation: "stream", context: { key: this.key, reason: "not_found" } }));
+            }
+            return result_1.Result.ok(streamWithErrorCheck(result));
+        }
+        catch (cause) {
+            return result_1.Result.err(new index_ts_1.StoreError({ operation: "stream", cause, context: { key: this.key } }));
+        }
+    }
+    async bytes() {
+        try {
+            const bytes = await __classPrivateFieldGet(this, _TypedStoreEntry_store, "f").getBlob(this.key);
+            if (bytes === null) {
+                return result_1.Result.err(new index_ts_1.StoreError({ operation: "bytes", context: { key: this.key, reason: "not_found" } }));
+            }
+            return result_1.Result.ok(bytes);
+        }
+        catch (cause) {
+            return result_1.Result.err(new index_ts_1.StoreError({ operation: "bytes", cause, context: { key: this.key } }));
+        }
+    }
+}
+exports.TypedStoreEntry = TypedStoreEntry;
+_TypedStoreEntry_store = new WeakMap();
+function streamWithErrorCheck(result) {
+    const reader = result.data.getReader();
+    return new ReadableStream({
+        async pull(controller) {
+            const next = await reader.read();
+            if (next.done) {
+                const error = await result.error;
+                if (error) {
+                    controller.error(error);
+                    return;
+                }
+                controller.close();
+                return;
+            }
+            controller.enqueue(next.value);
+        },
+        async cancel(reason) {
+            await reader.cancel(reason);
+        },
+    });
+}
+async function bytesFromStoreStream(stream) {
+    return bytesFromStream(stream);
+}

package/script/js/packages/trellis/tasks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks.d.ts","sourceRoot":"","sources":["../../../../../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/script/js/packages/trellis/tasks.js

@@ -0,0 +1,45 @@
+"use strict";
+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 _TrellisTasks_tasks, _TrellisTasks_log;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrellisTasks = void 0;
+const result_1 = require("@qlever-llc/result");
+const globals_ts_1 = require("./globals.js");
+class TrellisTasks {
+    constructor(opts) {
+        _TrellisTasks_tasks.set(this, {});
+        _TrellisTasks_log.set(this, void 0);
+        __classPrivateFieldSet(this, _TrellisTasks_log, opts.log ?? globals_ts_1.logger, "f");
+    }
+    /*
+     * Add a task to the task queue
+     */
+    add(name, task) {
+        if (name in __classPrivateFieldGet(this, _TrellisTasks_tasks, "f")) {
+            __classPrivateFieldGet(this, _TrellisTasks_log, "f").error({ name }, "Task already running?");
+            throw new Error(`Task ${name} already running`);
+        }
+        __classPrivateFieldGet(this, _TrellisTasks_log, "f").debug({ name }, "Added task");
+        __classPrivateFieldGet(this, _TrellisTasks_tasks, "f")[name] = task.then((r) => {
+            if (result_1.Result.isErr(r)) {
+                __classPrivateFieldGet(this, _TrellisTasks_log, "f").error(r, "Task encountered a runtime error");
+            }
+            return r;
+        });
+    }
+    wait() {
+        return result_1.AsyncResult.any(Object.values(__classPrivateFieldGet(this, _TrellisTasks_tasks, "f")));
+    }
+}
+exports.TrellisTasks = TrellisTasks;
+_TrellisTasks_tasks = new WeakMap(), _TrellisTasks_log = new WeakMap();

package/script/js/packages/trellis/telemetry/carrier.d.ts

@@ -0,0 +1,9 @@
+import { type Context, type Span } from "@opentelemetry/api";
+export interface HeaderCarrier {
+    get(key: string): string | undefined;
+    set(key: string, value: string): void;
+}
+export declare function injectTraceContext(carrier: HeaderCarrier, span?: Span): void;
+export declare function extractTraceContext(carrier: HeaderCarrier): Context;
+export declare function createMapCarrier(): HeaderCarrier;
+//# sourceMappingURL=carrier.d.ts.map

package/script/js/packages/trellis/telemetry/carrier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"carrier.d.ts","sourceRoot":"","sources":["../../../../../../telemetry/carrier.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAwB,KAAK,IAAI,EAAS,MAAM,oBAAoB,CAAC;AAE1F,MAAM,WAAW,aAAa;IAC5B,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IACrC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACvC;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,IAAI,GAAG,IAAI,CAM5E;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAKnE;AAED,wBAAgB,gBAAgB,IAAI,aAAa,CAMhD"}

package/script/js/packages/trellis/telemetry/carrier.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectTraceContext = injectTraceContext;
+exports.extractTraceContext = extractTraceContext;
+exports.createMapCarrier = createMapCarrier;
+const api_1 = require("@opentelemetry/api");
+function injectTraceContext(carrier, span) {
+    const ctx = span ? api_1.trace.setSpan(api_1.context.active(), span) : api_1.context.active();
+    api_1.propagation.inject(ctx, carrier, {
+        set: (c, k, v) => c.set(k, v),
+    });
+}
+function extractTraceContext(carrier) {
+    return api_1.propagation.extract(api_1.context.active(), carrier, {
+        get: (c, k) => c.get(k),
+        keys: () => [],
+    });
+}
+function createMapCarrier() {
+    const map = new Map();
+    return {
+        get: (key) => map.get(key),
+        set: (key, value) => map.set(key, value),
+    };
+}

package/script/js/packages/trellis/telemetry/core.d.ts

@@ -0,0 +1,8 @@
+import { type Context, context, type Span, SpanKind, SpanStatusCode, type Tracer, trace } from "@opentelemetry/api";
+export declare function getTracer(scope?: string): Tracer;
+export declare function getActiveSpan(): Span | undefined;
+export declare function withSpan<T>(span: Span, fn: () => T): T;
+export declare function withSpanAsync<T>(span: Span, fn: () => Promise<T>): Promise<T>;
+export { context, SpanKind, SpanStatusCode, trace };
+export type { Context, Span };
+//# sourceMappingURL=core.d.ts.map

package/script/js/packages/trellis/telemetry/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../../../../telemetry/core.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,OAAO,EACP,KAAK,IAAI,EACT,QAAQ,EACR,cAAc,EACd,KAAK,MAAM,EACX,KAAK,EACN,MAAM,oBAAoB,CAAC;AAE5B,wBAAgB,SAAS,CAAC,KAAK,SAAgC,GAAG,MAAM,CAEvE;AAED,wBAAgB,aAAa,IAAI,IAAI,GAAG,SAAS,CAEhD;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAEtD;AAED,wBAAsB,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAEnF;AAED,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,KAAK,EAAE,CAAC;AACpD,YAAY,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC"}

package/script/js/packages/trellis/telemetry/core.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trace = exports.SpanStatusCode = exports.SpanKind = exports.context = void 0;
+exports.getTracer = getTracer;
+exports.getActiveSpan = getActiveSpan;
+exports.withSpan = withSpan;
+exports.withSpanAsync = withSpanAsync;
+const api_1 = require("@opentelemetry/api");
+Object.defineProperty(exports, "context", { enumerable: true, get: function () { return api_1.context; } });
+Object.defineProperty(exports, "SpanKind", { enumerable: true, get: function () { return api_1.SpanKind; } });
+Object.defineProperty(exports, "SpanStatusCode", { enumerable: true, get: function () { return api_1.SpanStatusCode; } });
+Object.defineProperty(exports, "trace", { enumerable: true, get: function () { return api_1.trace; } });
+function getTracer(scope = "@qlever-llc/trellis/tracing") {
+    return api_1.trace.getTracer(scope);
+}
+function getActiveSpan() {
+    return api_1.trace.getActiveSpan();
+}
+function withSpan(span, fn) {
+    return api_1.context.with(api_1.trace.setSpan(api_1.context.active(), span), fn);
+}
+async function withSpanAsync(span, fn) {
+    return api_1.context.with(api_1.trace.setSpan(api_1.context.active(), span), fn);
+}

package/script/js/packages/trellis/telemetry/env.d.ts

@@ -0,0 +1,2 @@
+export declare function getEnv(key: string): string | undefined;
+//# sourceMappingURL=env.d.ts.map

package/script/js/packages/trellis/telemetry/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../../../../../telemetry/env.ts"],"names":[],"mappings":"AAWA,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAQtD"}

package/script/js/packages/trellis/telemetry/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../../../../telemetry/init.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAE7C,wBAAgB,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAGrD;AAED,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/script/js/packages/trellis/telemetry/init.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initTelemetry = void 0;
+exports.initTracing = initTracing;
+const result_ts_1 = require("./result.js");
+const runtime_ts_1 = require("./runtime.js");
+Object.defineProperty(exports, "initTelemetry", { enumerable: true, get: function () { return runtime_ts_1.initTelemetry; } });
+function initTracing(serviceName) {
+    (0, result_ts_1.configureErrorTraceId)();
+    (0, runtime_ts_1.initTelemetry)(serviceName);
+}

package/script/js/packages/trellis/telemetry/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../telemetry/mod.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACzF,YAAY,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EACL,OAAO,EACP,aAAa,EACb,SAAS,EACT,QAAQ,EACR,cAAc,EACd,KAAK,EACL,QAAQ,EACR,aAAa,GACd,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,YAAY,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AACjD,OAAO,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC"}

package/script/js/packages/trellis/telemetry/mod.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startServerSpan = exports.startClientSpan = exports.getTrellisTracer = exports.configureErrorTraceId = exports.createNatsHeaderCarrier = exports.getEnv = exports.withSpanAsync = exports.withSpan = exports.trace = exports.SpanStatusCode = exports.SpanKind = exports.getTracer = exports.getActiveSpan = exports.context = exports.injectTraceContext = exports.extractTraceContext = exports.createMapCarrier = void 0;
+var carrier_ts_1 = require("./carrier.js");
+Object.defineProperty(exports, "createMapCarrier", { enumerable: true, get: function () { return carrier_ts_1.createMapCarrier; } });
+Object.defineProperty(exports, "extractTraceContext", { enumerable: true, get: function () { return carrier_ts_1.extractTraceContext; } });
+Object.defineProperty(exports, "injectTraceContext", { enumerable: true, get: function () { return carrier_ts_1.injectTraceContext; } });
+var core_ts_1 = require("./core.js");
+Object.defineProperty(exports, "context", { enumerable: true, get: function () { return core_ts_1.context; } });
+Object.defineProperty(exports, "getActiveSpan", { enumerable: true, get: function () { return core_ts_1.getActiveSpan; } });
+Object.defineProperty(exports, "getTracer", { enumerable: true, get: function () { return core_ts_1.getTracer; } });
+Object.defineProperty(exports, "SpanKind", { enumerable: true, get: function () { return core_ts_1.SpanKind; } });
+Object.defineProperty(exports, "SpanStatusCode", { enumerable: true, get: function () { return core_ts_1.SpanStatusCode; } });
+Object.defineProperty(exports, "trace", { enumerable: true, get: function () { return core_ts_1.trace; } });
+Object.defineProperty(exports, "withSpan", { enumerable: true, get: function () { return core_ts_1.withSpan; } });
+Object.defineProperty(exports, "withSpanAsync", { enumerable: true, get: function () { return core_ts_1.withSpanAsync; } });
+var env_ts_1 = require("./env.js");
+Object.defineProperty(exports, "getEnv", { enumerable: true, get: function () { return env_ts_1.getEnv; } });
+var nats_ts_1 = require("./nats.js");
+Object.defineProperty(exports, "createNatsHeaderCarrier", { enumerable: true, get: function () { return nats_ts_1.createNatsHeaderCarrier; } });
+var result_ts_1 = require("./result.js");
+Object.defineProperty(exports, "configureErrorTraceId", { enumerable: true, get: function () { return result_ts_1.configureErrorTraceId; } });
+var trellis_ts_1 = require("./trellis.js");
+Object.defineProperty(exports, "getTrellisTracer", { enumerable: true, get: function () { return trellis_ts_1.getTrellisTracer; } });
+Object.defineProperty(exports, "startClientSpan", { enumerable: true, get: function () { return trellis_ts_1.startClientSpan; } });
+Object.defineProperty(exports, "startServerSpan", { enumerable: true, get: function () { return trellis_ts_1.startServerSpan; } });

package/script/js/packages/trellis/telemetry/nats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nats.d.ts","sourceRoot":"","sources":["../../../../../../telemetry/nats.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAElD,MAAM,WAAW,eAAe;IAC9B,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IACrC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACvC;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,eAAe,GAAG,aAAa,CAK/E"}

package/script/js/packages/trellis/telemetry/nats.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNatsHeaderCarrier = createNatsHeaderCarrier;
+function createNatsHeaderCarrier(headers) {
+    return {
+        get: (key) => headers.get(key),
+        set: (key, value) => headers.set(key, value),
+    };
+}

package/script/js/packages/trellis/telemetry/result.d.ts

@@ -0,0 +1,2 @@
+export declare function configureErrorTraceId(): void;
+//# sourceMappingURL=result.d.ts.map

package/script/js/packages/trellis/telemetry/result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../../../../../telemetry/result.ts"],"names":[],"mappings":"AAKA,wBAAgB,qBAAqB,IAAI,IAAI,CAc5C"}

package/script/js/packages/trellis/telemetry/result.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureErrorTraceId = configureErrorTraceId;
+const api_1 = require("@opentelemetry/api");
+const result_1 = require("@qlever-llc/result");
+let traceIdGetterConfigured = false;
+function configureErrorTraceId() {
+    if (traceIdGetterConfigured)
+        return;
+    traceIdGetterConfigured = true;
+    result_1.BaseError.traceIdGetter = () => {
+        const span = api_1.trace.getActiveSpan();
+        if (!span)
+            return undefined;
+        const spanContext = span.spanContext();
+        if (spanContext.traceId === "00000000000000000000000000000000") {
+            return undefined;
+        }
+        return spanContext.traceId;
+    };
+}

package/script/js/packages/trellis/telemetry/runtime.d.ts

@@ -0,0 +1,2 @@
+export declare function initTelemetry(serviceName: string): void;
+//# sourceMappingURL=runtime.d.ts.map

package/script/js/packages/trellis/telemetry/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../../../../telemetry/runtime.ts"],"names":[],"mappings":"AAuFA,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAKvD"}