@atrim/instrument-node 0.8.1-dev.ae570af.20260116212440 → 0.9.0

package/target/dist/integrations/effect/auto/index.d.cts

@@ -1,359 +1,8 @@
-import { Layer, Supervisor, Effect, Context, Option, Fiber, Exit, FiberRef } from 'effect';
-import * as OtelApi from '@opentelemetry/api';
-import { AutoInstrumentationConfig, InstrumentationConfig } from '@atrim/instrument-core';
+import { Context, Layer, Effect, FiberRef, Option, Supervisor, Fiber, Exit } from 'effect';
+import { InstrumentationConfig, AutoInstrumentationConfig } from '@atrim/instrument-core';
 export { AutoInstrumentationConfig } from '@atrim/instrument-core';
 import * as effect_Fiber from 'effect/Fiber';
 
-/**
- * Effect-Native Tracing Layer
- *
- * Uses @effect/opentelemetry's NodeSdk.layer for proper Effect integration.
- * This provides automatic HTTP request tracing and Effect.withSpan() support.
- *
- * Requires @effect/opentelemetry peer dependency to be installed.
- */
-
-/**
- * Create a layer that provides Effect-native tracing via NodeSdk.layer
- *
- * This integrates with Effect's built-in tracing system, which means:
- * - HTTP requests are automatically traced by @effect/platform
- * - Effect.withSpan() creates proper OTel spans
- * - Parent-child span relationships work correctly
- * - No need to fork fibers for tracing to work
- *
- * Configuration is loaded from instrumentation.yaml (exporter_config section).
- *
- * @example
- * ```typescript
- * import { EffectTracingLive } from '@atrim/instrument-node/effect/auto'
- *
- * // HTTP requests automatically traced!
- * const HttpLive = router.pipe(
- *   HttpServer.serve(),
- *   Layer.provide(ServerLive),
- *   Layer.provide(EffectTracingLive),
- * )
- * ```
- */
-declare const createEffectTracingLayer: () => Layer.Layer<never>;
-/**
- * Effect-native tracing layer using @effect/opentelemetry
- *
- * This is the **recommended** layer for Effect HTTP applications. It provides:
- * - Automatic HTTP request tracing (built into @effect/platform)
- * - Full Effect.withSpan() support for manual spans
- * - Proper parent-child span relationships
- * - No need to fork fibers manually
- *
- * Configuration is loaded from your instrumentation.yaml file.
- *
- * @example
- * ```yaml
- * # instrumentation.yaml
- * effect:
- *   exporter_config:
- *     type: otlp        # or 'console' for dev
- *     endpoint: http://localhost:4318
- *     headers:
- *       x-api-key: your-key
- *     processor: batch   # or 'simple' for immediate export
- * ```
- *
- * @example
- * ```typescript
- * import { EffectTracingLive } from '@atrim/instrument-node/effect/auto'
- * import { HttpRouter, HttpServer } from "@effect/platform"
- * import { NodeHttpServer, NodeRuntime } from "@effect/platform-node"
- *
- * const router = HttpRouter.empty.pipe(
- *   HttpRouter.get("/", Effect.succeed(HttpServerResponse.text("Hello!"))),
- * )
- *
- * const HttpLive = router.pipe(
- *   HttpServer.serve(),
- *   Layer.provide(NodeHttpServer.layer(createServer, { port: 3000 })),
- *   Layer.provide(EffectTracingLive),  // <- Just add this!
- * )
- *
- * NodeRuntime.runMain(Layer.launch(HttpLive))
- * // All HTTP requests now automatically traced!
- * ```
- */
-declare const EffectTracingLive: Layer.Layer<never>;
-/**
- * Create a combined layer that provides both:
- * 1. Effect-native HTTP tracing (via Effect's Tracer + global OTel provider)
- * 2. Fiber-level auto-tracing (via Supervisor)
- *
- * This gives you automatic spans for:
- * - Every HTTP request (from Effect's platform middleware)
- * - Every forked fiber (from our Supervisor)
- *
- * No manual Effect.withSpan() calls needed.
- *
- * ARCHITECTURE NOTE:
- * Unlike EffectTracingLive which uses NodeSdk.layer (scoped provider),
- * CombinedTracingLive uses a single GLOBAL TracerProvider so that both
- * Effect's Tracer and our Supervisor use the same provider and exporter.
- *
- * This solves the dual-provider problem where HTTP spans and fiber spans
- * would otherwise go to different exporters.
- */
-declare const createCombinedTracingLayer: () => Layer.Layer<never>;
-/**
- * Combined tracing layer providing both HTTP and fiber-level auto-tracing
- *
- * This is the **most comprehensive** tracing option. You get automatic spans for:
- * - Every HTTP request (from Effect's @effect/platform middleware)
- * - Every forked fiber (from our Supervisor)
- *
- * No manual Effect.withSpan() calls needed - everything is traced automatically.
- *
- * @example
- * ```yaml
- * # instrumentation.yaml
- * effect:
- *   auto_instrumentation:
- *     enabled: true
- *     granularity: fiber
- *   exporter_config:
- *     type: otlp
- *     endpoint: http://localhost:4318
- * ```
- *
- * @example
- * ```typescript
- * import { CombinedTracingLive } from '@atrim/instrument-node/effect/auto'
- *
- * const HttpLive = router.pipe(
- *   HttpServer.serve(),
- *   Layer.provide(ServerLive),
- *   Layer.provide(CombinedTracingLive),
- * )
- *
- * // Both HTTP requests AND forked fibers are auto-traced!
- * ```
- */
-declare const CombinedTracingLive: Layer.Layer<never>;
-
-/**
- * Auto-Tracing Supervisor for Effect-TS
- *
- * Provides automatic tracing of all Effect fibers without manual Effect.withSpan() calls.
- * Uses Effect's Supervisor API to intercept fiber creation/termination and create
- * OpenTelemetry spans automatically.
- *
- * @example
- * ```typescript
- * import { AutoTracingLive } from '@atrim/instrument-node/effect/auto'
- *
- * const program = Effect.gen(function* () {
- *   yield* doWork()  // Automatically traced!
- * }).pipe(Effect.provide(AutoTracingLive))
- * ```
- */
-
-/**
- * FiberRef to enable/disable auto-tracing for specific fibers
- * Use withoutAutoTracing() to disable
- */
-declare const AutoTracingEnabled: FiberRef.FiberRef<boolean>;
-/**
- * FiberRef to override auto-generated span name
- * Use setSpanName() to override
- */
-declare const AutoTracingSpanName: FiberRef.FiberRef<Option.Option<string>>;
-/**
- * Supervisor that automatically creates OpenTelemetry spans for all Effect fibers
- *
- * This supervisor intercepts fiber creation and termination, creating spans
- * based on configuration from instrumentation.yaml.
- */
-declare class AutoTracingSupervisor extends Supervisor.AbstractSupervisor<void> {
-    private readonly config;
-    private readonly fiberSpans;
-    private readonly fiberStartTimes;
-    private _tracer;
-    private readonly tracerProvider;
-    private readonly includePatterns;
-    private readonly excludePatterns;
-    private activeFiberCount;
-    private _rootSpan;
-    constructor(config: AutoInstrumentationConfig, tracerProvider?: OtelApi.TracerProvider);
-    /**
-     * Set the root span for parent context propagation
-     */
-    setRootSpan(span: OtelApi.Span): void;
-    /**
-     * Get the tracer lazily - uses provided TracerProvider if available, otherwise uses global
-     */
-    private get tracer();
-    /**
-     * Returns the current value (void for this supervisor)
-     */
-    get value(): Effect.Effect<void>;
-    /**
-     * Called when a fiber starts executing
-     */
-    onStart<A, E, R>(_context: Context.Context<R>, _effect: Effect.Effect<A, E, R>, parent: Option.Option<Fiber.RuntimeFiber<unknown, unknown>>, fiber: Fiber.RuntimeFiber<A, E>): void;
-    /**
-     * Called when a fiber completes (success or failure)
-     */
-    onEnd<A, E>(exit: Exit.Exit<A, E>, fiber: Fiber.RuntimeFiber<A, E>): void;
-    /**
-     * Get attributes for span links from config
-     */
-    private getLinkAttributes;
-    /**
-     * Check if a span name should be traced based on filter patterns
-     */
-    private shouldTrace;
-    /**
-     * Get initial span attributes for a fiber
-     */
-    private getInitialAttributes;
-    /**
-     * Parse stack trace to get source info
-     */
-    private parseStackTrace;
-    /**
-     * Parse min_duration string to nanoseconds
-     */
-    private parseMinDuration;
-}
-/**
- * Create a custom AutoTracingSupervisor with the given config
- */
-declare const createAutoTracingSupervisor: (config: AutoInstrumentationConfig, tracerProvider?: OtelApi.TracerProvider) => AutoTracingSupervisor;
-/**
- * Layer that provides auto-tracing with custom configuration
- *
- * @example
- * ```typescript
- * const CustomAutoTracing = createAutoTracingLayer({
- *   enabled: true,
- *   span_naming: {
- *     default: 'app.{function}',
- *     rules: [{ match: { file: 'src/services/.*' }, name: 'service.{function}' }]
- *   }
- * })
- * ```
- */
-declare const createAutoTracingLayer: (options?: {
-    config?: AutoInstrumentationConfig;
-}) => Layer.Layer<never>;
-/**
- * Wrap an Effect with auto-tracing supervision
- *
- * This creates a span for the main effect AND supervises all child fibers.
- * Use this when you need to ensure all fibers in an effect are traced.
- *
- * @example
- * ```typescript
- * const program = Effect.gen(function* () {
- *   yield* doWork()  // Automatically traced!
- * })
- *
- * const tracedProgram = withAutoTracing(program, { enabled: true, ... })
- * Effect.runPromise(tracedProgram)
- * ```
- */
-declare const withAutoTracing: <A, E, R>(effect: Effect.Effect<A, E, R>, config: AutoInstrumentationConfig, mainSpanName?: string) => Effect.Effect<A, E, R>;
-/**
- * Zero-config auto-tracing layer
- *
- * Loads configuration from instrumentation.yaml and automatically traces
- * all Effect fibers based on the configuration.
- *
- * @example
- * ```typescript
- * import { AutoTracingLive } from '@atrim/instrument-node/effect/auto'
- *
- * const program = Effect.gen(function* () {
- *   yield* doWork()  // Automatically traced!
- * }).pipe(Effect.provide(AutoTracingLive))
- * ```
- */
-declare const AutoTracingLive: Layer.Layer<never>;
-/**
- * Disable auto-tracing for a specific Effect
- *
- * @example
- * ```typescript
- * const program = Effect.gen(function* () {
- *   yield* publicWork()  // Traced
- *   yield* withoutAutoTracing(internalWork())  // NOT traced
- * })
- * ```
- */
-declare const withoutAutoTracing: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
-/**
- * Override the auto-generated span name for a specific Effect
- *
- * @example
- * ```typescript
- * const program = Effect.gen(function* () {
- *   yield* setSpanName('custom.operation.name')(myEffect)
- * })
- * ```
- */
-declare const setSpanName: (name: string) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
-/**
- * Create a fully YAML-driven auto-instrumentation layer
- *
- * This layer reads all configuration from instrumentation.yaml including:
- * - Exporter configuration (type, endpoint, processor)
- * - Auto-tracing configuration (naming rules, filters, performance)
- * - Service metadata (name, version)
- *
- * @example
- * ```typescript
- * import { createFullAutoTracingLayer } from '@atrim/instrument-node/effect/auto'
- *
- * // Everything configured via instrumentation.yaml - no code config needed!
- * const AppLive = createFullAutoTracingLayer()
- *
- * Effect.runPromise(program.pipe(Effect.provide(AppLive)))
- * ```
- */
-declare const createFullAutoTracingLayer: () => Layer.Layer<never>;
-/**
- * Fully YAML-driven auto-instrumentation layer
- *
- * This is the recommended way to use auto-instrumentation. All configuration
- * comes from instrumentation.yaml - no code configuration needed.
- *
- * @example
- * ```yaml
- * # instrumentation.yaml
- * effect:
- *   auto_instrumentation:
- *     enabled: true
- *     span_naming:
- *       default: "effect.{function}"
- *       rules:
- *         - match: { function: "internal.*" }
- *           name: "internal.{function}"
- *     filter:
- *       exclude:
- *         - "^internal\\."
- *   exporter_config:
- *     type: otlp              # or 'console' for dev
- *     endpoint: http://localhost:4318
- *     processor: batch        # or 'simple' for dev
- * ```
- *
- * @example
- * ```typescript
- * import { FullAutoTracingLive } from '@atrim/instrument-node/effect/auto'
- *
- * // Just provide the layer - everything else from YAML!
- * Effect.runPromise(program.pipe(Effect.provide(FullAutoTracingLive)))
- * ```
- */
-declare const FullAutoTracingLive: Layer.Layer<never>;
-
 /**
  * Node.js configuration loader
  *
@@ -383,11 +32,11 @@ interface ConfigLoaderOptions {
  */
 declare const defaultAutoTracingConfig: AutoInstrumentationConfig;
 declare const AutoTracingConfig_base: Context.TagClass<AutoTracingConfig, "AutoTracingConfig", {
+    enabled: boolean;
     filter: {
         include: string[];
         exclude: string[];
     };
-    enabled: boolean;
     granularity: "fiber" | "operator";
     span_naming: {
         default: string;
@@ -402,7 +51,7 @@ declare const AutoTracingConfig_base: Context.TagClass<AutoTracingConfig, "AutoT
         }[];
     };
     span_relationships: {
-        type: "both" | "parent-child" | "span-links";
+        type: "parent-child" | "span-links" | "both";
         link_attributes?: {
             "link.type": string;
             custom?: Record<string, string> | undefined;
@@ -446,6 +95,188 @@ declare const AutoTracingConfigLive: Layer.Layer<AutoTracingConfig, never, never
  * Layer that provides custom auto-tracing configuration
  */
 declare const AutoTracingConfigLayer: (config: AutoInstrumentationConfig) => Layer.Layer<AutoTracingConfig>;
+/**
+ * Load the full instrumentation config synchronously
+ *
+ * This is needed for layers that cannot use Layer.unwrapEffect (which breaks
+ * tracer propagation). Falls back to default config if file doesn't exist.
+ */
+declare const loadFullConfigSync: () => InstrumentationConfig;
+
+/**
+ * Span Control FiberRefs for Effect-TS Tracing
+ *
+ * Provides FiberRefs that control span creation behavior. These can be used to:
+ * - Disable auto-tracing for specific fibers/effects
+ * - Override auto-generated span names
+ *
+ * These FiberRefs are checked by the UnifiedTracingSupervisor during span creation.
+ *
+ * @example
+ * ```typescript
+ * import { withoutAutoTracing, setSpanName } from '@atrim/instrument-node/effect/auto'
+ *
+ * const program = Effect.gen(function* () {
+ *   // Automatically traced
+ *   yield* publicWork()
+ *
+ *   // Opt-out of tracing
+ *   yield* withoutAutoTracing(internalWork())
+ *
+ *   // Custom span name
+ *   yield* setSpanName('custom.operation')(criticalWork())
+ * }).pipe(withUnifiedTracing)
+ * ```
+ */
+
+/**
+ * FiberRef to enable/disable auto-tracing for specific fibers.
+ *
+ * When set to `false`, the UnifiedTracingSupervisor will skip span creation
+ * for the fiber and its children (unless they override it back to `true`).
+ *
+ * Default: `true` (auto-tracing enabled)
+ */
+declare const AutoTracingEnabled: FiberRef.FiberRef<boolean>;
+/**
+ * FiberRef to override the auto-generated span name.
+ *
+ * When set to `Some(name)`, the UnifiedTracingSupervisor will use this name
+ * instead of inferring it from source location.
+ *
+ * Default: `None` (use inferred name)
+ */
+declare const AutoTracingSpanName: FiberRef.FiberRef<Option.Option<string>>;
+/**
+ * Disable auto-tracing for a specific Effect.
+ *
+ * Use this to opt-out of automatic span creation for internal operations
+ * that don't need to be traced.
+ *
+ * @example
+ * ```typescript
+ * const program = Effect.gen(function* () {
+ *   yield* publicWork()  // Traced
+ *   yield* withoutAutoTracing(internalWork())  // NOT traced
+ * })
+ * ```
+ */
+declare const withoutAutoTracing: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+/**
+ * Override the auto-generated span name for a specific Effect.
+ *
+ * Use this when you want a custom span name instead of the inferred one.
+ *
+ * @example
+ * ```typescript
+ * const program = Effect.gen(function* () {
+ *   yield* setSpanName('custom.operation.name')(myEffect)
+ * })
+ * ```
+ */
+declare const setSpanName: (name: string) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+
+/**
+ * Unified Tracing Supervisor for Effect-TS
+ *
+ * Combines operation tracing (Effect.all, Effect.forEach, Effect.fork) with
+ * fiber-level tracing, ensuring correct parent-child span relationships.
+ *
+ * Key feature: Fork spans are correctly set as parents of their resulting fiber spans.
+ *
+ * Requires the @clayroach/effect fork with OperationMeta and source capture support.
+ *
+ * @example
+ * ```typescript
+ * import { withUnifiedTracing } from '@atrim/instrument-node/effect/auto'
+ *
+ * const program = Effect.gen(function* () {
+ *   // Creates spans: effect.all -> child fiber spans
+ *   yield* Effect.all([doA(), doB()])
+ *
+ *   // Creates spans: effect.fork -> forked fiber span (correct hierarchy!)
+ *   yield* Effect.fork(backgroundTask())
+ * }).pipe(withUnifiedTracing)
+ * ```
+ */
+
+/**
+ * Operation metadata stored in the trace field by Effect.all, Effect.forEach, etc.
+ */
+interface OperationMeta {
+    readonly _tag: 'OperationMeta';
+    readonly op: string;
+    readonly count?: number;
+    readonly capturedAt: string;
+}
+/**
+ * Unified supervisor that handles both operation tracing and fiber tracing,
+ * ensuring correct parent-child relationships for fork spans.
+ */
+declare class UnifiedTracingSupervisor extends Supervisor.AbstractSupervisor<void> {
+    private readonly config;
+    private readonly pendingForkSpans;
+    private readonly fiberSpans;
+    private readonly fiberContexts;
+    private readonly fiberStartTimes;
+    private readonly processedEffects;
+    private readonly configuredOps;
+    private _tracer;
+    private activeFiberCount;
+    constructor(config: AutoInstrumentationConfig);
+    private get tracer();
+    get value(): Effect.Effect<void>;
+    onEffect<A, E>(fiber: Fiber.RuntimeFiber<A, E>, effect: Effect.Effect<unknown, unknown, unknown>): void;
+    onStart<A, E, R>(_context: Context.Context<R>, _effect: Effect.Effect<A, E, R>, parent: Option.Option<Fiber.RuntimeFiber<unknown, unknown>>, fiber: Fiber.RuntimeFiber<A, E>): void;
+    onEnd<A, E>(exit: Exit.Exit<A, E>, fiber: Fiber.RuntimeFiber<A, E>): void;
+    private cleanup;
+    private resolveParentContext;
+    private resolveParentContextFromFiberRefs;
+    private parseMinDuration;
+}
+/**
+ * Create the UnifiedTracingLive layer
+ */
+declare const createUnifiedTracingLayer: () => Layer.Layer<never>;
+/**
+ * Unified Tracing Layer - combines operation and fiber tracing with correct hierarchy
+ *
+ * NOTE: Uses Layer.suspend to defer provider setup until the layer is actually used.
+ * This prevents the global TracerProvider from being set at module import time,
+ * allowing tests to set up their own provider first.
+ */
+declare const UnifiedTracingLive: Layer.Layer<never>;
+/**
+ * Helper to enable OpSupervision runtime flag
+ */
+declare const enableOpSupervision: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+/**
+ * Wrap an effect with unified tracing (OpSupervision + layer)
+ *
+ * @example
+ * ```typescript
+ * const program = Effect.gen(function* () {
+ *   yield* Effect.fork(myTask())  // Fork span is parent of fiber span!
+ * }).pipe(withUnifiedTracing)
+ * ```
+ */
+declare const withUnifiedTracing: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, never>>;
+/**
+ * Wrap an effect with auto-tracing using a custom config
+ *
+ * This is the legacy API for backward compatibility. It allows passing a custom
+ * config and optional root span name.
+ *
+ * @deprecated Use `withUnifiedTracing` with `UnifiedTracingLive` layer instead.
+ *
+ * @example
+ * ```typescript
+ * const result = await Effect.runPromise(withAutoTracing(program, config, 'my-root-span'))
+ * ```
+ */
+declare const withAutoTracing: <A, E, R>(effect: Effect.Effect<A, E, R>, config?: AutoInstrumentationConfig, rootSpanName?: string) => Effect.Effect<A, E, R>;
+declare const flushAndShutdown: () => Promise<void>;
+declare const forceFlush: () => Promise<void>;
 
 /**
  * Span Name Inference for Auto-Tracing
@@ -590,306 +421,8 @@ declare function patchEffectFork(): void;
 declare function unpatchEffectFork(): void;
 
 /**
- * Source Capture Supervisor for Effect-TS (POC)
- *
- * Uses Effect's native source capture feature (from @clayroach/effect@3.19.14-source-capture.0)
- * to automatically capture call-site locations when fibers are forked.
- *
- * This is the POC implementation for issue #145:
- * https://github.com/atrim-ai/instrumentation/issues/145
- *
- * @example
- * ```typescript
- * import { SourceCaptureTracingLive } from '@atrim/instrument-node/effect/auto'
- *
- * const program = Effect.gen(function* () {
- *   yield* Effect.fork(doWork())  // Automatically traced with source location!
- * }).pipe(Effect.provide(SourceCaptureTracingLive))
- *
- * // Span name will be "effect.sendEmail (user-handlers.ts:42)" instead of "effect.anonymous"
- * ```
- */
-
-/**
- * Supervisor that uses Effect's native source capture to create spans with
- * meaningful names based on the actual call site of Effect.fork().
- *
- * This supervisor reads from `currentSourceLocation` FiberRef which is
- * populated automatically by Effect when source capture is enabled via
- * `Layer.enableSourceCapture` or `Effect.withCaptureStackTraces(true)`.
- */
-declare class SourceCaptureSupervisor extends Supervisor.AbstractSupervisor<void> {
-    private readonly config;
-    private readonly fiberSpans;
-    private readonly fiberContexts;
-    private readonly fiberStartTimes;
-    private _tracer;
-    private activeFiberCount;
-    private _rootSpan;
-    constructor(config: AutoInstrumentationConfig);
-    /**
-     * Set the default root span for auto-instrumentation.
-     * Fibers without a ParentSpan will use this as their parent.
-     */
-    setRootSpan(span: OtelApi.Span): void;
-    /**
-     * Get the root span (if set)
-     */
-    get rootSpan(): OtelApi.Span | null;
-    /**
-     * Get the tracer lazily from global OTel API
-     */
-    private get tracer();
-    /**
-     * Returns the current value (void for this supervisor)
-     */
-    get value(): Effect.Effect<void>;
-    /**
-     * Called when a fiber starts executing
-     */
-    onStart<A, E, R>(_context: Context.Context<R>, _effect: Effect.Effect<A, E, R>, parent: Option.Option<Fiber.RuntimeFiber<unknown, unknown>>, fiber: Fiber.RuntimeFiber<A, E>): void;
-    /**
-     * Called when a fiber completes (success or failure)
-     */
-    onEnd<A, E>(exit: Exit.Exit<A, E>, fiber: Fiber.RuntimeFiber<A, E>): void;
-    /**
-     * Parse min_duration string to nanoseconds
-     */
-    private parseMinDuration;
-}
-/**
- * Create the SourceCaptureTracingLive layer
- *
- * This layer:
- * 1. Enables Effect's native source capture via Layer.enableSourceCapture
- * 2. Uses the global TracerProvider (set at module load time)
- * 3. Adds the SourceCaptureSupervisor that reads native source locations
- *
- * The key difference from CombinedTracingLive is that this uses Effect's
- * NATIVE source capture instead of our manual tracedFork() workaround.
- */
-declare const createSourceCaptureTracingLayer: () => Layer.Layer<never>;
-/**
- * Native Source Capture Tracing Layer (POC for issue #145)
- *
- * This layer uses Effect's NATIVE source capture feature to automatically
- * capture call-site locations when fibers are forked. No more need for
- * manual `tracedFork()` calls!
- *
- * **Key difference from CombinedTracingLive:**
- * - CombinedTracingLive: Requires `tracedFork()` wrapper for source capture
- * - SourceCaptureTracingLive: Uses Effect's native source capture (no wrappers!)
- *
- * @example
- * ```yaml
- * # instrumentation.yaml
- * effect:
- *   auto_instrumentation:
- *     enabled: true
- *   exporter_config:
- *     type: console  # or 'otlp'
- * ```
- *
- * @example
- * ```typescript
- * import { SourceCaptureTracingLive } from '@atrim/instrument-node/effect/auto'
- *
- * const program = Effect.gen(function* () {
- *   // Just use regular Effect.fork() - no wrapper needed!
- *   yield* Effect.fork(sendEmail())  // Span: "effect.sendEmail (user-handlers.ts:42)"
- *   yield* Effect.fork(processOrder())  // Span: "effect.processOrder (order-service.ts:18)"
- * }).pipe(Effect.provide(SourceCaptureTracingLive))
- *
- * Effect.runPromise(program)
- * ```
- */
-declare const SourceCaptureTracingLive: Layer.Layer<never>;
-/**
- * Disable source capture for a hot path (opt-out)
- *
- * Use this to disable source capture for performance-critical code paths
- * where the ~0.001ms overhead is unacceptable.
- */
-declare const withoutSourceCapture: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
-/**
- * Flush all pending spans and shutdown the TracerProvider.
- * Call this before your application exits to ensure all spans are exported.
- *
- * @example
- * ```typescript
- * import { flushAndShutdown } from '@atrim/instrument-node/effect/auto'
- *
- * // At the end of your application
- * await flushAndShutdown()
- * process.exit(0)
- * ```
- */
-declare const flushAndShutdown: () => Promise<void>;
-/**
- * Force flush all pending spans without shutting down.
- * Use this if you need to ensure spans are exported but want to continue tracing.
- */
-declare const forceFlush: () => Promise<void>;
-
-/**
- * Operation Tracing Supervisor for Effect-TS
- *
- * Uses OpSupervision to trace high-level Effect operations like Effect.all,
- * Effect.forEach, etc. This supervisor reads operation metadata from the
- * `trace` field that Effect populates when operations are created.
- *
- * Requires the @clayroach/effect fork which adds OperationMeta to the trace field.
- *
- * The `OperationTracingLive` layer automatically enables the OpSupervision runtime
- * flag, so no additional configuration is needed.
- *
- * @example
- * ```typescript
- * import { OperationTracingLive } from '@atrim/instrument-node/effect/auto'
- *
- * const program = Effect.gen(function* () {
- *   // Automatically traced with span "effect.all" including item count
- *   yield* Effect.all([doA(), doB(), doC()])
- *
- *   // Automatically traced with span "effect.forEach"
- *   yield* Effect.forEach(items, processItem)
- * }).pipe(Effect.provide(OperationTracingLive))
- * ```
- */
-
-/**
- * Operation metadata stored in the trace field by Effect.all, Effect.forEach, etc.
- * This matches the OperationMeta interface in the Effect fork's core.ts
- */
-interface OperationMeta {
-    readonly _tag: 'OperationMeta';
-    readonly op: string;
-    readonly count?: number;
-    readonly capturedAt: string;
-}
-/**
- * Global span naming configuration for operation tracing
- */
-interface SpanNamingConfig {
-    /** Include source location in span name (default: true) */
-    readonly includeLocation: boolean;
-    /** Span name template with variables: {op}, {file}, {filename}, {line}, {column} */
-    readonly template: string;
-}
-/**
- * Configuration for which operations to trace
- */
-interface OperationConfig {
-    readonly name: string;
-    readonly spanNameTemplate?: string;
-    readonly includeCount?: boolean;
-    readonly includeStack?: boolean;
-}
-/**
- * Supervisor that traces Effect operations using OpSupervision.
- *
- * When OpSupervision is enabled, the Effect runtime calls `onEffect(fiber, effect)`
- * for every Effect operation in the runLoop. This supervisor checks if the effect
- * has OperationMeta in its trace field and creates spans accordingly.
- */
-declare class OperationTracingSupervisor extends Supervisor.AbstractSupervisor<void> {
-    private readonly configuredOps;
-    private readonly spanNaming;
-    private readonly processedEffects;
-    private readonly fiberSpans;
-    private _tracer;
-    constructor(operations: OperationConfig[], spanNaming?: SpanNamingConfig);
-    /**
-     * Get the tracer lazily from global OTel API
-     */
-    private get tracer();
-    /**
-     * Returns the current value (void for this supervisor)
-     */
-    get value(): Effect.Effect<void>;
-    /**
-     * Called for EVERY Effect operation when OpSupervision is enabled.
-     *
-     * This is the key hook for operation-level tracing. We check if the effect
-     * has OperationMeta and create a span if configured.
-     */
-    onEffect<A, E>(fiber: Fiber.RuntimeFiber<A, E>, effect: Effect.Effect<unknown, unknown, unknown>): void;
-    /**
-     * Called when a fiber starts - we don't need this for operation tracing
-     */
-    onStart(): void;
-    /**
-     * Called when a fiber ends - end all spans for this fiber
-     */
-    onEnd<A, E>(exit: Exit.Exit<A, E>, fiber: Fiber.RuntimeFiber<A, E>): void;
-}
-/**
- * Create a Layer that adds the OperationTracingSupervisor.
- *
- * NOTE: This layer adds the supervisor, but OpSupervision must also be enabled
- * for the runtime to call onEffect(). Use Effect.withRuntimeFlags to enable
- * OpSupervision, or use the enableOpSupervision helper.
- *
- * @param operations - Configuration for which operations to trace
- * @param spanNaming - Global span naming configuration
- */
-declare const makeOperationTracingLayer: (operations?: OperationConfig[], spanNaming?: SpanNamingConfig) => Layer.Layer<never>;
-/**
- * Helper to enable OpSupervision runtime flag for an effect.
- *
- * OpSupervision causes the runtime to call supervisor.onEffect() for every
- * Effect operation. This has a performance cost but enables operation-level tracing.
- *
- * @example
- * ```typescript
- * const program = myEffect.pipe(
- *   enableOpSupervision,
- *   Effect.provide(OperationTracingLive)
- * )
- * ```
- */
-declare const enableOpSupervision: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
-/**
- * Pre-configured layer for automatic operation tracing.
- *
- * **Zero-config by default** - Works out of the box with sensible defaults:
- * - Traces `Effect.all` and `Effect.forEach` operations
- * - Includes item count and source location in span attributes
- *
- * **Important:** You must enable OpSupervision for operation tracing to work.
- * Use `withOperationTracing(effect)` for the simplest setup, or manually:
- * `enableOpSupervision` + `Effect.provide(OperationTracingLive)`.
- *
- * @example
- * ```typescript
- * // Simplest: use withOperationTracing wrapper
- * const program = Effect.gen(function* () {
- *   yield* Effect.all([doA(), doB()])  // Automatically traced
- * }).pipe(withOperationTracing)
- *
- * // Or manually enable OpSupervision + provide layer
- * const program = myEffect.pipe(
- *   enableOpSupervision,
- *   Effect.provide(OperationTracingLive)
- * )
- * ```
- */
-declare const OperationTracingLive: Layer.Layer<never, never, never>;
-/**
- * Convenience wrapper that enables operation tracing for an effect.
- *
- * This is the simplest way to use operation tracing - just wrap your effect:
- *
- * @example
- * ```typescript
- * const program = Effect.gen(function* () {
- *   yield* Effect.all([doA(), doB()])  // Automatically creates "effect.all" span
- *   yield* Effect.forEach(items, process)  // Automatically creates "effect.forEach" span
- * }).pipe(withOperationTracing)
- *
- * Effect.runPromise(program)
- * ```
+ * @deprecated Use new UnifiedTracingSupervisor(config) instead
  */
-declare const withOperationTracing: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+declare const createAutoTracingSupervisor: (config: AutoInstrumentationConfig) => any;
 
-export { AutoTracingConfig, AutoTracingConfigLayer, AutoTracingConfigLive, AutoTracingEnabled, AutoTracingLive, AutoTracingSpanName, AutoTracingSupervisor, CapturedSourceLocation, CombinedTracingLive, EffectTracingLive, FullAutoTracingLive, type OperationConfig, type OperationMeta, OperationTracingLive, OperationTracingSupervisor, SourceCaptureSupervisor, SourceCaptureTracingLive, type SourceInfo, type TemplateVariables, captureCallSite, createAutoTracingLayer, createAutoTracingSupervisor, createCombinedTracingLayer, createEffectTracingLayer, createFullAutoTracingLayer, createSourceCaptureTracingLayer, defaultAutoTracingConfig, enableOpSupervision, flushAndShutdown, forceFlush, inferSpanName, isEffectForkPatched, loadAutoTracingConfig, loadAutoTracingConfigSync, makeOperationTracingLayer, patchEffectFork, sanitizeSpanName, setSpanName, tracedFork, tracedForkDaemon, unpatchEffectFork, withAutoTracing, withOperationTracing, withoutAutoTracing, withoutSourceCapture };
+export { AutoTracingConfig, AutoTracingConfigLayer, AutoTracingConfigLive, AutoTracingEnabled, UnifiedTracingLive as AutoTracingLive, AutoTracingSpanName, UnifiedTracingSupervisor as AutoTracingSupervisor, CapturedSourceLocation, UnifiedTracingLive as CombinedTracingLive, UnifiedTracingLive as FullAutoTracingLive, type OperationMeta, UnifiedTracingLive as OperationTracingLive, UnifiedTracingSupervisor as SourceCaptureSupervisor, UnifiedTracingLive as SourceCaptureTracingLive, type SourceInfo, type TemplateVariables, UnifiedTracingLive, UnifiedTracingSupervisor, captureCallSite, createUnifiedTracingLayer as createAutoTracingLayer, createAutoTracingSupervisor, createUnifiedTracingLayer as createFullAutoTracingLayer, createUnifiedTracingLayer, defaultAutoTracingConfig, enableOpSupervision, flushAndShutdown, forceFlush, inferSpanName, isEffectForkPatched, loadAutoTracingConfig, loadAutoTracingConfigSync, loadFullConfigSync, patchEffectFork, sanitizeSpanName, setSpanName, tracedFork, tracedForkDaemon, unpatchEffectFork, withAutoTracing, withUnifiedTracing as withOperationTracing, withUnifiedTracing, withoutAutoTracing };