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

package/target/dist/integrations/effect/auto/index.js

@@ -1,10 +1,4 @@
-import { Data, Context, Effect, Layer, FiberRef, Option, Supervisor, FiberRefs, Tracer, Exit, GlobalValue, RuntimeFlagsPatch, RuntimeFlags } from 'effect';
-import { NodeSdk, Resource, Tracer as Tracer$1 } from '@effect/opentelemetry';
-import { BasicTracerProvider, ConsoleSpanExporter, SimpleSpanProcessor, BatchSpanProcessor } from '@opentelemetry/sdk-trace-base';
-import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
-import { resourceFromAttributes } from '@opentelemetry/resources';
-import { ATTR_SERVICE_VERSION, ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
-import * as OtelApi from '@opentelemetry/api';
+import { FiberRef, Context, Layer, Effect, Data, GlobalValue, Supervisor, FiberRefs, Option, Exit, Tracer, RuntimeFlagsPatch, RuntimeFlags } from 'effect';
 import { FileSystem } from '@effect/platform/FileSystem';
 import * as HttpClient from '@effect/platform/HttpClient';
 import * as HttpClientRequest from '@effect/platform/HttpClientRequest';
@@ -14,251 +8,35 @@ import { z } from 'zod';
 import * as fs from 'fs';
 import * as path2 from 'path';
 import * as TracerModule from 'effect/Tracer';
+import { Resource, Tracer as Tracer$1 } from '@effect/opentelemetry';
+import * as OtelApi from '@opentelemetry/api';
+import { ConsoleSpanExporter, SimpleSpanProcessor, BatchSpanProcessor, BasicTracerProvider } from '@opentelemetry/sdk-trace-base';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
+import { resourceFromAttributes } from '@opentelemetry/resources';
+import { ATTR_SERVICE_VERSION, ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
 
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var __defProp2 = Object.defineProperty;
-var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
-var PatternConfigSchema = z.object({
-  pattern: z.string(),
-  enabled: z.boolean().optional(),
-  description: z.string().optional()
-});
-var AutoIsolationConfigSchema = z.object({
-  // Global enable/disable for auto-isolation
-  enabled: z.boolean().default(false),
-  // Which operators to auto-isolate
-  operators: z.object({
-    fiberset_run: z.boolean().default(true),
-    effect_fork: z.boolean().default(true),
-    effect_fork_daemon: z.boolean().default(true),
-    effect_fork_in: z.boolean().default(false)
-  }).default({}),
-  // Virtual parent tracking configuration
-  tracking: z.object({
-    use_span_links: z.boolean().default(true),
-    use_attributes: z.boolean().default(true),
-    capture_logical_parent: z.boolean().default(true)
-  }).default({}),
-  // Span categorization
-  attributes: z.object({
-    category: z.string().default("background_task"),
-    add_metadata: z.boolean().default(true)
-  }).default({})
-});
-var SpanNamingRuleSchema = z.object({
-  // Match criteria (all specified criteria must match)
-  match: z.object({
-    // Regex pattern to match file path
-    file: z.string().optional(),
-    // Regex pattern to match function name
-    function: z.string().optional(),
-    // Regex pattern to match module name
-    module: z.string().optional()
-  }),
-  // Span name template with variables:
-  // {fiber_id} - Fiber ID
-  // {function} - Function name
-  // {module} - Module name
-  // {file} - File path
-  // {line} - Line number
-  // {operator} - Effect operator (gen, all, forEach, etc.)
-  // {match:field:N} - Captured regex group from match
-  name: z.string()
-});
-var AutoInstrumentationConfigSchema = z.object({
-  // Enable/disable auto-instrumentation
-  enabled: z.boolean().default(false),
-  // Tracing granularity
-  // - 'fiber': Trace at fiber creation (recommended, lower overhead)
-  // - 'operator': Trace each Effect operator (higher granularity, more overhead)
-  granularity: z.enum(["fiber", "operator"]).default("fiber"),
-  // Smart span naming configuration
-  span_naming: z.object({
-    // Default span name template when no rules match
-    default: z.string().default("effect.fiber.{fiber_id}"),
-    // Infer span names from source code (requires stack trace parsing)
-    // Adds ~50-100μs overhead per fiber
-    infer_from_source: z.boolean().default(true),
-    // Naming rules (first match wins)
-    rules: z.array(SpanNamingRuleSchema).default([])
-  }).default({}),
-  // Span relationship configuration for forked fibers
-  // Controls how child fiber spans relate to their parent/forking context
-  span_relationships: z.object({
-    // Relationship type between forked fiber spans and their parent context
-    // - 'parent-child': Use parent-child relationship (default, traditional tracing)
-    //   Parent span shows child as nested. Works well with most observability tools.
-    // - 'span-links': Use span links (semantically correct for async forks per OTel spec)
-    //   Fibers get independent traces linked to parent. Better for long-running fibers.
-    // - 'both': Create parent-child AND add span links
-    //   Maximum visibility but may create redundant data.
-    type: z.enum(["parent-child", "span-links", "both"]).default("parent-child"),
-    // Custom attributes to add to span links (only used when type includes links)
-    link_attributes: z.object({
-      // Link type identifier
-      "link.type": z.string().default("fork"),
-      // Custom attributes (key-value pairs)
-      custom: z.record(z.string()).optional()
-    }).optional()
-  }).default({}),
-  // Pattern-based filtering
-  filter: z.object({
-    // Only trace spans matching these patterns (empty = trace all)
-    include: z.array(z.string()).default([]),
-    // Never trace spans matching these patterns
-    exclude: z.array(z.string()).default([])
-  }).default({}),
-  // Performance controls
-  performance: z.object({
-    // Sample rate (0.0 - 1.0)
-    sampling_rate: z.number().min(0).max(1).default(1),
-    // Skip fibers shorter than this duration (e.g., "10ms", "100 millis")
-    min_duration: z.string().default("0ms"),
-    // Maximum concurrent traced fibers (0 = unlimited)
-    max_concurrent: z.number().default(0)
-  }).default({}),
-  // Automatic metadata extraction
-  metadata: z.object({
-    // Extract Effect fiber information
-    fiber_info: z.boolean().default(true),
-    // Extract source location (file:line)
-    source_location: z.boolean().default(true),
-    // Extract parent fiber information
-    parent_fiber: z.boolean().default(true)
-  }).default({})
-});
-var OperationTracingConfigSchema = z.object({
-  // Enable/disable operation tracing
-  enabled: z.boolean().default(false),
-  // Global span naming settings
-  span_naming: z.object({
-    // Include source location (file:line) in span name
-    // Default: true - produces "effect.all (index.ts:42)"
-    // When false - produces "effect.all"
-    include_location: z.boolean().default(true),
-    // Span name template with variables:
-    // {op} - Operation name (all, forEach, retry, etc.)
-    // {file} - Full file path
-    // {filename} - Just the filename (basename)
-    // {line} - Line number
-    // {column} - Column number
-    // Default: "effect.{op} ({filename}:{line})"
-    template: z.string().default("effect.{op} ({filename}:{line})")
-  }).default({}),
-  // Operations to trace
-  operations: z.array(
-    z.object({
-      // Operation name: 'all', 'forEach', 'retry', etc.
-      name: z.string(),
-      // Custom span name template (overrides global span_naming.template)
-      // Supports same variables: {op}, {file}, {filename}, {line}, {column}
-      span_name: z.string().optional(),
-      // Include item count in span attributes
-      include_count: z.boolean().default(true),
-      // Include stack trace in span attributes
-      include_stack: z.boolean().default(true)
-    })
-  ).default([])
-});
-var HttpFilteringConfigSchema = z.object({
-  // Patterns to ignore for outgoing HTTP requests (string patterns only in YAML)
-  ignore_outgoing_urls: z.array(z.string()).optional(),
-  // Patterns to ignore for incoming HTTP requests (string patterns only in YAML)
-  ignore_incoming_paths: z.array(z.string()).optional(),
-  // Require parent span for outgoing requests (prevents root spans for HTTP calls)
-  require_parent_for_outgoing_spans: z.boolean().optional(),
-  // Trace context propagation configuration
-  // Controls which cross-origin requests receive W3C Trace Context headers (traceparent, tracestate)
-  propagate_trace_context: z.object({
-    // Strategy for trace propagation
-    // - "all": Propagate to all cross-origin requests (may cause CORS errors)
-    // - "none": Never propagate trace headers
-    // - "same-origin": Only propagate to same-origin requests (default, safe)
-    // - "patterns": Propagate based on include_urls patterns
-    strategy: z.enum(["all", "none", "same-origin", "patterns"]).default("same-origin"),
-    // URL patterns to include when strategy is "patterns"
-    // Supports regex patterns (e.g., "^https://api\\.myapp\\.com")
-    include_urls: z.array(z.string()).optional()
-  }).optional()
-});
-var ExporterConfigSchema = z.object({
-  // Exporter type: 'otlp' | 'console' | 'none'
-  // - 'otlp': Export to OTLP endpoint (production)
-  // - 'console': Log spans to console (development)
-  // - 'none': No export (disable tracing)
-  type: z.enum(["otlp", "console", "none"]).default("otlp"),
-  // OTLP endpoint URL (for type: otlp)
-  // Defaults to OTEL_EXPORTER_OTLP_ENDPOINT env var or http://localhost:4318
-  endpoint: z.string().optional(),
-  // Custom headers to send with OTLP requests (for type: otlp)
-  // Useful for authentication (x-api-key, Authorization, etc.)
-  headers: z.record(z.string()).optional(),
-  // Span processor type
-  // - 'batch': Batch spans for export (production, lower overhead)
-  // - 'simple': Export immediately (development, no batching delay)
-  processor: z.enum(["batch", "simple"]).default("batch"),
-  // Batch processor settings (for processor: batch)
-  batch: z.object({
-    // Max time to wait before exporting (milliseconds)
-    scheduled_delay_millis: z.number().default(1e3),
-    // Max batch size
-    max_export_batch_size: z.number().default(100)
-  }).optional()
-});
-var InstrumentationConfigSchema = z.object({
-  version: z.string(),
-  instrumentation: z.object({
-    enabled: z.boolean(),
-    description: z.string().optional(),
-    logging: z.enum(["on", "off", "minimal"]).optional().default("on"),
-    instrument_patterns: z.array(PatternConfigSchema),
-    ignore_patterns: z.array(PatternConfigSchema)
-  }),
-  effect: z.object({
-    // Enable/disable Effect tracing entirely
-    // When false, EffectInstrumentationLive returns Layer.empty
-    enabled: z.boolean().default(true),
-    // Exporter mode (legacy - use exporter.type instead):
-    // - "unified": Use global TracerProvider from Node SDK (recommended, enables filtering)
-    // - "standalone": Use Effect's own OTLP exporter (bypasses Node SDK filtering)
-    exporter: z.enum(["unified", "standalone"]).default("unified"),
-    // Exporter configuration (for auto-instrumentation)
-    exporter_config: ExporterConfigSchema.optional(),
-    auto_extract_metadata: z.boolean(),
-    auto_isolation: AutoIsolationConfigSchema.optional(),
-    // Auto-instrumentation: automatic tracing of all Effect fibers
-    auto_instrumentation: AutoInstrumentationConfigSchema.optional(),
-    // Operation tracing: automatic tracing of Effect.all, Effect.forEach, etc.
-    operation_tracing: OperationTracingConfigSchema.optional()
-  }).optional(),
-  http: HttpFilteringConfigSchema.optional()
-});
-var defaultConfig = {
-  version: "1.0",
-  instrumentation: {
-    enabled: true,
-    logging: "on",
-    description: "Default instrumentation configuration",
-    instrument_patterns: [
-      { pattern: "^app\\.", enabled: true, description: "Application operations" },
-      { pattern: "^http\\.server\\.", enabled: true, description: "HTTP server operations" },
-      { pattern: "^http\\.client\\.", enabled: true, description: "HTTP client operations" }
-    ],
-    ignore_patterns: [
-      { pattern: "^test\\.", description: "Test utilities" },
-      { pattern: "^internal\\.", description: "Internal operations" },
-      { pattern: "^health\\.", description: "Health checks" }
-    ]
-  },
-  effect: {
-    enabled: true,
-    exporter: "unified",
-    auto_extract_metadata: true
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
 };
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 function parseAndValidateConfig(content) {
   let parsed;
   if (typeof content === "string") {
@@ -268,262 +46,508 @@ function parseAndValidateConfig(content) {
   }
   return InstrumentationConfigSchema.parse(parsed);
 }
-(class extends Data.TaggedError("ConfigError") {
-  get message() {
-    return this.reason;
-  }
-});
-var ConfigUrlError = class extends Data.TaggedError("ConfigUrlError") {
-  get message() {
-    return this.reason;
-  }
-};
-var ConfigValidationError = class extends Data.TaggedError("ConfigValidationError") {
-  get message() {
-    return this.reason;
-  }
-};
-var ConfigFileError = class extends Data.TaggedError("ConfigFileError") {
-  get message() {
-    return this.reason;
-  }
-};
-(class extends Data.TaggedError("ServiceDetectionError") {
-  get message() {
-    return this.reason;
-  }
-});
-(class extends Data.TaggedError("InitializationError") {
-  get message() {
-    return this.reason;
-  }
-});
-(class extends Data.TaggedError("ExportError") {
-  get message() {
-    return this.reason;
-  }
-});
-(class extends Data.TaggedError("ShutdownError") {
-  get message() {
-    return this.reason;
-  }
-});
-var SECURITY_DEFAULTS = {
-  maxConfigSize: 1e6,
-  // 1MB
-  requestTimeout: 5e3
-  // 5 seconds
-};
-var ConfigLoader = class extends Context.Tag("ConfigLoader")() {
-};
-var parseYamlContent = (content, uri) => Effect.gen(function* () {
-  const parsed = yield* Effect.try({
-    try: () => parse(content),
-    catch: (error) => new ConfigValidationError({
-      reason: uri ? `Failed to parse YAML from ${uri}` : "Failed to parse YAML",
-      cause: error
-    })
-  });
-  return yield* Effect.try({
-    try: () => InstrumentationConfigSchema.parse(parsed),
-    catch: (error) => new ConfigValidationError({
-      reason: uri ? `Invalid configuration schema from ${uri}` : "Invalid configuration schema",
-      cause: error
-    })
-  });
-});
-var loadFromFileWithFs = (fs3, path3, uri) => Effect.gen(function* () {
-  const content = yield* fs3.readFileString(path3).pipe(
-    Effect.mapError(
-      (error) => new ConfigFileError({
-        reason: `Failed to read config file at ${uri}`,
-        cause: error
-      })
-    )
-  );
-  if (content.length > SECURITY_DEFAULTS.maxConfigSize) {
-    return yield* Effect.fail(
-      new ConfigFileError({
-        reason: `Config file exceeds maximum size of ${SECURITY_DEFAULTS.maxConfigSize} bytes`
-      })
-    );
-  }
-  return yield* parseYamlContent(content, uri);
-});
-var loadFromHttpWithClient = (client, url) => Effect.scoped(
-  Effect.gen(function* () {
-    if (url.startsWith("http://")) {
-      return yield* Effect.fail(
-        new ConfigUrlError({
-          reason: "Insecure protocol: only HTTPS URLs are allowed"
+var __defProp2, __defNormalProp2, __publicField2, PatternConfigSchema, AutoIsolationConfigSchema, SpanNamingRuleSchema, AutoInstrumentationConfigSchema, OperationTracingConfigSchema, HttpFilteringConfigSchema, ExporterConfigSchema, InstrumentationConfigSchema, defaultConfig, ConfigUrlError, ConfigValidationError, ConfigFileError, SECURITY_DEFAULTS, ConfigLoader, parseYamlContent, loadFromFileWithFs, loadFromHttpWithClient, makeConfigLoader, Logger, logger;
+var init_dist = __esm({
+  "../core/target/dist/index.js"() {
+    __defProp2 = Object.defineProperty;
+    __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+    __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
+    PatternConfigSchema = z.object({
+      pattern: z.string(),
+      enabled: z.boolean().optional(),
+      description: z.string().optional()
+    });
+    AutoIsolationConfigSchema = z.object({
+      // Global enable/disable for auto-isolation
+      enabled: z.boolean().default(false),
+      // Which operators to auto-isolate
+      operators: z.object({
+        fiberset_run: z.boolean().default(true),
+        effect_fork: z.boolean().default(true),
+        effect_fork_daemon: z.boolean().default(true),
+        effect_fork_in: z.boolean().default(false)
+      }).default({}),
+      // Virtual parent tracking configuration
+      tracking: z.object({
+        use_span_links: z.boolean().default(true),
+        use_attributes: z.boolean().default(true),
+        capture_logical_parent: z.boolean().default(true)
+      }).default({}),
+      // Span categorization
+      attributes: z.object({
+        category: z.string().default("background_task"),
+        add_metadata: z.boolean().default(true)
+      }).default({})
+    });
+    SpanNamingRuleSchema = z.object({
+      // Match criteria (all specified criteria must match)
+      match: z.object({
+        // Regex pattern to match file path
+        file: z.string().optional(),
+        // Regex pattern to match function name
+        function: z.string().optional(),
+        // Regex pattern to match module name
+        module: z.string().optional()
+      }),
+      // Span name template with variables:
+      // {fiber_id} - Fiber ID
+      // {function} - Function name
+      // {module} - Module name
+      // {file} - File path
+      // {line} - Line number
+      // {operator} - Effect operator (gen, all, forEach, etc.)
+      // {match:field:N} - Captured regex group from match
+      name: z.string()
+    });
+    AutoInstrumentationConfigSchema = z.object({
+      // Enable/disable auto-instrumentation
+      enabled: z.boolean().default(false),
+      // Tracing granularity
+      // - 'fiber': Trace at fiber creation (recommended, lower overhead)
+      // - 'operator': Trace each Effect operator (higher granularity, more overhead)
+      granularity: z.enum(["fiber", "operator"]).default("fiber"),
+      // Smart span naming configuration
+      span_naming: z.object({
+        // Default span name template when no rules match
+        default: z.string().default("effect.fiber.{fiber_id}"),
+        // Infer span names from source code (requires stack trace parsing)
+        // Adds ~50-100μs overhead per fiber
+        infer_from_source: z.boolean().default(true),
+        // Naming rules (first match wins)
+        rules: z.array(SpanNamingRuleSchema).default([])
+      }).default({}),
+      // Span relationship configuration for forked fibers
+      // Controls how child fiber spans relate to their parent/forking context
+      span_relationships: z.object({
+        // Relationship type between forked fiber spans and their parent context
+        // - 'parent-child': Use parent-child relationship (default, traditional tracing)
+        //   Parent span shows child as nested. Works well with most observability tools.
+        // - 'span-links': Use span links (semantically correct for async forks per OTel spec)
+        //   Fibers get independent traces linked to parent. Better for long-running fibers.
+        // - 'both': Create parent-child AND add span links
+        //   Maximum visibility but may create redundant data.
+        type: z.enum(["parent-child", "span-links", "both"]).default("parent-child"),
+        // Custom attributes to add to span links (only used when type includes links)
+        link_attributes: z.object({
+          // Link type identifier
+          "link.type": z.string().default("fork"),
+          // Custom attributes (key-value pairs)
+          custom: z.record(z.string()).optional()
+        }).optional()
+      }).default({}),
+      // Pattern-based filtering
+      filter: z.object({
+        // Only trace spans matching these patterns (empty = trace all)
+        include: z.array(z.string()).default([]),
+        // Never trace spans matching these patterns
+        exclude: z.array(z.string()).default([])
+      }).default({}),
+      // Performance controls
+      performance: z.object({
+        // Sample rate (0.0 - 1.0)
+        sampling_rate: z.number().min(0).max(1).default(1),
+        // Skip fibers shorter than this duration (e.g., "10ms", "100 millis")
+        min_duration: z.string().default("0ms"),
+        // Maximum concurrent traced fibers (0 = unlimited)
+        max_concurrent: z.number().default(0)
+      }).default({}),
+      // Automatic metadata extraction
+      metadata: z.object({
+        // Extract Effect fiber information
+        fiber_info: z.boolean().default(true),
+        // Extract source location (file:line)
+        source_location: z.boolean().default(true),
+        // Extract parent fiber information
+        parent_fiber: z.boolean().default(true)
+      }).default({})
+    });
+    OperationTracingConfigSchema = z.object({
+      // Enable/disable operation tracing
+      enabled: z.boolean().default(false),
+      // Global span naming settings
+      span_naming: z.object({
+        // Include source location (file:line) in span name
+        // Default: true - produces "effect.all (index.ts:42)"
+        // When false - produces "effect.all"
+        include_location: z.boolean().default(true),
+        // Span name template with variables:
+        // {op} - Operation name (all, forEach, retry, etc.)
+        // {file} - Full file path
+        // {filename} - Just the filename (basename)
+        // {line} - Line number
+        // {column} - Column number
+        // Default: "effect.{op} ({filename}:{line})"
+        template: z.string().default("effect.{op} ({filename}:{line})")
+      }).default({}),
+      // Operations to trace
+      operations: z.array(
+        z.object({
+          // Operation name: 'all', 'forEach', 'retry', etc.
+          name: z.string(),
+          // Custom span name template (overrides global span_naming.template)
+          // Supports same variables: {op}, {file}, {filename}, {line}, {column}
+          span_name: z.string().optional(),
+          // Include item count in span attributes
+          include_count: z.boolean().default(true),
+          // Include stack trace in span attributes
+          include_stack: z.boolean().default(true)
         })
-      );
-    }
-    const request = HttpClientRequest.get(url).pipe(
-      HttpClientRequest.setHeaders({
-        Accept: "application/yaml, text/yaml, application/x-yaml"
-      })
-    );
-    const response = yield* client.execute(request).pipe(
-      Effect.timeout(`${SECURITY_DEFAULTS.requestTimeout} millis`),
-      Effect.mapError((error) => {
-        if (error._tag === "TimeoutException") {
-          return new ConfigUrlError({
-            reason: `Config fetch timeout after ${SECURITY_DEFAULTS.requestTimeout}ms from ${url}`
-          });
-        }
-        return new ConfigUrlError({
-          reason: `Failed to load config from URL: ${url}`,
+      ).default([])
+    });
+    HttpFilteringConfigSchema = z.object({
+      // Patterns to ignore for outgoing HTTP requests (string patterns only in YAML)
+      ignore_outgoing_urls: z.array(z.string()).optional(),
+      // Patterns to ignore for incoming HTTP requests (string patterns only in YAML)
+      ignore_incoming_paths: z.array(z.string()).optional(),
+      // Require parent span for outgoing requests (prevents root spans for HTTP calls)
+      require_parent_for_outgoing_spans: z.boolean().optional(),
+      // Trace context propagation configuration
+      // Controls which cross-origin requests receive W3C Trace Context headers (traceparent, tracestate)
+      propagate_trace_context: z.object({
+        // Strategy for trace propagation
+        // - "all": Propagate to all cross-origin requests (may cause CORS errors)
+        // - "none": Never propagate trace headers
+        // - "same-origin": Only propagate to same-origin requests (default, safe)
+        // - "patterns": Propagate based on include_urls patterns
+        strategy: z.enum(["all", "none", "same-origin", "patterns"]).default("same-origin"),
+        // URL patterns to include when strategy is "patterns"
+        // Supports regex patterns (e.g., "^https://api\\.myapp\\.com")
+        include_urls: z.array(z.string()).optional()
+      }).optional()
+    });
+    ExporterConfigSchema = z.object({
+      // Exporter type: 'otlp' | 'console' | 'none'
+      // - 'otlp': Export to OTLP endpoint (production)
+      // - 'console': Log spans to console (development)
+      // - 'none': No export (disable tracing)
+      type: z.enum(["otlp", "console", "none"]).default("otlp"),
+      // OTLP endpoint URL (for type: otlp)
+      // Defaults to OTEL_EXPORTER_OTLP_ENDPOINT env var or http://localhost:4318
+      endpoint: z.string().optional(),
+      // Custom headers to send with OTLP requests (for type: otlp)
+      // Useful for authentication (x-api-key, Authorization, etc.)
+      headers: z.record(z.string()).optional(),
+      // Span processor type
+      // - 'batch': Batch spans for export (production, lower overhead)
+      // - 'simple': Export immediately (development, no batching delay)
+      processor: z.enum(["batch", "simple"]).default("batch"),
+      // Batch processor settings (for processor: batch)
+      batch: z.object({
+        // Max time to wait before exporting (milliseconds)
+        scheduled_delay_millis: z.number().default(1e3),
+        // Max batch size
+        max_export_batch_size: z.number().default(100)
+      }).optional()
+    });
+    InstrumentationConfigSchema = z.object({
+      version: z.string(),
+      instrumentation: z.object({
+        enabled: z.boolean(),
+        description: z.string().optional(),
+        logging: z.enum(["on", "off", "minimal"]).optional().default("on"),
+        instrument_patterns: z.array(PatternConfigSchema),
+        ignore_patterns: z.array(PatternConfigSchema)
+      }),
+      effect: z.object({
+        // Enable/disable Effect tracing entirely
+        // When false, EffectInstrumentationLive returns Layer.empty
+        enabled: z.boolean().default(true),
+        // Exporter mode (legacy - use exporter.type instead):
+        // - "unified": Use global TracerProvider from Node SDK (recommended, enables filtering)
+        // - "standalone": Use Effect's own OTLP exporter (bypasses Node SDK filtering)
+        exporter: z.enum(["unified", "standalone"]).default("unified"),
+        // Exporter configuration (for auto-instrumentation)
+        exporter_config: ExporterConfigSchema.optional(),
+        auto_extract_metadata: z.boolean(),
+        auto_isolation: AutoIsolationConfigSchema.optional(),
+        // Auto-instrumentation: automatic tracing of all Effect fibers
+        auto_instrumentation: AutoInstrumentationConfigSchema.optional(),
+        // Operation tracing: automatic tracing of Effect.all, Effect.forEach, etc.
+        operation_tracing: OperationTracingConfigSchema.optional()
+      }).optional(),
+      http: HttpFilteringConfigSchema.optional()
+    });
+    defaultConfig = {
+      version: "1.0",
+      instrumentation: {
+        enabled: true,
+        logging: "on",
+        description: "Default instrumentation configuration",
+        instrument_patterns: [
+          { pattern: "^app\\.", enabled: true, description: "Application operations" },
+          { pattern: "^http\\.server\\.", enabled: true, description: "HTTP server operations" },
+          { pattern: "^http\\.client\\.", enabled: true, description: "HTTP client operations" }
+        ],
+        ignore_patterns: [
+          { pattern: "^test\\.", description: "Test utilities" },
+          { pattern: "^internal\\.", description: "Internal operations" },
+          { pattern: "^health\\.", description: "Health checks" }
+        ]
+      },
+      effect: {
+        enabled: true,
+        exporter: "unified",
+        auto_extract_metadata: true
+      }
+    };
+    (class extends Data.TaggedError("ConfigError") {
+      get message() {
+        return this.reason;
+      }
+    });
+    ConfigUrlError = class extends Data.TaggedError("ConfigUrlError") {
+      get message() {
+        return this.reason;
+      }
+    };
+    ConfigValidationError = class extends Data.TaggedError("ConfigValidationError") {
+      get message() {
+        return this.reason;
+      }
+    };
+    ConfigFileError = class extends Data.TaggedError("ConfigFileError") {
+      get message() {
+        return this.reason;
+      }
+    };
+    (class extends Data.TaggedError("ServiceDetectionError") {
+      get message() {
+        return this.reason;
+      }
+    });
+    (class extends Data.TaggedError("InitializationError") {
+      get message() {
+        return this.reason;
+      }
+    });
+    (class extends Data.TaggedError("ExportError") {
+      get message() {
+        return this.reason;
+      }
+    });
+    (class extends Data.TaggedError("ShutdownError") {
+      get message() {
+        return this.reason;
+      }
+    });
+    SECURITY_DEFAULTS = {
+      maxConfigSize: 1e6,
+      // 1MB
+      requestTimeout: 5e3
+      // 5 seconds
+    };
+    ConfigLoader = class extends Context.Tag("ConfigLoader")() {
+    };
+    parseYamlContent = (content, uri) => Effect.gen(function* () {
+      const parsed = yield* Effect.try({
+        try: () => parse(content),
+        catch: (error) => new ConfigValidationError({
+          reason: uri ? `Failed to parse YAML from ${uri}` : "Failed to parse YAML",
           cause: error
-        });
-      })
-    );
-    if (response.status >= 400) {
-      return yield* Effect.fail(
-        new ConfigUrlError({
-          reason: `HTTP ${response.status} from ${url}`
         })
-      );
-    }
-    const text = yield* response.text.pipe(
-      Effect.mapError(
-        (error) => new ConfigUrlError({
-          reason: `Failed to read response body from ${url}`,
+      });
+      return yield* Effect.try({
+        try: () => InstrumentationConfigSchema.parse(parsed),
+        catch: (error) => new ConfigValidationError({
+          reason: uri ? `Invalid configuration schema from ${uri}` : "Invalid configuration schema",
           cause: error
         })
-      )
-    );
-    if (text.length > SECURITY_DEFAULTS.maxConfigSize) {
-      return yield* Effect.fail(
-        new ConfigUrlError({
-          reason: `Config exceeds maximum size of ${SECURITY_DEFAULTS.maxConfigSize} bytes`
-        })
+      });
+    });
+    loadFromFileWithFs = (fs2, path3, uri) => Effect.gen(function* () {
+      const content = yield* fs2.readFileString(path3).pipe(
+        Effect.mapError(
+          (error) => new ConfigFileError({
+            reason: `Failed to read config file at ${uri}`,
+            cause: error
+          })
+        )
       );
-    }
-    return yield* parseYamlContent(text, url);
-  })
-);
-var makeConfigLoader = Effect.gen(function* () {
-  const fs3 = yield* Effect.serviceOption(FileSystem);
-  const http = yield* HttpClient.HttpClient;
-  const loadFromUriUncached = (uri) => Effect.gen(function* () {
-    if (uri.startsWith("file://")) {
-      const path3 = uri.slice(7);
-      if (fs3._tag === "None") {
+      if (content.length > SECURITY_DEFAULTS.maxConfigSize) {
         return yield* Effect.fail(
           new ConfigFileError({
-            reason: "FileSystem not available (browser environment?)",
-            cause: { uri }
+            reason: `Config file exceeds maximum size of ${SECURITY_DEFAULTS.maxConfigSize} bytes`
           })
         );
       }
-      return yield* loadFromFileWithFs(fs3.value, path3, uri);
-    }
-    if (uri.startsWith("http://") || uri.startsWith("https://")) {
-      return yield* loadFromHttpWithClient(http, uri);
-    }
-    if (fs3._tag === "Some") {
-      return yield* loadFromFileWithFs(fs3.value, uri, uri);
-    } else {
-      return yield* loadFromHttpWithClient(http, uri);
-    }
-  });
-  const loadFromUriCached = yield* Effect.cachedFunction(loadFromUriUncached);
-  return ConfigLoader.of({
-    loadFromUri: loadFromUriCached,
-    loadFromInline: (content) => Effect.gen(function* () {
-      if (typeof content === "string") {
-        return yield* parseYamlContent(content);
-      }
-      return yield* Effect.try({
-        try: () => InstrumentationConfigSchema.parse(content),
-        catch: (error) => new ConfigValidationError({
-          reason: "Invalid configuration schema",
-          cause: error
+      return yield* parseYamlContent(content, uri);
+    });
+    loadFromHttpWithClient = (client, url) => Effect.scoped(
+      Effect.gen(function* () {
+        if (url.startsWith("http://")) {
+          return yield* Effect.fail(
+            new ConfigUrlError({
+              reason: "Insecure protocol: only HTTPS URLs are allowed"
+            })
+          );
+        }
+        const request = HttpClientRequest.get(url).pipe(
+          HttpClientRequest.setHeaders({
+            Accept: "application/yaml, text/yaml, application/x-yaml"
+          })
+        );
+        const response = yield* client.execute(request).pipe(
+          Effect.timeout(`${SECURITY_DEFAULTS.requestTimeout} millis`),
+          Effect.mapError((error) => {
+            if (error._tag === "TimeoutException") {
+              return new ConfigUrlError({
+                reason: `Config fetch timeout after ${SECURITY_DEFAULTS.requestTimeout}ms from ${url}`
+              });
+            }
+            return new ConfigUrlError({
+              reason: `Failed to load config from URL: ${url}`,
+              cause: error
+            });
+          })
+        );
+        if (response.status >= 400) {
+          return yield* Effect.fail(
+            new ConfigUrlError({
+              reason: `HTTP ${response.status} from ${url}`
+            })
+          );
+        }
+        const text = yield* response.text.pipe(
+          Effect.mapError(
+            (error) => new ConfigUrlError({
+              reason: `Failed to read response body from ${url}`,
+              cause: error
+            })
+          )
+        );
+        if (text.length > SECURITY_DEFAULTS.maxConfigSize) {
+          return yield* Effect.fail(
+            new ConfigUrlError({
+              reason: `Config exceeds maximum size of ${SECURITY_DEFAULTS.maxConfigSize} bytes`
+            })
+          );
+        }
+        return yield* parseYamlContent(text, url);
+      })
+    );
+    makeConfigLoader = Effect.gen(function* () {
+      const fs2 = yield* Effect.serviceOption(FileSystem);
+      const http = yield* HttpClient.HttpClient;
+      const loadFromUriUncached = (uri) => Effect.gen(function* () {
+        if (uri.startsWith("file://")) {
+          const path3 = uri.slice(7);
+          if (fs2._tag === "None") {
+            return yield* Effect.fail(
+              new ConfigFileError({
+                reason: "FileSystem not available (browser environment?)",
+                cause: { uri }
+              })
+            );
+          }
+          return yield* loadFromFileWithFs(fs2.value, path3, uri);
+        }
+        if (uri.startsWith("http://") || uri.startsWith("https://")) {
+          return yield* loadFromHttpWithClient(http, uri);
+        }
+        if (fs2._tag === "Some") {
+          return yield* loadFromFileWithFs(fs2.value, uri, uri);
+        } else {
+          return yield* loadFromHttpWithClient(http, uri);
+        }
+      });
+      const loadFromUriCached = yield* Effect.cachedFunction(loadFromUriUncached);
+      return ConfigLoader.of({
+        loadFromUri: loadFromUriCached,
+        loadFromInline: (content) => Effect.gen(function* () {
+          if (typeof content === "string") {
+            return yield* parseYamlContent(content);
+          }
+          return yield* Effect.try({
+            try: () => InstrumentationConfigSchema.parse(content),
+            catch: (error) => new ConfigValidationError({
+              reason: "Invalid configuration schema",
+              cause: error
+            })
+          });
         })
       });
-    })
-  });
-});
-Layer.effect(ConfigLoader, makeConfigLoader);
-var Logger = class {
-  constructor() {
-    __publicField2(this, "level", "on");
-    __publicField2(this, "hasLoggedMinimal", false);
-  }
-  /**
-   * Set the logging level
-   */
-  setLevel(level) {
-    this.level = level;
-    this.hasLoggedMinimal = false;
-  }
-  /**
-   * Get the current logging level
-   */
-  getLevel() {
-    return this.level;
-  }
-  /**
-   * Log a minimal initialization message (only shown once in minimal mode)
-   */
-  minimal(message) {
-    if (this.level === "off") {
-      return;
-    }
-    if (this.level === "minimal" && !this.hasLoggedMinimal) {
-      console.log(message);
-      this.hasLoggedMinimal = true;
-      return;
-    }
-    if (this.level === "on") {
-      console.log(message);
-    }
-  }
-  /**
-   * Log an informational message
-   */
-  log(...args) {
-    if (this.level === "on") {
-      console.log(...args);
-    }
-  }
-  /**
-   * Log a warning message (shown in minimal mode)
-   */
-  warn(...args) {
-    if (this.level !== "off") {
-      console.warn(...args);
-    }
-  }
-  /**
-   * Log an error message (shown in minimal mode)
-   */
-  error(...args) {
-    if (this.level !== "off") {
-      console.error(...args);
-    }
-  }
-  /**
-   * Check if full logging is enabled
-   */
-  isEnabled() {
-    return this.level === "on";
-  }
-  /**
-   * Check if minimal logging is enabled
-   */
-  isMinimal() {
-    return this.level === "minimal";
-  }
-  /**
-   * Check if logging is completely disabled
-   */
-  isDisabled() {
-    return this.level === "off";
+    });
+    Layer.effect(ConfigLoader, makeConfigLoader);
+    Logger = class {
+      constructor() {
+        __publicField2(this, "level", "on");
+        __publicField2(this, "hasLoggedMinimal", false);
+      }
+      /**
+       * Set the logging level
+       */
+      setLevel(level) {
+        this.level = level;
+        this.hasLoggedMinimal = false;
+      }
+      /**
+       * Get the current logging level
+       */
+      getLevel() {
+        return this.level;
+      }
+      /**
+       * Log a minimal initialization message (only shown once in minimal mode)
+       */
+      minimal(message) {
+        if (this.level === "off") {
+          return;
+        }
+        if (this.level === "minimal" && !this.hasLoggedMinimal) {
+          console.log(message);
+          this.hasLoggedMinimal = true;
+          return;
+        }
+        if (this.level === "on") {
+          console.log(message);
+        }
+      }
+      /**
+       * Log an informational message
+       */
+      log(...args) {
+        if (this.level === "on") {
+          console.log(...args);
+        }
+      }
+      /**
+       * Log a warning message (shown in minimal mode)
+       */
+      warn(...args) {
+        if (this.level !== "off") {
+          console.warn(...args);
+        }
+      }
+      /**
+       * Log an error message (shown in minimal mode)
+       */
+      error(...args) {
+        if (this.level !== "off") {
+          console.error(...args);
+        }
+      }
+      /**
+       * Check if full logging is enabled
+       */
+      isEnabled() {
+        return this.level === "on";
+      }
+      /**
+       * Check if minimal logging is enabled
+       */
+      isMinimal() {
+        return this.level === "minimal";
+      }
+      /**
+       * Check if logging is completely disabled
+       */
+      isDisabled() {
+        return this.level === "off";
+      }
+    };
+    logger = new Logger();
   }
-};
-var logger = new Logger();
+});
 async function loadFromFile(filePath) {
   const { readFile } = await import('fs/promises');
   const content = await readFile(filePath, "utf-8");
@@ -564,170 +588,589 @@ async function loadConfigWithOptions(options = {}) {
   if (options.configPath) {
     return loadConfig(options.configPath);
   }
-  const { existsSync: existsSync3 } = await import('fs');
+  const { existsSync: existsSync2 } = await import('fs');
   const { join: join2 } = await import('path');
   const defaultPath = join2(process.cwd(), "instrumentation.yaml");
-  if (existsSync3(defaultPath)) {
+  if (existsSync2(defaultPath)) {
     return loadConfig(defaultPath);
   }
   return defaultConfig;
 }
-
-// src/integrations/effect/auto/config.ts
-var defaultAutoTracingConfig = {
-  enabled: false,
-  granularity: "fiber",
-  span_naming: {
-    default: "effect.fiber.{fiber_id}",
-    infer_from_source: true,
-    rules: []
-  },
-  span_relationships: {
-    type: "parent-child"
-  },
-  filter: {
-    include: [],
-    exclude: []
-  },
-  performance: {
-    sampling_rate: 1,
-    min_duration: "0ms",
-    max_concurrent: 0
-  },
-  metadata: {
-    fiber_info: true,
-    source_location: true,
-    parent_fiber: true
-  }
-};
-var AutoTracingConfig = class extends Context.Tag("AutoTracingConfig")() {
-};
-var loadAutoTracingConfig = (options) => Effect.gen(function* () {
-  const config = yield* Effect.tryPromise({
-    try: () => loadConfigWithOptions(options),
-    catch: (error) => {
-      logger.log(`@atrim/auto-trace: Failed to load config: ${error}`);
-      return error;
-    }
-  }).pipe(Effect.catchAll(() => Effect.succeed(null)));
-  if (!config) {
-    logger.log("@atrim/auto-trace: No config found, using defaults");
-    return defaultAutoTracingConfig;
+var init_config_loader = __esm({
+  "src/core/config-loader.ts"() {
+    init_dist();
   }
-  const autoConfig = config.effect?.auto_instrumentation;
-  if (!autoConfig) {
-    logger.log("@atrim/auto-trace: No auto_instrumentation config, using defaults");
-    return defaultAutoTracingConfig;
-  }
-  const parsed = AutoInstrumentationConfigSchema.safeParse(autoConfig);
-  if (!parsed.success) {
-    logger.log(`@atrim/auto-trace: Invalid config, using defaults: ${parsed.error.message}`);
-    return defaultAutoTracingConfig;
+});
+var defaultAutoTracingConfig, AutoTracingConfig, loadAutoTracingConfig, loadAutoTracingConfigSync, AutoTracingConfigLive, AutoTracingConfigLayer, loadFullConfigSync;
+var init_config = __esm({
+  "src/integrations/effect/auto/config.ts"() {
+    init_dist();
+    init_config_loader();
+    defaultAutoTracingConfig = {
+      enabled: false,
+      granularity: "fiber",
+      span_naming: {
+        default: "effect.fiber.{fiber_id}",
+        infer_from_source: true,
+        rules: []
+      },
+      span_relationships: {
+        type: "parent-child"
+      },
+      filter: {
+        include: [],
+        exclude: []
+      },
+      performance: {
+        sampling_rate: 1,
+        min_duration: "0ms",
+        max_concurrent: 0
+      },
+      metadata: {
+        fiber_info: true,
+        source_location: true,
+        parent_fiber: true
+      }
+    };
+    AutoTracingConfig = class extends Context.Tag("AutoTracingConfig")() {
+    };
+    loadAutoTracingConfig = (options) => Effect.gen(function* () {
+      const config = yield* Effect.tryPromise({
+        try: () => loadConfigWithOptions(options),
+        catch: (error) => {
+          logger.log(`@atrim/auto-trace: Failed to load config: ${error}`);
+          return error;
+        }
+      }).pipe(Effect.catchAll(() => Effect.succeed(null)));
+      if (!config) {
+        logger.log("@atrim/auto-trace: No config found, using defaults");
+        return defaultAutoTracingConfig;
+      }
+      const autoConfig = config.effect?.auto_instrumentation;
+      if (!autoConfig) {
+        logger.log("@atrim/auto-trace: No auto_instrumentation config, using defaults");
+        return defaultAutoTracingConfig;
+      }
+      const parsed = AutoInstrumentationConfigSchema.safeParse(autoConfig);
+      if (!parsed.success) {
+        logger.log(`@atrim/auto-trace: Invalid config, using defaults: ${parsed.error.message}`);
+        return defaultAutoTracingConfig;
+      }
+      logger.log("@atrim/auto-trace: Loaded config from instrumentation.yaml");
+      return parsed.data;
+    });
+    loadAutoTracingConfigSync = () => {
+      return defaultAutoTracingConfig;
+    };
+    AutoTracingConfigLive = Layer.effect(AutoTracingConfig, loadAutoTracingConfig());
+    AutoTracingConfigLayer = (config) => Layer.succeed(AutoTracingConfig, config);
+    loadFullConfigSync = () => {
+      const defaultPath = path2.join(process.cwd(), "instrumentation.yaml");
+      try {
+        if (fs.existsSync(defaultPath)) {
+          const content = fs.readFileSync(defaultPath, "utf-8");
+          const parsed = yaml.parse(content);
+          const result = InstrumentationConfigSchema.safeParse(parsed);
+          if (result.success) {
+            logger.log(`@atrim/auto-trace: Loaded config from ${defaultPath}`);
+            return result.data;
+          } else {
+            logger.log(`@atrim/auto-trace: Invalid config, using defaults: ${result.error.message}`);
+            return defaultConfig;
+          }
+        }
+      } catch (error) {
+        logger.log(`@atrim/auto-trace: Failed to load config: ${error}`);
+      }
+      logger.log("@atrim/auto-trace: No config found, using defaults");
+      return defaultConfig;
+    };
   }
-  logger.log("@atrim/auto-trace: Loaded config from instrumentation.yaml");
-  return parsed.data;
 });
-var loadAutoTracingConfigSync = () => {
-  return defaultAutoTracingConfig;
-};
-var AutoTracingConfigLive = Layer.effect(AutoTracingConfig, loadAutoTracingConfig());
-var AutoTracingConfigLayer = (config) => Layer.succeed(AutoTracingConfig, config);
-var loadFullConfig = (options) => Effect.gen(function* () {
-  const config = yield* Effect.tryPromise({
-    try: () => loadConfigWithOptions(options),
-    catch: (error) => {
-      logger.log(`@atrim/auto-trace: Failed to load config: ${error}`);
-      return error;
-    }
-  }).pipe(Effect.catchAll(() => Effect.succeed(null)));
-  if (!config) {
-    logger.log("@atrim/auto-trace: No config found, using defaults");
-    return defaultConfig;
+var AutoTracingEnabled, AutoTracingSpanName, withoutAutoTracing, setSpanName;
+var init_span_control = __esm({
+  "src/integrations/effect/auto/span-control.ts"() {
+    AutoTracingEnabled = FiberRef.unsafeMake(true);
+    AutoTracingSpanName = FiberRef.unsafeMake(Option.none());
+    withoutAutoTracing = (effect) => effect.pipe(Effect.locally(AutoTracingEnabled, false));
+    setSpanName = (name) => (effect) => effect.pipe(Effect.locally(AutoTracingSpanName, Option.some(name)));
   }
-  return config;
 });
-var loadFullConfigSync = () => {
-  const defaultPath = path2.join(process.cwd(), "instrumentation.yaml");
-  try {
-    if (fs.existsSync(defaultPath)) {
-      const content = fs.readFileSync(defaultPath, "utf-8");
-      const parsed = yaml.parse(content);
-      const result = InstrumentationConfigSchema.safeParse(parsed);
-      if (result.success) {
-        logger.log(`@atrim/auto-trace: Loaded config from ${defaultPath}`);
-        return result.data;
-      } else {
-        logger.log(`@atrim/auto-trace: Invalid config, using defaults: ${result.error.message}`);
-        return defaultConfig;
-      }
-    }
-  } catch (error) {
-    logger.log(`@atrim/auto-trace: Failed to load config: ${error}`);
+
+// src/integrations/effect/auto/unified-tracing-supervisor.ts
+var unified_tracing_supervisor_exports = {};
+__export(unified_tracing_supervisor_exports, {
+  AutoTracingEnabled: () => AutoTracingEnabled,
+  AutoTracingSpanName: () => AutoTracingSpanName,
+  UnifiedTracingLive: () => UnifiedTracingLive,
+  UnifiedTracingSupervisor: () => UnifiedTracingSupervisor,
+  createUnifiedTracingLayer: () => createUnifiedTracingLayer,
+  enableOpSupervision: () => enableOpSupervision,
+  flushAndShutdown: () => flushAndShutdown,
+  forceFlush: () => forceFlush,
+  setSpanName: () => setSpanName,
+  withAutoTracing: () => withAutoTracing,
+  withUnifiedTracing: () => withUnifiedTracing,
+  withoutAutoTracing: () => withoutAutoTracing
+});
+function getOperationMeta(effect) {
+  const trace2 = effect.trace;
+  if (trace2 && trace2._tag === "OperationMeta") {
+    return trace2;
   }
-  logger.log("@atrim/auto-trace: No config found, using defaults");
-  return defaultConfig;
-};
-var CapturedSourceLocation = FiberRef.unsafeMake(void 0);
-function captureCallSite(skipFrames = 0) {
-  const originalLimit = Error.stackTraceLimit;
-  Error.stackTraceLimit = 10;
-  const error = new Error();
-  Error.stackTraceLimit = originalLimit;
-  if (!error.stack) return void 0;
-  const lines = error.stack.split("\n");
-  const startIndex = 3 + skipFrames;
-  for (let i = startIndex; i < lines.length; i++) {
-    const line = lines[i];
-    if (line === void 0) continue;
-    if (line.includes("@atrim/instrument") || line.includes("node_modules/effect")) {
+  return void 0;
+}
+function parseSourceLocation(stack) {
+  const lines = stack.split("\n");
+  for (const line of lines.slice(1)) {
+    if (line.includes("node_modules") || line.includes("/effect/") || line.includes("fiberRuntime.ts") || line.includes("core.ts")) {
       continue;
     }
-    const match = line.match(/at\s+(?:(.+?)\s+)?\(?(.+?):(\d+):(\d+)\)?/);
-    if (match) {
-      const [, funcName, filePath, lineNum, colNum] = match;
+    const match = line.match(/at\s+(?:.*?\s+\()?(.+):(\d+):(\d+)\)?/);
+    if (match && match[1] && match[2]) {
       return {
-        function: funcName?.trim() ?? "anonymous",
-        file: filePath ?? "unknown",
-        line: parseInt(lineNum ?? "0", 10),
-        column: parseInt(colNum ?? "0", 10)
+        file: match[1],
+        line: parseInt(match[2], 10),
+        ...match[3] ? { column: parseInt(match[3], 10) } : {}
       };
     }
   }
   return void 0;
 }
-var tracedFork = (effect) => {
-  const callSite = captureCallSite();
-  if (!callSite) {
-    return Effect.fork(effect);
-  }
-  return FiberRef.set(CapturedSourceLocation, callSite).pipe(Effect.zipRight(Effect.fork(effect)));
-};
-var tracedForkDaemon = (effect) => {
-  const callSite = captureCallSite();
-  if (!callSite) {
-    return Effect.forkDaemon(effect);
-  }
-  return FiberRef.set(CapturedSourceLocation, callSite).pipe(
-    Effect.zipRight(Effect.forkDaemon(effect))
-  );
-};
-
-// src/integrations/effect/auto/patch-fork.ts
-var patchAttempted = false;
-function isEffectForkPatched() {
-  return false;
+function makeSourceKey(source) {
+  if (!source) return "unknown";
+  return `${source.file}:${source.line}`;
 }
-function patchEffectFork() {
-  if (patchAttempted) {
-    return;
+function formatLocation(source) {
+  if (!source) return "unknown";
+  const filename = source.file.split("/").pop() ?? source.file;
+  return `${filename}:${source.line}`;
+}
+function getGlobalProviderSetup() {
+  if (_globalProviderSetup === void 0) {
+    _globalProviderSetup = setupGlobalTracerProvider();
   }
-  patchAttempted = true;
-  logger.log("@atrim/auto-trace: Effect.fork auto-patching not available (ESM limitation)");
-  logger.log("@atrim/auto-trace: Use tracedFork() for call-site capture");
-}
-function unpatchEffectFork() {
-  patchAttempted = false;
+  return _globalProviderSetup;
 }
+var currentSourceLocation, UnifiedTracingSupervisor, setupGlobalTracerProvider, _globalProviderSetup, createUnifiedTracingLayer, UnifiedTracingLive, enableOpSupervision, withUnifiedTracing, withAutoTracing, flushAndShutdown, forceFlush;
+var init_unified_tracing_supervisor = __esm({
+  "src/integrations/effect/auto/unified-tracing-supervisor.ts"() {
+    init_dist();
+    init_config();
+    init_span_control();
+    init_span_control();
+    currentSourceLocation = GlobalValue.globalValue(
+      /* @__PURE__ */ Symbol.for("effect/FiberRef/currentSourceLocation"),
+      () => FiberRef.unsafeMake(void 0)
+    );
+    UnifiedTracingSupervisor = class extends Supervisor.AbstractSupervisor {
+      constructor(config) {
+        super();
+        this.config = config;
+        // ========== Fork span registry ==========
+        // Maps sourceKey -> pending fork span (for correlating with child fibers)
+        __publicField(this, "pendingForkSpans", /* @__PURE__ */ new Map());
+        // ========== Fiber tracking ==========
+        __publicField(this, "fiberSpans", /* @__PURE__ */ new WeakMap());
+        __publicField(this, "fiberContexts", /* @__PURE__ */ new WeakMap());
+        __publicField(this, "fiberStartTimes", /* @__PURE__ */ new WeakMap());
+        // ========== Operation tracking ==========
+        __publicField(this, "processedEffects", /* @__PURE__ */ new WeakSet());
+        __publicField(this, "configuredOps");
+        // ========== OTel ==========
+        __publicField(this, "_tracer", null);
+        __publicField(this, "activeFiberCount", 0);
+        const defaultOps = [
+          { name: "all", includeCount: true, includeStack: true },
+          { name: "forEach", includeCount: true, includeStack: true },
+          { name: "fork", includeStack: true }
+        ];
+        this.configuredOps = new Map(defaultOps.map((op) => [op.name, op]));
+        logger.log("@atrim/unified-tracing: Supervisor initialized");
+        logger.log(`  Operations: ${Array.from(this.configuredOps.keys()).join(", ")}`);
+      }
+      get tracer() {
+        if (!this._tracer) {
+          this._tracer = OtelApi.trace.getTracer("@atrim/unified-tracing", "1.0.0");
+        }
+        return this._tracer;
+      }
+      get value() {
+        return Effect.void;
+      }
+      // ==========================================================================
+      // onEffect - Operation-level tracing (Effect.all, Effect.forEach, Effect.fork)
+      // ==========================================================================
+      onEffect(fiber, effect) {
+        if (this.processedEffects.has(effect)) {
+          return;
+        }
+        const meta = getOperationMeta(effect);
+        if (!meta) {
+          return;
+        }
+        const opConfig = this.configuredOps.get(meta.op);
+        if (!opConfig) {
+          return;
+        }
+        this.processedEffects.add(effect);
+        const fiberId = fiber.id().id;
+        const location = parseSourceLocation(meta.capturedAt);
+        const sourceKey = makeSourceKey(location);
+        logger.log(`@atrim/unified-tracing: onEffect "${meta.op}" in fiber ${fiberId} at ${sourceKey}`);
+        const parentContext = this.resolveParentContext(fiber);
+        const spanName = location ? `effect.${meta.op} (${formatLocation(location)})` : `effect.${meta.op}`;
+        const span = this.tracer.startSpan(spanName, { kind: OtelApi.SpanKind.INTERNAL }, parentContext);
+        span.setAttribute("effect.operation", meta.op);
+        if (opConfig.includeCount && meta.count !== void 0) {
+          span.setAttribute("effect.item_count", meta.count);
+        }
+        if (opConfig.includeStack && location) {
+          span.setAttribute("code.filepath", location.file);
+          span.setAttribute("code.lineno", location.line);
+          if (location.column !== void 0) {
+            span.setAttribute("code.column", location.column);
+          }
+        }
+        logger.log(
+          `@atrim/unified-tracing: Created operation span "${spanName}" spanId=${span.spanContext().spanId}`
+        );
+        if (meta.op === "fork") {
+          const forkContext = OtelApi.trace.setSpan(parentContext, span);
+          this.pendingForkSpans.set(sourceKey, {
+            forkSpan: span,
+            forkContext,
+            timestamp: process.hrtime.bigint(),
+            spanEnded: false
+          });
+          logger.log(`@atrim/unified-tracing: Registered pending fork at ${sourceKey}`);
+        } else {
+          span.setStatus({ code: OtelApi.SpanStatusCode.OK });
+          span.end();
+        }
+      }
+      // ==========================================================================
+      // onStart - Fiber-level tracing
+      // ==========================================================================
+      onStart(_context, _effect, parent, fiber) {
+        const fiberId = fiber.id().id;
+        const fiberRefs = fiber.getFiberRefs();
+        const enabled = FiberRefs.getOrDefault(fiberRefs, AutoTracingEnabled);
+        if (!enabled) {
+          logger.log(`@atrim/unified-tracing: Auto-tracing disabled for fiber ${fiberId}`);
+          return;
+        }
+        const samplingRate = this.config.performance?.sampling_rate ?? 1;
+        if (samplingRate < 1 && Math.random() > samplingRate) {
+          return;
+        }
+        const nameOverride = FiberRefs.getOrDefault(fiberRefs, AutoTracingSpanName);
+        const sourceLocation = FiberRefs.getOrDefault(fiberRefs, currentSourceLocation);
+        const sourceKey = makeSourceKey(sourceLocation);
+        logger.log(`@atrim/unified-tracing: onStart fiber ${fiberId} at ${sourceKey}`);
+        let parentContext;
+        const pendingFork = this.pendingForkSpans.get(sourceKey);
+        if (pendingFork) {
+          parentContext = pendingFork.forkContext;
+          logger.log(
+            `@atrim/unified-tracing: Matched fiber ${fiberId} to fork span at ${sourceKey} - using fork span as parent`
+          );
+          if (!pendingFork.spanEnded) {
+            pendingFork.forkSpan.setStatus({ code: OtelApi.SpanStatusCode.OK });
+            pendingFork.forkSpan.end();
+            logger.log(`@atrim/unified-tracing: Ended fork span at ${sourceKey}`);
+          }
+          this.pendingForkSpans.delete(sourceKey);
+        } else {
+          parentContext = this.resolveParentContextFromFiberRefs(
+            fiberRefs,
+            _context,
+            parent
+          );
+        }
+        let spanName;
+        if (Option.isSome(nameOverride)) {
+          spanName = nameOverride.value;
+        } else if (sourceLocation) {
+          spanName = `effect.fiber (${formatLocation(sourceLocation)})`;
+        } else {
+          spanName = `effect.fiber-${fiberId}`;
+        }
+        const span = this.tracer.startSpan(spanName, { kind: OtelApi.SpanKind.INTERNAL }, parentContext);
+        span.setAttribute("effect.auto_traced", true);
+        span.setAttribute("effect.fiber.id", fiberId);
+        if (sourceLocation) {
+          span.setAttribute("code.filepath", sourceLocation.file);
+          span.setAttribute("code.lineno", sourceLocation.line);
+          if (sourceLocation.column !== void 0) {
+            span.setAttribute("code.column", sourceLocation.column);
+          }
+        }
+        if (Option.isSome(parent)) {
+          span.setAttribute("effect.fiber.parent_id", parent.value.id().id);
+        }
+        logger.log(
+          `@atrim/unified-tracing: Created fiber span "${spanName}" spanId=${span.spanContext().spanId}`
+        );
+        const newContext = OtelApi.trace.setSpan(parentContext, span);
+        this.fiberSpans.set(fiber, span);
+        this.fiberContexts.set(fiber, newContext);
+        this.fiberStartTimes.set(fiber, process.hrtime.bigint());
+        this.activeFiberCount++;
+      }
+      // ==========================================================================
+      // onEnd - Fiber completion
+      // ==========================================================================
+      onEnd(exit, fiber) {
+        const fiberId = fiber.id().id;
+        const span = this.fiberSpans.get(fiber);
+        if (!span) {
+          return;
+        }
+        const startTime = this.fiberStartTimes.get(fiber);
+        if (startTime) {
+          const duration = process.hrtime.bigint() - startTime;
+          const minDuration = this.parseMinDuration(this.config.performance?.min_duration);
+          if (minDuration > 0 && duration < minDuration) {
+            this.cleanup(fiber);
+            return;
+          }
+        }
+        if (Exit.isSuccess(exit)) {
+          span.setStatus({ code: OtelApi.SpanStatusCode.OK });
+        } else {
+          span.setStatus({ code: OtelApi.SpanStatusCode.ERROR, message: "Fiber failed" });
+          span.setAttribute("effect.fiber.failed", true);
+        }
+        span.end();
+        logger.log(`@atrim/unified-tracing: Ended fiber span for fiber ${fiberId}`);
+        this.cleanup(fiber);
+      }
+      // ==========================================================================
+      // Helpers
+      // ==========================================================================
+      cleanup(fiber) {
+        this.fiberSpans.delete(fiber);
+        this.fiberContexts.delete(fiber);
+        this.fiberStartTimes.delete(fiber);
+        this.activeFiberCount--;
+      }
+      resolveParentContext(fiber) {
+        const fiberContext = fiber.currentContext;
+        const maybeParentSpan = Context.getOption(fiberContext, Tracer.ParentSpan);
+        if (Option.isSome(maybeParentSpan)) {
+          const effectSpan = maybeParentSpan.value;
+          return OtelApi.trace.setSpan(
+            OtelApi.ROOT_CONTEXT,
+            OtelApi.trace.wrapSpanContext({
+              traceId: effectSpan.traceId,
+              spanId: effectSpan.spanId,
+              traceFlags: OtelApi.TraceFlags.SAMPLED
+            })
+          );
+        }
+        return OtelApi.ROOT_CONTEXT;
+      }
+      resolveParentContextFromFiberRefs(fiberRefs, context2, parent) {
+        const inheritedCtx = FiberRefs.getOrDefault(fiberRefs, TracerModule.currentOtelSpanContext);
+        if (inheritedCtx) {
+          const span = OtelApi.trace.getSpan(inheritedCtx);
+          if (span) {
+            logger.log(
+              `@atrim/unified-tracing: Using inherited OTel context from FiberRef - spanId=${span.spanContext().spanId}`
+            );
+          }
+          return inheritedCtx;
+        }
+        const maybeParentSpan = Context.getOption(context2, Tracer.ParentSpan);
+        if (Option.isSome(maybeParentSpan)) {
+          const effectSpan = maybeParentSpan.value;
+          logger.log(
+            `@atrim/unified-tracing: Using Effect ParentSpan - traceId=${effectSpan.traceId.slice(0, 8)}..., spanId=${effectSpan.spanId.slice(0, 8)}...`
+          );
+          return OtelApi.trace.setSpan(
+            OtelApi.ROOT_CONTEXT,
+            OtelApi.trace.wrapSpanContext({
+              traceId: effectSpan.traceId,
+              spanId: effectSpan.spanId,
+              traceFlags: OtelApi.TraceFlags.SAMPLED
+            })
+          );
+        }
+        const activeContext = OtelApi.context.active();
+        const activeSpan = OtelApi.trace.getSpan(activeContext);
+        if (activeSpan && activeSpan.spanContext().traceFlags === OtelApi.TraceFlags.SAMPLED) {
+          logger.log(
+            `@atrim/unified-tracing: Auto-bridging from active OTel context - spanId=${activeSpan.spanContext().spanId}`
+          );
+          return activeContext;
+        }
+        if (Option.isSome(parent)) {
+          const parentCtx = this.fiberContexts.get(parent.value);
+          if (parentCtx) {
+            logger.log(`@atrim/unified-tracing: Using parent fiber's context`);
+            return parentCtx;
+          }
+        }
+        return OtelApi.ROOT_CONTEXT;
+      }
+      parseMinDuration(duration) {
+        if (!duration || duration === "0ms") return BigInt(0);
+        const match = duration.match(/^(\d+)\s*(ms|millis|s|sec|seconds|us|micros)?$/i);
+        if (!match) return BigInt(0);
+        const value = parseInt(match[1] ?? "0", 10);
+        const unit = (match[2] ?? "ms").toLowerCase();
+        switch (unit) {
+          case "us":
+          case "micros":
+            return BigInt(value) * BigInt(1e3);
+          case "ms":
+          case "millis":
+            return BigInt(value) * BigInt(1e6);
+          case "s":
+          case "sec":
+          case "seconds":
+            return BigInt(value) * BigInt(1e9);
+          default:
+            return BigInt(value) * BigInt(1e6);
+        }
+      }
+    };
+    setupGlobalTracerProvider = () => {
+      const config = loadFullConfigSync();
+      const serviceName = process.env.OTEL_SERVICE_NAME || "effect-service";
+      const serviceVersion = process.env.npm_package_version || "1.0.0";
+      const exporterConfig = config.effect?.exporter_config ?? {
+        type: "otlp",
+        processor: "batch"
+      };
+      logger.log("@atrim/unified-tracing: Setting up global TracerProvider");
+      logger.log(`  Service: ${serviceName}`);
+      logger.log(`  Exporter: ${exporterConfig.type}`);
+      if (exporterConfig.type === "none") {
+        logger.log('@atrim/unified-tracing: Exporter type is "none", skipping provider setup');
+        return null;
+      }
+      let exporter;
+      if (exporterConfig.type === "console") {
+        exporter = new ConsoleSpanExporter();
+      } else {
+        const endpoint = exporterConfig.endpoint || process.env.OTEL_EXPORTER_OTLP_ENDPOINT || "http://localhost:4318";
+        const otlpConfig = {
+          url: `${endpoint}/v1/traces`
+        };
+        if (exporterConfig.headers) {
+          otlpConfig.headers = exporterConfig.headers;
+        }
+        exporter = new OTLPTraceExporter(otlpConfig);
+      }
+      let spanProcessor;
+      if (exporterConfig.processor === "simple" || exporterConfig.type === "console") {
+        spanProcessor = new SimpleSpanProcessor(exporter);
+      } else {
+        const batchConfig = exporterConfig.batch ?? {
+          scheduled_delay_millis: 1e3,
+          max_export_batch_size: 100
+        };
+        spanProcessor = new BatchSpanProcessor(exporter, {
+          scheduledDelayMillis: batchConfig.scheduled_delay_millis,
+          maxExportBatchSize: batchConfig.max_export_batch_size
+        });
+      }
+      const provider = new BasicTracerProvider({
+        resource: resourceFromAttributes({
+          [ATTR_SERVICE_NAME]: serviceName,
+          [ATTR_SERVICE_VERSION]: serviceVersion
+        }),
+        spanProcessors: [spanProcessor]
+      });
+      OtelApi.trace.setGlobalTracerProvider(provider);
+      logger.log("@atrim/unified-tracing: Global TracerProvider registered");
+      return { provider, spanProcessor };
+    };
+    createUnifiedTracingLayer = () => {
+      const config = loadFullConfigSync();
+      const autoConfig = config.effect?.auto_instrumentation ?? {
+        enabled: true,
+        granularity: "fiber",
+        span_naming: { default: "effect.{function}", infer_from_source: true, rules: [] },
+        span_relationships: { type: "parent-child" },
+        filter: { include: [], exclude: [] },
+        performance: { sampling_rate: 1, min_duration: "0ms", max_concurrent: 0 },
+        metadata: { fiber_info: true, source_location: true, parent_fiber: true }
+      };
+      if (!getGlobalProviderSetup()) {
+        logger.log("@atrim/unified-tracing: No TracerProvider, using empty layer");
+        return Layer.empty;
+      }
+      const supervisor = new UnifiedTracingSupervisor(autoConfig);
+      const supervisorLayer = Supervisor.addSupervisor(supervisor);
+      const serviceName = process.env.OTEL_SERVICE_NAME || "effect-service";
+      const serviceVersion = process.env.npm_package_version || "1.0.0";
+      const resourceLayer = Resource.layer({ serviceName, serviceVersion });
+      const effectTracerLayer = Tracer$1.layerGlobal;
+      const tracerWithResource = effectTracerLayer.pipe(Layer.provide(resourceLayer));
+      const opSupervisionLayer = Layer.effectDiscard(
+        Effect.patchRuntimeFlags(RuntimeFlagsPatch.enable(RuntimeFlags.OpSupervision))
+      );
+      return Layer.mergeAll(
+        Layer.discard(tracerWithResource),
+        Layer.enableSourceCapture,
+        supervisorLayer,
+        opSupervisionLayer
+      );
+    };
+    UnifiedTracingLive = Layer.suspend(
+      () => createUnifiedTracingLayer()
+    );
+    enableOpSupervision = (effect) => Effect.withRuntimeFlagsPatch(effect, RuntimeFlagsPatch.enable(RuntimeFlags.OpSupervision));
+    withUnifiedTracing = (effect) => effect.pipe(enableOpSupervision, Effect.provide(UnifiedTracingLive));
+    withAutoTracing = (effect, config, rootSpanName) => {
+      const autoConfig = config ?? {
+        enabled: true,
+        granularity: "fiber",
+        span_naming: { default: "effect.{function}", infer_from_source: true, rules: [] },
+        span_relationships: { type: "parent-child" },
+        filter: { include: [], exclude: [] },
+        performance: { sampling_rate: 1, min_duration: "0ms", max_concurrent: 0 },
+        metadata: { fiber_info: true, source_location: true, parent_fiber: true }
+      };
+      const supervisor = new UnifiedTracingSupervisor(autoConfig);
+      const supervisorLayer = Supervisor.addSupervisor(supervisor);
+      const opSupervisionLayer = Layer.effectDiscard(
+        Effect.patchRuntimeFlags(RuntimeFlagsPatch.enable(RuntimeFlags.OpSupervision))
+      );
+      const combinedLayer = Layer.mergeAll(
+        supervisorLayer,
+        Layer.enableSourceCapture,
+        opSupervisionLayer
+      );
+      const wrappedEffect = rootSpanName ? effect.pipe(Effect.withSpan(rootSpanName)) : effect;
+      return wrappedEffect.pipe(Effect.provide(combinedLayer));
+    };
+    flushAndShutdown = async () => {
+      const setup = getGlobalProviderSetup();
+      if (setup?.provider) {
+        logger.log("@atrim/unified-tracing: Flushing and shutting down TracerProvider...");
+        await setup.provider.forceFlush();
+        await setup.provider.shutdown();
+        logger.log("@atrim/unified-tracing: TracerProvider shutdown complete");
+      }
+    };
+    forceFlush = async () => {
+      const setup = getGlobalProviderSetup();
+      if (setup?.provider) {
+        logger.log("@atrim/unified-tracing: Force flushing TracerProvider...");
+        await setup.provider.forceFlush();
+        logger.log("@atrim/unified-tracing: Force flush complete");
+      }
+    };
+  }
+});
+
+// src/integrations/effect/auto/index.ts
+init_unified_tracing_supervisor();
+init_config();
 var compiledRulesCache = /* @__PURE__ */ new WeakMap();
 function compileNamingRules(rules) {
   const cached = compiledRulesCache.get(rules);
@@ -848,1293 +1291,83 @@ function sanitizeSpanName(name) {
   }
   return sanitized;
 }
-
-// src/integrations/effect/auto/supervisor.ts
-var AutoTracingEnabled = FiberRef.unsafeMake(true);
-var AutoTracingSpanName = FiberRef.unsafeMake(Option.none());
-var AutoTracingSupervisor = class extends Supervisor.AbstractSupervisor {
-  constructor(config, tracerProvider) {
-    super();
-    this.config = config;
-    // WeakMap to associate fibers with their OTel spans
-    __publicField(this, "fiberSpans", /* @__PURE__ */ new WeakMap());
-    // WeakMap for fiber start times (for min_duration filtering)
-    __publicField(this, "fiberStartTimes", /* @__PURE__ */ new WeakMap());
-    // OpenTelemetry tracer - lazily initialized
-    __publicField(this, "_tracer", null);
-    // Optional TracerProvider (if provided, use this instead of global)
-    __publicField(this, "tracerProvider", null);
-    // Compiled filter patterns
-    __publicField(this, "includePatterns");
-    __publicField(this, "excludePatterns");
-    // Active fiber count (for max_concurrent limiting)
-    __publicField(this, "activeFiberCount", 0);
-    // Root span for parent context (set by withAutoTracing)
-    __publicField(this, "_rootSpan", null);
-    if (tracerProvider) {
-      this.tracerProvider = tracerProvider;
-      logger.log("@atrim/auto-trace: Using provided TracerProvider");
-    }
-    this.includePatterns = (config.filter?.include || []).map((p) => new RegExp(p));
-    this.excludePatterns = (config.filter?.exclude || []).map((p) => new RegExp(p));
-    logger.log("@atrim/auto-trace: Supervisor initialized");
-    logger.log(`  Granularity: ${config.granularity || "fiber"}`);
-    logger.log(`  Sampling rate: ${config.performance?.sampling_rate ?? 1}`);
-    logger.log(`  Infer from source: ${config.span_naming?.infer_from_source ?? true}`);
-  }
-  /**
-   * Set the root span for parent context propagation
-   */
-  setRootSpan(span) {
-    this._rootSpan = span;
-  }
-  /**
-   * Get the tracer lazily - uses provided TracerProvider if available, otherwise uses global
-   */
-  get tracer() {
-    if (!this._tracer) {
-      if (this.tracerProvider) {
-        logger.log("@atrim/auto-trace: Getting tracer from provided TracerProvider");
-        this._tracer = this.tracerProvider.getTracer("@atrim/auto-trace", "1.0.0");
-      } else {
-        logger.log("@atrim/auto-trace: Getting tracer from global API");
-        this._tracer = OtelApi.trace.getTracer("@atrim/auto-trace", "1.0.0");
-      }
-    }
-    return this._tracer;
-  }
-  /**
-   * Returns the current value (void for this supervisor)
-   */
-  get value() {
-    return Effect.void;
-  }
-  /**
-   * Called when a fiber starts executing
-   */
-  onStart(_context, _effect, parent, fiber) {
-    logger.log(`@atrim/auto-trace: onStart called for fiber ${fiber.id().id}`);
-    const fiberRefsValue = fiber.getFiberRefs();
-    const enabled = FiberRefs.getOrDefault(fiberRefsValue, AutoTracingEnabled);
-    if (!enabled) {
-      logger.log(`@atrim/auto-trace: Auto-tracing disabled for fiber ${fiber.id().id}`);
-      return;
-    }
-    const samplingRate = this.config.performance?.sampling_rate ?? 1;
-    if (samplingRate < 1 && Math.random() > samplingRate) {
-      return;
-    }
-    const maxConcurrent = this.config.performance?.max_concurrent ?? 0;
-    if (maxConcurrent > 0 && this.activeFiberCount >= maxConcurrent) {
-      return;
-    }
-    const nameOverride = FiberRefs.getOrDefault(fiberRefsValue, AutoTracingSpanName);
-    let sourceInfo = FiberRefs.getOrDefault(fiberRefsValue, CapturedSourceLocation);
-    if (sourceInfo) {
-      logger.log(`@atrim/auto-trace: Using captured source location for fiber ${fiber.id().id}`);
-      logger.log(`  function: ${sourceInfo.function}`);
-      logger.log(`  file: ${sourceInfo.file}`);
-      logger.log(`  line: ${sourceInfo.line}`);
-    } else if (this.config.span_naming?.infer_from_source) {
-      sourceInfo = this.parseStackTrace();
-      if (sourceInfo) {
-        logger.log(`@atrim/auto-trace: Inferred source from stack for fiber ${fiber.id().id}`);
-        logger.log(`  function: ${sourceInfo.function}`);
-        logger.log(`  file: ${sourceInfo.file}`);
-        logger.log(`  line: ${sourceInfo.line}`);
-      } else {
-        logger.log(`@atrim/auto-trace: No source info for fiber ${fiber.id().id}`);
-      }
-    }
-    let spanName;
-    if (Option.isSome(nameOverride)) {
-      spanName = nameOverride.value;
-    } else {
-      spanName = inferSpanName(fiber.id().id, sourceInfo, this.config);
-    }
-    if (!this.shouldTrace(spanName)) {
-      return;
-    }
-    const relationshipType = this.config.span_relationships?.type ?? "parent-child";
-    const useParentChild = relationshipType === "parent-child" || relationshipType === "both";
-    const useSpanLinks = relationshipType === "span-links" || relationshipType === "both";
-    let parentContext = OtelApi.ROOT_CONTEXT;
-    let parentFiberId;
-    let spanLinks = [];
-    const maybeEffectParentSpan = Context.getOption(_context, Tracer.ParentSpan);
-    if (Option.isSome(maybeEffectParentSpan)) {
-      const effectSpan = maybeEffectParentSpan.value;
-      logger.log(
-        `@atrim/auto-trace: Found ParentSpan - traceId=${effectSpan.traceId.slice(0, 8)}..., spanId=${effectSpan.spanId.slice(0, 8)}...`
-      );
-      const otelSpanContext = {
-        traceId: effectSpan.traceId,
-        spanId: effectSpan.spanId,
-        traceFlags: effectSpan.sampled ? OtelApi.TraceFlags.SAMPLED : OtelApi.TraceFlags.NONE,
-        isRemote: false
-      };
-      if (useParentChild) {
-        const wrappedSpan = OtelApi.trace.wrapSpanContext(otelSpanContext);
-        parentContext = OtelApi.trace.setSpan(OtelApi.ROOT_CONTEXT, wrappedSpan);
-      }
-      if (useSpanLinks) {
-        const linkAttributes = this.getLinkAttributes();
-        spanLinks.push({
-          context: otelSpanContext,
-          attributes: linkAttributes
-        });
-        logger.log(`@atrim/auto-trace: Added span link to parent (${relationshipType})`);
-      }
-    } else if (Option.isSome(parent)) {
-      parentFiberId = parent.value.id().id;
-      const parentSpan = this.fiberSpans.get(parent.value);
-      if (parentSpan) {
-        if (useParentChild) {
-          parentContext = OtelApi.trace.setSpan(OtelApi.ROOT_CONTEXT, parentSpan);
-        }
-        if (useSpanLinks) {
-          const linkAttributes = this.getLinkAttributes();
-          spanLinks.push({
-            context: parentSpan.spanContext(),
-            attributes: linkAttributes
-          });
-        }
-      } else if (this._rootSpan) {
-        if (useParentChild) {
-          parentContext = OtelApi.trace.setSpan(OtelApi.ROOT_CONTEXT, this._rootSpan);
-        }
-        if (useSpanLinks) {
-          const linkAttributes = this.getLinkAttributes();
-          spanLinks.push({
-            context: this._rootSpan.spanContext(),
-            attributes: linkAttributes
-          });
-        }
-      }
-    } else if (this._rootSpan) {
-      if (useParentChild) {
-        parentContext = OtelApi.trace.setSpan(OtelApi.ROOT_CONTEXT, this._rootSpan);
-      }
-      if (useSpanLinks) {
-        const linkAttributes = this.getLinkAttributes();
-        spanLinks.push({
-          context: this._rootSpan.spanContext(),
-          attributes: linkAttributes
-        });
-      }
-    }
-    if (Option.isSome(parent)) {
-      parentFiberId = parent.value.id().id;
-    }
-    const spanOptions = {
-      kind: OtelApi.SpanKind.INTERNAL,
-      attributes: this.getInitialAttributes(fiber, sourceInfo, parentFiberId)
-    };
-    if (spanLinks.length > 0) {
-      spanOptions.links = spanLinks;
-    }
-    const span = this.tracer.startSpan(spanName, spanOptions, parentContext);
-    logger.log(`@atrim/auto-trace: Created span "${spanName}" for fiber ${fiber.id().id}`);
-    this.fiberSpans.set(fiber, span);
-    this.fiberStartTimes.set(fiber, process.hrtime.bigint());
-    this.activeFiberCount++;
-  }
-  /**
-   * Called when a fiber completes (success or failure)
-   */
-  onEnd(exit, fiber) {
-    logger.log(`@atrim/auto-trace: onEnd called for fiber ${fiber.id().id}`);
-    const span = this.fiberSpans.get(fiber);
-    if (!span) {
-      logger.log(
-        `@atrim/auto-trace: No span found for fiber ${fiber.id().id} (skipped or filtered)`
-      );
-      return;
-    }
-    const startTime = this.fiberStartTimes.get(fiber);
-    if (startTime) {
-      const duration = process.hrtime.bigint() - startTime;
-      const minDuration = this.parseMinDuration(this.config.performance?.min_duration);
-      if (minDuration > 0 && duration < minDuration) {
-        this.fiberSpans.delete(fiber);
-        this.fiberStartTimes.delete(fiber);
-        this.activeFiberCount--;
-        return;
-      }
-    }
-    if (Exit.isSuccess(exit)) {
-      span.setStatus({ code: OtelApi.SpanStatusCode.OK });
-    } else {
-      span.setStatus({
-        code: OtelApi.SpanStatusCode.ERROR,
-        message: "Fiber failed"
-      });
-      span.setAttribute("effect.fiber.failed", true);
-    }
-    span.end();
-    logger.log(`@atrim/auto-trace: Ended span for fiber ${fiber.id().id}`);
-    this.fiberSpans.delete(fiber);
-    this.fiberStartTimes.delete(fiber);
-    this.activeFiberCount--;
-  }
-  /**
-   * Get attributes for span links from config
-   */
-  getLinkAttributes() {
-    const linkConfig = this.config.span_relationships?.link_attributes;
-    const attrs = {
-      "link.type": linkConfig?.["link.type"] ?? "fork"
-    };
-    if (linkConfig?.custom) {
-      for (const [key, value] of Object.entries(linkConfig.custom)) {
-        attrs[key] = value;
-      }
-    }
-    return attrs;
-  }
-  /**
-   * Check if a span name should be traced based on filter patterns
-   */
-  shouldTrace(spanName) {
-    for (const pattern of this.excludePatterns) {
-      if (pattern.test(spanName)) {
-        return false;
-      }
-    }
-    if (this.includePatterns.length > 0) {
-      for (const pattern of this.includePatterns) {
-        if (pattern.test(spanName)) {
-          return true;
-        }
-      }
-      return false;
-    }
-    return true;
-  }
-  /**
-   * Get initial span attributes for a fiber
-   */
-  getInitialAttributes(fiber, sourceInfo, parentFiberId) {
-    const attrs = {
-      "effect.auto_traced": true
-    };
-    if (this.config.metadata?.fiber_info !== false) {
-      attrs["effect.fiber.id"] = fiber.id().id;
-    }
-    if (this.config.metadata?.source_location !== false && sourceInfo) {
-      attrs["code.function"] = sourceInfo.function;
-      attrs["code.filepath"] = sourceInfo.file;
-      attrs["code.lineno"] = sourceInfo.line;
-      attrs["code.column"] = sourceInfo.column;
-    }
-    if (this.config.metadata?.parent_fiber !== false && parentFiberId !== void 0) {
-      attrs["effect.fiber.parent_id"] = parentFiberId;
-    }
-    return attrs;
-  }
-  /**
-   * Parse stack trace to get source info
-   */
-  parseStackTrace() {
-    const stack = new Error().stack;
-    if (!stack) {
-      logger.log("@atrim/auto-trace: [parseStackTrace] No stack available");
-      return void 0;
-    }
-    const lines = stack.split("\n");
-    logger.log(`@atrim/auto-trace: [parseStackTrace] Stack has ${lines.length} lines`);
-    for (let i = 0; i < Math.min(10, lines.length); i++) {
-      logger.log(`@atrim/auto-trace: [stack ${i}] ${lines[i]}`);
-    }
-    for (let i = 3; i < lines.length; i++) {
-      const line = lines[i];
-      if (line === void 0) continue;
-      if (!line.includes("node_modules/effect") && !line.includes("@atrim/instrument") && !line.includes("auto/supervisor")) {
-        logger.log(`@atrim/auto-trace: [parseStackTrace] Found user frame: ${line}`);
-        const match = line.match(/at\s+(?:(.+?)\s+)?\(?(.+?):(\d+):(\d+)\)?/);
-        if (match) {
-          const [, funcName, filePath, lineNum, colNum] = match;
-          const sourceInfo = {
-            function: funcName ?? "anonymous",
-            file: filePath ?? "unknown",
-            line: parseInt(lineNum ?? "0", 10),
-            column: parseInt(colNum ?? "0", 10)
-          };
-          logger.log(
-            `@atrim/auto-trace: [parseStackTrace] Parsed: ${sourceInfo.function} at ${sourceInfo.file}:${sourceInfo.line}`
-          );
-          return sourceInfo;
-        }
-      }
-    }
-    logger.log("@atrim/auto-trace: [parseStackTrace] No user code frame found in stack");
-    return void 0;
-  }
-  /**
-   * Parse min_duration string to nanoseconds
-   */
-  parseMinDuration(duration) {
-    if (!duration || duration === "0ms") return BigInt(0);
-    const match = duration.match(/^(\d+)\s*(ms|millis|s|sec|seconds|us|micros)?$/i);
-    if (!match) return BigInt(0);
-    const value = parseInt(match[1] ?? "0", 10);
-    const unit = (match[2] ?? "ms").toLowerCase();
-    switch (unit) {
-      case "us":
-      case "micros":
-        return BigInt(value) * BigInt(1e3);
-      case "ms":
-      case "millis":
-        return BigInt(value) * BigInt(1e6);
-      case "s":
-      case "sec":
-      case "seconds":
-        return BigInt(value) * BigInt(1e9);
-      default:
-        return BigInt(value) * BigInt(1e6);
-    }
-  }
-};
-var createAutoTracingSupervisor = (config, tracerProvider) => {
-  return new AutoTracingSupervisor(config, tracerProvider);
-};
-var createAutoTracingLayer = (options) => {
-  return Layer.unwrapEffect(
-    Effect.gen(function* () {
-      const config = options?.config ?? (yield* loadAutoTracingConfig());
-      if (!config.enabled) {
-        logger.log("@atrim/auto-trace: Auto-tracing disabled via config");
-        return Layer.empty;
-      }
-      patchEffectFork();
-      const supervisor = createAutoTracingSupervisor(config);
-      return Supervisor.addSupervisor(supervisor);
-    })
-  );
-};
-var withAutoTracing = (effect, config, mainSpanName) => {
-  if (!config.enabled) {
-    logger.log("@atrim/auto-trace: Auto-tracing disabled via config");
-    return effect;
-  }
-  const supervisor = createAutoTracingSupervisor(config);
-  const tracer = OtelApi.trace.getTracer("@atrim/auto-trace", "1.0.0");
-  const spanName = mainSpanName ?? inferSpanName(0, void 0, config);
-  const mainSpan = tracer.startSpan(spanName, {
-    kind: OtelApi.SpanKind.INTERNAL,
-    attributes: {
-      "effect.auto_traced": true,
-      "effect.fiber.id": 0,
-      // Main fiber
-      "effect.main_fiber": true
-    }
-  });
-  supervisor.setRootSpan(mainSpan);
-  return Effect.acquireUseRelease(
-    // Acquire: return the span (already started)
-    Effect.succeed(mainSpan),
-    // Use: run the supervised effect
-    () => Effect.supervised(supervisor)(effect),
-    // Release: end the span
-    (span, exit) => Effect.sync(() => {
-      if (Exit.isSuccess(exit)) {
-        span.setStatus({ code: OtelApi.SpanStatusCode.OK });
-      } else {
-        span.setStatus({
-          code: OtelApi.SpanStatusCode.ERROR,
-          message: "Effect failed"
-        });
-      }
-      span.end();
-    })
-  );
-};
-var AutoTracingLive = createAutoTracingLayer();
-var withoutAutoTracing = (effect) => effect.pipe(Effect.locally(AutoTracingEnabled, false));
-var setSpanName = (name) => (effect) => effect.pipe(Effect.locally(AutoTracingSpanName, Option.some(name)));
-var createExporterLayer = (exporterConfig, serviceName, serviceVersion) => {
-  const config = exporterConfig ?? {
-    type: "otlp",
-    processor: "batch",
-    batch: {
-      scheduled_delay_millis: 1e3,
-      max_export_batch_size: 100
-    }
-  };
-  if (config.type === "none") {
-    logger.log('@atrim/auto-trace: Exporter type is "none", no spans will be exported');
-    return Layer.empty;
-  }
-  const createSpanExporter = () => {
-    if (config.type === "console") {
-      logger.log("@atrim/auto-trace: Using ConsoleSpanExporter");
-      return new ConsoleSpanExporter();
-    }
-    const endpoint = config.endpoint || process.env.OTEL_EXPORTER_OTLP_ENDPOINT || "http://localhost:4318";
-    logger.log(`@atrim/auto-trace: Using OTLPTraceExporter (${endpoint})`);
-    const exporterConfig2 = {
-      url: `${endpoint}/v1/traces`
-    };
-    if (config.headers) {
-      exporterConfig2.headers = config.headers;
-      logger.log(
-        `@atrim/auto-trace: Using custom headers: ${Object.keys(config.headers).join(", ")}`
-      );
-    }
-    return new OTLPTraceExporter(exporterConfig2);
-  };
-  const createSpanProcessor = () => {
-    const exporter = createSpanExporter();
-    if (config.processor === "simple" || config.type === "console") {
-      logger.log("@atrim/auto-trace: Using SimpleSpanProcessor");
-      return new SimpleSpanProcessor(exporter);
+var CapturedSourceLocation = FiberRef.unsafeMake(void 0);
+function captureCallSite(skipFrames = 0) {
+  const originalLimit = Error.stackTraceLimit;
+  Error.stackTraceLimit = 10;
+  const error = new Error();
+  Error.stackTraceLimit = originalLimit;
+  if (!error.stack) return void 0;
+  const lines = error.stack.split("\n");
+  const startIndex = 3 + skipFrames;
+  for (let i = startIndex; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === void 0) continue;
+    if (line.includes("@atrim/instrument") || line.includes("node_modules/effect")) {
+      continue;
     }
-    const batchConfig = config.batch ?? {
-      scheduled_delay_millis: 1e3,
-      max_export_batch_size: 100
-    };
-    logger.log("@atrim/auto-trace: Using BatchSpanProcessor");
-    return new BatchSpanProcessor(exporter, {
-      scheduledDelayMillis: batchConfig.scheduled_delay_millis,
-      maxExportBatchSize: batchConfig.max_export_batch_size
-    });
-  };
-  return Layer.effectDiscard(
-    Effect.sync(() => {
-      const provider = new BasicTracerProvider({
-        resource: resourceFromAttributes({
-          [ATTR_SERVICE_NAME]: serviceName,
-          [ATTR_SERVICE_VERSION]: serviceVersion
-        }),
-        spanProcessors: [createSpanProcessor()]
-      });
-      OtelApi.trace.setGlobalTracerProvider(provider);
-      logger.log("@atrim/auto-trace: Global TracerProvider registered");
-      return () => {
-        provider.shutdown().catch((err) => {
-          logger.log(`@atrim/auto-trace: Error shutting down provider: ${err}`);
-        });
-      };
-    })
-  );
-};
-var createFullAutoTracingLayer = () => {
-  return Layer.unwrapEffect(
-    Effect.gen(function* () {
-      const config = yield* loadFullConfig();
-      const serviceName = process.env.OTEL_SERVICE_NAME || "effect-service";
-      const serviceVersion = process.env.npm_package_version || "1.0.0";
-      const autoConfig = config.effect?.auto_instrumentation;
-      if (!autoConfig?.enabled) {
-        logger.log("@atrim/auto-trace: Auto-instrumentation disabled via config");
-        return Layer.empty;
-      }
-      patchEffectFork();
-      const exporterConfig = config.effect?.exporter_config;
-      logger.log("@atrim/auto-trace: Full auto-instrumentation enabled");
-      logger.log(`  Service: ${serviceName}`);
-      logger.log(`  Exporter: ${exporterConfig?.type ?? "otlp"}`);
-      const exporterLayer = createExporterLayer(exporterConfig, serviceName, serviceVersion);
-      const supervisor = createAutoTracingSupervisor(autoConfig);
-      const supervisorLayer = Supervisor.addSupervisor(supervisor);
-      return Layer.mergeAll(exporterLayer, supervisorLayer);
-    })
-  );
-};
-var FullAutoTracingLive = createFullAutoTracingLayer();
-
-// src/integrations/effect/auto/effect-tracing.ts
-var createEffectTracingLayer = () => {
-  return Layer.unwrapEffect(
-    Effect.gen(function* () {
-      const config = yield* loadFullConfig();
-      const serviceName = process.env.OTEL_SERVICE_NAME || "effect-service";
-      const serviceVersion = process.env.npm_package_version || "1.0.0";
-      const exporterConfig = config.effect?.exporter_config ?? {
-        type: "otlp",
-        processor: "batch"
-      };
-      logger.log("@atrim/auto-trace: Effect-native tracing enabled");
-      logger.log(`  Service: ${serviceName}`);
-      logger.log(`  Exporter: ${exporterConfig.type}`);
-      if (exporterConfig.type === "none") {
-        logger.log('@atrim/auto-trace: Exporter type is "none", using empty layer');
-        return Layer.empty;
-      }
-      const createSpanProcessor = () => {
-        if (exporterConfig.type === "console") {
-          logger.log("@atrim/auto-trace: Using ConsoleSpanExporter with SimpleSpanProcessor");
-          return new SimpleSpanProcessor(new ConsoleSpanExporter());
-        }
-        const endpoint = exporterConfig.endpoint || process.env.OTEL_EXPORTER_OTLP_ENDPOINT || "http://localhost:4318";
-        logger.log(`@atrim/auto-trace: Using OTLPTraceExporter (${endpoint})`);
-        const otlpConfig = {
-          url: `${endpoint}/v1/traces`
-        };
-        if (exporterConfig.headers) {
-          otlpConfig.headers = exporterConfig.headers;
-          logger.log(
-            `@atrim/auto-trace: Using custom headers: ${Object.keys(exporterConfig.headers).join(", ")}`
-          );
-        }
-        const exporter = new OTLPTraceExporter(otlpConfig);
-        if (exporterConfig.processor === "simple") {
-          logger.log("@atrim/auto-trace: Using SimpleSpanProcessor");
-          return new SimpleSpanProcessor(exporter);
-        }
-        const batchConfig = exporterConfig.batch ?? {
-          scheduled_delay_millis: 1e3,
-          max_export_batch_size: 100
-        };
-        logger.log("@atrim/auto-trace: Using BatchSpanProcessor");
-        return new BatchSpanProcessor(exporter, {
-          scheduledDelayMillis: batchConfig.scheduled_delay_millis,
-          maxExportBatchSize: batchConfig.max_export_batch_size
-        });
-      };
-      const sdkLayer = NodeSdk.layer(() => ({
-        resource: {
-          serviceName,
-          serviceVersion
-        },
-        spanProcessor: createSpanProcessor()
-      }));
-      logger.log("@atrim/auto-trace: NodeSdk layer created - HTTP requests will be auto-traced");
-      return Layer.discard(sdkLayer);
-    })
-  );
-};
-var EffectTracingLive = createEffectTracingLayer();
-var createCombinedTracingLayer = () => {
-  return Layer.unwrapEffect(
-    Effect.gen(function* () {
-      const config = yield* loadFullConfig();
-      const serviceName = process.env.OTEL_SERVICE_NAME || "effect-service";
-      const serviceVersion = process.env.npm_package_version || "1.0.0";
-      const exporterConfig = config.effect?.exporter_config ?? {
-        type: "otlp",
-        processor: "batch"
-      };
-      const autoConfig = config.effect?.auto_instrumentation ?? {
-        enabled: true,
-        granularity: "fiber",
-        span_naming: {
-          default: "effect.{function}",
-          infer_from_source: true,
-          rules: []
-        },
-        span_relationships: {
-          type: "parent-child"
-        },
-        filter: { include: [], exclude: [] },
-        performance: { sampling_rate: 1, min_duration: "0ms", max_concurrent: 0 },
-        metadata: { fiber_info: true, source_location: true, parent_fiber: true }
-      };
-      logger.log("@atrim/auto-trace: Combined tracing enabled (HTTP + Fiber)");
-      logger.log(`  Service: ${serviceName}`);
-      logger.log(`  Exporter: ${exporterConfig.type}`);
-      if (exporterConfig.type === "none") {
-        logger.log('@atrim/auto-trace: Exporter type is "none", using empty layer');
-        return Layer.empty;
-      }
-      const createSpanExporter = () => {
-        if (exporterConfig.type === "console") {
-          logger.log("@atrim/auto-trace: Using ConsoleSpanExporter");
-          return new ConsoleSpanExporter();
-        }
-        const endpoint = exporterConfig.endpoint || process.env.OTEL_EXPORTER_OTLP_ENDPOINT || "http://localhost:4318";
-        logger.log(`@atrim/auto-trace: Using OTLPTraceExporter (${endpoint})`);
-        const otlpConfig = {
-          url: `${endpoint}/v1/traces`
-        };
-        if (exporterConfig.headers) {
-          otlpConfig.headers = exporterConfig.headers;
-          logger.log(
-            `@atrim/auto-trace: Using custom headers: ${Object.keys(exporterConfig.headers).join(", ")}`
-          );
-        }
-        return new OTLPTraceExporter(otlpConfig);
-      };
-      const createSpanProcessor = () => {
-        const exporter = createSpanExporter();
-        if (exporterConfig.processor === "simple" || exporterConfig.type === "console") {
-          logger.log("@atrim/auto-trace: Using SimpleSpanProcessor");
-          return new SimpleSpanProcessor(exporter);
-        }
-        const batchConfig = exporterConfig.batch ?? {
-          scheduled_delay_millis: 1e3,
-          max_export_batch_size: 100
-        };
-        logger.log("@atrim/auto-trace: Using BatchSpanProcessor");
-        return new BatchSpanProcessor(exporter, {
-          scheduledDelayMillis: batchConfig.scheduled_delay_millis,
-          maxExportBatchSize: batchConfig.max_export_batch_size
-        });
+    const match = line.match(/at\s+(?:(.+?)\s+)?\(?(.+?):(\d+):(\d+)\)?/);
+    if (match) {
+      const [, funcName, filePath, lineNum, colNum] = match;
+      return {
+        function: funcName?.trim() ?? "anonymous",
+        file: filePath ?? "unknown",
+        line: parseInt(lineNum ?? "0", 10),
+        column: parseInt(colNum ?? "0", 10)
       };
-      const globalProviderLayer = Layer.effectDiscard(
-        Effect.sync(() => {
-          const provider = new BasicTracerProvider({
-            resource: resourceFromAttributes({
-              [ATTR_SERVICE_NAME]: serviceName,
-              [ATTR_SERVICE_VERSION]: serviceVersion
-            }),
-            spanProcessors: [createSpanProcessor()]
-          });
-          OtelApi.trace.setGlobalTracerProvider(provider);
-          logger.log("@atrim/auto-trace: Global TracerProvider registered");
-        })
-      );
-      const resourceLayer = Resource.layer({
-        serviceName,
-        serviceVersion
-      });
-      const effectTracerLayer = Tracer$1.layerGlobal;
-      const supervisor = createAutoTracingSupervisor(autoConfig);
-      const supervisorLayer = Supervisor.addSupervisor(supervisor);
-      logger.log("@atrim/auto-trace: Combined layer created");
-      logger.log("  - HTTP requests: auto-traced via Effect platform (global provider)");
-      logger.log("  - Forked fibers: auto-traced via Supervisor (global provider)");
-      const tracerWithResource = effectTracerLayer.pipe(Layer.provide(resourceLayer));
-      return Layer.mergeAll(globalProviderLayer, Layer.discard(tracerWithResource), supervisorLayer);
-    })
-  );
-};
-var CombinedTracingLive = createCombinedTracingLayer();
-var currentSourceLocation = GlobalValue.globalValue(
-  /* @__PURE__ */ Symbol.for("effect/FiberRef/currentSourceLocation"),
-  () => FiberRef.unsafeMake(void 0)
-);
-var sourceFileCache = /* @__PURE__ */ new Map();
-function extractFunctionNameFromSource(location) {
-  try {
-    let lines = sourceFileCache.get(location.file);
-    if (!lines) {
-      if (!fs.existsSync(location.file)) {
-        return void 0;
-      }
-      const content = fs.readFileSync(location.file, "utf-8");
-      lines = content.split("\n");
-      sourceFileCache.set(location.file, lines);
-    }
-    const lineIndex = location.line - 1;
-    if (lineIndex < 0 || lineIndex >= lines.length) {
-      return void 0;
     }
-    const line = lines[lineIndex];
-    if (!line) return void 0;
-    const fromColumn = line.slice(location.column - 1);
-    const forkPattern = /(?:fork|forkDaemon|forkScoped|forkIn)\s*\(\s*([a-zA-Z_$][a-zA-Z0-9_$]*)/;
-    const match = fromColumn.match(forkPattern);
-    if (match && match[1]) {
-      return match[1];
-    }
-    const fullLinePattern = /(?:fork|forkDaemon|forkScoped|forkIn)\s*\(\s*([a-zA-Z_$][a-zA-Z0-9_$]*)/;
-    const fullMatch = line.match(fullLinePattern);
-    if (fullMatch && fullMatch[1]) {
-      return fullMatch[1];
-    }
-    return void 0;
-  } catch {
-    return void 0;
   }
+  return void 0;
 }
-var AutoTracingEnabled2 = FiberRef.unsafeMake(true);
-var AutoTracingSpanName2 = FiberRef.unsafeMake(Option.none());
-var SourceCaptureSupervisor = class extends Supervisor.AbstractSupervisor {
-  constructor(config) {
-    super();
-    this.config = config;
-    // WeakMap to associate fibers with their OTel spans
-    __publicField(this, "fiberSpans", /* @__PURE__ */ new WeakMap());
-    // WeakMap to associate fibers with their OTel contexts (for child fiber lookups)
-    __publicField(this, "fiberContexts", /* @__PURE__ */ new WeakMap());
-    // WeakMap for fiber start times (for min_duration filtering)
-    __publicField(this, "fiberStartTimes", /* @__PURE__ */ new WeakMap());
-    // OpenTelemetry tracer - lazily initialized
-    __publicField(this, "_tracer", null);
-    // Active fiber count (for max_concurrent limiting)
-    __publicField(this, "activeFiberCount", 0);
-    // Default root span for fibers without a ParentSpan in their context
-    // This enables auto-instrumentation without requiring Effect.withSpan()
-    __publicField(this, "_rootSpan", null);
-    logger.log("@atrim/source-capture: Supervisor initialized (native source capture)");
-    logger.log(`  Granularity: ${config.granularity || "fiber"}`);
-    logger.log(`  Sampling rate: ${config.performance?.sampling_rate ?? 1}`);
-  }
-  /**
-   * Set the default root span for auto-instrumentation.
-   * Fibers without a ParentSpan will use this as their parent.
-   */
-  setRootSpan(span) {
-    this._rootSpan = span;
-    logger.log(`@atrim/source-capture: Root span set - spanId=${span.spanContext().spanId}`);
-  }
-  /**
-   * Get the root span (if set)
-   */
-  get rootSpan() {
-    return this._rootSpan;
-  }
-  /**
-   * Get the tracer lazily from global OTel API
-   */
-  get tracer() {
-    if (!this._tracer) {
-      logger.log("@atrim/source-capture: Getting tracer from global API");
-      this._tracer = OtelApi.trace.getTracer("@atrim/source-capture", "1.0.0");
-    }
-    return this._tracer;
-  }
-  /**
-   * Returns the current value (void for this supervisor)
-   */
-  get value() {
-    return Effect.void;
-  }
-  /**
-   * Called when a fiber starts executing
-   */
-  onStart(_context, _effect, parent, fiber) {
-    const fiberId = fiber.id().id;
-    logger.log(`@atrim/source-capture: onStart called for fiber ${fiberId}`);
-    const fiberRefsValue = fiber.getFiberRefs();
-    const enabled = FiberRefs.getOrDefault(fiberRefsValue, AutoTracingEnabled2);
-    if (!enabled) {
-      logger.log(`@atrim/source-capture: Auto-tracing disabled for fiber ${fiberId}`);
-      return;
-    }
-    const samplingRate = this.config.performance?.sampling_rate ?? 1;
-    if (samplingRate < 1 && Math.random() > samplingRate) {
-      return;
-    }
-    const maxConcurrent = this.config.performance?.max_concurrent ?? 0;
-    if (maxConcurrent > 0 && this.activeFiberCount >= maxConcurrent) {
-      return;
-    }
-    const nameOverride = FiberRefs.getOrDefault(fiberRefsValue, AutoTracingSpanName2);
-    const nativeSourceLocation = FiberRefs.getOrDefault(fiberRefsValue, currentSourceLocation);
-    if (nativeSourceLocation) {
-      logger.log(`@atrim/source-capture: Found native source location for fiber ${fiberId}`);
-      logger.log(`  file: ${nativeSourceLocation.file}`);
-      logger.log(`  line: ${nativeSourceLocation.line}`);
-      logger.log(`  column: ${nativeSourceLocation.column}`);
-      logger.log(`  functionName: ${nativeSourceLocation.functionName ?? "N/A"}`);
-    } else {
-      logger.log(
-        `@atrim/source-capture: No source location for fiber ${fiberId} (source capture may be disabled)`
-      );
-    }
-    let spanName;
-    let extractedFuncName;
-    if (Option.isSome(nameOverride)) {
-      spanName = nameOverride.value;
-    } else if (nativeSourceLocation) {
-      extractedFuncName = extractFunctionNameFromSource(nativeSourceLocation);
-      const funcName = extractedFuncName ?? nativeSourceLocation.functionName ?? "anonymous";
-      const fileName = nativeSourceLocation.file.split("/").pop() ?? "unknown";
-      spanName = `effect.${funcName} (${fileName}:${nativeSourceLocation.line})`;
-      if (extractedFuncName) {
-        logger.log(
-          `@atrim/source-capture: Extracted function name "${extractedFuncName}" from source`
-        );
-      }
-    } else {
-      spanName = `effect.fiber-${fiberId}`;
-    }
-    let parentContext = OtelApi.ROOT_CONTEXT;
-    let parentFiberId;
-    const inheritedOtelContext = FiberRefs.getOrDefault(
-      fiberRefsValue,
-      TracerModule.currentOtelSpanContext
-    );
-    if (inheritedOtelContext) {
-      parentContext = inheritedOtelContext;
-      const inheritedSpan = OtelApi.trace.getSpan(inheritedOtelContext);
-      if (inheritedSpan) {
-        const spanCtx = inheritedSpan.spanContext();
-        logger.log(
-          `@atrim/source-capture: Using inherited OTel context - traceId=${spanCtx.traceId}, spanId=${spanCtx.spanId}`
-        );
-      }
-    } else {
-      const maybeEffectParentSpan = Context.getOption(_context, Tracer.ParentSpan);
-      if (Option.isSome(maybeEffectParentSpan)) {
-        const effectSpan = maybeEffectParentSpan.value;
-        logger.log(
-          `@atrim/source-capture: Found ParentSpan - traceId=${effectSpan.traceId}, spanId=${effectSpan.spanId}`
-        );
-        const otelSpanContext = {
-          traceId: effectSpan.traceId,
-          spanId: effectSpan.spanId,
-          traceFlags: effectSpan.sampled ? OtelApi.TraceFlags.SAMPLED : OtelApi.TraceFlags.NONE,
-          isRemote: false
-        };
-        const wrappedSpan = OtelApi.trace.wrapSpanContext(otelSpanContext);
-        parentContext = OtelApi.trace.setSpan(OtelApi.ROOT_CONTEXT, wrappedSpan);
-      } else if (Option.isSome(parent)) {
-        parentFiberId = parent.value.id().id;
-        const parentOtelContext = this.fiberContexts.get(parent.value);
-        if (parentOtelContext) {
-          parentContext = parentOtelContext;
-          const parentSpan = OtelApi.trace.getSpan(parentOtelContext);
-          if (parentSpan) {
-            logger.log(
-              `@atrim/source-capture: Using parent fiber's OTel context - traceId=${parentSpan.spanContext().traceId}`
-            );
-          }
-        } else {
-          const parentSpan = this.fiberSpans.get(parent.value);
-          if (parentSpan) {
-            parentContext = OtelApi.trace.setSpan(OtelApi.ROOT_CONTEXT, parentSpan);
-          }
-        }
-      }
-    }
-    if (Option.isSome(parent)) {
-      parentFiberId = parent.value.id().id;
-    }
-    const attributes = {
-      "effect.auto_traced": true,
-      "effect.source_capture": true,
-      "effect.fiber.id": fiberId
-    };
-    if (nativeSourceLocation) {
-      attributes["code.function"] = extractedFuncName ?? nativeSourceLocation.functionName ?? "anonymous";
-      attributes["code.filepath"] = nativeSourceLocation.file;
-      attributes["code.lineno"] = nativeSourceLocation.line;
-      attributes["code.column"] = nativeSourceLocation.column;
-    }
-    if (parentFiberId !== void 0) {
-      attributes["effect.fiber.parent_id"] = parentFiberId;
-    }
-    const span = this.tracer.startSpan(
-      spanName,
-      {
-        kind: OtelApi.SpanKind.INTERNAL,
-        attributes
-      },
-      parentContext
-    );
-    logger.log(`@atrim/source-capture: Created span "${spanName}" for fiber ${fiberId}`);
-    const newContext = OtelApi.trace.setSpan(parentContext, span);
-    this.fiberSpans.set(fiber, span);
-    this.fiberContexts.set(fiber, newContext);
-    this.fiberStartTimes.set(fiber, process.hrtime.bigint());
-    this.activeFiberCount++;
-  }
-  /**
-   * Called when a fiber completes (success or failure)
-   */
-  onEnd(exit, fiber) {
-    const fiberId = fiber.id().id;
-    logger.log(`@atrim/source-capture: onEnd called for fiber ${fiberId}`);
-    const span = this.fiberSpans.get(fiber);
-    if (!span) {
-      logger.log(`@atrim/source-capture: No span found for fiber ${fiberId} (skipped or filtered)`);
-      return;
-    }
-    const startTime = this.fiberStartTimes.get(fiber);
-    if (startTime) {
-      const duration = process.hrtime.bigint() - startTime;
-      const minDuration = this.parseMinDuration(this.config.performance?.min_duration);
-      if (minDuration > 0 && duration < minDuration) {
-        this.fiberSpans.delete(fiber);
-        this.fiberContexts.delete(fiber);
-        this.fiberStartTimes.delete(fiber);
-        this.activeFiberCount--;
-        return;
-      }
-    }
-    if (Exit.isSuccess(exit)) {
-      span.setStatus({ code: OtelApi.SpanStatusCode.OK });
-    } else {
-      span.setStatus({
-        code: OtelApi.SpanStatusCode.ERROR,
-        message: "Fiber failed"
-      });
-      span.setAttribute("effect.fiber.failed", true);
-    }
-    span.end();
-    logger.log(`@atrim/source-capture: Ended span for fiber ${fiberId}`);
-    this.fiberSpans.delete(fiber);
-    this.fiberContexts.delete(fiber);
-    this.fiberStartTimes.delete(fiber);
-    this.activeFiberCount--;
-  }
-  /**
-   * Parse min_duration string to nanoseconds
-   */
-  parseMinDuration(duration) {
-    if (!duration || duration === "0ms") return BigInt(0);
-    const match = duration.match(/^(\d+)\s*(ms|millis|s|sec|seconds|us|micros)?$/i);
-    if (!match) return BigInt(0);
-    const value = parseInt(match[1] ?? "0", 10);
-    const unit = (match[2] ?? "ms").toLowerCase();
-    switch (unit) {
-      case "us":
-      case "micros":
-        return BigInt(value) * BigInt(1e3);
-      case "ms":
-      case "millis":
-        return BigInt(value) * BigInt(1e6);
-      case "s":
-      case "sec":
-      case "seconds":
-        return BigInt(value) * BigInt(1e9);
-      default:
-        return BigInt(value) * BigInt(1e6);
-    }
-  }
-};
-var setupGlobalTracerProvider = () => {
-  const config = loadFullConfigSync();
-  const serviceName = process.env.OTEL_SERVICE_NAME || "effect-service";
-  const serviceVersion = process.env.npm_package_version || "1.0.0";
-  const exporterConfig = config.effect?.exporter_config ?? {
-    type: "otlp",
-    processor: "batch"
-  };
-  logger.log("@atrim/source-capture: Setting up global TracerProvider");
-  logger.log(`  Service: ${serviceName}`);
-  logger.log(`  Exporter: ${exporterConfig.type}`);
-  if (exporterConfig.type === "none") {
-    logger.log('@atrim/source-capture: Exporter type is "none", skipping provider setup');
-    return null;
-  }
-  let exporter;
-  if (exporterConfig.type === "console") {
-    logger.log("@atrim/source-capture: Using ConsoleSpanExporter");
-    exporter = new ConsoleSpanExporter();
-  } else {
-    const endpoint = exporterConfig.endpoint || process.env.OTEL_EXPORTER_OTLP_ENDPOINT || "http://localhost:4318";
-    logger.log(`@atrim/source-capture: Using OTLPTraceExporter (${endpoint})`);
-    const otlpConfig = {
-      url: `${endpoint}/v1/traces`
-    };
-    if (exporterConfig.headers) {
-      otlpConfig.headers = exporterConfig.headers;
-      logger.log(
-        `@atrim/source-capture: Using headers: ${Object.keys(exporterConfig.headers).join(", ")}`
-      );
-    }
-    exporter = new OTLPTraceExporter(otlpConfig);
-  }
-  let spanProcessor;
-  if (exporterConfig.processor === "simple" || exporterConfig.type === "console") {
-    logger.log("@atrim/source-capture: Using SimpleSpanProcessor");
-    spanProcessor = new SimpleSpanProcessor(exporter);
-  } else {
-    const batchConfig = exporterConfig.batch ?? {
-      scheduled_delay_millis: 1e3,
-      max_export_batch_size: 100
-    };
-    logger.log("@atrim/source-capture: Using BatchSpanProcessor");
-    spanProcessor = new BatchSpanProcessor(exporter, {
-      scheduledDelayMillis: batchConfig.scheduled_delay_millis,
-      maxExportBatchSize: batchConfig.max_export_batch_size
-    });
+var tracedFork = (effect) => {
+  const callSite = captureCallSite();
+  if (!callSite) {
+    return Effect.fork(effect);
   }
-  const provider = new BasicTracerProvider({
-    resource: resourceFromAttributes({
-      [ATTR_SERVICE_NAME]: serviceName,
-      [ATTR_SERVICE_VERSION]: serviceVersion
-    }),
-    spanProcessors: [spanProcessor]
-  });
-  OtelApi.trace.setGlobalTracerProvider(provider);
-  logger.log("@atrim/source-capture: Global TracerProvider registered");
-  return { provider, spanProcessor };
+  return FiberRef.set(CapturedSourceLocation, callSite).pipe(Effect.zipRight(Effect.fork(effect)));
 };
-var globalProviderSetup = setupGlobalTracerProvider();
-var createSourceCaptureTracingLayer = () => {
-  const config = loadFullConfigSync();
-  const autoConfig = config.effect?.auto_instrumentation ?? {
-    enabled: true,
-    granularity: "fiber",
-    span_naming: {
-      default: "effect.{function}",
-      infer_from_source: true,
-      rules: []
-    },
-    span_relationships: {
-      type: "parent-child"
-    },
-    filter: { include: [], exclude: [] },
-    performance: { sampling_rate: 1, min_duration: "0ms", max_concurrent: 0 },
-    metadata: { fiber_info: true, source_location: true, parent_fiber: true }
-  };
-  if (!globalProviderSetup) {
-    logger.log("@atrim/source-capture: No TracerProvider, using empty layer");
-    return Layer.empty;
+var tracedForkDaemon = (effect) => {
+  const callSite = captureCallSite();
+  if (!callSite) {
+    return Effect.forkDaemon(effect);
   }
-  const supervisor = new SourceCaptureSupervisor(autoConfig);
-  const supervisorLayer = Supervisor.addSupervisor(supervisor);
-  logger.log("@atrim/source-capture: Creating layer");
-  logger.log("  - Source capture: ENABLED via Layer.enableSourceCapture");
-  logger.log("  - Effect.withSpan(): exports to OTel via our tracer");
-  logger.log("  - Forked fibers: auto-traced via SourceCaptureSupervisor");
-  const serviceName = process.env.OTEL_SERVICE_NAME || "effect-service";
-  const serviceVersion = process.env.npm_package_version || "1.0.0";
-  const otelTracer = OtelApi.trace.getTracer(serviceName, serviceVersion);
-  logger.log(`@atrim/source-capture: Using tracer "${serviceName}" from our provider`);
-  const effectTracerLayer = Tracer$1.layerWithoutOtelTracer.pipe(
-    Layer.provide(Layer.succeed(Tracer$1.OtelTracer, otelTracer))
+  return FiberRef.set(CapturedSourceLocation, callSite).pipe(
+    Effect.zipRight(Effect.forkDaemon(effect))
   );
-  return Layer.mergeAll(effectTracerLayer, Layer.enableSourceCapture, supervisorLayer);
-};
-var SourceCaptureTracingLive = createSourceCaptureTracingLayer();
-var withoutSourceCapture = (effect) => Effect.withCaptureStackTraces(false)(effect);
-var flushAndShutdown = async () => {
-  if (globalProviderSetup?.provider) {
-    logger.log("@atrim/source-capture: Flushing and shutting down TracerProvider...");
-    await globalProviderSetup.provider.forceFlush();
-    await globalProviderSetup.provider.shutdown();
-    logger.log("@atrim/source-capture: TracerProvider shutdown complete");
-  }
-};
-var forceFlush = async () => {
-  if (globalProviderSetup?.provider) {
-    logger.log("@atrim/source-capture: Force flushing TracerProvider...");
-    await globalProviderSetup.provider.forceFlush();
-    logger.log("@atrim/source-capture: Force flush complete");
-  }
 };
-var defaultSpanNaming = {
-  includeLocation: true,
-  template: "effect.{op} ({filename}:{line})"
-};
-function parseSourceLocation(stack) {
-  const lines = stack.split("\n");
-  for (const line of lines.slice(1)) {
-    if (line.includes("node_modules") || line.includes("/effect/") || line.includes("fiberRuntime.ts") || line.includes("core.ts")) {
-      continue;
-    }
-    const match = line.match(/at\s+(?:.*?\s+\()?(.+):(\d+):(\d+)\)?/);
-    if (match && match[1] && match[2]) {
-      return {
-        file: match[1],
-        line: parseInt(match[2], 10),
-        column: match[3] ? parseInt(match[3], 10) : void 0
-      };
-    }
-  }
-  return void 0;
+
+// src/integrations/effect/auto/patch-fork.ts
+init_dist();
+var patchAttempted = false;
+function isEffectForkPatched() {
+  return false;
 }
-function getOperationMeta(effect) {
-  const trace5 = effect.trace;
-  if (trace5 && trace5._tag === "OperationMeta") {
-    return trace5;
+function patchEffectFork() {
+  if (patchAttempted) {
+    return;
   }
-  return void 0;
+  patchAttempted = true;
+  logger.log("@atrim/auto-trace: Effect.fork auto-patching not available (ESM limitation)");
+  logger.log("@atrim/auto-trace: Use tracedFork() for call-site capture");
 }
-function applyTemplate2(template, vars) {
-  return template.replace(/\{op\}/g, vars.op).replace(/\{file\}/g, vars.file).replace(/\{filename\}/g, vars.filename).replace(/\{line\}/g, vars.line).replace(/\{column\}/g, vars.column);
+function unpatchEffectFork() {
+  patchAttempted = false;
 }
-var OperationTracingSupervisor = class extends Supervisor.AbstractSupervisor {
-  constructor(operations, spanNaming = defaultSpanNaming) {
-    super();
-    // Map of configured operations by name
-    __publicField(this, "configuredOps");
-    // Global span naming configuration
-    __publicField(this, "spanNaming");
-    // Track processed effects to avoid duplicate spans (using WeakSet for GC)
-    __publicField(this, "processedEffects", /* @__PURE__ */ new WeakSet());
-    // Track spans per fiber for proper lifecycle management
-    __publicField(this, "fiberSpans", /* @__PURE__ */ new WeakMap());
-    // OpenTelemetry tracer - lazily initialized
-    __publicField(this, "_tracer", null);
-    this.configuredOps = new Map(operations.map((op) => [op.name, op]));
-    this.spanNaming = spanNaming;
-    logger.log("@atrim/operation-tracing: Supervisor initialized");
-    logger.log(`  Configured operations: ${Array.from(this.configuredOps.keys()).join(", ")}`);
-  }
-  /**
-   * Get the tracer lazily from global OTel API
-   */
-  get tracer() {
-    if (!this._tracer) {
-      this._tracer = OtelApi.trace.getTracer("@atrim/operation-tracing", "1.0.0");
-    }
-    return this._tracer;
-  }
-  /**
-   * Returns the current value (void for this supervisor)
-   */
-  get value() {
-    return 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(fiber, effect) {
-    if (this.processedEffects.has(effect)) {
-      return;
-    }
-    const meta = getOperationMeta(effect);
-    if (!meta) {
-      return;
-    }
-    const config = this.configuredOps.get(meta.op);
-    if (!config) {
-      return;
-    }
-    this.processedEffects.add(effect);
-    const fiberId = fiber.id().id;
-    logger.log(`@atrim/operation-tracing: Found operation "${meta.op}" in fiber ${fiberId}`);
-    ({
-      "effect.operation": meta.op
-    });
-    if (config.includeCount && meta.count !== void 0) {
-      meta.count;
-    }
-    const location = config.includeStack ? parseSourceLocation(meta.capturedAt) : void 0;
-    if (config.includeStack && location) {
-      location.file;
-      location.line;
-      if (location.column !== void 0) {
-        location.column;
-      }
-    }
-    let spanName;
-    const templateVars = {
-      op: meta.op,
-      file: location?.file ?? "unknown",
-      filename: location?.file?.split("/").pop() ?? "unknown",
-      line: location?.line?.toString() ?? "0",
-      column: location?.column?.toString() ?? "0"
-    };
-    if (config.spanNameTemplate) {
-      spanName = applyTemplate2(config.spanNameTemplate, templateVars);
-    } else if (this.spanNaming.includeLocation && location) {
-      spanName = applyTemplate2(this.spanNaming.template, templateVars);
-    } else {
-      spanName = `effect.${meta.op}`;
-    }
-    let parentContext = OtelApi.ROOT_CONTEXT;
-    const fiberContext = fiber.currentContext;
-    const maybeEffectParentSpan = Context.getOption(fiberContext, TracerModule.ParentSpan);
-    if (Option.isSome(maybeEffectParentSpan)) {
-      const effectSpan = maybeEffectParentSpan.value;
-      parentContext = OtelApi.trace.setSpan(
-        OtelApi.ROOT_CONTEXT,
-        OtelApi.trace.wrapSpanContext({
-          traceId: effectSpan.traceId,
-          spanId: effectSpan.spanId,
-          traceFlags: OtelApi.TraceFlags.SAMPLED
-        })
-      );
-      logger.log(
-        `@atrim/operation-tracing: Using parent span traceId=${effectSpan.traceId.slice(0, 8)}...`
-      );
-    }
-    const span = this.tracer.startSpan(
-      spanName,
-      {
-        kind: OtelApi.SpanKind.INTERNAL
-      },
-      parentContext
-    );
-    span.setAttribute("effect.operation", meta.op);
-    if (config.includeCount && meta.count !== void 0) {
-      span.setAttribute("effect.item_count", meta.count);
-    }
-    if (config.includeStack && location) {
-      span.setAttribute("code.filepath", location.file);
-      span.setAttribute("code.lineno", location.line);
-      if (location.column !== void 0) {
-        span.setAttribute("code.column", location.column);
-      }
-    }
-    logger.log(
-      `@atrim/operation-tracing: Created span "${spanName}" - spanId=${span.spanContext().spanId}`
-    );
-    span.setStatus({ code: OtelApi.SpanStatusCode.OK });
-    span.end();
-    logger.log(`@atrim/operation-tracing: Ended span "${spanName}"`);
-    let spanMap = this.fiberSpans.get(fiber);
-    if (!spanMap) {
-      spanMap = /* @__PURE__ */ new Map();
-      this.fiberSpans.set(fiber, spanMap);
-    }
-    const spanKey = `${meta.op}-${meta.capturedAt.slice(0, 100)}`;
-    spanMap.set(spanKey, span);
-  }
-  /**
-   * Called when a fiber starts - we don't need this for operation tracing
-   */
-  onStart() {
-  }
-  /**
-   * Called when a fiber ends - end all spans for this fiber
-   */
-  onEnd(exit, fiber) {
-    const spanMap = this.fiberSpans.get(fiber);
-    if (!spanMap) {
-      return;
-    }
-    const isError = exit._tag === "Failure";
-    const fiberId = fiber.id().id;
-    for (const [_key, span] of spanMap) {
-      span.setStatus({
-        code: isError ? OtelApi.SpanStatusCode.ERROR : OtelApi.SpanStatusCode.OK
-      });
-      span.end();
-      logger.log(
-        `@atrim/operation-tracing: Ended span for fiber ${fiberId} (${isError ? "error" : "success"})`
-      );
-    }
-    this.fiberSpans.delete(fiber);
-  }
-};
-var defaultOperations = [
-  { name: "all", includeCount: true, includeStack: true },
-  { name: "forEach", includeCount: true, includeStack: true }
-];
-var makeOperationTracingLayer = (operations = defaultOperations, spanNaming = defaultSpanNaming) => {
-  const supervisor = new OperationTracingSupervisor(operations, spanNaming);
-  return Supervisor.addSupervisor(supervisor);
-};
-var enableOpSupervision = (effect) => Effect.withRuntimeFlagsPatch(effect, RuntimeFlagsPatch.enable(RuntimeFlags.OpSupervision));
-var loadOperationTracingLayer = () => Layer.unwrapEffect(
-  Effect.gen(function* () {
-    const config = yield* Effect.tryPromise({
-      try: () => loadConfigWithOptions(),
-      catch: (error) => {
-        logger.log(`@atrim/operation-tracing: Failed to load config: ${error}`);
-        return error;
-      }
-    }).pipe(Effect.catchAll(() => Effect.succeed(null)));
-    const opTracingConfig = config?.effect?.operation_tracing;
-    if (opTracingConfig?.enabled === false) {
-      logger.log("@atrim/operation-tracing: Operation tracing disabled in config");
-      return Layer.empty;
-    }
-    const spanNaming = {
-      includeLocation: opTracingConfig?.span_naming?.include_location ?? true,
-      template: opTracingConfig?.span_naming?.template ?? "effect.{op} ({filename}:{line})"
-    };
-    logger.log(
-      `@atrim/operation-tracing: Span naming - includeLocation=${spanNaming.includeLocation}, template="${spanNaming.template}"`
-    );
-    const operations = opTracingConfig?.operations ? opTracingConfig.operations.map((op) => ({
-      name: op.name,
-      ...op.span_name && { spanNameTemplate: op.span_name },
-      includeCount: op.include_count ?? true,
-      includeStack: op.include_stack ?? true
-    })) : defaultOperations;
-    const source = opTracingConfig?.operations ? "instrumentation.yaml" : "defaults";
-    logger.log(
-      `@atrim/operation-tracing: Loaded ${operations.length} operation configs from ${source}`
-    );
-    return makeOperationTracingLayer(operations, spanNaming);
-  })
-);
-var OperationTracingLive = loadOperationTracingLayer();
-var withOperationTracing = (effect) => effect.pipe(enableOpSupervision, Effect.provide(OperationTracingLive));
 
-export { AutoTracingConfig, AutoTracingConfigLayer, AutoTracingConfigLive, AutoTracingEnabled, AutoTracingLive, AutoTracingSpanName, AutoTracingSupervisor, CapturedSourceLocation, CombinedTracingLive, EffectTracingLive, FullAutoTracingLive, OperationTracingLive, OperationTracingSupervisor, SourceCaptureSupervisor, SourceCaptureTracingLive, 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 };
+// src/integrations/effect/auto/index.ts
+init_unified_tracing_supervisor();
+init_unified_tracing_supervisor();
+init_unified_tracing_supervisor();
+init_unified_tracing_supervisor();
+init_unified_tracing_supervisor();
+init_unified_tracing_supervisor();
+init_unified_tracing_supervisor();
+init_unified_tracing_supervisor();
+init_unified_tracing_supervisor();
+init_unified_tracing_supervisor();
+init_unified_tracing_supervisor();
+var createAutoTracingSupervisor = (config) => new (init_unified_tracing_supervisor(), __toCommonJS(unified_tracing_supervisor_exports)).UnifiedTracingSupervisor(config);
+
+export { AutoTracingConfig, AutoTracingConfigLayer, AutoTracingConfigLive, AutoTracingEnabled, UnifiedTracingLive as AutoTracingLive, AutoTracingSpanName, UnifiedTracingSupervisor as AutoTracingSupervisor, CapturedSourceLocation, UnifiedTracingLive as CombinedTracingLive, UnifiedTracingLive as FullAutoTracingLive, UnifiedTracingLive as OperationTracingLive, UnifiedTracingSupervisor as SourceCaptureSupervisor, UnifiedTracingLive as SourceCaptureTracingLive, 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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map