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

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

@@ -1,12 +1,6 @@
 'use strict';
 
 var effect = require('effect');
-var opentelemetry = require('@effect/opentelemetry');
-var sdkTraceBase = require('@opentelemetry/sdk-trace-base');
-var exporterTraceOtlpHttp = require('@opentelemetry/exporter-trace-otlp-http');
-var resources = require('@opentelemetry/resources');
-var semanticConventions = require('@opentelemetry/semantic-conventions');
-var OtelApi = require('@opentelemetry/api');
 var FileSystem = require('@effect/platform/FileSystem');
 var HttpClient = require('@effect/platform/HttpClient');
 var HttpClientRequest = require('@effect/platform/HttpClientRequest');
@@ -15,6 +9,12 @@ var zod = require('zod');
 var fs = require('fs');
 var path2 = require('path');
 var TracerModule = require('effect/Tracer');
+var opentelemetry = require('@effect/opentelemetry');
+var OtelApi = require('@opentelemetry/api');
+var sdkTraceBase = require('@opentelemetry/sdk-trace-base');
+var exporterTraceOtlpHttp = require('@opentelemetry/exporter-trace-otlp-http');
+var resources = require('@opentelemetry/resources');
+var semanticConventions = require('@opentelemetry/semantic-conventions');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -34,258 +34,36 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var OtelApi__namespace = /*#__PURE__*/_interopNamespace(OtelApi);
 var HttpClient__namespace = /*#__PURE__*/_interopNamespace(HttpClient);
 var HttpClientRequest__namespace = /*#__PURE__*/_interopNamespace(HttpClientRequest);
 var yaml__namespace = /*#__PURE__*/_interopNamespace(yaml);
 var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
 var path2__namespace = /*#__PURE__*/_interopNamespace(path2);
 var TracerModule__namespace = /*#__PURE__*/_interopNamespace(TracerModule);
+var OtelApi__namespace = /*#__PURE__*/_interopNamespace(OtelApi);
 
 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 = zod.z.object({
-  pattern: zod.z.string(),
-  enabled: zod.z.boolean().optional(),
-  description: zod.z.string().optional()
-});
-var AutoIsolationConfigSchema = zod.z.object({
-  // Global enable/disable for auto-isolation
-  enabled: zod.z.boolean().default(false),
-  // Which operators to auto-isolate
-  operators: zod.z.object({
-    fiberset_run: zod.z.boolean().default(true),
-    effect_fork: zod.z.boolean().default(true),
-    effect_fork_daemon: zod.z.boolean().default(true),
-    effect_fork_in: zod.z.boolean().default(false)
-  }).default({}),
-  // Virtual parent tracking configuration
-  tracking: zod.z.object({
-    use_span_links: zod.z.boolean().default(true),
-    use_attributes: zod.z.boolean().default(true),
-    capture_logical_parent: zod.z.boolean().default(true)
-  }).default({}),
-  // Span categorization
-  attributes: zod.z.object({
-    category: zod.z.string().default("background_task"),
-    add_metadata: zod.z.boolean().default(true)
-  }).default({})
-});
-var SpanNamingRuleSchema = zod.z.object({
-  // Match criteria (all specified criteria must match)
-  match: zod.z.object({
-    // Regex pattern to match file path
-    file: zod.z.string().optional(),
-    // Regex pattern to match function name
-    function: zod.z.string().optional(),
-    // Regex pattern to match module name
-    module: zod.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: zod.z.string()
-});
-var AutoInstrumentationConfigSchema = zod.z.object({
-  // Enable/disable auto-instrumentation
-  enabled: zod.z.boolean().default(false),
-  // Tracing granularity
-  // - 'fiber': Trace at fiber creation (recommended, lower overhead)
-  // - 'operator': Trace each Effect operator (higher granularity, more overhead)
-  granularity: zod.z.enum(["fiber", "operator"]).default("fiber"),
-  // Smart span naming configuration
-  span_naming: zod.z.object({
-    // Default span name template when no rules match
-    default: zod.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: zod.z.boolean().default(true),
-    // Naming rules (first match wins)
-    rules: zod.z.array(SpanNamingRuleSchema).default([])
-  }).default({}),
-  // Span relationship configuration for forked fibers
-  // Controls how child fiber spans relate to their parent/forking context
-  span_relationships: zod.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: zod.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: zod.z.object({
-      // Link type identifier
-      "link.type": zod.z.string().default("fork"),
-      // Custom attributes (key-value pairs)
-      custom: zod.z.record(zod.z.string()).optional()
-    }).optional()
-  }).default({}),
-  // Pattern-based filtering
-  filter: zod.z.object({
-    // Only trace spans matching these patterns (empty = trace all)
-    include: zod.z.array(zod.z.string()).default([]),
-    // Never trace spans matching these patterns
-    exclude: zod.z.array(zod.z.string()).default([])
-  }).default({}),
-  // Performance controls
-  performance: zod.z.object({
-    // Sample rate (0.0 - 1.0)
-    sampling_rate: zod.z.number().min(0).max(1).default(1),
-    // Skip fibers shorter than this duration (e.g., "10ms", "100 millis")
-    min_duration: zod.z.string().default("0ms"),
-    // Maximum concurrent traced fibers (0 = unlimited)
-    max_concurrent: zod.z.number().default(0)
-  }).default({}),
-  // Automatic metadata extraction
-  metadata: zod.z.object({
-    // Extract Effect fiber information
-    fiber_info: zod.z.boolean().default(true),
-    // Extract source location (file:line)
-    source_location: zod.z.boolean().default(true),
-    // Extract parent fiber information
-    parent_fiber: zod.z.boolean().default(true)
-  }).default({})
-});
-var OperationTracingConfigSchema = zod.z.object({
-  // Enable/disable operation tracing
-  enabled: zod.z.boolean().default(false),
-  // Global span naming settings
-  span_naming: zod.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: zod.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: zod.z.string().default("effect.{op} ({filename}:{line})")
-  }).default({}),
-  // Operations to trace
-  operations: zod.z.array(
-    zod.z.object({
-      // Operation name: 'all', 'forEach', 'retry', etc.
-      name: zod.z.string(),
-      // Custom span name template (overrides global span_naming.template)
-      // Supports same variables: {op}, {file}, {filename}, {line}, {column}
-      span_name: zod.z.string().optional(),
-      // Include item count in span attributes
-      include_count: zod.z.boolean().default(true),
-      // Include stack trace in span attributes
-      include_stack: zod.z.boolean().default(true)
-    })
-  ).default([])
-});
-var HttpFilteringConfigSchema = zod.z.object({
-  // Patterns to ignore for outgoing HTTP requests (string patterns only in YAML)
-  ignore_outgoing_urls: zod.z.array(zod.z.string()).optional(),
-  // Patterns to ignore for incoming HTTP requests (string patterns only in YAML)
-  ignore_incoming_paths: zod.z.array(zod.z.string()).optional(),
-  // Require parent span for outgoing requests (prevents root spans for HTTP calls)
-  require_parent_for_outgoing_spans: zod.z.boolean().optional(),
-  // Trace context propagation configuration
-  // Controls which cross-origin requests receive W3C Trace Context headers (traceparent, tracestate)
-  propagate_trace_context: zod.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: zod.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: zod.z.array(zod.z.string()).optional()
-  }).optional()
-});
-var ExporterConfigSchema = zod.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: zod.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: zod.z.string().optional(),
-  // Custom headers to send with OTLP requests (for type: otlp)
-  // Useful for authentication (x-api-key, Authorization, etc.)
-  headers: zod.z.record(zod.z.string()).optional(),
-  // Span processor type
-  // - 'batch': Batch spans for export (production, lower overhead)
-  // - 'simple': Export immediately (development, no batching delay)
-  processor: zod.z.enum(["batch", "simple"]).default("batch"),
-  // Batch processor settings (for processor: batch)
-  batch: zod.z.object({
-    // Max time to wait before exporting (milliseconds)
-    scheduled_delay_millis: zod.z.number().default(1e3),
-    // Max batch size
-    max_export_batch_size: zod.z.number().default(100)
-  }).optional()
-});
-var InstrumentationConfigSchema = zod.z.object({
-  version: zod.z.string(),
-  instrumentation: zod.z.object({
-    enabled: zod.z.boolean(),
-    description: zod.z.string().optional(),
-    logging: zod.z.enum(["on", "off", "minimal"]).optional().default("on"),
-    instrument_patterns: zod.z.array(PatternConfigSchema),
-    ignore_patterns: zod.z.array(PatternConfigSchema)
-  }),
-  effect: zod.z.object({
-    // Enable/disable Effect tracing entirely
-    // When false, EffectInstrumentationLive returns Layer.empty
-    enabled: zod.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: zod.z.enum(["unified", "standalone"]).default("unified"),
-    // Exporter configuration (for auto-instrumentation)
-    exporter_config: ExporterConfigSchema.optional(),
-    auto_extract_metadata: zod.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") {
@@ -295,262 +73,508 @@ function parseAndValidateConfig(content) {
   }
   return InstrumentationConfigSchema.parse(parsed);
 }
-(class extends effect.Data.TaggedError("ConfigError") {
-  get message() {
-    return this.reason;
-  }
-});
-var ConfigUrlError = class extends effect.Data.TaggedError("ConfigUrlError") {
-  get message() {
-    return this.reason;
-  }
-};
-var ConfigValidationError = class extends effect.Data.TaggedError("ConfigValidationError") {
-  get message() {
-    return this.reason;
-  }
-};
-var ConfigFileError = class extends effect.Data.TaggedError("ConfigFileError") {
-  get message() {
-    return this.reason;
-  }
-};
-(class extends effect.Data.TaggedError("ServiceDetectionError") {
-  get message() {
-    return this.reason;
-  }
-});
-(class extends effect.Data.TaggedError("InitializationError") {
-  get message() {
-    return this.reason;
-  }
-});
-(class extends effect.Data.TaggedError("ExportError") {
-  get message() {
-    return this.reason;
-  }
-});
-(class extends effect.Data.TaggedError("ShutdownError") {
-  get message() {
-    return this.reason;
-  }
-});
-var SECURITY_DEFAULTS = {
-  maxConfigSize: 1e6,
-  // 1MB
-  requestTimeout: 5e3
-  // 5 seconds
-};
-var ConfigLoader = class extends effect.Context.Tag("ConfigLoader")() {
-};
-var parseYamlContent = (content, uri) => effect.Effect.gen(function* () {
-  const parsed = yield* effect.Effect.try({
-    try: () => yaml.parse(content),
-    catch: (error) => new ConfigValidationError({
-      reason: uri ? `Failed to parse YAML from ${uri}` : "Failed to parse YAML",
-      cause: error
-    })
-  });
-  return yield* effect.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.Effect.gen(function* () {
-  const content = yield* fs3.readFileString(path3).pipe(
-    effect.Effect.mapError(
-      (error) => new ConfigFileError({
-        reason: `Failed to read config file at ${uri}`,
-        cause: error
-      })
-    )
-  );
-  if (content.length > SECURITY_DEFAULTS.maxConfigSize) {
-    return yield* effect.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.Effect.scoped(
-  effect.Effect.gen(function* () {
-    if (url.startsWith("http://")) {
-      return yield* effect.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 = zod.z.object({
+      pattern: zod.z.string(),
+      enabled: zod.z.boolean().optional(),
+      description: zod.z.string().optional()
+    });
+    AutoIsolationConfigSchema = zod.z.object({
+      // Global enable/disable for auto-isolation
+      enabled: zod.z.boolean().default(false),
+      // Which operators to auto-isolate
+      operators: zod.z.object({
+        fiberset_run: zod.z.boolean().default(true),
+        effect_fork: zod.z.boolean().default(true),
+        effect_fork_daemon: zod.z.boolean().default(true),
+        effect_fork_in: zod.z.boolean().default(false)
+      }).default({}),
+      // Virtual parent tracking configuration
+      tracking: zod.z.object({
+        use_span_links: zod.z.boolean().default(true),
+        use_attributes: zod.z.boolean().default(true),
+        capture_logical_parent: zod.z.boolean().default(true)
+      }).default({}),
+      // Span categorization
+      attributes: zod.z.object({
+        category: zod.z.string().default("background_task"),
+        add_metadata: zod.z.boolean().default(true)
+      }).default({})
+    });
+    SpanNamingRuleSchema = zod.z.object({
+      // Match criteria (all specified criteria must match)
+      match: zod.z.object({
+        // Regex pattern to match file path
+        file: zod.z.string().optional(),
+        // Regex pattern to match function name
+        function: zod.z.string().optional(),
+        // Regex pattern to match module name
+        module: zod.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: zod.z.string()
+    });
+    AutoInstrumentationConfigSchema = zod.z.object({
+      // Enable/disable auto-instrumentation
+      enabled: zod.z.boolean().default(false),
+      // Tracing granularity
+      // - 'fiber': Trace at fiber creation (recommended, lower overhead)
+      // - 'operator': Trace each Effect operator (higher granularity, more overhead)
+      granularity: zod.z.enum(["fiber", "operator"]).default("fiber"),
+      // Smart span naming configuration
+      span_naming: zod.z.object({
+        // Default span name template when no rules match
+        default: zod.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: zod.z.boolean().default(true),
+        // Naming rules (first match wins)
+        rules: zod.z.array(SpanNamingRuleSchema).default([])
+      }).default({}),
+      // Span relationship configuration for forked fibers
+      // Controls how child fiber spans relate to their parent/forking context
+      span_relationships: zod.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: zod.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: zod.z.object({
+          // Link type identifier
+          "link.type": zod.z.string().default("fork"),
+          // Custom attributes (key-value pairs)
+          custom: zod.z.record(zod.z.string()).optional()
+        }).optional()
+      }).default({}),
+      // Pattern-based filtering
+      filter: zod.z.object({
+        // Only trace spans matching these patterns (empty = trace all)
+        include: zod.z.array(zod.z.string()).default([]),
+        // Never trace spans matching these patterns
+        exclude: zod.z.array(zod.z.string()).default([])
+      }).default({}),
+      // Performance controls
+      performance: zod.z.object({
+        // Sample rate (0.0 - 1.0)
+        sampling_rate: zod.z.number().min(0).max(1).default(1),
+        // Skip fibers shorter than this duration (e.g., "10ms", "100 millis")
+        min_duration: zod.z.string().default("0ms"),
+        // Maximum concurrent traced fibers (0 = unlimited)
+        max_concurrent: zod.z.number().default(0)
+      }).default({}),
+      // Automatic metadata extraction
+      metadata: zod.z.object({
+        // Extract Effect fiber information
+        fiber_info: zod.z.boolean().default(true),
+        // Extract source location (file:line)
+        source_location: zod.z.boolean().default(true),
+        // Extract parent fiber information
+        parent_fiber: zod.z.boolean().default(true)
+      }).default({})
+    });
+    OperationTracingConfigSchema = zod.z.object({
+      // Enable/disable operation tracing
+      enabled: zod.z.boolean().default(false),
+      // Global span naming settings
+      span_naming: zod.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: zod.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: zod.z.string().default("effect.{op} ({filename}:{line})")
+      }).default({}),
+      // Operations to trace
+      operations: zod.z.array(
+        zod.z.object({
+          // Operation name: 'all', 'forEach', 'retry', etc.
+          name: zod.z.string(),
+          // Custom span name template (overrides global span_naming.template)
+          // Supports same variables: {op}, {file}, {filename}, {line}, {column}
+          span_name: zod.z.string().optional(),
+          // Include item count in span attributes
+          include_count: zod.z.boolean().default(true),
+          // Include stack trace in span attributes
+          include_stack: zod.z.boolean().default(true)
         })
-      );
-    }
-    const request = HttpClientRequest__namespace.get(url).pipe(
-      HttpClientRequest__namespace.setHeaders({
-        Accept: "application/yaml, text/yaml, application/x-yaml"
-      })
-    );
-    const response = yield* client.execute(request).pipe(
-      effect.Effect.timeout(`${SECURITY_DEFAULTS.requestTimeout} millis`),
-      effect.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 = zod.z.object({
+      // Patterns to ignore for outgoing HTTP requests (string patterns only in YAML)
+      ignore_outgoing_urls: zod.z.array(zod.z.string()).optional(),
+      // Patterns to ignore for incoming HTTP requests (string patterns only in YAML)
+      ignore_incoming_paths: zod.z.array(zod.z.string()).optional(),
+      // Require parent span for outgoing requests (prevents root spans for HTTP calls)
+      require_parent_for_outgoing_spans: zod.z.boolean().optional(),
+      // Trace context propagation configuration
+      // Controls which cross-origin requests receive W3C Trace Context headers (traceparent, tracestate)
+      propagate_trace_context: zod.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: zod.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: zod.z.array(zod.z.string()).optional()
+      }).optional()
+    });
+    ExporterConfigSchema = zod.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: zod.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: zod.z.string().optional(),
+      // Custom headers to send with OTLP requests (for type: otlp)
+      // Useful for authentication (x-api-key, Authorization, etc.)
+      headers: zod.z.record(zod.z.string()).optional(),
+      // Span processor type
+      // - 'batch': Batch spans for export (production, lower overhead)
+      // - 'simple': Export immediately (development, no batching delay)
+      processor: zod.z.enum(["batch", "simple"]).default("batch"),
+      // Batch processor settings (for processor: batch)
+      batch: zod.z.object({
+        // Max time to wait before exporting (milliseconds)
+        scheduled_delay_millis: zod.z.number().default(1e3),
+        // Max batch size
+        max_export_batch_size: zod.z.number().default(100)
+      }).optional()
+    });
+    InstrumentationConfigSchema = zod.z.object({
+      version: zod.z.string(),
+      instrumentation: zod.z.object({
+        enabled: zod.z.boolean(),
+        description: zod.z.string().optional(),
+        logging: zod.z.enum(["on", "off", "minimal"]).optional().default("on"),
+        instrument_patterns: zod.z.array(PatternConfigSchema),
+        ignore_patterns: zod.z.array(PatternConfigSchema)
+      }),
+      effect: zod.z.object({
+        // Enable/disable Effect tracing entirely
+        // When false, EffectInstrumentationLive returns Layer.empty
+        enabled: zod.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: zod.z.enum(["unified", "standalone"]).default("unified"),
+        // Exporter configuration (for auto-instrumentation)
+        exporter_config: ExporterConfigSchema.optional(),
+        auto_extract_metadata: zod.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 effect.Data.TaggedError("ConfigError") {
+      get message() {
+        return this.reason;
+      }
+    });
+    ConfigUrlError = class extends effect.Data.TaggedError("ConfigUrlError") {
+      get message() {
+        return this.reason;
+      }
+    };
+    ConfigValidationError = class extends effect.Data.TaggedError("ConfigValidationError") {
+      get message() {
+        return this.reason;
+      }
+    };
+    ConfigFileError = class extends effect.Data.TaggedError("ConfigFileError") {
+      get message() {
+        return this.reason;
+      }
+    };
+    (class extends effect.Data.TaggedError("ServiceDetectionError") {
+      get message() {
+        return this.reason;
+      }
+    });
+    (class extends effect.Data.TaggedError("InitializationError") {
+      get message() {
+        return this.reason;
+      }
+    });
+    (class extends effect.Data.TaggedError("ExportError") {
+      get message() {
+        return this.reason;
+      }
+    });
+    (class extends effect.Data.TaggedError("ShutdownError") {
+      get message() {
+        return this.reason;
+      }
+    });
+    SECURITY_DEFAULTS = {
+      maxConfigSize: 1e6,
+      // 1MB
+      requestTimeout: 5e3
+      // 5 seconds
+    };
+    ConfigLoader = class extends effect.Context.Tag("ConfigLoader")() {
+    };
+    parseYamlContent = (content, uri) => effect.Effect.gen(function* () {
+      const parsed = yield* effect.Effect.try({
+        try: () => yaml.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.Effect.fail(
-        new ConfigUrlError({
-          reason: `HTTP ${response.status} from ${url}`
         })
-      );
-    }
-    const text = yield* response.text.pipe(
-      effect.Effect.mapError(
-        (error) => new ConfigUrlError({
-          reason: `Failed to read response body from ${url}`,
+      });
+      return yield* effect.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.Effect.fail(
-        new ConfigUrlError({
-          reason: `Config exceeds maximum size of ${SECURITY_DEFAULTS.maxConfigSize} bytes`
-        })
+      });
+    });
+    loadFromFileWithFs = (fs2, path3, uri) => effect.Effect.gen(function* () {
+      const content = yield* fs2.readFileString(path3).pipe(
+        effect.Effect.mapError(
+          (error) => new ConfigFileError({
+            reason: `Failed to read config file at ${uri}`,
+            cause: error
+          })
+        )
       );
-    }
-    return yield* parseYamlContent(text, url);
-  })
-);
-var makeConfigLoader = effect.Effect.gen(function* () {
-  const fs3 = yield* effect.Effect.serviceOption(FileSystem.FileSystem);
-  const http = yield* HttpClient__namespace.HttpClient;
-  const loadFromUriUncached = (uri) => effect.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.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.Effect.cachedFunction(loadFromUriUncached);
-  return ConfigLoader.of({
-    loadFromUri: loadFromUriCached,
-    loadFromInline: (content) => effect.Effect.gen(function* () {
-      if (typeof content === "string") {
-        return yield* parseYamlContent(content);
-      }
-      return yield* effect.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.Effect.scoped(
+      effect.Effect.gen(function* () {
+        if (url.startsWith("http://")) {
+          return yield* effect.Effect.fail(
+            new ConfigUrlError({
+              reason: "Insecure protocol: only HTTPS URLs are allowed"
+            })
+          );
+        }
+        const request = HttpClientRequest__namespace.get(url).pipe(
+          HttpClientRequest__namespace.setHeaders({
+            Accept: "application/yaml, text/yaml, application/x-yaml"
+          })
+        );
+        const response = yield* client.execute(request).pipe(
+          effect.Effect.timeout(`${SECURITY_DEFAULTS.requestTimeout} millis`),
+          effect.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.Effect.fail(
+            new ConfigUrlError({
+              reason: `HTTP ${response.status} from ${url}`
+            })
+          );
+        }
+        const text = yield* response.text.pipe(
+          effect.Effect.mapError(
+            (error) => new ConfigUrlError({
+              reason: `Failed to read response body from ${url}`,
+              cause: error
+            })
+          )
+        );
+        if (text.length > SECURITY_DEFAULTS.maxConfigSize) {
+          return yield* effect.Effect.fail(
+            new ConfigUrlError({
+              reason: `Config exceeds maximum size of ${SECURITY_DEFAULTS.maxConfigSize} bytes`
+            })
+          );
+        }
+        return yield* parseYamlContent(text, url);
+      })
+    );
+    makeConfigLoader = effect.Effect.gen(function* () {
+      const fs2 = yield* effect.Effect.serviceOption(FileSystem.FileSystem);
+      const http = yield* HttpClient__namespace.HttpClient;
+      const loadFromUriUncached = (uri) => effect.Effect.gen(function* () {
+        if (uri.startsWith("file://")) {
+          const path3 = uri.slice(7);
+          if (fs2._tag === "None") {
+            return yield* effect.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.Effect.cachedFunction(loadFromUriUncached);
+      return ConfigLoader.of({
+        loadFromUri: loadFromUriCached,
+        loadFromInline: (content) => effect.Effect.gen(function* () {
+          if (typeof content === "string") {
+            return yield* parseYamlContent(content);
+          }
+          return yield* effect.Effect.try({
+            try: () => InstrumentationConfigSchema.parse(content),
+            catch: (error) => new ConfigValidationError({
+              reason: "Invalid configuration schema",
+              cause: error
+            })
+          });
         })
       });
-    })
-  });
-});
-effect.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";
+    });
+    effect.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");
@@ -591,170 +615,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 effect.Context.Tag("AutoTracingConfig")() {
-};
-var loadAutoTracingConfig = (options) => effect.Effect.gen(function* () {
-  const config = yield* effect.Effect.tryPromise({
-    try: () => loadConfigWithOptions(options),
-    catch: (error) => {
-      logger.log(`@atrim/auto-trace: Failed to load config: ${error}`);
-      return error;
-    }
-  }).pipe(effect.Effect.catchAll(() => effect.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;
+});
+exports.defaultAutoTracingConfig = void 0; exports.AutoTracingConfig = void 0; exports.loadAutoTracingConfig = void 0; exports.loadAutoTracingConfigSync = void 0; exports.AutoTracingConfigLive = void 0; exports.AutoTracingConfigLayer = void 0; exports.loadFullConfigSync = void 0;
+var init_config = __esm({
+  "src/integrations/effect/auto/config.ts"() {
+    init_dist();
+    init_config_loader();
+    exports.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
+      }
+    };
+    exports.AutoTracingConfig = class extends effect.Context.Tag("AutoTracingConfig")() {
+    };
+    exports.loadAutoTracingConfig = (options) => effect.Effect.gen(function* () {
+      const config = yield* effect.Effect.tryPromise({
+        try: () => loadConfigWithOptions(options),
+        catch: (error) => {
+          logger.log(`@atrim/auto-trace: Failed to load config: ${error}`);
+          return error;
+        }
+      }).pipe(effect.Effect.catchAll(() => effect.Effect.succeed(null)));
+      if (!config) {
+        logger.log("@atrim/auto-trace: No config found, using defaults");
+        return exports.defaultAutoTracingConfig;
+      }
+      const autoConfig = config.effect?.auto_instrumentation;
+      if (!autoConfig) {
+        logger.log("@atrim/auto-trace: No auto_instrumentation config, using defaults");
+        return exports.defaultAutoTracingConfig;
+      }
+      const parsed = AutoInstrumentationConfigSchema.safeParse(autoConfig);
+      if (!parsed.success) {
+        logger.log(`@atrim/auto-trace: Invalid config, using defaults: ${parsed.error.message}`);
+        return exports.defaultAutoTracingConfig;
+      }
+      logger.log("@atrim/auto-trace: Loaded config from instrumentation.yaml");
+      return parsed.data;
+    });
+    exports.loadAutoTracingConfigSync = () => {
+      return exports.defaultAutoTracingConfig;
+    };
+    exports.AutoTracingConfigLive = effect.Layer.effect(exports.AutoTracingConfig, exports.loadAutoTracingConfig());
+    exports.AutoTracingConfigLayer = (config) => effect.Layer.succeed(exports.AutoTracingConfig, config);
+    exports.loadFullConfigSync = () => {
+      const defaultPath = path2__namespace.join(process.cwd(), "instrumentation.yaml");
+      try {
+        if (fs__namespace.existsSync(defaultPath)) {
+          const content = fs__namespace.readFileSync(defaultPath, "utf-8");
+          const parsed = yaml__namespace.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 = effect.Layer.effect(AutoTracingConfig, loadAutoTracingConfig());
-var AutoTracingConfigLayer = (config) => effect.Layer.succeed(AutoTracingConfig, config);
-var loadFullConfig = (options) => effect.Effect.gen(function* () {
-  const config = yield* effect.Effect.tryPromise({
-    try: () => loadConfigWithOptions(options),
-    catch: (error) => {
-      logger.log(`@atrim/auto-trace: Failed to load config: ${error}`);
-      return error;
-    }
-  }).pipe(effect.Effect.catchAll(() => effect.Effect.succeed(null)));
-  if (!config) {
-    logger.log("@atrim/auto-trace: No config found, using defaults");
-    return defaultConfig;
+exports.AutoTracingEnabled = void 0; exports.AutoTracingSpanName = void 0; exports.withoutAutoTracing = void 0; exports.setSpanName = void 0;
+var init_span_control = __esm({
+  "src/integrations/effect/auto/span-control.ts"() {
+    exports.AutoTracingEnabled = effect.FiberRef.unsafeMake(true);
+    exports.AutoTracingSpanName = effect.FiberRef.unsafeMake(effect.Option.none());
+    exports.withoutAutoTracing = (effect$1) => effect$1.pipe(effect.Effect.locally(exports.AutoTracingEnabled, false));
+    exports.setSpanName = (name) => (effect$1) => effect$1.pipe(effect.Effect.locally(exports.AutoTracingSpanName, effect.Option.some(name)));
   }
-  return config;
 });
-var loadFullConfigSync = () => {
-  const defaultPath = path2__namespace.join(process.cwd(), "instrumentation.yaml");
-  try {
-    if (fs__namespace.existsSync(defaultPath)) {
-      const content = fs__namespace.readFileSync(defaultPath, "utf-8");
-      const parsed = yaml__namespace.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: () => exports.AutoTracingEnabled,
+  AutoTracingSpanName: () => exports.AutoTracingSpanName,
+  UnifiedTracingLive: () => exports.UnifiedTracingLive,
+  UnifiedTracingSupervisor: () => exports.UnifiedTracingSupervisor,
+  createUnifiedTracingLayer: () => exports.createUnifiedTracingLayer,
+  enableOpSupervision: () => exports.enableOpSupervision,
+  flushAndShutdown: () => exports.flushAndShutdown,
+  forceFlush: () => exports.forceFlush,
+  setSpanName: () => exports.setSpanName,
+  withAutoTracing: () => exports.withAutoTracing,
+  withUnifiedTracing: () => exports.withUnifiedTracing,
+  withoutAutoTracing: () => exports.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 = effect.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$1) => {
-  const callSite = captureCallSite();
-  if (!callSite) {
-    return effect.Effect.fork(effect$1);
-  }
-  return effect.FiberRef.set(CapturedSourceLocation, callSite).pipe(effect.Effect.zipRight(effect.Effect.fork(effect$1)));
-};
-var tracedForkDaemon = (effect$1) => {
-  const callSite = captureCallSite();
-  if (!callSite) {
-    return effect.Effect.forkDaemon(effect$1);
+function makeSourceKey(source) {
+  if (!source) return "unknown";
+  return `${source.file}:${source.line}`;
+}
+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();
   }
-  return effect.FiberRef.set(CapturedSourceLocation, callSite).pipe(
-    effect.Effect.zipRight(effect.Effect.forkDaemon(effect$1))
-  );
-};
-
-// src/integrations/effect/auto/patch-fork.ts
-var patchAttempted = false;
-function isEffectForkPatched() {
-  return false;
+  return _globalProviderSetup;
 }
-function patchEffectFork() {
-  if (patchAttempted) {
-    return;
+var currentSourceLocation; exports.UnifiedTracingSupervisor = void 0; var setupGlobalTracerProvider, _globalProviderSetup; exports.createUnifiedTracingLayer = void 0; exports.UnifiedTracingLive = void 0; exports.enableOpSupervision = void 0; exports.withUnifiedTracing = void 0; exports.withAutoTracing = void 0; exports.flushAndShutdown = void 0; exports.forceFlush = void 0;
+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 = effect.GlobalValue.globalValue(
+      /* @__PURE__ */ Symbol.for("effect/FiberRef/currentSourceLocation"),
+      () => effect.FiberRef.unsafeMake(void 0)
+    );
+    exports.UnifiedTracingSupervisor = class extends effect.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__namespace.trace.getTracer("@atrim/unified-tracing", "1.0.0");
+        }
+        return this._tracer;
+      }
+      get value() {
+        return effect.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__namespace.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__namespace.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__namespace.SpanStatusCode.OK });
+          span.end();
+        }
+      }
+      // ==========================================================================
+      // onStart - Fiber-level tracing
+      // ==========================================================================
+      onStart(_context, _effect, parent, fiber) {
+        const fiberId = fiber.id().id;
+        const fiberRefs = fiber.getFiberRefs();
+        const enabled = effect.FiberRefs.getOrDefault(fiberRefs, exports.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 = effect.FiberRefs.getOrDefault(fiberRefs, exports.AutoTracingSpanName);
+        const sourceLocation = effect.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__namespace.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 (effect.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__namespace.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 (effect.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__namespace.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 (effect.Exit.isSuccess(exit)) {
+          span.setStatus({ code: OtelApi__namespace.SpanStatusCode.OK });
+        } else {
+          span.setStatus({ code: OtelApi__namespace.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 = effect.Context.getOption(fiberContext, effect.Tracer.ParentSpan);
+        if (effect.Option.isSome(maybeParentSpan)) {
+          const effectSpan = maybeParentSpan.value;
+          return OtelApi__namespace.trace.setSpan(
+            OtelApi__namespace.ROOT_CONTEXT,
+            OtelApi__namespace.trace.wrapSpanContext({
+              traceId: effectSpan.traceId,
+              spanId: effectSpan.spanId,
+              traceFlags: OtelApi__namespace.TraceFlags.SAMPLED
+            })
+          );
+        }
+        return OtelApi__namespace.ROOT_CONTEXT;
+      }
+      resolveParentContextFromFiberRefs(fiberRefs, context2, parent) {
+        const inheritedCtx = effect.FiberRefs.getOrDefault(fiberRefs, TracerModule__namespace.currentOtelSpanContext);
+        if (inheritedCtx) {
+          const span = OtelApi__namespace.trace.getSpan(inheritedCtx);
+          if (span) {
+            logger.log(
+              `@atrim/unified-tracing: Using inherited OTel context from FiberRef - spanId=${span.spanContext().spanId}`
+            );
+          }
+          return inheritedCtx;
+        }
+        const maybeParentSpan = effect.Context.getOption(context2, effect.Tracer.ParentSpan);
+        if (effect.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__namespace.trace.setSpan(
+            OtelApi__namespace.ROOT_CONTEXT,
+            OtelApi__namespace.trace.wrapSpanContext({
+              traceId: effectSpan.traceId,
+              spanId: effectSpan.spanId,
+              traceFlags: OtelApi__namespace.TraceFlags.SAMPLED
+            })
+          );
+        }
+        const activeContext = OtelApi__namespace.context.active();
+        const activeSpan = OtelApi__namespace.trace.getSpan(activeContext);
+        if (activeSpan && activeSpan.spanContext().traceFlags === OtelApi__namespace.TraceFlags.SAMPLED) {
+          logger.log(
+            `@atrim/unified-tracing: Auto-bridging from active OTel context - spanId=${activeSpan.spanContext().spanId}`
+          );
+          return activeContext;
+        }
+        if (effect.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__namespace.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 = exports.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 sdkTraceBase.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 exporterTraceOtlpHttp.OTLPTraceExporter(otlpConfig);
+      }
+      let spanProcessor;
+      if (exporterConfig.processor === "simple" || exporterConfig.type === "console") {
+        spanProcessor = new sdkTraceBase.SimpleSpanProcessor(exporter);
+      } else {
+        const batchConfig = exporterConfig.batch ?? {
+          scheduled_delay_millis: 1e3,
+          max_export_batch_size: 100
+        };
+        spanProcessor = new sdkTraceBase.BatchSpanProcessor(exporter, {
+          scheduledDelayMillis: batchConfig.scheduled_delay_millis,
+          maxExportBatchSize: batchConfig.max_export_batch_size
+        });
+      }
+      const provider = new sdkTraceBase.BasicTracerProvider({
+        resource: resources.resourceFromAttributes({
+          [semanticConventions.ATTR_SERVICE_NAME]: serviceName,
+          [semanticConventions.ATTR_SERVICE_VERSION]: serviceVersion
+        }),
+        spanProcessors: [spanProcessor]
+      });
+      OtelApi__namespace.trace.setGlobalTracerProvider(provider);
+      logger.log("@atrim/unified-tracing: Global TracerProvider registered");
+      return { provider, spanProcessor };
+    };
+    exports.createUnifiedTracingLayer = () => {
+      const config = exports.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 effect.Layer.empty;
+      }
+      const supervisor = new exports.UnifiedTracingSupervisor(autoConfig);
+      const supervisorLayer = effect.Supervisor.addSupervisor(supervisor);
+      const serviceName = process.env.OTEL_SERVICE_NAME || "effect-service";
+      const serviceVersion = process.env.npm_package_version || "1.0.0";
+      const resourceLayer = opentelemetry.Resource.layer({ serviceName, serviceVersion });
+      const effectTracerLayer = opentelemetry.Tracer.layerGlobal;
+      const tracerWithResource = effectTracerLayer.pipe(effect.Layer.provide(resourceLayer));
+      const opSupervisionLayer = effect.Layer.effectDiscard(
+        effect.Effect.patchRuntimeFlags(effect.RuntimeFlagsPatch.enable(effect.RuntimeFlags.OpSupervision))
+      );
+      return effect.Layer.mergeAll(
+        effect.Layer.discard(tracerWithResource),
+        effect.Layer.enableSourceCapture,
+        supervisorLayer,
+        opSupervisionLayer
+      );
+    };
+    exports.UnifiedTracingLive = effect.Layer.suspend(
+      () => exports.createUnifiedTracingLayer()
+    );
+    exports.enableOpSupervision = (effect$1) => effect.Effect.withRuntimeFlagsPatch(effect$1, effect.RuntimeFlagsPatch.enable(effect.RuntimeFlags.OpSupervision));
+    exports.withUnifiedTracing = (effect$1) => effect$1.pipe(exports.enableOpSupervision, effect.Effect.provide(exports.UnifiedTracingLive));
+    exports.withAutoTracing = (effect$1, 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 exports.UnifiedTracingSupervisor(autoConfig);
+      const supervisorLayer = effect.Supervisor.addSupervisor(supervisor);
+      const opSupervisionLayer = effect.Layer.effectDiscard(
+        effect.Effect.patchRuntimeFlags(effect.RuntimeFlagsPatch.enable(effect.RuntimeFlags.OpSupervision))
+      );
+      const combinedLayer = effect.Layer.mergeAll(
+        supervisorLayer,
+        effect.Layer.enableSourceCapture,
+        opSupervisionLayer
+      );
+      const wrappedEffect = rootSpanName ? effect$1.pipe(effect.Effect.withSpan(rootSpanName)) : effect$1;
+      return wrappedEffect.pipe(effect.Effect.provide(combinedLayer));
+    };
+    exports.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");
+      }
+    };
+    exports.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");
+      }
+    };
   }
-  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;
-}
+});
+
+// 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);
@@ -875,1333 +1318,102 @@ function sanitizeSpanName(name) {
   }
   return sanitized;
 }
-
-// src/integrations/effect/auto/supervisor.ts
-var AutoTracingEnabled = effect.FiberRef.unsafeMake(true);
-var AutoTracingSpanName = effect.FiberRef.unsafeMake(effect.Option.none());
-var AutoTracingSupervisor = class extends effect.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__namespace.trace.getTracer("@atrim/auto-trace", "1.0.0");
-      }
-    }
-    return this._tracer;
-  }
-  /**
-   * Returns the current value (void for this supervisor)
-   */
-  get value() {
-    return effect.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 = effect.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 = effect.FiberRefs.getOrDefault(fiberRefsValue, AutoTracingSpanName);
-    let sourceInfo = effect.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 (effect.Option.isSome(nameOverride)) {
-      spanName = nameOverride.value;
-    } else {
-      spanName = inferSpanName(fiber.id().id, sourceInfo, this.config);
-    }
-    if (!this.shouldTrace(spanName)) {
-      return;
+var CapturedSourceLocation = effect.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 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__namespace.ROOT_CONTEXT;
-    let parentFiberId;
-    let spanLinks = [];
-    const maybeEffectParentSpan = effect.Context.getOption(_context, effect.Tracer.ParentSpan);
-    if (effect.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__namespace.TraceFlags.SAMPLED : OtelApi__namespace.TraceFlags.NONE,
-        isRemote: false
+    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)
       };
-      if (useParentChild) {
-        const wrappedSpan = OtelApi__namespace.trace.wrapSpanContext(otelSpanContext);
-        parentContext = OtelApi__namespace.trace.setSpan(OtelApi__namespace.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 (effect.Option.isSome(parent)) {
-      parentFiberId = parent.value.id().id;
-      const parentSpan = this.fiberSpans.get(parent.value);
-      if (parentSpan) {
-        if (useParentChild) {
-          parentContext = OtelApi__namespace.trace.setSpan(OtelApi__namespace.ROOT_CONTEXT, parentSpan);
-        }
-        if (useSpanLinks) {
-          const linkAttributes = this.getLinkAttributes();
-          spanLinks.push({
-            context: parentSpan.spanContext(),
-            attributes: linkAttributes
-          });
-        }
-      } else if (this._rootSpan) {
-        if (useParentChild) {
-          parentContext = OtelApi__namespace.trace.setSpan(OtelApi__namespace.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__namespace.trace.setSpan(OtelApi__namespace.ROOT_CONTEXT, this._rootSpan);
-      }
-      if (useSpanLinks) {
-        const linkAttributes = this.getLinkAttributes();
-        spanLinks.push({
-          context: this._rootSpan.spanContext(),
-          attributes: linkAttributes
-        });
-      }
-    }
-    if (effect.Option.isSome(parent)) {
-      parentFiberId = parent.value.id().id;
-    }
-    const spanOptions = {
-      kind: OtelApi__namespace.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 (effect.Exit.isSuccess(exit)) {
-      span.setStatus({ code: OtelApi__namespace.SpanStatusCode.OK });
-    } else {
-      span.setStatus({
-        code: OtelApi__namespace.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);
-    }
+  return void 0;
+}
+var tracedFork = (effect$1) => {
+  const callSite = captureCallSite();
+  if (!callSite) {
+    return effect.Effect.fork(effect$1);
   }
+  return effect.FiberRef.set(CapturedSourceLocation, callSite).pipe(effect.Effect.zipRight(effect.Effect.fork(effect$1)));
 };
-var createAutoTracingSupervisor = (config, tracerProvider) => {
-  return new AutoTracingSupervisor(config, tracerProvider);
-};
-var createAutoTracingLayer = (options) => {
-  return effect.Layer.unwrapEffect(
-    effect.Effect.gen(function* () {
-      const config = options?.config ?? (yield* loadAutoTracingConfig());
-      if (!config.enabled) {
-        logger.log("@atrim/auto-trace: Auto-tracing disabled via config");
-        return effect.Layer.empty;
-      }
-      patchEffectFork();
-      const supervisor = createAutoTracingSupervisor(config);
-      return effect.Supervisor.addSupervisor(supervisor);
-    })
-  );
-};
-var withAutoTracing = (effect$1, config, mainSpanName) => {
-  if (!config.enabled) {
-    logger.log("@atrim/auto-trace: Auto-tracing disabled via config");
-    return effect$1;
+var tracedForkDaemon = (effect$1) => {
+  const callSite = captureCallSite();
+  if (!callSite) {
+    return effect.Effect.forkDaemon(effect$1);
   }
-  const supervisor = createAutoTracingSupervisor(config);
-  const tracer = OtelApi__namespace.trace.getTracer("@atrim/auto-trace", "1.0.0");
-  const spanName = mainSpanName ?? inferSpanName(0, void 0, config);
-  const mainSpan = tracer.startSpan(spanName, {
-    kind: OtelApi__namespace.SpanKind.INTERNAL,
-    attributes: {
-      "effect.auto_traced": true,
-      "effect.fiber.id": 0,
-      // Main fiber
-      "effect.main_fiber": true
-    }
-  });
-  supervisor.setRootSpan(mainSpan);
-  return effect.Effect.acquireUseRelease(
-    // Acquire: return the span (already started)
-    effect.Effect.succeed(mainSpan),
-    // Use: run the supervised effect
-    () => effect.Effect.supervised(supervisor)(effect$1),
-    // Release: end the span
-    (span, exit) => effect.Effect.sync(() => {
-      if (effect.Exit.isSuccess(exit)) {
-        span.setStatus({ code: OtelApi__namespace.SpanStatusCode.OK });
-      } else {
-        span.setStatus({
-          code: OtelApi__namespace.SpanStatusCode.ERROR,
-          message: "Effect failed"
-        });
-      }
-      span.end();
-    })
+  return effect.FiberRef.set(CapturedSourceLocation, callSite).pipe(
+    effect.Effect.zipRight(effect.Effect.forkDaemon(effect$1))
   );
 };
-var AutoTracingLive = createAutoTracingLayer();
-var withoutAutoTracing = (effect$1) => effect$1.pipe(effect.Effect.locally(AutoTracingEnabled, false));
-var setSpanName = (name) => (effect$1) => effect$1.pipe(effect.Effect.locally(AutoTracingSpanName, effect.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 effect.Layer.empty;
-  }
-  const createSpanExporter = () => {
-    if (config.type === "console") {
-      logger.log("@atrim/auto-trace: Using ConsoleSpanExporter");
-      return new sdkTraceBase.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 exporterTraceOtlpHttp.OTLPTraceExporter(exporterConfig2);
-  };
-  const createSpanProcessor = () => {
-    const exporter = createSpanExporter();
-    if (config.processor === "simple" || config.type === "console") {
-      logger.log("@atrim/auto-trace: Using SimpleSpanProcessor");
-      return new sdkTraceBase.SimpleSpanProcessor(exporter);
-    }
-    const batchConfig = config.batch ?? {
-      scheduled_delay_millis: 1e3,
-      max_export_batch_size: 100
-    };
-    logger.log("@atrim/auto-trace: Using BatchSpanProcessor");
-    return new sdkTraceBase.BatchSpanProcessor(exporter, {
-      scheduledDelayMillis: batchConfig.scheduled_delay_millis,
-      maxExportBatchSize: batchConfig.max_export_batch_size
-    });
-  };
-  return effect.Layer.effectDiscard(
-    effect.Effect.sync(() => {
-      const provider = new sdkTraceBase.BasicTracerProvider({
-        resource: resources.resourceFromAttributes({
-          [semanticConventions.ATTR_SERVICE_NAME]: serviceName,
-          [semanticConventions.ATTR_SERVICE_VERSION]: serviceVersion
-        }),
-        spanProcessors: [createSpanProcessor()]
-      });
-      OtelApi__namespace.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 effect.Layer.unwrapEffect(
-    effect.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 effect.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 = effect.Supervisor.addSupervisor(supervisor);
-      return effect.Layer.mergeAll(exporterLayer, supervisorLayer);
-    })
-  );
-};
-var FullAutoTracingLive = createFullAutoTracingLayer();
 
-// src/integrations/effect/auto/effect-tracing.ts
-var createEffectTracingLayer = () => {
-  return effect.Layer.unwrapEffect(
-    effect.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 effect.Layer.empty;
-      }
-      const createSpanProcessor = () => {
-        if (exporterConfig.type === "console") {
-          logger.log("@atrim/auto-trace: Using ConsoleSpanExporter with SimpleSpanProcessor");
-          return new sdkTraceBase.SimpleSpanProcessor(new sdkTraceBase.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 exporterTraceOtlpHttp.OTLPTraceExporter(otlpConfig);
-        if (exporterConfig.processor === "simple") {
-          logger.log("@atrim/auto-trace: Using SimpleSpanProcessor");
-          return new sdkTraceBase.SimpleSpanProcessor(exporter);
-        }
-        const batchConfig = exporterConfig.batch ?? {
-          scheduled_delay_millis: 1e3,
-          max_export_batch_size: 100
-        };
-        logger.log("@atrim/auto-trace: Using BatchSpanProcessor");
-        return new sdkTraceBase.BatchSpanProcessor(exporter, {
-          scheduledDelayMillis: batchConfig.scheduled_delay_millis,
-          maxExportBatchSize: batchConfig.max_export_batch_size
-        });
-      };
-      const sdkLayer = opentelemetry.NodeSdk.layer(() => ({
-        resource: {
-          serviceName,
-          serviceVersion
-        },
-        spanProcessor: createSpanProcessor()
-      }));
-      logger.log("@atrim/auto-trace: NodeSdk layer created - HTTP requests will be auto-traced");
-      return effect.Layer.discard(sdkLayer);
-    })
-  );
-};
-var EffectTracingLive = createEffectTracingLayer();
-var createCombinedTracingLayer = () => {
-  return effect.Layer.unwrapEffect(
-    effect.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 effect.Layer.empty;
-      }
-      const createSpanExporter = () => {
-        if (exporterConfig.type === "console") {
-          logger.log("@atrim/auto-trace: Using ConsoleSpanExporter");
-          return new sdkTraceBase.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 exporterTraceOtlpHttp.OTLPTraceExporter(otlpConfig);
-      };
-      const createSpanProcessor = () => {
-        const exporter = createSpanExporter();
-        if (exporterConfig.processor === "simple" || exporterConfig.type === "console") {
-          logger.log("@atrim/auto-trace: Using SimpleSpanProcessor");
-          return new sdkTraceBase.SimpleSpanProcessor(exporter);
-        }
-        const batchConfig = exporterConfig.batch ?? {
-          scheduled_delay_millis: 1e3,
-          max_export_batch_size: 100
-        };
-        logger.log("@atrim/auto-trace: Using BatchSpanProcessor");
-        return new sdkTraceBase.BatchSpanProcessor(exporter, {
-          scheduledDelayMillis: batchConfig.scheduled_delay_millis,
-          maxExportBatchSize: batchConfig.max_export_batch_size
-        });
-      };
-      const globalProviderLayer = effect.Layer.effectDiscard(
-        effect.Effect.sync(() => {
-          const provider = new sdkTraceBase.BasicTracerProvider({
-            resource: resources.resourceFromAttributes({
-              [semanticConventions.ATTR_SERVICE_NAME]: serviceName,
-              [semanticConventions.ATTR_SERVICE_VERSION]: serviceVersion
-            }),
-            spanProcessors: [createSpanProcessor()]
-          });
-          OtelApi__namespace.trace.setGlobalTracerProvider(provider);
-          logger.log("@atrim/auto-trace: Global TracerProvider registered");
-        })
-      );
-      const resourceLayer = opentelemetry.Resource.layer({
-        serviceName,
-        serviceVersion
-      });
-      const effectTracerLayer = opentelemetry.Tracer.layerGlobal;
-      const supervisor = createAutoTracingSupervisor(autoConfig);
-      const supervisorLayer = effect.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(effect.Layer.provide(resourceLayer));
-      return effect.Layer.mergeAll(globalProviderLayer, effect.Layer.discard(tracerWithResource), supervisorLayer);
-    })
-  );
-};
-var CombinedTracingLive = createCombinedTracingLayer();
-var currentSourceLocation = effect.GlobalValue.globalValue(
-  /* @__PURE__ */ Symbol.for("effect/FiberRef/currentSourceLocation"),
-  () => effect.FiberRef.unsafeMake(void 0)
-);
-var sourceFileCache = /* @__PURE__ */ new Map();
-function extractFunctionNameFromSource(location) {
-  try {
-    let lines = sourceFileCache.get(location.file);
-    if (!lines) {
-      if (!fs__namespace.existsSync(location.file)) {
-        return void 0;
-      }
-      const content = fs__namespace.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;
-  }
-}
-var AutoTracingEnabled2 = effect.FiberRef.unsafeMake(true);
-var AutoTracingSpanName2 = effect.FiberRef.unsafeMake(effect.Option.none());
-var SourceCaptureSupervisor = class extends effect.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__namespace.trace.getTracer("@atrim/source-capture", "1.0.0");
-    }
-    return this._tracer;
-  }
-  /**
-   * Returns the current value (void for this supervisor)
-   */
-  get value() {
-    return effect.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 = effect.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 = effect.FiberRefs.getOrDefault(fiberRefsValue, AutoTracingSpanName2);
-    const nativeSourceLocation = effect.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 (effect.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__namespace.ROOT_CONTEXT;
-    let parentFiberId;
-    const inheritedOtelContext = effect.FiberRefs.getOrDefault(
-      fiberRefsValue,
-      TracerModule__namespace.currentOtelSpanContext
-    );
-    if (inheritedOtelContext) {
-      parentContext = inheritedOtelContext;
-      const inheritedSpan = OtelApi__namespace.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 = effect.Context.getOption(_context, effect.Tracer.ParentSpan);
-      if (effect.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__namespace.TraceFlags.SAMPLED : OtelApi__namespace.TraceFlags.NONE,
-          isRemote: false
-        };
-        const wrappedSpan = OtelApi__namespace.trace.wrapSpanContext(otelSpanContext);
-        parentContext = OtelApi__namespace.trace.setSpan(OtelApi__namespace.ROOT_CONTEXT, wrappedSpan);
-      } else if (effect.Option.isSome(parent)) {
-        parentFiberId = parent.value.id().id;
-        const parentOtelContext = this.fiberContexts.get(parent.value);
-        if (parentOtelContext) {
-          parentContext = parentOtelContext;
-          const parentSpan = OtelApi__namespace.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__namespace.trace.setSpan(OtelApi__namespace.ROOT_CONTEXT, parentSpan);
-          }
-        }
-      }
-    }
-    if (effect.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__namespace.SpanKind.INTERNAL,
-        attributes
-      },
-      parentContext
-    );
-    logger.log(`@atrim/source-capture: Created span "${spanName}" for fiber ${fiberId}`);
-    const newContext = OtelApi__namespace.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 (effect.Exit.isSuccess(exit)) {
-      span.setStatus({ code: OtelApi__namespace.SpanStatusCode.OK });
-    } else {
-      span.setStatus({
-        code: OtelApi__namespace.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 sdkTraceBase.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 exporterTraceOtlpHttp.OTLPTraceExporter(otlpConfig);
-  }
-  let spanProcessor;
-  if (exporterConfig.processor === "simple" || exporterConfig.type === "console") {
-    logger.log("@atrim/source-capture: Using SimpleSpanProcessor");
-    spanProcessor = new sdkTraceBase.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 sdkTraceBase.BatchSpanProcessor(exporter, {
-      scheduledDelayMillis: batchConfig.scheduled_delay_millis,
-      maxExportBatchSize: batchConfig.max_export_batch_size
-    });
-  }
-  const provider = new sdkTraceBase.BasicTracerProvider({
-    resource: resources.resourceFromAttributes({
-      [semanticConventions.ATTR_SERVICE_NAME]: serviceName,
-      [semanticConventions.ATTR_SERVICE_VERSION]: serviceVersion
-    }),
-    spanProcessors: [spanProcessor]
-  });
-  OtelApi__namespace.trace.setGlobalTracerProvider(provider);
-  logger.log("@atrim/source-capture: Global TracerProvider registered");
-  return { provider, spanProcessor };
-};
-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 effect.Layer.empty;
-  }
-  const supervisor = new SourceCaptureSupervisor(autoConfig);
-  const supervisorLayer = effect.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__namespace.trace.getTracer(serviceName, serviceVersion);
-  logger.log(`@atrim/source-capture: Using tracer "${serviceName}" from our provider`);
-  const effectTracerLayer = opentelemetry.Tracer.layerWithoutOtelTracer.pipe(
-    effect.Layer.provide(effect.Layer.succeed(opentelemetry.Tracer.OtelTracer, otelTracer))
-  );
-  return effect.Layer.mergeAll(effectTracerLayer, effect.Layer.enableSourceCapture, supervisorLayer);
-};
-var SourceCaptureTracingLive = createSourceCaptureTracingLayer();
-var withoutSourceCapture = (effect$1) => effect.Effect.withCaptureStackTraces(false)(effect$1);
-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 effect.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__namespace.trace.getTracer("@atrim/operation-tracing", "1.0.0");
-    }
-    return this._tracer;
-  }
-  /**
-   * Returns the current value (void for this supervisor)
-   */
-  get value() {
-    return effect.Effect.void;
-  }
-  /**
-   * Called for EVERY Effect operation when OpSupervision is enabled.
-   *
-   * This is the key hook for operation-level tracing. We check if the effect
-   * has OperationMeta and create a span if configured.
-   */
-  onEffect(fiber, effect$1) {
-    if (this.processedEffects.has(effect$1)) {
-      return;
-    }
-    const meta = getOperationMeta(effect$1);
-    if (!meta) {
-      return;
-    }
-    const config = this.configuredOps.get(meta.op);
-    if (!config) {
-      return;
-    }
-    this.processedEffects.add(effect$1);
-    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__namespace.ROOT_CONTEXT;
-    const fiberContext = fiber.currentContext;
-    const maybeEffectParentSpan = effect.Context.getOption(fiberContext, TracerModule__namespace.ParentSpan);
-    if (effect.Option.isSome(maybeEffectParentSpan)) {
-      const effectSpan = maybeEffectParentSpan.value;
-      parentContext = OtelApi__namespace.trace.setSpan(
-        OtelApi__namespace.ROOT_CONTEXT,
-        OtelApi__namespace.trace.wrapSpanContext({
-          traceId: effectSpan.traceId,
-          spanId: effectSpan.spanId,
-          traceFlags: OtelApi__namespace.TraceFlags.SAMPLED
-        })
-      );
-      logger.log(
-        `@atrim/operation-tracing: Using parent span traceId=${effectSpan.traceId.slice(0, 8)}...`
-      );
-    }
-    const span = this.tracer.startSpan(
-      spanName,
-      {
-        kind: OtelApi__namespace.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__namespace.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__namespace.SpanStatusCode.ERROR : OtelApi__namespace.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 effect.Supervisor.addSupervisor(supervisor);
-};
-var enableOpSupervision = (effect$1) => effect.Effect.withRuntimeFlagsPatch(effect$1, effect.RuntimeFlagsPatch.enable(effect.RuntimeFlags.OpSupervision));
-var loadOperationTracingLayer = () => effect.Layer.unwrapEffect(
-  effect.Effect.gen(function* () {
-    const config = yield* effect.Effect.tryPromise({
-      try: () => loadConfigWithOptions(),
-      catch: (error) => {
-        logger.log(`@atrim/operation-tracing: Failed to load config: ${error}`);
-        return error;
-      }
-    }).pipe(effect.Effect.catchAll(() => effect.Effect.succeed(null)));
-    const opTracingConfig = config?.effect?.operation_tracing;
-    if (opTracingConfig?.enabled === false) {
-      logger.log("@atrim/operation-tracing: Operation tracing disabled in config");
-      return effect.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$1) => effect$1.pipe(enableOpSupervision, effect.Effect.provide(OperationTracingLive));
 
-exports.AutoTracingConfig = AutoTracingConfig;
-exports.AutoTracingConfigLayer = AutoTracingConfigLayer;
-exports.AutoTracingConfigLive = AutoTracingConfigLive;
-exports.AutoTracingEnabled = AutoTracingEnabled;
-exports.AutoTracingLive = AutoTracingLive;
-exports.AutoTracingSpanName = AutoTracingSpanName;
-exports.AutoTracingSupervisor = AutoTracingSupervisor;
+// 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);
+
+exports.AutoTracingLive = exports.UnifiedTracingLive;
+exports.AutoTracingSupervisor = exports.UnifiedTracingSupervisor;
 exports.CapturedSourceLocation = CapturedSourceLocation;
-exports.CombinedTracingLive = CombinedTracingLive;
-exports.EffectTracingLive = EffectTracingLive;
-exports.FullAutoTracingLive = FullAutoTracingLive;
-exports.OperationTracingLive = OperationTracingLive;
-exports.OperationTracingSupervisor = OperationTracingSupervisor;
-exports.SourceCaptureSupervisor = SourceCaptureSupervisor;
-exports.SourceCaptureTracingLive = SourceCaptureTracingLive;
+exports.CombinedTracingLive = exports.UnifiedTracingLive;
+exports.FullAutoTracingLive = exports.UnifiedTracingLive;
+exports.OperationTracingLive = exports.UnifiedTracingLive;
+exports.SourceCaptureSupervisor = exports.UnifiedTracingSupervisor;
+exports.SourceCaptureTracingLive = exports.UnifiedTracingLive;
 exports.captureCallSite = captureCallSite;
-exports.createAutoTracingLayer = createAutoTracingLayer;
+exports.createAutoTracingLayer = exports.createUnifiedTracingLayer;
 exports.createAutoTracingSupervisor = createAutoTracingSupervisor;
-exports.createCombinedTracingLayer = createCombinedTracingLayer;
-exports.createEffectTracingLayer = createEffectTracingLayer;
-exports.createFullAutoTracingLayer = createFullAutoTracingLayer;
-exports.createSourceCaptureTracingLayer = createSourceCaptureTracingLayer;
-exports.defaultAutoTracingConfig = defaultAutoTracingConfig;
-exports.enableOpSupervision = enableOpSupervision;
-exports.flushAndShutdown = flushAndShutdown;
-exports.forceFlush = forceFlush;
+exports.createFullAutoTracingLayer = exports.createUnifiedTracingLayer;
 exports.inferSpanName = inferSpanName;
 exports.isEffectForkPatched = isEffectForkPatched;
-exports.loadAutoTracingConfig = loadAutoTracingConfig;
-exports.loadAutoTracingConfigSync = loadAutoTracingConfigSync;
-exports.makeOperationTracingLayer = makeOperationTracingLayer;
 exports.patchEffectFork = patchEffectFork;
 exports.sanitizeSpanName = sanitizeSpanName;
-exports.setSpanName = setSpanName;
 exports.tracedFork = tracedFork;
 exports.tracedForkDaemon = tracedForkDaemon;
 exports.unpatchEffectFork = unpatchEffectFork;
-exports.withAutoTracing = withAutoTracing;
-exports.withOperationTracing = withOperationTracing;
-exports.withoutAutoTracing = withoutAutoTracing;
-exports.withoutSourceCapture = withoutSourceCapture;
+exports.withOperationTracing = exports.withUnifiedTracing;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map