kernl 0.12.4 → 0.12.6

package/dist/tracing/__tests__/span.test.js

@@ -0,0 +1,188 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { SpanImpl, NoopSpan } from "../span.js";
+import { TestSubscriber } from "./helpers.js";
+describe("SpanImpl", () => {
+    let subscriber;
+    let span;
+    beforeEach(() => {
+        subscriber = new TestSubscriber();
+        span = new SpanImpl("test_span_1", subscriber);
+    });
+    describe("id", () => {
+        it("should return the span id", () => {
+            expect(span.id).toBe("test_span_1");
+        });
+    });
+    describe("noop", () => {
+        it("should return false", () => {
+            expect(span.noop()).toBe(false);
+        });
+    });
+    describe("enter", () => {
+        it("should call subscriber.enter", () => {
+            span.enter();
+            expect(subscriber.entered.has("test_span_1")).toBe(true);
+        });
+        it("should be idempotent (double enter does nothing)", () => {
+            span.enter();
+            span.enter();
+            const enterCalls = subscriber.calls.filter((c) => c.method === "enter" && c.spanId === "test_span_1");
+            expect(enterCalls).toHaveLength(1);
+        });
+        it("should not enter after close", () => {
+            span.close();
+            span.enter();
+            expect(subscriber.entered.has("test_span_1")).toBe(false);
+        });
+    });
+    describe("exit", () => {
+        it("should call subscriber.exit after enter", () => {
+            span.enter();
+            span.exit();
+            expect(subscriber.exited.has("test_span_1")).toBe(true);
+        });
+        it("should not exit if not entered", () => {
+            span.exit();
+            expect(subscriber.exited.has("test_span_1")).toBe(false);
+        });
+        it("should be idempotent (double exit does nothing)", () => {
+            span.enter();
+            span.exit();
+            span.exit();
+            const exitCalls = subscriber.calls.filter((c) => c.method === "exit" && c.spanId === "test_span_1");
+            expect(exitCalls).toHaveLength(1);
+        });
+        it("should not exit after close", () => {
+            span.enter();
+            span.close();
+            subscriber.exited.clear(); // clear the exit from close
+            subscriber.calls = [];
+            span.exit();
+            expect(subscriber.exited.has("test_span_1")).toBe(false);
+        });
+    });
+    describe("record", () => {
+        it("should call subscriber.record", () => {
+            span.record({ state: "running" });
+            const recorded = subscriber.getRecorded("test_span_1");
+            expect(recorded).toHaveLength(1);
+            expect(recorded[0]).toEqual({ state: "running" });
+        });
+        it("should allow multiple records", () => {
+            span.record({ state: "running" });
+            span.record({ result: "done" });
+            const recorded = subscriber.getRecorded("test_span_1");
+            expect(recorded).toHaveLength(2);
+        });
+        it("should not record after close", () => {
+            span.close();
+            span.record({ state: "running" });
+            const recorded = subscriber.getRecorded("test_span_1");
+            expect(recorded).toHaveLength(0);
+        });
+    });
+    describe("error", () => {
+        it("should call subscriber.error", () => {
+            const err = new Error("test error");
+            span.error(err);
+            const errors = subscriber.errors.get("test_span_1");
+            expect(errors).toHaveLength(1);
+            expect(errors[0]).toBe(err);
+        });
+        it("should allow multiple errors", () => {
+            span.error(new Error("error 1"));
+            span.error(new Error("error 2"));
+            const errors = subscriber.errors.get("test_span_1");
+            expect(errors).toHaveLength(2);
+        });
+        it("should not error after close", () => {
+            span.close();
+            span.error(new Error("test"));
+            const errors = subscriber.errors.get("test_span_1");
+            expect(errors).toBeUndefined();
+        });
+    });
+    describe("close", () => {
+        it("should call subscriber.close", () => {
+            span.close();
+            expect(subscriber.closed.has("test_span_1")).toBe(true);
+        });
+        it("should be idempotent (double close does nothing)", () => {
+            span.close();
+            span.close();
+            const closeCalls = subscriber.calls.filter((c) => c.method === "close" && c.spanId === "test_span_1");
+            expect(closeCalls).toHaveLength(1);
+        });
+        it("should auto-exit if entered but not exited", () => {
+            span.enter();
+            span.close();
+            expect(subscriber.exited.has("test_span_1")).toBe(true);
+            expect(subscriber.closed.has("test_span_1")).toBe(true);
+            // Verify order: exit before close
+            const exitIndex = subscriber.calls.findIndex((c) => c.method === "exit" && c.spanId === "test_span_1");
+            const closeIndex = subscriber.calls.findIndex((c) => c.method === "close" && c.spanId === "test_span_1");
+            expect(exitIndex).toBeLessThan(closeIndex);
+        });
+        it("should not exit if already exited", () => {
+            span.enter();
+            span.exit();
+            subscriber.calls = []; // clear calls
+            span.close();
+            const exitCalls = subscriber.calls.filter((c) => c.method === "exit" && c.spanId === "test_span_1");
+            expect(exitCalls).toHaveLength(0);
+        });
+        it("should not exit if never entered", () => {
+            span.close();
+            expect(subscriber.exited.has("test_span_1")).toBe(false);
+            expect(subscriber.closed.has("test_span_1")).toBe(true);
+        });
+    });
+    describe("full lifecycle", () => {
+        it("should handle enter -> record -> exit -> close", () => {
+            span.enter();
+            span.record({ state: "running" });
+            span.exit();
+            span.close();
+            expect(subscriber.isComplete("test_span_1")).toBe(true);
+            const methods = subscriber.calls
+                .filter((c) => c.spanId === "test_span_1")
+                .map((c) => c.method);
+            expect(methods).toEqual(["enter", "record", "exit", "close"]);
+        });
+        it("should handle enter -> error -> close (auto-exit)", () => {
+            span.enter();
+            span.error(new Error("oops"));
+            span.close();
+            expect(subscriber.isComplete("test_span_1")).toBe(true);
+            const methods = subscriber.calls
+                .filter((c) => c.spanId === "test_span_1")
+                .map((c) => c.method);
+            expect(methods).toEqual(["enter", "error", "exit", "close"]);
+        });
+    });
+});
+describe("NoopSpan", () => {
+    let span;
+    beforeEach(() => {
+        span = new NoopSpan();
+    });
+    describe("id", () => {
+        it("should return null", () => {
+            expect(span.id).toBeNull();
+        });
+    });
+    describe("noop", () => {
+        it("should return true", () => {
+            expect(span.noop()).toBe(true);
+        });
+    });
+    describe("methods", () => {
+        it("should not throw on any method", () => {
+            expect(() => span.enter()).not.toThrow();
+            expect(() => span.exit()).not.toThrow();
+            expect(() => span.record({ state: "running" })).not.toThrow();
+            expect(() => span.error(new Error("test"))).not.toThrow();
+            expect(() => span.close()).not.toThrow();
+        });
+    });
+});

package/dist/tracing/dispatch.d.ts

@@ -0,0 +1,43 @@
+import type { SpanId, SpanData, EventData } from "./types.js";
+import type { Subscriber } from "./subscriber.js";
+import { Span } from "./span.js";
+/**
+ * Get the current span ID from async context.
+ */
+export declare function current(): SpanId | null;
+/**
+ * Run a function within a span context.
+ * All spans created within `fn` will have `spanId` as their parent (unless overridden).
+ */
+export declare function run<T>(spanId: SpanId | null, fn: () => T): T;
+/**
+ * Set the global subscriber. Can only be set once.
+ */
+export declare function setSubscriber(subscriber: Subscriber): void;
+/**
+ * Clear the global subscriber.
+ */
+export declare function clearSubscriber(): void;
+/**
+ * Get the current global subscriber.
+ */
+export declare function getSubscriber(): Subscriber | null;
+type ParentOption = SpanId | "current" | null;
+/**
+ * Create a new span.
+ *
+ * @param data - The span data (must include `kind`)
+ * @param parent - Parent span: SpanId, "current" (from async context), or null (no parent)
+ * @returns A Span object for managing the span lifecycle
+ */
+export declare function span<T extends SpanData>(data: T, parent?: ParentOption): Span<T>;
+type EventParentOption = SpanId | "current" | null;
+/**
+ * Emit an event (moment in time, no duration).
+ *
+ * @param data - The event data (must include `kind`)
+ * @param parent - Parent span: SpanId, "current" (from async context), or null (no parent)
+ */
+export declare function event(data: EventData, parent?: EventParentOption): void;
+export {};
+//# sourceMappingURL=dispatch.d.ts.map

package/dist/tracing/dispatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../../src/tracing/dispatch.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,IAAI,EAAsB,MAAM,QAAQ,CAAC;AAYlD;;GAEG;AACH,wBAAgB,OAAO,IAAI,MAAM,GAAG,IAAI,CAEvC;AAED;;;GAGG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAE5D;AAQD;;GAEG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CAK1D;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,IAAI,CAEtC;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,UAAU,GAAG,IAAI,CAEjD;AAMD,KAAK,YAAY,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;AAE9C;;;;;;GAMG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,QAAQ,EACrC,IAAI,EAAE,CAAC,EACP,MAAM,GAAE,YAAwB,GAC/B,IAAI,CAAC,CAAC,CAAC,CAYT;AAMD,KAAK,iBAAiB,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;AAEnD;;;;;GAKG;AACH,wBAAgB,KAAK,CACnB,IAAI,EAAE,SAAS,EACf,MAAM,GAAE,iBAA6B,GACpC,IAAI,CAON"}

package/dist/tracing/dispatch.js

@@ -0,0 +1,70 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { SpanImpl, NoopSpan } from "./span.js";
+const gctx = new AsyncLocalStorage();
+/**
+ * Get the current span ID from async context.
+ */
+export function current() {
+    return gctx.getStore()?.spanId ?? null;
+}
+/**
+ * Run a function within a span context.
+ * All spans created within `fn` will have `spanId` as their parent (unless overridden).
+ */
+export function run(spanId, fn) {
+    return gctx.run({ spanId }, fn);
+}
+// -----------------------------------------------------------------------------
+// Global Subscriber
+// -----------------------------------------------------------------------------
+let globalSubscriber = null;
+/**
+ * Set the global subscriber. Can only be set once.
+ */
+export function setSubscriber(subscriber) {
+    if (globalSubscriber !== null) {
+        throw new Error("Global subscriber already set");
+    }
+    globalSubscriber = subscriber;
+}
+/**
+ * Clear the global subscriber.
+ */
+export function clearSubscriber() {
+    globalSubscriber = null;
+}
+/**
+ * Get the current global subscriber.
+ */
+export function getSubscriber() {
+    return globalSubscriber;
+}
+/**
+ * Create a new span.
+ *
+ * @param data - The span data (must include `kind`)
+ * @param parent - Parent span: SpanId, "current" (from async context), or null (no parent)
+ * @returns A Span object for managing the span lifecycle
+ */
+export function span(data, parent = "current") {
+    const subscriber = globalSubscriber;
+    if (!subscriber || !subscriber.enabled(data)) {
+        return new NoopSpan();
+    }
+    const resolvedParent = parent === "current" ? current() : parent;
+    const id = subscriber.span(data, resolvedParent);
+    return new SpanImpl(id, subscriber);
+}
+/**
+ * Emit an event (moment in time, no duration).
+ *
+ * @param data - The event data (must include `kind`)
+ * @param parent - Parent span: SpanId, "current" (from async context), or null (no parent)
+ */
+export function event(data, parent = "current") {
+    const subscriber = globalSubscriber;
+    if (!subscriber)
+        return;
+    const resolvedParent = parent === "current" ? current() : parent;
+    subscriber.event(data, resolvedParent);
+}

package/dist/tracing/index.d.ts

@@ -0,0 +1,8 @@
+export type { SpanId, SpanData, SpanKind, ThreadSpan, ModelCallSpan, ToolCallSpan, EventData, EventKind, ThreadErrorEvent, ThreadAbortedEvent, ThreadGuardrailTriggeredEvent, ToolApprovalRequestedEvent, ToolApprovalGrantedEvent, ToolApprovalDeniedEvent, } from "./types.js";
+export type { Subscriber } from "./subscriber.js";
+export type { Span } from "./span.js";
+export { SpanImpl, NoopSpan } from "./span.js";
+export { span, event, run, current, setSubscriber, clearSubscriber, getSubscriber, } from "./dispatch.js";
+export { CompositeSubscriber } from "./subscribers/composite.js";
+export { ConsoleSubscriber } from "./subscribers/console.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/tracing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tracing/index.ts"],"names":[],"mappings":"AACA,YAAY,EACV,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,aAAa,EACb,YAAY,EACZ,SAAS,EACT,SAAS,EACT,gBAAgB,EAChB,kBAAkB,EAClB,6BAA6B,EAC7B,0BAA0B,EAC1B,wBAAwB,EACxB,uBAAuB,GACxB,MAAM,SAAS,CAAC;AAGjB,YAAY,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAG/C,YAAY,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AACnC,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAG5C,OAAO,EACL,IAAI,EACJ,KAAK,EACL,GAAG,EACH,OAAO,EACP,aAAa,EACb,eAAe,EACf,aAAa,GACd,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/tracing/index.js

@@ -0,0 +1,6 @@
+export { SpanImpl, NoopSpan } from "./span.js";
+// Dispatch
+export { span, event, run, current, setSubscriber, clearSubscriber, getSubscriber, } from "./dispatch.js";
+// Subscribers
+export { CompositeSubscriber } from "./subscribers/composite.js";
+export { ConsoleSubscriber } from "./subscribers/console.js";

package/dist/tracing/span.d.ts

@@ -0,0 +1,69 @@
+import type { SpanId, SpanData } from "./types.js";
+import type { Subscriber } from "./subscriber.js";
+/**
+ * A Span represents a unit of work with duration.
+ *
+ * Spans track enter/exit for timing, can record additional fields,
+ * and must be closed when complete.
+ */
+export interface Span<T extends SpanData = SpanData> {
+    /**
+     * The unique identifier for this span, or null if this is a noop span.
+     */
+    readonly id: SpanId | null;
+    /**
+     * Mark the span as entered (execution begins).
+     */
+    enter(): void;
+    /**
+     * Mark the span as exited (execution paused/left).
+     */
+    exit(): void;
+    /**
+     * Record additional fields on the span.
+     */
+    record(fields: Partial<T>): void;
+    /**
+     * Record an error on the span.
+     */
+    error(err: Error): void;
+    /**
+     * Close the span. Also calls exit() if not already exited.
+     */
+    close(): void;
+    /**
+     * Returns true if this is a noop span (tracing disabled).
+     */
+    noop(): boolean;
+}
+/**
+ * A real span that dispatches to a subscriber.
+ */
+export declare class SpanImpl<T extends SpanData = SpanData> implements Span<T> {
+    readonly id: SpanId;
+    private readonly subscriber;
+    private entered;
+    private exited;
+    private closed;
+    constructor(id: SpanId, subscriber: Subscriber);
+    enter(): void;
+    exit(): void;
+    record(fields: Partial<T>): void;
+    error(err: Error): void;
+    close(): void;
+    noop(): boolean;
+}
+/**
+ * A noop span that does nothing. Used when tracing is disabled
+ * or the subscriber is not interested in this span.
+ */
+export declare class NoopSpan<T extends SpanData = SpanData> implements Span<T> {
+    readonly id: SpanId | null;
+    enter(): void;
+    exit(): void;
+    record(_fields: Partial<T>): void;
+    error(_err: Error): void;
+    close(): void;
+    noop(): boolean;
+}
+//# sourceMappingURL=span.d.ts.map

package/dist/tracing/span.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"span.d.ts","sourceRoot":"","sources":["../../src/tracing/span.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAChD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C;;;;;GAKG;AACH,MAAM,WAAW,IAAI,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ;IACjD;;OAEG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAE3B;;OAEG;IACH,KAAK,IAAI,IAAI,CAAC;IAEd;;OAEG;IACH,IAAI,IAAI,IAAI,CAAC;IAEb;;OAEG;IACH,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAEjC;;OAEG;IACH,KAAK,CAAC,GAAG,EAAE,KAAK,GAAG,IAAI,CAAC;IAExB;;OAEG;IACH,KAAK,IAAI,IAAI,CAAC;IAEd;;OAEG;IACH,IAAI,IAAI,OAAO,CAAC;CACjB;AAED;;GAEG;AACH,qBAAa,QAAQ,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ,CAAE,YAAW,IAAI,CAAC,CAAC,CAAC;IACrE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAa;IACxC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,MAAM,CAAS;gBAEX,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU;IAK9C,KAAK,IAAI,IAAI;IAOb,IAAI,IAAI,IAAI;IAMZ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI;IAKhC,KAAK,CAAC,GAAG,EAAE,KAAK,GAAG,IAAI;IAKvB,KAAK,IAAI,IAAI;IASb,IAAI,IAAI,OAAO;CAGhB;AAED;;;GAGG;AACH,qBAAa,QAAQ,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ,CAAE,YAAW,IAAI,CAAC,CAAC,CAAC;IACrE,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAQ;IAElC,KAAK,IAAI,IAAI;IACb,IAAI,IAAI,IAAI;IACZ,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI;IACjC,KAAK,CAAC,IAAI,EAAE,KAAK,GAAG,IAAI;IACxB,KAAK,IAAI,IAAI;IAEb,IAAI,IAAI,OAAO;CAGhB"}

package/dist/tracing/span.js

@@ -0,0 +1,64 @@
+/**
+ * A real span that dispatches to a subscriber.
+ */
+export class SpanImpl {
+    id;
+    subscriber;
+    entered = false;
+    exited = false;
+    closed = false;
+    constructor(id, subscriber) {
+        this.id = id;
+        this.subscriber = subscriber;
+    }
+    enter() {
+        if (this.closed || this.entered)
+            return;
+        this.entered = true;
+        this.exited = false;
+        this.subscriber.enter(this.id);
+    }
+    exit() {
+        if (this.closed || !this.entered || this.exited)
+            return;
+        this.exited = true;
+        this.subscriber.exit(this.id);
+    }
+    record(fields) {
+        if (this.closed)
+            return;
+        this.subscriber.record(this.id, fields);
+    }
+    error(err) {
+        if (this.closed)
+            return;
+        this.subscriber.error(this.id, err);
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        if (this.entered && !this.exited) {
+            this.subscriber.exit(this.id);
+        }
+        this.subscriber.close(this.id);
+    }
+    noop() {
+        return false;
+    }
+}
+/**
+ * A noop span that does nothing. Used when tracing is disabled
+ * or the subscriber is not interested in this span.
+ */
+export class NoopSpan {
+    id = null;
+    enter() { }
+    exit() { }
+    record(_fields) { }
+    error(_err) { }
+    close() { }
+    noop() {
+        return true;
+    }
+}

package/dist/tracing/subscriber.d.ts

@@ -0,0 +1,53 @@
+import type { SpanId, SpanData, EventData } from "./types.js";
+/**
+ * A Subscriber receives span and event notifications from the tracing system.
+ *
+ * Implementations can export data to backends like Laminar, log to console,
+ * collect metrics, etc.
+ */
+export interface Subscriber {
+    /**
+     * Returns whether this subscriber is interested in spans of this kind.
+     * If false, a noop span is returned and no further methods are called.
+     */
+    enabled(data: SpanData): boolean;
+    /**
+     * Called when a new span is created. Returns a unique SpanId for this span.
+     */
+    span(data: SpanData, parent: SpanId | null): SpanId;
+    /**
+     * Called when a span is entered (execution begins within the span).
+     */
+    enter(span: SpanId): void;
+    /**
+     * Called when a span is exited (execution leaves the span, but span may not be done).
+     */
+    exit(span: SpanId): void;
+    /**
+     * Called to record additional data on an existing span.
+     */
+    record(span: SpanId, delta: Partial<SpanData>): void;
+    /**
+     * Called when an error occurs within a span.
+     */
+    error(span: SpanId, error: Error): void;
+    /**
+     * Called when a span is closed (span is complete and will not receive more data).
+     * Implicitly calls exit() if the span was entered but not yet exited.
+     */
+    close(span: SpanId): void;
+    /**
+     * Called when an event (moment in time, no duration) occurs.
+     */
+    event(data: EventData, parent: SpanId | null): void;
+    /**
+     * Flush any buffered data to the backend.
+     */
+    flush(): Promise<void>;
+    /**
+     * Gracefully shutdown the subscriber, flushing remaining data.
+     * @param timeout Optional timeout in milliseconds
+     */
+    shutdown(timeout?: number): Promise<void>;
+}
+//# sourceMappingURL=subscriber.d.ts.map

package/dist/tracing/subscriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscriber.d.ts","sourceRoot":"","sources":["../../src/tracing/subscriber.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAE3D;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB;;;OAGG;IACH,OAAO,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC;IAEjC;;OAEG;IACH,IAAI,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAAC;IAEpD;;OAEG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAE1B;;OAEG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAEzB;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC;IAErD;;OAEG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IAExC;;;OAGG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAE1B;;OAEG;IACH,KAAK,CAAC,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;IAEpD;;OAEG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvB;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3C"}

package/dist/tracing/subscriber.js

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

package/dist/tracing/subscribers/composite.d.ts

@@ -0,0 +1,26 @@
+import type { SpanId, SpanData, EventData } from "../types.js";
+import type { Subscriber } from "../subscriber.js";
+/**
+ * A subscriber that fans out to multiple subscribers.
+ *
+ * - `enabled()` returns true if ANY subscriber is interested
+ * - `span()` calls all subscribers and returns a composite SpanId
+ * - All other methods dispatch to all subscribers
+ */
+export declare class CompositeSubscriber implements Subscriber {
+    private readonly subscribers;
+    private readonly spanMap;
+    private nextId;
+    constructor(subscribers: Subscriber[]);
+    enabled(data: SpanData): boolean;
+    span(data: SpanData, parent: SpanId | null): SpanId;
+    enter(span: SpanId): void;
+    exit(span: SpanId): void;
+    record(span: SpanId, delta: Partial<SpanData>): void;
+    error(span: SpanId, error: Error): void;
+    close(span: SpanId): void;
+    event(data: EventData, parent: SpanId | null): void;
+    flush(): Promise<void>;
+    shutdown(timeout?: number): Promise<void>;
+}
+//# sourceMappingURL=composite.d.ts.map

package/dist/tracing/subscribers/composite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composite.d.ts","sourceRoot":"","sources":["../../../src/tracing/subscribers/composite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD;;;;;;GAMG;AACH,qBAAa,mBAAoB,YAAW,UAAU;IACpD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAe;IAC3C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA+B;IACvD,OAAO,CAAC,MAAM,CAAK;gBAEP,WAAW,EAAE,UAAU,EAAE;IAIrC,OAAO,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO;IAIhC,IAAI,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM;IAsBnD,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAQzB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAQxB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,IAAI;IAQpD,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI;IAQvC,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IASzB,KAAK,CAAC,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IAQ7C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAGhD"}

package/dist/tracing/subscribers/composite.js

@@ -0,0 +1,96 @@
+/**
+ * A subscriber that fans out to multiple subscribers.
+ *
+ * - `enabled()` returns true if ANY subscriber is interested
+ * - `span()` calls all subscribers and returns a composite SpanId
+ * - All other methods dispatch to all subscribers
+ */
+export class CompositeSubscriber {
+    subscribers;
+    spanMap = new Map();
+    nextId = 0;
+    constructor(subscribers) {
+        this.subscribers = subscribers;
+    }
+    enabled(data) {
+        return this.subscribers.some((s) => s.enabled(data));
+    }
+    span(data, parent) {
+        const compositeId = `composite_${this.nextId++}`;
+        const childIds = [];
+        // Resolve parent for each subscriber
+        const parentIds = parent ? this.spanMap.get(parent) : null;
+        for (let i = 0; i < this.subscribers.length; i++) {
+            const sub = this.subscribers[i];
+            if (sub.enabled(data)) {
+                const parentId = parentIds?.[i] ?? null;
+                const childId = sub.span(data, parentId);
+                childIds.push(childId);
+            }
+            else {
+                childIds.push(""); // placeholder for disabled subscriber
+            }
+        }
+        this.spanMap.set(compositeId, childIds);
+        return compositeId;
+    }
+    enter(span) {
+        const ids = this.spanMap.get(span);
+        if (!ids)
+            return;
+        for (let i = 0; i < this.subscribers.length; i++) {
+            if (ids[i])
+                this.subscribers[i].enter(ids[i]);
+        }
+    }
+    exit(span) {
+        const ids = this.spanMap.get(span);
+        if (!ids)
+            return;
+        for (let i = 0; i < this.subscribers.length; i++) {
+            if (ids[i])
+                this.subscribers[i].exit(ids[i]);
+        }
+    }
+    record(span, delta) {
+        const ids = this.spanMap.get(span);
+        if (!ids)
+            return;
+        for (let i = 0; i < this.subscribers.length; i++) {
+            if (ids[i])
+                this.subscribers[i].record(ids[i], delta);
+        }
+    }
+    error(span, error) {
+        const ids = this.spanMap.get(span);
+        if (!ids)
+            return;
+        for (let i = 0; i < this.subscribers.length; i++) {
+            if (ids[i])
+                this.subscribers[i].error(ids[i], error);
+        }
+    }
+    close(span) {
+        const ids = this.spanMap.get(span);
+        if (!ids)
+            return;
+        for (let i = 0; i < this.subscribers.length; i++) {
+            if (ids[i])
+                this.subscribers[i].close(ids[i]);
+        }
+        this.spanMap.delete(span);
+    }
+    event(data, parent) {
+        const parentIds = parent ? this.spanMap.get(parent) : null;
+        for (let i = 0; i < this.subscribers.length; i++) {
+            const parentId = parentIds?.[i] ?? null;
+            this.subscribers[i].event(data, parentId);
+        }
+    }
+    async flush() {
+        await Promise.all(this.subscribers.map((s) => s.flush()));
+    }
+    async shutdown(timeout) {
+        await Promise.all(this.subscribers.map((s) => s.shutdown(timeout)));
+    }
+}

package/dist/tracing/subscribers/console.d.ts

@@ -0,0 +1,22 @@
+import type { SpanId, SpanData, EventData } from "../types.js";
+import type { Subscriber } from "../subscriber.js";
+/**
+ * A simple console subscriber for development and debugging.
+ * Logs span lifecycle events and events to the console.
+ */
+export declare class ConsoleSubscriber implements Subscriber {
+    private spans;
+    private nextId;
+    enabled(_data: SpanData): boolean;
+    span(data: SpanData, parent: SpanId | null): SpanId;
+    enter(spanId: SpanId): void;
+    exit(spanId: SpanId): void;
+    record(spanId: SpanId, delta: Partial<SpanData>): void;
+    error(spanId: SpanId, error: Error): void;
+    close(spanId: SpanId): void;
+    event(data: EventData, parent: SpanId | null): void;
+    flush(): Promise<void>;
+    shutdown(_timeout?: number): Promise<void>;
+    private fmt;
+}
+//# sourceMappingURL=console.d.ts.map