@pristine-ts/telemetry 2.0.3 → 2.0.4

package/dist/types/enums/span-keyname.enum.d.ts

@@ -1,29 +1 @@
-/**
- * This enum is for the different span names that are integrated in Pristine.
- */
-export declare enum SpanKeynameEnum {
-    ChildContainerCreation = "child.container.creation",
-    ChildContainerRegistration = "child.container.registration",
-    ConfigurationInitialization = "configuration.initialization",
-    ErrorResponseInterceptors = "error.response.interceptors",
-    EventDispatcherResolver = "event.dispatcher.resolver",
-    EventExecution = "event.execution",
-    EventInitialization = "event.initialization",
-    EventPreMappingInterception = "event.pre-mapping.interception",
-    EventPostMappingInterception = "event.post-mapping.interception",
-    EventPreResponseMappingInterception = "event.pre-response-mapping.interception",
-    EventPostResponseMappingInterception = "event.post-response-mapping.interception",
-    EventMapping = "event.mapping",
-    KernelInitialization = "kernel.initialization",
-    ModuleInitialization = "module.initialization",
-    ModuleInitializationImportModules = "module.initialization.import.modules",
-    RequestExecution = "request.execution",
-    RequestInterceptors = "request.interceptors",
-    ResponseInterceptors = "response.interceptors",
-    RootExecution = "root.execution",
-    RouterControllerResolver = "router.controller.resolver",
-    RouterFindMethodRouterNode = "router.find.method.router.node",
-    RouterRequestAuthentication = "router.request.authentication",
-    RouterRequestExecution = "router.request.execution",
-    RouterSetup = "router.setup"
-}
+export { SpanKeynameEnum } from "@pristine-ts/common";

package/dist/types/interfaces/tracing-manager.interface.d.ts

@@ -1,50 +1 @@
-import { Span } from "../models/span.model";
-import { Trace } from "../models/trace.model";
-/**
- * This interface specifies what a tracing manager should implement.
- */
-export interface TracingManagerInterface {
-    /**
-     * This property contains a reference to the active trace.
-     */
-    trace?: Trace;
-    /**
-     * This methods starts the Tracing. This should be the first method called before doing anything else.
-     * @param spanRootKeyname The keyname of the span at the root.
-     * @param traceId The trace id if there is one.
-     * @param context The context if there is one.
-     */
-    startTracing(spanRootKeyname?: string, traceId?: string, context?: {
-        [key: string]: string;
-    }): Span;
-    /**
-     * This method ends the trace entirely.
-     */
-    endTrace(): void;
-    /**
-     * This method starts a new span.
-     * @param keyname The keyname for this new span.
-     * @param parentKeyname The keyname of the parent span.
-     * @param parentId The id of the parent span.
-     * @param context The context if there is one.
-     */
-    startSpan(keyname: string, parentKeyname?: string, parentId?: string, context?: {
-        [key: string]: string;
-    }): Span;
-    /**
-     * This methods adds an already created Span to the trace. It assumes that it its hierarchy is correct.
-     * @param span The span to add.
-     */
-    addSpan(span: Span): Span;
-    /**
-     * This methods ends the span by setting the end date and by calling the tracers.
-     * It will also end the trace if the rootspan is being ended.
-     * @param span The span to end.
-     */
-    endSpan(span: Span): void;
-    /**
-     * This method ends the span using a keyname.
-     * @param keyname The keyname of the span to end.
-     */
-    endSpanKeyname(keyname: string): void;
-}
+export { TracingManagerInterface } from "@pristine-ts/common";

package/dist/types/managers/tracing.manager.d.ts

@@ -9,13 +9,23 @@ import { LogHandlerInterface } from "@pristine-ts/logging";
  * It is tagged and can be injected using TracingManagerInterface which facilitates mocking.
  * It is module scoped to the TelemetryModuleKeyname.
  *
+ * **Where the active `Trace` lives.** The active trace is stored on `EventContext.trace`,
+ * propagated via `AsyncLocalStorage`. Every `TracingManager` instance — whether resolved
+ * from the root container (kernel boot) or from a per-event child container — reads and
+ * writes spans through the same `EventContext.trace` reference, so a span started in the
+ * kernel and an event added in a controller belong to the same trace tree.
+ *
+ * **Fallback `this.trace`.** During kernel boot (`Kernel.start()` and friends), there is
+ * no `EventContext` yet — the framework hasn't started handling an event. In that window
+ * the manager falls back to `this.trace`. This is the only time `this.trace` is touched.
+ *
  * **Lifecycle: container-scoped, not singleton.** Each per-event DI child container gets
- * its own `TracingManager` instance with its own `trace` and `spans` state. Earlier
- * versions used `@singleton()` — a single instance shared across every event — which
- * was a latent bug: parallel events would clobber each other's `this.trace`. Resolving
- * `TracingManager` from the root container still returns the root instance (used for
- * kernel-initialization spans before any event has started); resolving from a child
- * container returns the per-event instance, which is what application code wants.
+ * its own `TracingManager` instance. The per-instance `this.trace` fallback is what keeps
+ * parallel events isolated *if* tracing is somehow started outside an EventContext.
+ * Resolving `TracingManager` from the root container returns the root instance (used for
+ * kernel-initialization spans); resolving from a child container returns the per-event
+ * instance — both will agree on what trace is active inside an event because they read
+ * from EventContext.
  */
 export declare class TracingManager implements TracingManagerInterface {
     private readonly tracers;
@@ -24,15 +34,10 @@ export declare class TracingManager implements TracingManagerInterface {
     private readonly debug;
     private readonly tracingContext;
     /**
-     * This property contains a reference to the active trace.
+     * Fallback trace used only during kernel boot when no `EventContext` is active.
+     * Inside an event, the active trace lives on `EventContext.trace` instead.
      */
     trace?: Trace;
-    /**
-     * This object contains a map of all the spans sorted by their keyname.
-     */
-    spans: {
-        [keyname: string]: Span[];
-    };
     /**
      * The Tracing Manager provides methods to help with tracing.
      * It is tagged and can be injected using TracingManagerInterface which facilitates mocking.
@@ -45,6 +50,16 @@ export declare class TracingManager implements TracingManagerInterface {
      * @param tracingContext The tracing context.
      */
     constructor(tracers: TracerInterface[], loghandler: LogHandlerInterface, isActive: boolean, debug: boolean, tracingContext: TracingContext);
+    /**
+     * Returns the currently active trace from the EventContext, falling back to the
+     * per-instance `this.trace` when no EventContext is active (kernel boot).
+     */
+    private getActiveTrace;
+    /**
+     * Stores `trace` as the active trace — on `EventContext.trace` when an event is active,
+     * otherwise on the instance fallback `this.trace`.
+     */
+    private setActiveTrace;
     /**
      * This methods starts the Tracing. This should be the first method called before doing anything else.
      * @param spanRootKeyname The keyname of the span at the root.
@@ -84,4 +99,47 @@ export declare class TracingManager implements TracingManagerInterface {
      * This method ends the trace entirely.
      */
     endTrace(): void;
+    /**
+     * Attaches a named, timestamped event to the most-recently-started in-progress span.
+     * Use for noteworthy moments that don't warrant a child span — "validation passed",
+     * "found 50 rows", "rate limit ok". Cheap (just pushes onto an array); shows up in
+     * the trace rendered by tracers (ConsoleTracer, FileTracer, X-Ray, etc.).
+     *
+     * If no span is currently active (no trace started, or every span has already ended),
+     * a warning is logged and the marker is dropped. The warning is the explicit signal
+     * that "this marker call had nowhere to go" — usually the sign of a missing
+     * `startTracing()` call earlier in the flow.
+     */
+    addEventToCurrentSpan(message: string, attributes?: {
+        [key: string]: string;
+    }): void;
+    /**
+     * Returns the active trace's spans + their events as a flat, timestamp-sorted list of
+     * `{kind, name, date, attributes}` entries. Public utility for custom tracers, debug
+     * endpoints, test helpers, or anyone who wants "the active trace as a flat list."
+     * Returns an empty array when no active trace exists.
+     */
+    getCurrentTrail(): Array<{
+        kind: "span" | "event";
+        name: string;
+        date: Date;
+        attributes: {
+            [key: string]: string;
+        };
+    }>;
+    /**
+     * Finds the deepest in-progress span — the leaf of the still-open subtree. Used as
+     * the target for `addEventToCurrentSpan`. Intuition: events attach to whatever is
+     * currently open at the bottom of the call stack.
+     *
+     * Walking the in-progress subtree (rather than ranking all spans by start date)
+     * avoids the edge case where a parent and child have the same `Date.now()` value —
+     * picking the "latest started" by raw timestamp would incorrectly attach to the
+     * parent. Depth-first traversal of in-progress children naturally lands on the
+     * deepest leaf. Tie-broken by latest start date when multiple leaves exist.
+     *
+     * Returns undefined when nothing is in progress (no trace, or every span has ended).
+     * @private
+     */
+    private findActiveLeafSpan;
 }

package/dist/types/models/models.d.ts

@@ -1,2 +1,3 @@
+export * from "./span-event.model";
 export * from "./span.model";
 export * from "./trace.model";

package/dist/types/models/span-event.model.d.ts

@@ -0,0 +1 @@
+export { SpanEvent } from "@pristine-ts/common";

package/dist/types/models/span.model.d.ts

@@ -1,73 +1 @@
-import { Trace } from "./trace.model";
-import { TracingManagerInterface } from "../interfaces/tracing-manager.interface";
-/**
- * This model represents a span.
- */
-export declare class Span {
-    keyname: string;
-    /**
-     * The unique id of the span.
-     */
-    id: string;
-    /**
-     * The tracing manager.
-     */
-    tracingManager?: TracingManagerInterface;
-    /**
-     * The trace the span is attached to.
-     */
-    trace?: Trace;
-    /**
-     * The timestamp in milliseconds at which the span was started.
-     */
-    startDate: number;
-    /**
-     * The timestamp in milliseconds at which the span was ended.
-     */
-    endDate?: number;
-    /**
-     * The parent span.
-     */
-    parentSpan?: Span;
-    /**
-     * The children spans.
-     */
-    children: Span[];
-    /**
-     * The context associated with the span.
-     */
-    context: {
-        [key: string]: string;
-    };
-    /**
-     * Whether or not the span is in progress, meaning it has not ended.
-     */
-    inProgress: boolean;
-    /**
-     * This model represents a span.
-     * @param keyname The keyname of the span.
-     * @param id The unique id of the span.
-     * @param context The context to associate with the span.
-     */
-    constructor(keyname: string, id?: string, context?: {
-        [key: string]: string;
-    });
-    /**
-     * This method returns the duration of the span in milliseconds.
-     */
-    getDuration(): number;
-    /**
-     * This method ends the span.
-     */
-    end(): void;
-    /**
-     * This method sets the trace for the span and all of its children.
-     * @param trace The trace the span should be attached to.
-     */
-    setTrace(trace: Trace): void;
-    /**
-     * This method adds a child span to the current span. It only adds it if it's not already part of the children.
-     * @param span The span to add as a child.
-     */
-    addChild(span: Span): void;
-}
+export { Span, SpanLifecycleOwnerInterface } from "@pristine-ts/common";

package/dist/types/models/trace.model.d.ts

@@ -1,44 +1 @@
-import { Span } from "./span.model";
-/**
- * This model represents a trace.
- */
-export declare class Trace {
-    /**
-     * The unique id of the trace.
-     */
-    id: string;
-    /**
-     * The timestamp in milliseconds at which the trace was started.
-     */
-    startDate: number;
-    /**
-     * The timestamp in milliseconds at which the trace was ended.
-     */
-    endDate?: number;
-    /**
-     * The span that is at the root.
-     */
-    rootSpan?: Span;
-    /**
-     * The context associated with the trace.
-     */
-    context?: {
-        [key: string]: string;
-    };
-    /**
-     * Whether or not the trace was ended.
-     */
-    hasEnded: boolean;
-    /**
-     * This model represents a trace.
-     * @param id The unique id of the trace.
-     * @param context The context associated with the trace.
-     */
-    constructor(id?: string, context?: {
-        [key: string]: string;
-    });
-    /**
-     * This returns the duration of the trace in miliseconds.
-     */
-    getDuration(): number;
-}
+export { Trace } from "@pristine-ts/common";

package/dist/types/telemetry.module.d.ts

@@ -1,5 +1,4 @@
 import { ModuleInterface } from "@pristine-ts/common";
-export * from "./decorators/decorators";
 export * from "./enums/enums";
 export * from "./interfaces/interfaces";
 export * from "./managers/managers";

package/dist/types/utils/span-runner.d.ts

@@ -1,55 +1 @@
-import { TracingManagerInterface } from "../interfaces/tracing-manager.interface";
-/**
- * Options to scope a `runWithSpan` call beyond just naming the span.
- */
-export interface SpanRunnerOptions {
-    /** When set, attach the new span as a child of the most recent span with this keyname. */
-    parentKeyname?: string;
-    /** Disambiguates parents when multiple spans share the same `parentKeyname`. */
-    parentId?: string;
-    /** Free-form context recorded on the span and surfaced in the rendered output. */
-    context?: {
-        [key: string]: string;
-    };
-}
-/**
- * Runs a function inside a span that is automatically ended when the function returns
- * or throws.
- *
- * Two call shapes are supported:
- *
- * **Explicit form** (`runWithSpan(tracingManager, name, fn)`) — pass the manager you've
- * already injected. Works anywhere, including outside an event context. Use this when
- * you have a `TracingManager` reference in hand:
- *
- * ```ts
- * return spanRunner.runWithSpan(this.tracingManager, "payment.charge",
- *   () => this.client.charge(amount));
- * ```
- *
- * **ALS form** (`runWithSpan(name, fn)`) — auto-resolves the `TracingManager` from the
- * active `EventContext`'s container. Concise; works when called from anywhere inside
- * a Pristine event (controller, service, etc.) without needing the manager threaded
- * through:
- *
- * ```ts
- * return spanRunner.runWithSpan("payment.charge", () => this.client.charge(amount));
- * ```
- *
- * If the ALS form is used outside any `EventContext` (e.g. a unit test that doesn't
- * boot a kernel), no span is created and `fn` runs unchanged — same no-throw contract
- * as the rest of the tracing layer.
- *
- * On thrown errors: the error's name/message is attached to the span's context (visible
- * in the rendered tree/JSON output) and then re-thrown. The span is ended either way.
- *
- * Stateless — instantiate once and reuse, or use the exported singleton `spanRunner`.
- */
-export declare class SpanRunner {
-    runWithSpan<T>(tracingManager: TracingManagerInterface, spanKeyname: string, fn: () => Promise<T> | T, options?: SpanRunnerOptions): Promise<T>;
-    runWithSpan<T>(spanKeyname: string, fn: () => Promise<T> | T, options?: SpanRunnerOptions): Promise<T>;
-}
-/**
- * Default singleton. Stateless so sharing is safe.
- */
-export declare const spanRunner: SpanRunner;
+export { SpanRunner, SpanRunnerOptions, spanRunner } from "@pristine-ts/common";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pristine-ts/telemetry",
-  "version": "2.0.3",
+  "version": "2.0.4",
   "description": "",
   "module": "dist/lib/esm/telemetry.module.js",
   "main": "dist/lib/cjs/telemetry.module.js",
@@ -12,8 +12,8 @@
     "test:cov": "jest --coverage"
   },
   "dependencies": {
-    "@pristine-ts/common": "^2.0.3",
-    "@pristine-ts/logging": "^2.0.3",
+    "@pristine-ts/common": "^2.0.4",
+    "@pristine-ts/logging": "^2.0.4",
     "uuid": "^9.0.1"
   },
   "devDependencies": {
@@ -61,7 +61,7 @@
       "src/*.{js,ts}"
     ]
   },
-  "gitHead": "c741bb430ab8f6286068dc3870fcadf4cefd0023",
+  "gitHead": "f376d34e13c1b17b7764c0b47708148e4e51390b",
   "repository": {
     "type": "git",
     "url": "https://github.com/magieno/pristine-ts.git",

package/dist/lib/cjs/decorators/decorators.js

@@ -1,18 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./traced.decorator"), exports);
-//# sourceMappingURL=decorators.js.map

package/dist/lib/cjs/decorators/decorators.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../../../src/decorators/decorators.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,qDAAmC"}

package/dist/lib/cjs/decorators/traced.decorator.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.traced = traced;
-const span_runner_1 = require("../utils/span-runner");
-/**
- * Method decorator that wraps the decorated method in a span. The span is automatically
- * ended when the method returns or throws, and the `TracingManager` is auto-resolved
- * from the active `EventContext` — no need to inject it manually.
- *
- * ```ts
- * class PaymentService {
- *   @traced()                                // span name = "PaymentService.charge"
- *   async charge(amount: number) { ... }
- *
- *   @traced("payment.refund.action")         // explicit name
- *   async refund(chargeId: string) { ... }
- * }
- * ```
- *
- * **Behavior outside an event context.** When the decorated method runs without an
- * active `EventContext` (e.g. a unit test calling the method directly, or background
- * work that escaped the event lifecycle), the decorator is a no-op — the original
- * method runs unchanged. Tracing must never throw or alter semantics.
- *
- * **Sync methods become async.** The decorator awaits the wrapped method internally,
- * so any decorated method returns a `Promise`. Decorating a sync method changes its
- * signature visible to callers — apply `@traced` to methods you'd already be awaiting
- * (DB calls, HTTP, expensive computations), not to tight sync helpers.
- *
- * **Type-level caveat.** TypeScript's parameter and method decorator types don't carry
- * enough information for the compiler to verify that the wrapped method's return type
- * is compatible with `Promise<T>`. The wrapper is type-safe at runtime; the call site's
- * static types are unchanged. Pair with explicit `: Promise<T>` annotations on the
- * method when you want the static type to match what's actually returned.
- *
- * @param spanName Optional explicit name for the span. Defaults to
- *   `${ClassName}.${methodName}`.
- */
-function traced(spanName) {
-    return (target, propertyKey, descriptor) => {
-        var _a, _b, _c;
-        const original = descriptor.value;
-        if (typeof original !== "function") {
-            // Decorator was applied to something other than a method (a getter, a property
-            // with no initial value, etc.). Leave it alone — silently no-op rather than
-            // throw at decoration time.
-            return descriptor;
-        }
-        // Resolve a stable default name at decoration time. `target.constructor.name` is
-        // the class name for instance methods; for static methods, `target.name` is the
-        // class. We cover both via the fallback chain.
-        const className = (_c = (_b = (_a = target === null || target === void 0 ? void 0 : target.constructor) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : target === null || target === void 0 ? void 0 : target.name) !== null && _c !== void 0 ? _c : "anonymous";
-        const resolvedName = spanName !== null && spanName !== void 0 ? spanName : `${className}.${String(propertyKey)}`;
-        descriptor.value = function (...args) {
-            return span_runner_1.spanRunner.runWithSpan(resolvedName, () => original.apply(this, args));
-        };
-        return descriptor;
-    };
-}
-//# sourceMappingURL=traced.decorator.js.map

package/dist/lib/cjs/decorators/traced.decorator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"traced.decorator.js","sourceRoot":"","sources":["../../../../src/decorators/traced.decorator.ts"],"names":[],"mappings":";;AAoCA,wBAsBC;AA1DD,sDAAgD;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,SAAgB,MAAM,CAAC,QAAiB;IACtC,OAAO,CAAC,MAAW,EAAE,WAA4B,EAAE,UAA8B,EAAE,EAAE;;QACnF,MAAM,QAAQ,GAAG,UAAU,CAAC,KAAK,CAAC;QAClC,IAAI,OAAO,QAAQ,KAAK,UAAU,EAAE,CAAC;YACnC,+EAA+E;YAC/E,4EAA4E;YAC5E,4BAA4B;YAC5B,OAAO,UAAU,CAAC;QACpB,CAAC;QAED,iFAAiF;QACjF,gFAAgF;QAChF,+CAA+C;QAC/C,MAAM,SAAS,GAAW,MAAA,MAAA,MAAA,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,WAAW,0CAAE,IAAI,mCAAI,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,IAAI,mCAAI,WAAW,CAAC;QACnF,MAAM,YAAY,GAAG,QAAQ,aAAR,QAAQ,cAAR,QAAQ,GAAI,GAAG,SAAS,IAAI,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC;QAEvE,UAAU,CAAC,KAAK,GAAG,UAAyB,GAAG,IAAW;YACxD,OAAO,wBAAU,CAAC,WAAW,CAAC,YAAY,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;QAChF,CAAC,CAAC;QAEF,OAAO,UAAU,CAAC;IACpB,CAAC,CAAC;AACJ,CAAC"}

package/dist/lib/esm/decorators/decorators.js

@@ -1,2 +0,0 @@
-export * from "./traced.decorator";
-//# sourceMappingURL=decorators.js.map

package/dist/lib/esm/decorators/decorators.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../../../src/decorators/decorators.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/dist/lib/esm/decorators/traced.decorator.js

@@ -1,57 +0,0 @@
-import { spanRunner } from "../utils/span-runner";
-/**
- * Method decorator that wraps the decorated method in a span. The span is automatically
- * ended when the method returns or throws, and the `TracingManager` is auto-resolved
- * from the active `EventContext` — no need to inject it manually.
- *
- * ```ts
- * class PaymentService {
- *   @traced()                                // span name = "PaymentService.charge"
- *   async charge(amount: number) { ... }
- *
- *   @traced("payment.refund.action")         // explicit name
- *   async refund(chargeId: string) { ... }
- * }
- * ```
- *
- * **Behavior outside an event context.** When the decorated method runs without an
- * active `EventContext` (e.g. a unit test calling the method directly, or background
- * work that escaped the event lifecycle), the decorator is a no-op — the original
- * method runs unchanged. Tracing must never throw or alter semantics.
- *
- * **Sync methods become async.** The decorator awaits the wrapped method internally,
- * so any decorated method returns a `Promise`. Decorating a sync method changes its
- * signature visible to callers — apply `@traced` to methods you'd already be awaiting
- * (DB calls, HTTP, expensive computations), not to tight sync helpers.
- *
- * **Type-level caveat.** TypeScript's parameter and method decorator types don't carry
- * enough information for the compiler to verify that the wrapped method's return type
- * is compatible with `Promise<T>`. The wrapper is type-safe at runtime; the call site's
- * static types are unchanged. Pair with explicit `: Promise<T>` annotations on the
- * method when you want the static type to match what's actually returned.
- *
- * @param spanName Optional explicit name for the span. Defaults to
- *   `${ClassName}.${methodName}`.
- */
-export function traced(spanName) {
-    return (target, propertyKey, descriptor) => {
-        var _a, _b, _c;
-        const original = descriptor.value;
-        if (typeof original !== "function") {
-            // Decorator was applied to something other than a method (a getter, a property
-            // with no initial value, etc.). Leave it alone — silently no-op rather than
-            // throw at decoration time.
-            return descriptor;
-        }
-        // Resolve a stable default name at decoration time. `target.constructor.name` is
-        // the class name for instance methods; for static methods, `target.name` is the
-        // class. We cover both via the fallback chain.
-        const className = (_c = (_b = (_a = target === null || target === void 0 ? void 0 : target.constructor) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : target === null || target === void 0 ? void 0 : target.name) !== null && _c !== void 0 ? _c : "anonymous";
-        const resolvedName = spanName !== null && spanName !== void 0 ? spanName : `${className}.${String(propertyKey)}`;
-        descriptor.value = function (...args) {
-            return spanRunner.runWithSpan(resolvedName, () => original.apply(this, args));
-        };
-        return descriptor;
-    };
-}
-//# sourceMappingURL=traced.decorator.js.map

package/dist/lib/esm/decorators/traced.decorator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"traced.decorator.js","sourceRoot":"","sources":["../../../../src/decorators/traced.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,sBAAsB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,UAAU,MAAM,CAAC,QAAiB;IACtC,OAAO,CAAC,MAAW,EAAE,WAA4B,EAAE,UAA8B,EAAE,EAAE;;QACnF,MAAM,QAAQ,GAAG,UAAU,CAAC,KAAK,CAAC;QAClC,IAAI,OAAO,QAAQ,KAAK,UAAU,EAAE,CAAC;YACnC,+EAA+E;YAC/E,4EAA4E;YAC5E,4BAA4B;YAC5B,OAAO,UAAU,CAAC;QACpB,CAAC;QAED,iFAAiF;QACjF,gFAAgF;QAChF,+CAA+C;QAC/C,MAAM,SAAS,GAAW,MAAA,MAAA,MAAA,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,WAAW,0CAAE,IAAI,mCAAI,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,IAAI,mCAAI,WAAW,CAAC;QACnF,MAAM,YAAY,GAAG,QAAQ,aAAR,QAAQ,cAAR,QAAQ,GAAI,GAAG,SAAS,IAAI,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC;QAEvE,UAAU,CAAC,KAAK,GAAG,UAAyB,GAAG,IAAW;YACxD,OAAO,UAAU,CAAC,WAAW,CAAC,YAAY,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;QAChF,CAAC,CAAC;QAEF,OAAO,UAAU,CAAC;IACpB,CAAC,CAAC;AACJ,CAAC"}

package/dist/types/decorators/decorators.d.ts

@@ -1 +0,0 @@
-export * from "./traced.decorator";

package/dist/types/decorators/traced.decorator.d.ts

@@ -1,35 +0,0 @@
-/**
- * Method decorator that wraps the decorated method in a span. The span is automatically
- * ended when the method returns or throws, and the `TracingManager` is auto-resolved
- * from the active `EventContext` — no need to inject it manually.
- *
- * ```ts
- * class PaymentService {
- *   @traced()                                // span name = "PaymentService.charge"
- *   async charge(amount: number) { ... }
- *
- *   @traced("payment.refund.action")         // explicit name
- *   async refund(chargeId: string) { ... }
- * }
- * ```
- *
- * **Behavior outside an event context.** When the decorated method runs without an
- * active `EventContext` (e.g. a unit test calling the method directly, or background
- * work that escaped the event lifecycle), the decorator is a no-op — the original
- * method runs unchanged. Tracing must never throw or alter semantics.
- *
- * **Sync methods become async.** The decorator awaits the wrapped method internally,
- * so any decorated method returns a `Promise`. Decorating a sync method changes its
- * signature visible to callers — apply `@traced` to methods you'd already be awaiting
- * (DB calls, HTTP, expensive computations), not to tight sync helpers.
- *
- * **Type-level caveat.** TypeScript's parameter and method decorator types don't carry
- * enough information for the compiler to verify that the wrapped method's return type
- * is compatible with `Promise<T>`. The wrapper is type-safe at runtime; the call site's
- * static types are unchanged. Pair with explicit `: Promise<T>` annotations on the
- * method when you want the static type to match what's actually returned.
- *
- * @param spanName Optional explicit name for the span. Defaults to
- *   `${ClassName}.${methodName}`.
- */
-export declare function traced(spanName?: string): MethodDecorator;