autotel-edge 3.16.13 → 3.16.15

package/dist/index.js

@@ -1,1152 +1,1022 @@
-export { OTLPExporter, createInitialiser, getActiveConfig, parseConfig, setConfig } from './chunk-INQQQVXN.js';
-import { setSpanName, createTraceContext } from './chunk-AL7ZD64M.js';
-export { getExecutionLogger } from './chunk-AL7ZD64M.js';
-export { parseError } from './chunk-M7Z4P5MC.js';
-import { sanitizeAttributes, isAttributeValue, isTimeInput, hrTimeDuration } from '@opentelemetry/core';
-import { SEMATTRS_EXCEPTION_MESSAGE, SEMATTRS_EXCEPTION_TYPE, SEMATTRS_EXCEPTION_STACKTRACE } from '@opentelemetry/semantic-conventions';
-import { trace, context, ROOT_CONTEXT, SpanStatusCode } from '@opentelemetry/api';
-export { context, propagation } from '@opentelemetry/api';
-import { RandomIdGenerator, SamplingDecision } from '@opentelemetry/sdk-trace-base';
-import { AsyncLocalStorage } from 'async_hooks';
-import { EventEmitter } from 'events';
-import { Buffer } from 'buffer';
-export { Buffer } from 'buffer';
+import { a as OTLPExporter, i as setConfig, n as getActiveConfig, r as parseConfig, t as createInitialiser } from "./config-0FktBGyj.js";
+import { n as createTraceContext, r as setSpanName, t as getExecutionLogger } from "./execution-logger-CoxSsBmU.js";
+import { parseError } from "./parse-error.js";
+import { hrTimeDuration, isAttributeValue, isTimeInput, sanitizeAttributes } from "@opentelemetry/core";
+import { SEMATTRS_EXCEPTION_MESSAGE, SEMATTRS_EXCEPTION_STACKTRACE, SEMATTRS_EXCEPTION_TYPE } from "@opentelemetry/semantic-conventions";
+import { ROOT_CONTEXT, SpanStatusCode, context, context as context$1, propagation, trace as trace$1 } from "@opentelemetry/api";
+import { RandomIdGenerator, SamplingDecision } from "@opentelemetry/sdk-trace-base";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { EventEmitter } from "node:events";
+import { Buffer } from "node:buffer";
 
+//#region src/core/span.ts
 function transformExceptionAttributes(exception) {
-  const attributes = {};
-  if (typeof exception === "string") {
-    attributes[SEMATTRS_EXCEPTION_MESSAGE] = exception;
-  } else {
-    if (exception.code) {
-      attributes[SEMATTRS_EXCEPTION_TYPE] = exception.code.toString();
-    } else if (exception.name) {
-      attributes[SEMATTRS_EXCEPTION_TYPE] = exception.name;
-    }
-    if (exception.message) {
-      attributes[SEMATTRS_EXCEPTION_MESSAGE] = exception.message;
-    }
-    if (exception.stack) {
-      attributes[SEMATTRS_EXCEPTION_STACKTRACE] = exception.stack;
-    }
-  }
-  return attributes;
+	const attributes = {};
+	if (typeof exception === "string") attributes[SEMATTRS_EXCEPTION_MESSAGE] = exception;
+	else {
+		if (exception.code) attributes[SEMATTRS_EXCEPTION_TYPE] = exception.code.toString();
+		else if (exception.name) attributes[SEMATTRS_EXCEPTION_TYPE] = exception.name;
+		if (exception.message) attributes[SEMATTRS_EXCEPTION_MESSAGE] = exception.message;
+		if (exception.stack) attributes[SEMATTRS_EXCEPTION_STACKTRACE] = exception.stack;
+	}
+	return attributes;
 }
 function millisToHr(millis) {
-  return [Math.trunc(millis / 1e3), millis % 1e3 * 1e6];
+	return [Math.trunc(millis / 1e3), millis % 1e3 * 1e6];
 }
 function getHrTime(input) {
-  const now = Date.now();
-  if (!input) {
-    return millisToHr(now);
-  } else if (input instanceof Date) {
-    return millisToHr(input.getTime());
-  } else if (typeof input === "number") {
-    return millisToHr(input);
-  } else if (Array.isArray(input)) {
-    return input;
-  }
-  const v = input;
-  throw new Error(`unreachable value: ${JSON.stringify(v)}`);
+	const now = Date.now();
+	if (!input) return millisToHr(now);
+	else if (input instanceof Date) return millisToHr(input.getTime());
+	else if (typeof input === "number") return millisToHr(input);
+	else if (Array.isArray(input)) return input;
+	throw new Error(`unreachable value: ${JSON.stringify(input)}`);
 }
 function isAttributeKey(key) {
-  return typeof key === "string" && key.length > 0;
+	return typeof key === "string" && key.length > 0;
 }
+/**
+* Lightweight Span implementation for edge runtimes
+*/
 var SpanImpl = class {
-  name;
-  _spanContext;
-  onEnd;
-  parentSpanId;
-  parentSpanContext;
-  kind;
-  attributes;
-  status = {
-    code: 0
-    // SpanStatusCode.UNSET
-  };
-  endTime = [0, 0];
-  _duration = [0, 0];
-  startTime;
-  events = [];
-  links;
-  resource;
-  instrumentationScope = {
-    name: "autotel-edge"
-  };
-  _ended = false;
-  _droppedAttributesCount = 0;
-  _droppedEventsCount = 0;
-  _droppedLinksCount = 0;
-  constructor(init) {
-    this.name = init.name;
-    this._spanContext = init.spanContext;
-    this.parentSpanId = init.parentSpanId;
-    this.parentSpanContext = init.parentSpanContext;
-    this.kind = init.spanKind || 0;
-    this.attributes = sanitizeAttributes(init.attributes);
-    this.startTime = getHrTime(init.startTime);
-    this.links = init.links || [];
-    this.resource = init.resource;
-    this.onEnd = init.onEnd;
-  }
-  addLink(link) {
-    this.links.push(link);
-    return this;
-  }
-  addLinks(links) {
-    this.links.push(...links);
-    return this;
-  }
-  spanContext() {
-    return this._spanContext;
-  }
-  setAttribute(key, value) {
-    if (isAttributeKey(key) && isAttributeValue(value)) {
-      this.attributes[key] = value;
-    }
-    return this;
-  }
-  setAttributes(attributes) {
-    for (const [key, value] of Object.entries(attributes)) {
-      this.setAttribute(key, value);
-    }
-    return this;
-  }
-  addEvent(name, attributesOrStartTime, startTime) {
-    if (isTimeInput(attributesOrStartTime)) {
-      startTime = attributesOrStartTime;
-      attributesOrStartTime = void 0;
-    }
-    const attributes = sanitizeAttributes(attributesOrStartTime);
-    const time = getHrTime(startTime);
-    this.events.push({ name, attributes, time });
-    return this;
-  }
-  setStatus(status) {
-    this.status = status;
-    return this;
-  }
-  updateName(name) {
-    this.name = name;
-    return this;
-  }
-  end(endTime) {
-    if (this._ended) {
-      return;
-    }
-    this._ended = true;
-    this.endTime = getHrTime(endTime);
-    this._duration = hrTimeDuration(this.startTime, this.endTime);
-    this.onEnd(this);
-  }
-  isRecording() {
-    return !this._ended;
-  }
-  recordException(exception, time) {
-    const attributes = transformExceptionAttributes(exception);
-    this.addEvent("exception", attributes, time);
-  }
-  get duration() {
-    return this._duration;
-  }
-  get ended() {
-    return this._ended;
-  }
-  get droppedAttributesCount() {
-    return this._droppedAttributesCount;
-  }
-  get droppedEventsCount() {
-    return this._droppedEventsCount;
-  }
-  get droppedLinksCount() {
-    return this._droppedLinksCount;
-  }
+	name;
+	_spanContext;
+	onEnd;
+	parentSpanId;
+	parentSpanContext;
+	kind;
+	attributes;
+	status = { code: 0 };
+	endTime = [0, 0];
+	_duration = [0, 0];
+	startTime;
+	events = [];
+	links;
+	resource;
+	instrumentationScope = { name: "autotel-edge" };
+	_ended = false;
+	_droppedAttributesCount = 0;
+	_droppedEventsCount = 0;
+	_droppedLinksCount = 0;
+	constructor(init) {
+		this.name = init.name;
+		this._spanContext = init.spanContext;
+		this.parentSpanId = init.parentSpanId;
+		this.parentSpanContext = init.parentSpanContext;
+		this.kind = init.spanKind || 0;
+		this.attributes = sanitizeAttributes(init.attributes);
+		this.startTime = getHrTime(init.startTime);
+		this.links = init.links || [];
+		this.resource = init.resource;
+		this.onEnd = init.onEnd;
+	}
+	addLink(link) {
+		this.links.push(link);
+		return this;
+	}
+	addLinks(links) {
+		this.links.push(...links);
+		return this;
+	}
+	spanContext() {
+		return this._spanContext;
+	}
+	setAttribute(key, value) {
+		if (isAttributeKey(key) && isAttributeValue(value)) this.attributes[key] = value;
+		return this;
+	}
+	setAttributes(attributes) {
+		for (const [key, value] of Object.entries(attributes)) this.setAttribute(key, value);
+		return this;
+	}
+	addEvent(name, attributesOrStartTime, startTime) {
+		if (isTimeInput(attributesOrStartTime)) {
+			startTime = attributesOrStartTime;
+			attributesOrStartTime = void 0;
+		}
+		const attributes = sanitizeAttributes(attributesOrStartTime);
+		const time = getHrTime(startTime);
+		this.events.push({
+			name,
+			attributes,
+			time
+		});
+		return this;
+	}
+	setStatus(status) {
+		this.status = status;
+		return this;
+	}
+	updateName(name) {
+		this.name = name;
+		return this;
+	}
+	end(endTime) {
+		if (this._ended) return;
+		this._ended = true;
+		this.endTime = getHrTime(endTime);
+		this._duration = hrTimeDuration(this.startTime, this.endTime);
+		this.onEnd(this);
+	}
+	isRecording() {
+		return !this._ended;
+	}
+	recordException(exception, time) {
+		const attributes = transformExceptionAttributes(exception);
+		this.addEvent("exception", attributes, time);
+	}
+	get duration() {
+		return this._duration;
+	}
+	get ended() {
+		return this._ended;
+	}
+	get droppedAttributesCount() {
+		return this._droppedAttributesCount;
+	}
+	get droppedEventsCount() {
+		return this._droppedEventsCount;
+	}
+	get droppedLinksCount() {
+		return this._droppedLinksCount;
+	}
 };
-var NewTraceFlags = {
-  RANDOM_TRACE_ID_SET: 2};
-var idGenerator = new RandomIdGenerator();
-var withNextSpanAttributes;
+
+//#endregion
+//#region src/core/tracer.ts
+const NewTraceFlags = {
+	RANDOM_TRACE_ID_SET: 2,
+	RANDOM_TRACE_ID_UNSET: 0
+};
+const idGenerator = new RandomIdGenerator();
+let withNextSpanAttributes;
 function getFlagAt(flagSequence, position) {
-  return (flagSequence >> position - 1 & 1) * position;
+	return (flagSequence >> position - 1 & 1) * position;
 }
+/**
+* WorkerTracer - Lightweight tracer for edge environments
+*/
 var WorkerTracer = class {
-  spanProcessors;
-  resource;
-  headSampler;
-  // Will be set via setHeadSampler
-  constructor(spanProcessors, resource) {
-    this.spanProcessors = spanProcessors;
-    this.resource = resource;
-  }
-  /**
-   * Set the head sampler (called from config)
-   */
-  setHeadSampler(sampler) {
-    this.headSampler = sampler;
-  }
-  /**
-   * Force flush spans for a specific trace
-   */
-  async forceFlush(traceId) {
-    const promises = this.spanProcessors.map(async (spanProcessor) => {
-      await spanProcessor.forceFlush(traceId);
-    });
-    await Promise.allSettled(promises);
-  }
-  /**
-   * Add extra resource attributes
-   */
-  addToResource(extra) {
-    this.resource.merge(extra);
-  }
-  /**
-   * Start a new span
-   */
-  startSpan(name, options = {}, context2 = context.active()) {
-    if (options.root) {
-      context2 = trace.deleteSpan(context2);
-    }
-    if (!this.headSampler) {
-      throw new Error(
-        "Head sampler not configured. This is a bug in the instrumentation logic"
-      );
-    }
-    const parentSpanContext = trace.getSpan(context2)?.spanContext();
-    const { traceId, randomTraceFlag } = getTraceInfo(parentSpanContext);
-    const spanKind = options.kind || 0;
-    const sanitisedAttrs = sanitizeAttributes(options.attributes);
-    const optionsWithSampler = options;
-    const sampler = optionsWithSampler.sampler || this.headSampler;
-    const samplingDecision = sampler.shouldSample(
-      context2,
-      traceId,
-      name,
-      spanKind,
-      sanitisedAttrs,
-      []
-    );
-    const { decision, traceState, attributes: attrs } = samplingDecision;
-    const attributes = Object.assign(
-      {},
-      options.attributes,
-      attrs,
-      withNextSpanAttributes
-    );
-    withNextSpanAttributes = {};
-    const spanId = idGenerator.generateSpanId();
-    const parentSpanId = parentSpanContext?.spanId;
-    const sampleFlag = decision === SamplingDecision.RECORD_AND_SAMPLED ? 1 : 0;
-    const traceFlags = sampleFlag + randomTraceFlag;
-    const spanContext = { traceId, spanId, traceFlags, traceState };
-    const span2 = new SpanImpl({
-      attributes: sanitizeAttributes(attributes),
-      name,
-      onEnd: (span3) => {
-        for (const sp of this.spanProcessors) {
-          sp.onEnd(span3);
-        }
-      },
-      resource: this.resource,
-      spanContext,
-      parentSpanContext,
-      parentSpanId,
-      spanKind,
-      startTime: options.startTime
-    });
-    for (const sp of this.spanProcessors) {
-      sp.onStart(span2, context2);
-    }
-    return span2;
-  }
-  startActiveSpan(name, ...args) {
-    const options = args.length > 1 ? args[0] : void 0;
-    const parentContext = args.length > 2 ? args[1] : context.active();
-    const fn = args.at(-1);
-    const span2 = this.startSpan(name, options, parentContext);
-    const contextWithSpanSet = trace.setSpan(parentContext, span2);
-    return context.with(contextWithSpanSet, fn, void 0, span2);
-  }
+	spanProcessors;
+	resource;
+	headSampler;
+	constructor(spanProcessors, resource) {
+		this.spanProcessors = spanProcessors;
+		this.resource = resource;
+	}
+	/**
+	* Set the head sampler (called from config)
+	*/
+	setHeadSampler(sampler) {
+		this.headSampler = sampler;
+	}
+	/**
+	* Force flush spans for a specific trace
+	*/
+	async forceFlush(traceId) {
+		const promises = this.spanProcessors.map(async (spanProcessor) => {
+			await spanProcessor.forceFlush(traceId);
+		});
+		await Promise.allSettled(promises);
+	}
+	/**
+	* Add extra resource attributes
+	*/
+	addToResource(extra) {
+		this.resource.merge(extra);
+	}
+	/**
+	* Start a new span
+	*/
+	startSpan(name, options = {}, context = context$1.active()) {
+		if (options.root) context = trace$1.deleteSpan(context);
+		if (!this.headSampler) throw new Error("Head sampler not configured. This is a bug in the instrumentation logic");
+		const parentSpanContext = trace$1.getSpan(context)?.spanContext();
+		const { traceId, randomTraceFlag } = getTraceInfo(parentSpanContext);
+		const spanKind = options.kind || 0;
+		const sanitisedAttrs = sanitizeAttributes(options.attributes);
+		const { decision, traceState, attributes: attrs } = (options.sampler || this.headSampler).shouldSample(context, traceId, name, spanKind, sanitisedAttrs, []);
+		const attributes = Object.assign({}, options.attributes, attrs, withNextSpanAttributes);
+		withNextSpanAttributes = {};
+		const spanId = idGenerator.generateSpanId();
+		const parentSpanId = parentSpanContext?.spanId;
+		const spanContext = {
+			traceId,
+			spanId,
+			traceFlags: (decision === SamplingDecision.RECORD_AND_SAMPLED ? 1 : 0) + randomTraceFlag,
+			traceState
+		};
+		const span = new SpanImpl({
+			attributes: sanitizeAttributes(attributes),
+			name,
+			onEnd: (span) => {
+				for (const sp of this.spanProcessors) sp.onEnd(span);
+			},
+			resource: this.resource,
+			spanContext,
+			parentSpanContext,
+			parentSpanId,
+			spanKind,
+			startTime: options.startTime
+		});
+		for (const sp of this.spanProcessors) sp.onStart(span, context);
+		return span;
+	}
+	startActiveSpan(name, ...args) {
+		const options = args.length > 1 ? args[0] : void 0;
+		const parentContext = args.length > 2 ? args[1] : context$1.active();
+		const fn = args.at(-1);
+		const span = this.startSpan(name, options, parentContext);
+		const contextWithSpanSet = trace$1.setSpan(parentContext, span);
+		return context$1.with(contextWithSpanSet, fn, void 0, span);
+	}
 };
+/**
+* Set attributes for the next span created
+*/
 function withNextSpan(attrs) {
-  withNextSpanAttributes = Object.assign({}, withNextSpanAttributes, attrs);
+	withNextSpanAttributes = Object.assign({}, withNextSpanAttributes, attrs);
 }
 function getTraceInfo(parentSpanContext) {
-  if (parentSpanContext && trace.isSpanContextValid(parentSpanContext)) {
-    const { traceId, traceFlags } = parentSpanContext;
-    return { traceId, randomTraceFlag: getFlagAt(traceFlags, 2) };
-  } else {
-    return {
-      traceId: idGenerator.generateTraceId(),
-      randomTraceFlag: NewTraceFlags.RANDOM_TRACE_ID_SET
-    };
-  }
+	if (parentSpanContext && trace$1.isSpanContextValid(parentSpanContext)) {
+		const { traceId, traceFlags } = parentSpanContext;
+		return {
+			traceId,
+			randomTraceFlag: getFlagAt(traceFlags, 2)
+		};
+	} else return {
+		traceId: idGenerator.generateTraceId(),
+		randomTraceFlag: NewTraceFlags.RANDOM_TRACE_ID_SET
+	};
 }
-var ADD_LISTENER_METHODS = [
-  "addListener",
-  "on",
-  "once",
-  "prependListener",
-  "prependOnceListener"
+
+//#endregion
+//#region src/core/context.ts
+const ADD_LISTENER_METHODS = [
+	"addListener",
+	"on",
+	"once",
+	"prependListener",
+	"prependOnceListener"
 ];
 var AbstractAsyncHooksContextManager = class {
-  /**
-   * Binds a context to the target function or event emitter
-   */
-  bind(context2, target) {
-    if (target instanceof EventEmitter) {
-      return this._bindEventEmitter(context2, target);
-    }
-    if (typeof target === "function") {
-      return this._bindFunction(context2, target);
-    }
-    return target;
-  }
-  _bindFunction(context2, target) {
-    const manager = this;
-    const contextWrapper = function(...args) {
-      return manager.with(context2, () => target.apply(this, args));
-    };
-    Object.defineProperty(contextWrapper, "length", {
-      enumerable: false,
-      configurable: true,
-      writable: false,
-      value: target.length
-    });
-    return contextWrapper;
-  }
-  /**
-   * By default, EventEmitter calls callbacks with their context, which we do
-   * not want. Instead we bind a specific context to all callbacks.
-   */
-  _bindEventEmitter(context2, ee) {
-    const map = this._getPatchMap(ee);
-    if (map !== void 0) return ee;
-    this._createPatchMap(ee);
-    for (const methodName of ADD_LISTENER_METHODS) {
-      if (ee[methodName] === void 0) continue;
-      ee[methodName] = this._patchAddListener(ee, ee[methodName], context2);
-    }
-    if (typeof ee.removeListener === "function") {
-      ee.removeListener = this._patchRemoveListener(ee, ee.removeListener);
-    }
-    if (typeof ee.off === "function") {
-      ee.off = this._patchRemoveListener(ee, ee.off);
-    }
-    if (typeof ee.removeAllListeners === "function") {
-      ee.removeAllListeners = this._patchRemoveAllListeners(
-        ee,
-        ee.removeAllListeners
-      );
-    }
-    return ee;
-  }
-  _patchRemoveListener(ee, original) {
-    const contextManager = this;
-    return function(event, listener) {
-      const events = contextManager._getPatchMap(ee)?.[event];
-      if (events === void 0) {
-        return original.call(this, event, listener);
-      }
-      const patchedListener = events.get(listener);
-      return original.call(this, event, patchedListener || listener);
-    };
-  }
-  _patchRemoveAllListeners(ee, original) {
-    const contextManager = this;
-    return function(event) {
-      const map = contextManager._getPatchMap(ee);
-      if (map !== void 0) {
-        if (arguments.length === 0) {
-          contextManager._createPatchMap(ee);
-        } else if (map[event] !== void 0) {
-          delete map[event];
-        }
-      }
-      return Reflect.apply(original, this, arguments);
-    };
-  }
-  _patchAddListener(ee, original, context2) {
-    const contextManager = this;
-    return function(event, listener) {
-      if (contextManager._wrapped) {
-        return original.call(this, event, listener);
-      }
-      let map = contextManager._getPatchMap(ee);
-      if (map === void 0) {
-        map = contextManager._createPatchMap(ee);
-      }
-      let listeners = map[event];
-      if (listeners === void 0) {
-        listeners = /* @__PURE__ */ new WeakMap();
-        map[event] = listeners;
-      }
-      const patchedListener = contextManager.bind(context2, listener);
-      listeners.set(listener, patchedListener);
-      contextManager._wrapped = true;
-      try {
-        return original.call(this, event, patchedListener);
-      } finally {
-        contextManager._wrapped = false;
-      }
-    };
-  }
-  _createPatchMap(ee) {
-    const map = /* @__PURE__ */ Object.create(null);
-    ee[this._kOtListeners] = map;
-    return map;
-  }
-  _getPatchMap(ee) {
-    return ee[this._kOtListeners];
-  }
-  _kOtListeners = /* @__PURE__ */ Symbol("OtListeners");
-  _wrapped = false;
+	/**
+	* Binds a context to the target function or event emitter
+	*/
+	bind(context, target) {
+		if (target instanceof EventEmitter) return this._bindEventEmitter(context, target);
+		if (typeof target === "function") return this._bindFunction(context, target);
+		return target;
+	}
+	_bindFunction(context, target) {
+		const manager = this;
+		const contextWrapper = function(...args) {
+			return manager.with(context, () => target.apply(this, args));
+		};
+		Object.defineProperty(contextWrapper, "length", {
+			enumerable: false,
+			configurable: true,
+			writable: false,
+			value: target.length
+		});
+		return contextWrapper;
+	}
+	/**
+	* By default, EventEmitter calls callbacks with their context, which we do
+	* not want. Instead we bind a specific context to all callbacks.
+	*/
+	_bindEventEmitter(context, ee) {
+		if (this._getPatchMap(ee) !== void 0) return ee;
+		this._createPatchMap(ee);
+		for (const methodName of ADD_LISTENER_METHODS) {
+			if (ee[methodName] === void 0) continue;
+			ee[methodName] = this._patchAddListener(ee, ee[methodName], context);
+		}
+		if (typeof ee.removeListener === "function") ee.removeListener = this._patchRemoveListener(ee, ee.removeListener);
+		if (typeof ee.off === "function") ee.off = this._patchRemoveListener(ee, ee.off);
+		if (typeof ee.removeAllListeners === "function") ee.removeAllListeners = this._patchRemoveAllListeners(ee, ee.removeAllListeners);
+		return ee;
+	}
+	_patchRemoveListener(ee, original) {
+		const contextManager = this;
+		return function(event, listener) {
+			const events = contextManager._getPatchMap(ee)?.[event];
+			if (events === void 0) return original.call(this, event, listener);
+			const patchedListener = events.get(listener);
+			return original.call(this, event, patchedListener || listener);
+		};
+	}
+	_patchRemoveAllListeners(ee, original) {
+		const contextManager = this;
+		return function(event) {
+			const map = contextManager._getPatchMap(ee);
+			if (map !== void 0) {
+				if (arguments.length === 0) contextManager._createPatchMap(ee);
+				else if (map[event] !== void 0) delete map[event];
+			}
+			return Reflect.apply(original, this, arguments);
+		};
+	}
+	_patchAddListener(ee, original, context) {
+		const contextManager = this;
+		return function(event, listener) {
+			/**
+			* This check prevents double-wrapping the listener.
+			* The implementation for ee.once wraps the listener and calls ee.on.
+			* Without this check, we would wrap that wrapped listener.
+			*/
+			if (contextManager._wrapped) return original.call(this, event, listener);
+			let map = contextManager._getPatchMap(ee);
+			if (map === void 0) map = contextManager._createPatchMap(ee);
+			let listeners = map[event];
+			if (listeners === void 0) {
+				listeners = /* @__PURE__ */ new WeakMap();
+				map[event] = listeners;
+			}
+			const patchedListener = contextManager.bind(context, listener);
+			listeners.set(listener, patchedListener);
+			contextManager._wrapped = true;
+			try {
+				return original.call(this, event, patchedListener);
+			} finally {
+				contextManager._wrapped = false;
+			}
+		};
+	}
+	_createPatchMap(ee) {
+		const map = Object.create(null);
+		ee[this._kOtListeners] = map;
+		return map;
+	}
+	_getPatchMap(ee) {
+		return ee[this._kOtListeners];
+	}
+	_kOtListeners = Symbol("OtListeners");
+	_wrapped = false;
 };
+/**
+* AsyncLocalStorage-based context manager for edge runtimes
+*/
 var AsyncLocalStorageContextManager = class extends AbstractAsyncHooksContextManager {
-  _asyncLocalStorage;
-  constructor() {
-    super();
-    this._asyncLocalStorage = new AsyncLocalStorage();
-  }
-  active() {
-    return this._asyncLocalStorage.getStore() ?? ROOT_CONTEXT;
-  }
-  with(context2, fn, thisArg, ...args) {
-    const cb = thisArg == null ? fn : fn.bind(thisArg);
-    return this._asyncLocalStorage.run(context2, cb, ...args);
-  }
-  enable() {
-    return this;
-  }
-  disable() {
-    this._asyncLocalStorage.disable();
-    return this;
-  }
+	_asyncLocalStorage;
+	constructor() {
+		super();
+		this._asyncLocalStorage = new AsyncLocalStorage();
+	}
+	active() {
+		return this._asyncLocalStorage.getStore() ?? ROOT_CONTEXT;
+	}
+	with(context, fn, thisArg, ...args) {
+		const cb = thisArg == null ? fn : fn.bind(thisArg);
+		return this._asyncLocalStorage.run(context, cb, ...args);
+	}
+	enable() {
+		return this;
+	}
+	disable() {
+		this._asyncLocalStorage.disable();
+		return this;
+	}
 };
+
+//#endregion
+//#region src/core/provider.ts
+/**
+* Tracer provider for edge environments
+*/
+let globalContextManagerRegistered = false;
+/**
+* WorkerTracerProvider - Registers tracer globally
+*/
 var WorkerTracerProvider = class {
-  tracer;
-  contextManager;
-  constructor(spanProcessors, resource) {
-    this.tracer = new WorkerTracer(spanProcessors, resource);
-    this.contextManager = new AsyncLocalStorageContextManager();
-  }
-  /**
-   * Get the tracer instance
-   */
-  getTracer(_name, _version, _config) {
-    return this.tracer;
-  }
-  /**
-   * Register this provider as the global tracer
-   */
-  register() {
-    this.contextManager.enable();
-    const provider = {
-      getTracer: (_name, _version) => this.tracer
-    };
-    trace.setGlobalTracerProvider(provider);
-  }
+	tracer;
+	contextManager;
+	constructor(spanProcessors, resource) {
+		this.tracer = new WorkerTracer(spanProcessors, resource);
+		this.contextManager = new AsyncLocalStorageContextManager();
+	}
+	/**
+	* Get the tracer instance
+	*/
+	getTracer(_name, _version, _config) {
+		return this.tracer;
+	}
+	/**
+	* Register this provider as the global tracer
+	*/
+	register() {
+		this.contextManager.enable();
+		if (!globalContextManagerRegistered) globalContextManagerRegistered = context$1.setGlobalContextManager(this.contextManager);
+		trace$1.setGlobalTracerProvider({ getTracer: (_name, _version) => this.tracer });
+	}
 };
+
+//#endregion
+//#region src/core/buffer.ts
+/**
+* Buffer polyfill for edge environments
+*
+* Cloudflare Workers and other edge runtimes need the Buffer global
+* for OpenTelemetry OTLP serialization.
+*/
 globalThis.Buffer = Buffer;
-var TRACE_FACTORY_MARK = "__autotelEdgeTraceFactory";
-var INSTRUMENTED_MARK = "__autotelEdgeInstrumented";
-var FACTORY_NAME_HINTS = {
-  ctx: true,
-  _ctx: true,
-  context: true,
-  tracecontext: true,
-  tracectx: true
+
+//#endregion
+//#region src/functional.ts
+/**
+* Functional API for autotel-edge
+*
+* Provides zero-boilerplate tracing helpers that mirror the Node.js runtime
+* implementation while staying optimized for edge environments.
+*/
+const TRACE_FACTORY_MARK = "__autotelEdgeTraceFactory";
+const INSTRUMENTED_MARK = "__autotelEdgeInstrumented";
+const FACTORY_NAME_HINTS = {
+	ctx: true,
+	_ctx: true,
+	context: true,
+	tracecontext: true,
+	tracectx: true
 };
-var SINGLE_LINE_COMMENT_REGEX = /\/\/.*$/gm;
-var MULTI_LINE_COMMENT_REGEX = /\/\*[\s\S]*?\*\//gm;
-var PARAM_TOKEN_SANITIZE_REGEX = new RegExp(String.raw`[{}\[\]\s]`, "g");
+const SINGLE_LINE_COMMENT_REGEX = /\/\/.*$/gm;
+const MULTI_LINE_COMMENT_REGEX = /\/\*[\s\S]*?\*\//gm;
+const PARAM_TOKEN_SANITIZE_REGEX = new RegExp(String.raw`[{}\[\]\s]`, "g");
 function markAsTraceFactory(fn) {
-  try {
-    Object.defineProperty(fn, TRACE_FACTORY_MARK, {
-      value: true,
-      configurable: true
-    });
-  } catch {
-    fn[TRACE_FACTORY_MARK] = true;
-  }
+	try {
+		Object.defineProperty(fn, TRACE_FACTORY_MARK, {
+			value: true,
+			configurable: true
+		});
+	} catch {
+		fn[TRACE_FACTORY_MARK] = true;
+	}
 }
 function hasFactoryMark(fn) {
-  return Boolean(fn[TRACE_FACTORY_MARK]);
+	return Boolean(fn[TRACE_FACTORY_MARK]);
 }
 function sanitizeParameterToken(token) {
-  const [firstToken] = token.split("=");
-  return (firstToken ?? "").replaceAll(PARAM_TOKEN_SANITIZE_REGEX, "").trim();
+	const [firstToken] = token.split("=");
+	return (firstToken ?? "").replaceAll(PARAM_TOKEN_SANITIZE_REGEX, "").trim();
 }
 function getFirstParameterToken(fn) {
-  let source = Function.prototype.toString.call(fn);
-  source = source.replaceAll(MULTI_LINE_COMMENT_REGEX, "").replaceAll(SINGLE_LINE_COMMENT_REGEX, "").trim();
-  const arrowMatch = source.match(/^(?:async\s*)?(?:\(([^)]*)\)|([^=()]+))\s*=>/);
-  if (arrowMatch) {
-    const params = (arrowMatch[1] ?? arrowMatch[2] ?? "").split(",");
-    const first = params[0]?.trim();
-    if (first) {
-      return sanitizeParameterToken(first);
-    }
-    return null;
-  }
-  const functionMatch = source.match(/^[^(]*\(([^)]*)\)/);
-  if (functionMatch) {
-    const params = functionMatch[1]?.split(",");
-    const first = params?.[0]?.trim();
-    if (first) {
-      return sanitizeParameterToken(first);
-    }
-  }
-  return null;
+	let source = Function.prototype.toString.call(fn);
+	source = source.replaceAll(MULTI_LINE_COMMENT_REGEX, "").replaceAll(SINGLE_LINE_COMMENT_REGEX, "").trim();
+	const arrowMatch = source.match(/^(?:async\s*)?(?:\(([^)]*)\)|([^=()]+))\s*=>/);
+	if (arrowMatch) {
+		const first = (arrowMatch[1] ?? arrowMatch[2] ?? "").split(",")[0]?.trim();
+		if (first) return sanitizeParameterToken(first);
+		return null;
+	}
+	const functionMatch = source.match(/^[^(]*\(([^)]*)\)/);
+	if (functionMatch) {
+		const first = (functionMatch[1]?.split(","))?.[0]?.trim();
+		if (first) return sanitizeParameterToken(first);
+	}
+	return null;
 }
 function looksLikeTraceFactory(fn) {
-  if (hasFactoryMark(fn)) {
-    return true;
-  }
-  if (fn.length === 0) {
-    return false;
-  }
-  const firstParam = getFirstParameterToken(fn);
-  if (!firstParam) {
-    return false;
-  }
-  const normalized = firstParam.toLowerCase();
-  if (Object.hasOwn(FACTORY_NAME_HINTS, normalized) || normalized.startsWith("ctx") || normalized.startsWith("_ctx") || normalized.startsWith("trace")) {
-    return true;
-  }
-  return false;
-}
+	if (hasFactoryMark(fn)) return true;
+	if (fn.length === 0) return false;
+	const firstParam = getFirstParameterToken(fn);
+	if (!firstParam) return false;
+	const normalized = firstParam.toLowerCase();
+	if (Object.hasOwn(FACTORY_NAME_HINTS, normalized) || normalized.startsWith("ctx") || normalized.startsWith("_ctx") || normalized.startsWith("trace")) return true;
+	return false;
+}
+/**
+* Check if a function that takes ctx returns another function (factory pattern)
+* vs returning a value directly (immediate execution pattern)
+*/
 function isFactoryReturningFunction(fnWithCtx) {
-  try {
-    const result = fnWithCtx(createDummyCtx());
-    return typeof result === "function";
-  } catch {
-    return false;
-  }
+	try {
+		return typeof fnWithCtx(createDummyCtx()) === "function";
+	} catch {
+		return false;
+	}
 }
 function isTraceFactoryFunction(fn) {
-  if (typeof fn !== "function") {
-    return false;
-  }
-  if (hasFactoryMark(fn)) {
-    return true;
-  }
-  if (looksLikeTraceFactory(fn)) {
-    markAsTraceFactory(fn);
-    return true;
-  }
-  return false;
+	if (typeof fn !== "function") return false;
+	if (hasFactoryMark(fn)) return true;
+	if (looksLikeTraceFactory(fn)) {
+		markAsTraceFactory(fn);
+		return true;
+	}
+	return false;
 }
 function ensureTraceFactory(fnOrFactory) {
-  if (isTraceFactoryFunction(fnOrFactory)) {
-    return fnOrFactory;
-  }
-  const plainFn = fnOrFactory;
-  const factory = (ctx) => {
-    return plainFn;
-  };
-  markAsTraceFactory(factory);
-  return factory;
-}
-var MAX_ERROR_MESSAGE_LENGTH = 500;
+	if (isTraceFactoryFunction(fnOrFactory)) return fnOrFactory;
+	const plainFn = fnOrFactory;
+	const factory = (ctx) => {
+		return plainFn;
+	};
+	markAsTraceFactory(factory);
+	return factory;
+}
+const MAX_ERROR_MESSAGE_LENGTH = 500;
 function createDummyCtx() {
-  return {
-    traceId: "",
-    spanId: "",
-    correlationId: "",
-    setAttribute: () => {
-    },
-    setAttributes: () => {
-    },
-    setStatus: () => {
-    },
-    recordException: () => {
-    },
-    addEvent: () => {
-    },
-    addLink: () => {
-    },
-    addLinks: () => {
-    },
-    updateName: () => {
-    },
-    isRecording: () => false
-  };
+	return {
+		traceId: "",
+		spanId: "",
+		correlationId: "",
+		setAttribute: () => {},
+		setAttributes: () => {},
+		setStatus: () => {},
+		recordException: () => {},
+		addEvent: () => {},
+		addLink: () => {},
+		addLinks: () => {},
+		updateName: () => {},
+		isRecording: () => false
+	};
 }
 function truncateErrorMessage(message) {
-  if (message.length <= MAX_ERROR_MESSAGE_LENGTH) {
-    return message;
-  }
-  return `${message.slice(0, MAX_ERROR_MESSAGE_LENGTH)}... (truncated)`;
+	if (message.length <= MAX_ERROR_MESSAGE_LENGTH) return message;
+	return `${message.slice(0, MAX_ERROR_MESSAGE_LENGTH)}... (truncated)`;
 }
 function inferFunctionName(fn) {
-  const displayName = fn.displayName;
-  if (displayName) {
-    return displayName;
-  }
-  if (fn.name && fn.name !== "anonymous") {
-    return fn.name;
-  }
-  const source = Function.prototype.toString.call(fn);
-  const match = source.match(/function\s+([^(\s]+)/);
-  if (match && match[1] && match[1] !== "anonymous") {
-    return match[1];
-  }
-  return void 0;
+	const displayName = fn.displayName;
+	if (displayName) return displayName;
+	if (fn.name && fn.name !== "anonymous") return fn.name;
+	const match = Function.prototype.toString.call(fn).match(/function\s+([^(\s]+)/);
+	if (match && match[1] && match[1] !== "anonymous") return match[1];
 }
 function getSpanName(options, fn, variableName) {
-  if (options.name) {
-    return options.name;
-  }
-  let fnName = variableName ?? inferFunctionName(fn);
-  fnName = fnName || "anonymous";
-  if (options.serviceName) {
-    return `${options.serviceName}.${fnName}`;
-  }
-  if (fnName && fnName !== "anonymous") {
-    return fnName;
-  }
-  return "unknown";
+	if (options.name) return options.name;
+	let fnName = variableName ?? inferFunctionName(fn);
+	fnName = fnName || "anonymous";
+	if (options.serviceName) return `${options.serviceName}.${fnName}`;
+	if (fnName && fnName !== "anonymous") return fnName;
+	return "unknown";
 }
 function isAsyncFunction(fn) {
-  return typeof fn === "function" && fn.constructor?.name === "AsyncFunction";
+	return typeof fn === "function" && fn.constructor?.name === "AsyncFunction";
 }
 function wrapWithTracingAsync(fnFactory, options, variableName) {
-  const tempFn = fnFactory(createDummyCtx());
-  const spanName = getSpanName(options, tempFn, variableName);
-  const wrappedFunction = async function wrappedFunction2(...args) {
-    const tracer = trace.getTracer("autotel-edge");
-    const spanOptions = options.sampler ? { sampler: options.sampler } : {};
-    return tracer.startActiveSpan(spanName, spanOptions, async (span2) => {
-      setSpanName(span2, spanName);
-      try {
-        const actualFn = fnFactory(createTraceContext(span2));
-        if (options.attributes) {
-          span2.setAttributes(options.attributes);
-        }
-        if (options.attributesFromArgs) {
-          const argsAttrs = options.attributesFromArgs(args);
-          span2.setAttributes(argsAttrs);
-        }
-        const result = await actualFn(...args);
-        if (options.attributesFromResult) {
-          const resultAttrs = options.attributesFromResult(result);
-          span2.setAttributes(resultAttrs);
-        }
-        span2.setAttribute("code.function", spanName);
-        span2.setStatus({ code: SpanStatusCode.OK });
-        span2.end();
-        return result;
-      } catch (error) {
-        const message = truncateErrorMessage(
-          error instanceof Error ? error.message : String(error ?? "Unknown error")
-        );
-        span2.setAttribute("code.function", spanName);
-        span2.setStatus({ code: SpanStatusCode.ERROR, message });
-        span2.recordException(error instanceof Error ? error : new Error(String(error)));
-        span2.end();
-        throw error;
-      }
-    });
-  };
-  Object.defineProperty(wrappedFunction, "name", {
-    value: tempFn.name || "trace",
-    configurable: true
-  });
-  wrappedFunction[INSTRUMENTED_MARK] = true;
-  return wrappedFunction;
+	const tempFn = fnFactory(createDummyCtx());
+	const spanName = getSpanName(options, tempFn, variableName);
+	const wrappedFunction = async function wrappedFunction(...args) {
+		const tracer = trace$1.getTracer("autotel-edge");
+		const spanOptions = options.sampler ? { sampler: options.sampler } : {};
+		return tracer.startActiveSpan(spanName, spanOptions, async (span) => {
+			setSpanName(span, spanName);
+			try {
+				const actualFn = fnFactory(createTraceContext(span));
+				if (options.attributes) span.setAttributes(options.attributes);
+				if (options.attributesFromArgs) {
+					const argsAttrs = options.attributesFromArgs(args);
+					span.setAttributes(argsAttrs);
+				}
+				const result = await actualFn(...args);
+				if (options.attributesFromResult) {
+					const resultAttrs = options.attributesFromResult(result);
+					span.setAttributes(resultAttrs);
+				}
+				span.setAttribute("code.function", spanName);
+				span.setStatus({ code: SpanStatusCode.OK });
+				span.end();
+				return result;
+			} catch (error) {
+				const message = truncateErrorMessage(error instanceof Error ? error.message : String(error ?? "Unknown error"));
+				span.setAttribute("code.function", spanName);
+				span.setStatus({
+					code: SpanStatusCode.ERROR,
+					message
+				});
+				span.recordException(error instanceof Error ? error : new Error(String(error)));
+				span.end();
+				throw error;
+			}
+		});
+	};
+	Object.defineProperty(wrappedFunction, "name", {
+		value: tempFn.name || "trace",
+		configurable: true
+	});
+	wrappedFunction[INSTRUMENTED_MARK] = true;
+	return wrappedFunction;
 }
 function wrapWithTracingSync(fnFactory, options, variableName) {
-  const tempFn = fnFactory(createDummyCtx());
-  const spanName = getSpanName(options, tempFn, variableName);
-  const wrappedFunction = function wrappedFunction2(...args) {
-    const tracer = trace.getTracer("autotel-edge");
-    const spanOptions = options.sampler ? { sampler: options.sampler } : {};
-    return tracer.startActiveSpan(spanName, spanOptions, (span2) => {
-      setSpanName(span2, spanName);
-      try {
-        const actualFn = fnFactory(createTraceContext(span2));
-        if (options.attributes) {
-          span2.setAttributes(options.attributes);
-        }
-        if (options.attributesFromArgs) {
-          const argsAttrs = options.attributesFromArgs(args);
-          span2.setAttributes(argsAttrs);
-        }
-        const result = actualFn(...args);
-        if (options.attributesFromResult) {
-          const resultAttrs = options.attributesFromResult(result);
-          span2.setAttributes(resultAttrs);
-        }
-        span2.setAttribute("code.function", spanName);
-        span2.setStatus({ code: SpanStatusCode.OK });
-        span2.end();
-        return result;
-      } catch (error) {
-        const message = truncateErrorMessage(
-          error instanceof Error ? error.message : String(error ?? "Unknown error")
-        );
-        span2.setAttribute("code.function", spanName);
-        span2.setStatus({ code: SpanStatusCode.ERROR, message });
-        span2.recordException(error instanceof Error ? error : new Error(String(error)));
-        span2.end();
-        throw error;
-      }
-    });
-  };
-  Object.defineProperty(wrappedFunction, "name", {
-    value: tempFn.name || "trace",
-    configurable: true
-  });
-  wrappedFunction[INSTRUMENTED_MARK] = true;
-  return wrappedFunction;
+	const tempFn = fnFactory(createDummyCtx());
+	const spanName = getSpanName(options, tempFn, variableName);
+	const wrappedFunction = function wrappedFunction(...args) {
+		const tracer = trace$1.getTracer("autotel-edge");
+		const spanOptions = options.sampler ? { sampler: options.sampler } : {};
+		return tracer.startActiveSpan(spanName, spanOptions, (span) => {
+			setSpanName(span, spanName);
+			try {
+				const actualFn = fnFactory(createTraceContext(span));
+				if (options.attributes) span.setAttributes(options.attributes);
+				if (options.attributesFromArgs) {
+					const argsAttrs = options.attributesFromArgs(args);
+					span.setAttributes(argsAttrs);
+				}
+				const result = actualFn(...args);
+				if (options.attributesFromResult) {
+					const resultAttrs = options.attributesFromResult(result);
+					span.setAttributes(resultAttrs);
+				}
+				span.setAttribute("code.function", spanName);
+				span.setStatus({ code: SpanStatusCode.OK });
+				span.end();
+				return result;
+			} catch (error) {
+				const message = truncateErrorMessage(error instanceof Error ? error.message : String(error ?? "Unknown error"));
+				span.setAttribute("code.function", spanName);
+				span.setStatus({
+					code: SpanStatusCode.ERROR,
+					message
+				});
+				span.recordException(error instanceof Error ? error : new Error(String(error)));
+				span.end();
+				throw error;
+			}
+		});
+	};
+	Object.defineProperty(wrappedFunction, "name", {
+		value: tempFn.name || "trace",
+		configurable: true
+	});
+	wrappedFunction[INSTRUMENTED_MARK] = true;
+	return wrappedFunction;
 }
 function wrapFactoryWithTracing(fnOrFactory, options, variableName) {
-  const factory = ensureTraceFactory(fnOrFactory);
-  const sampleFn = factory(createDummyCtx());
-  const useAsyncWrapper = isAsyncFunction(sampleFn);
-  if (useAsyncWrapper) {
-    return wrapWithTracingAsync(
-      factory,
-      options,
-      variableName
-    );
-  }
-  return wrapWithTracingSync(
-    factory,
-    options,
-    variableName
-  );
-}
+	const factory = ensureTraceFactory(fnOrFactory);
+	if (isAsyncFunction(factory(createDummyCtx()))) return wrapWithTracingAsync(factory, options, variableName);
+	return wrapWithTracingSync(factory, options, variableName);
+}
+/**
+* Execute a function immediately within a trace span
+* Used for the immediate execution pattern: trace((ctx) => result)
+*/
 function executeImmediately(fn, options) {
-  const tracer = trace.getTracer("@autotel/edge");
-  const spanName = options.name || "anonymous";
-  return tracer.startActiveSpan(spanName, (span2) => {
-    try {
-      setSpanName(span2, spanName);
-      const ctxValue = createTraceContext(span2);
-      const onSuccess = (result2) => {
-        span2.setStatus({ code: SpanStatusCode.OK });
-        if (options.attributes) {
-          for (const [key, value] of Object.entries(options.attributes)) {
-            span2.setAttribute(key, value);
-          }
-        }
-        span2.end();
-        return result2;
-      };
-      const onError = (error) => {
-        const errorMessage = error instanceof Error ? error.message : "Unknown error";
-        const truncatedMessage = truncateErrorMessage(errorMessage);
-        span2.setStatus({
-          code: SpanStatusCode.ERROR,
-          message: truncatedMessage
-        });
-        span2.setAttribute("error", true);
-        span2.setAttribute(
-          "exception.type",
-          error instanceof Error ? error.constructor.name : "Error"
-        );
-        span2.setAttribute("exception.message", truncatedMessage);
-        span2.recordException(
-          error instanceof Error ? error : new Error(String(error))
-        );
-        span2.end();
-        throw error;
-      };
-      const result = fn(ctxValue);
-      if (result instanceof Promise) {
-        return result.then(onSuccess, onError);
-      }
-      return onSuccess(result);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      const truncatedMessage = truncateErrorMessage(errorMessage);
-      span2.setStatus({
-        code: SpanStatusCode.ERROR,
-        message: truncatedMessage
-      });
-      span2.setAttribute("error", true);
-      span2.setAttribute("exception.message", truncatedMessage);
-      span2.recordException(
-        error instanceof Error ? error : new Error(String(error))
-      );
-      span2.end();
-      throw error;
-    }
-  });
-}
-function trace3(fnOrNameOrOptions, maybeFn) {
-  if (typeof fnOrNameOrOptions === "function") {
-    if (looksLikeTraceFactory(fnOrNameOrOptions) && !isFactoryReturningFunction(fnOrNameOrOptions)) {
-      return executeImmediately(
-        fnOrNameOrOptions,
-        {}
-      );
-    }
-    return wrapFactoryWithTracing(
-      fnOrNameOrOptions,
-      {}
-    );
-  }
-  if (typeof fnOrNameOrOptions === "string") {
-    if (!maybeFn) {
-      throw new Error("trace(name, fn): fn is required");
-    }
-    if (looksLikeTraceFactory(maybeFn) && !isFactoryReturningFunction(maybeFn)) {
-      return executeImmediately(
-        maybeFn,
-        { name: fnOrNameOrOptions }
-      );
-    }
-    return wrapFactoryWithTracing(
-      maybeFn,
-      { name: fnOrNameOrOptions }
-    );
-  }
-  if (!maybeFn) {
-    throw new Error("trace(options, fn): fn is required");
-  }
-  if (looksLikeTraceFactory(maybeFn) && !isFactoryReturningFunction(maybeFn)) {
-    return executeImmediately(
-      maybeFn,
-      fnOrNameOrOptions
-    );
-  }
-  return wrapFactoryWithTracing(
-    maybeFn,
-    fnOrNameOrOptions
-  );
+	const tracer = trace$1.getTracer("@autotel/edge");
+	const spanName = options.name || "anonymous";
+	return tracer.startActiveSpan(spanName, (span) => {
+		try {
+			setSpanName(span, spanName);
+			const ctxValue = createTraceContext(span);
+			const onSuccess = (result) => {
+				span.setStatus({ code: SpanStatusCode.OK });
+				if (options.attributes) for (const [key, value] of Object.entries(options.attributes)) span.setAttribute(key, value);
+				span.end();
+				return result;
+			};
+			const onError = (error) => {
+				const truncatedMessage = truncateErrorMessage(error instanceof Error ? error.message : "Unknown error");
+				span.setStatus({
+					code: SpanStatusCode.ERROR,
+					message: truncatedMessage
+				});
+				span.setAttribute("error", true);
+				span.setAttribute("exception.type", error instanceof Error ? error.constructor.name : "Error");
+				span.setAttribute("exception.message", truncatedMessage);
+				span.recordException(error instanceof Error ? error : new Error(String(error)));
+				span.end();
+				throw error;
+			};
+			const result = fn(ctxValue);
+			if (result instanceof Promise) return result.then(onSuccess, onError);
+			return onSuccess(result);
+		} catch (error) {
+			const truncatedMessage = truncateErrorMessage(error instanceof Error ? error.message : "Unknown error");
+			span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: truncatedMessage
+			});
+			span.setAttribute("error", true);
+			span.setAttribute("exception.message", truncatedMessage);
+			span.recordException(error instanceof Error ? error : new Error(String(error)));
+			span.end();
+			throw error;
+		}
+	});
+}
+function trace(fnOrNameOrOptions, maybeFn) {
+	if (typeof fnOrNameOrOptions === "function") {
+		if (looksLikeTraceFactory(fnOrNameOrOptions) && !isFactoryReturningFunction(fnOrNameOrOptions)) return executeImmediately(fnOrNameOrOptions, {});
+		return wrapFactoryWithTracing(fnOrNameOrOptions, {});
+	}
+	if (typeof fnOrNameOrOptions === "string") {
+		if (!maybeFn) throw new Error("trace(name, fn): fn is required");
+		if (looksLikeTraceFactory(maybeFn) && !isFactoryReturningFunction(maybeFn)) return executeImmediately(maybeFn, { name: fnOrNameOrOptions });
+		return wrapFactoryWithTracing(maybeFn, { name: fnOrNameOrOptions });
+	}
+	if (!maybeFn) throw new Error("trace(options, fn): fn is required");
+	if (looksLikeTraceFactory(maybeFn) && !isFactoryReturningFunction(maybeFn)) return executeImmediately(maybeFn, fnOrNameOrOptions);
+	return wrapFactoryWithTracing(maybeFn, fnOrNameOrOptions);
 }
 function withTracing(options) {
-  return (fnOrFactory) => wrapFactoryWithTracing(fnOrFactory, options);
+	return (fnOrFactory) => wrapFactoryWithTracing(fnOrFactory, options);
 }
 function shouldSkip(key, fn, skip) {
-  if (key.startsWith("_")) {
-    return true;
-  }
-  if (!skip || skip.length === 0) {
-    return false;
-  }
-  for (const pattern of skip) {
-    if (typeof pattern === "string" && key === pattern) {
-      return true;
-    }
-    if (pattern instanceof RegExp && pattern.test(key)) {
-      return true;
-    }
-    if (typeof pattern === "function" && pattern(key, fn)) {
-      return true;
-    }
-  }
-  return false;
+	if (key.startsWith("_")) return true;
+	if (!skip || skip.length === 0) return false;
+	for (const pattern of skip) {
+		if (typeof pattern === "string" && key === pattern) return true;
+		if (pattern instanceof RegExp && pattern.test(key)) return true;
+		if (typeof pattern === "function" && pattern(key, fn)) return true;
+	}
+	return false;
 }
 function instrument(options) {
-  const { functions, ...tracingOptions } = options;
-  const instrumented = {};
-  for (const key of Object.keys(functions)) {
-    const fn = functions[key];
-    if (typeof fn !== "function") {
-      instrumented[key] = fn;
-      continue;
-    }
-    if (shouldSkip(key, fn, tracingOptions.skip)) {
-      instrumented[key] = fn;
-      continue;
-    }
-    const fnOptions = {
-      ...tracingOptions,
-      ...tracingOptions.overrides?.[key],
-      name: tracingOptions.overrides?.[key]?.name ?? tracingOptions.name
-    };
-    const boundFn = fn.bind(functions);
-    const fnFactory = (_ctx) => boundFn;
-    instrumented[key] = wrapFactoryWithTracing(fnFactory, fnOptions, key);
-  }
-  return instrumented;
+	const { functions, ...tracingOptions } = options;
+	const instrumented = {};
+	for (const key of Object.keys(functions)) {
+		const fn = functions[key];
+		if (typeof fn !== "function") {
+			instrumented[key] = fn;
+			continue;
+		}
+		if (shouldSkip(key, fn, tracingOptions.skip)) {
+			instrumented[key] = fn;
+			continue;
+		}
+		const fnOptions = {
+			...tracingOptions,
+			...tracingOptions.overrides?.[key],
+			name: tracingOptions.overrides?.[key]?.name ?? tracingOptions.name
+		};
+		const boundFn = fn.bind(functions);
+		const fnFactory = (_ctx) => boundFn;
+		instrumented[key] = wrapFactoryWithTracing(fnFactory, fnOptions, key);
+	}
+	return instrumented;
 }
 function span(nameOrOptions, fn) {
-  const options = typeof nameOrOptions === "string" ? { name: nameOrOptions } : nameOrOptions;
-  const tracer = trace.getTracer("autotel-edge");
-  const execute = (span2) => {
-    setSpanName(span2, options.name);
-    try {
-      if (options.attributes) {
-        for (const [key, value] of Object.entries(options.attributes)) {
-          span2.setAttribute(key, value);
-        }
-      }
-      const result2 = fn(span2);
-      if (result2 instanceof Promise) {
-        return result2.then((value) => {
-          span2.setAttribute("code.function", options.name);
-          span2.setStatus({ code: SpanStatusCode.OK });
-          span2.end();
-          return value;
-        }).catch((error) => {
-          const message = truncateErrorMessage(
-            error instanceof Error ? error.message : String(error ?? "Unknown error")
-          );
-          span2.setAttribute("code.function", options.name);
-          span2.setStatus({ code: SpanStatusCode.ERROR, message });
-          span2.recordException(error instanceof Error ? error : new Error(String(error)));
-          span2.end();
-          throw error;
-        });
-      }
-      span2.setAttribute("code.function", options.name);
-      span2.setStatus({ code: SpanStatusCode.OK });
-      span2.end();
-      return result2;
-    } catch (error) {
-      const message = truncateErrorMessage(
-        error instanceof Error ? error.message : String(error ?? "Unknown error")
-      );
-      span2.setAttribute("code.function", options.name);
-      span2.setStatus({ code: SpanStatusCode.ERROR, message });
-      span2.recordException(error instanceof Error ? error : new Error(String(error)));
-      span2.end();
-      throw error;
-    }
-  };
-  const result = tracer.startActiveSpan(options.name, execute);
-  if (result instanceof Promise) {
-    return result;
-  }
-  return result;
+	const options = typeof nameOrOptions === "string" ? { name: nameOrOptions } : nameOrOptions;
+	const tracer = trace$1.getTracer("autotel-edge");
+	const execute = (span) => {
+		setSpanName(span, options.name);
+		try {
+			if (options.attributes) for (const [key, value] of Object.entries(options.attributes)) span.setAttribute(key, value);
+			const result = fn(span);
+			if (result instanceof Promise) return result.then((value) => {
+				span.setAttribute("code.function", options.name);
+				span.setStatus({ code: SpanStatusCode.OK });
+				span.end();
+				return value;
+			}).catch((error) => {
+				const message = truncateErrorMessage(error instanceof Error ? error.message : String(error ?? "Unknown error"));
+				span.setAttribute("code.function", options.name);
+				span.setStatus({
+					code: SpanStatusCode.ERROR,
+					message
+				});
+				span.recordException(error instanceof Error ? error : new Error(String(error)));
+				span.end();
+				throw error;
+			});
+			span.setAttribute("code.function", options.name);
+			span.setStatus({ code: SpanStatusCode.OK });
+			span.end();
+			return result;
+		} catch (error) {
+			const message = truncateErrorMessage(error instanceof Error ? error.message : String(error ?? "Unknown error"));
+			span.setAttribute("code.function", options.name);
+			span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message
+			});
+			span.recordException(error instanceof Error ? error : new Error(String(error)));
+			span.end();
+			throw error;
+		}
+	};
+	const result = tracer.startActiveSpan(options.name, execute);
+	if (result instanceof Promise) return result;
+	return result;
 }
 
-// src/composition.ts
+//#endregion
+//#region src/composition.ts
+/**
+* Identity helper for authoring an autotel configuration once with full
+* type-checking. Mirrors `defineConfig` patterns in tools like Vite / Vitest.
+*
+* @example
+* ```ts
+* import { defineConfig } from 'autotel-edge'
+*
+* export const otelConfig = defineConfig({
+*   service: { name: 'checkout' },
+*   exporter: { url: process.env.OTLP_URL! },
+* })
+* ```
+*/
 function defineConfig(config) {
-  return config;
-}
+	return config;
+}
+/**
+* Run a list of subscribers in registration order. Errors thrown by an
+* individual subscriber are caught and logged so a buggy subscriber never
+* blocks the others — important because `subscribers` is the primary
+* extensibility point for in-process side effects.
+*/
 function composeSubscribers(subscribers, options = {}) {
-  const label = options.name ?? "compose-subscribers";
-  return async (event) => {
-    for (const subscriber of subscribers) {
-      try {
-        await subscriber(event);
-      } catch (err) {
-        console.error(`[autotel-edge/${label}] subscriber failed:`, err);
-      }
-    }
-  };
-}
+	const label = options.name ?? "compose-subscribers";
+	return async (event) => {
+		for (const subscriber of subscribers) try {
+			await subscriber(event);
+		} catch (err) {
+			console.error(`[autotel-edge/${label}] subscriber failed:`, err);
+		}
+	};
+}
+/**
+* Chain post-processors so each one sees the output of the previous one.
+* This matches the standard OTel post-processor contract: take spans, return
+* spans (possibly filtered, redacted, or annotated).
+*/
 function composePostProcessors(processors) {
-  return (spans) => {
-    let current = spans;
-    for (const processor of processors) {
-      try {
-        current = processor(current);
-      } catch (err) {
-        console.error("[autotel-edge/compose-post-processors] failed:", err);
-      }
-    }
-    return current;
-  };
-}
+	return (spans) => {
+		let current = spans;
+		for (const processor of processors) try {
+			current = processor(current);
+		} catch (err) {
+			console.error("[autotel-edge/compose-post-processors] failed:", err);
+		}
+		return current;
+	};
+}
+/**
+* Fan out span lifecycle events to multiple span processors. Any single
+* processor's failure is isolated so it cannot break the others.
+*
+* Useful when you want to attach, say, a sampling processor + a custom
+* attribute redactor + the default batch processor without having to author a
+* single processor that knows about all three.
+*/
 function composeSpanProcessors(processors) {
-  const safe = (label, fn) => Promise.resolve().then(fn).catch((err) => {
-    console.error(`[autotel-edge/compose-span-processors:${label}]`, err);
-  });
-  return {
-    onStart(span2, parentContext) {
-      for (const processor of processors) {
-        try {
-          processor.onStart(span2, parentContext);
-        } catch (err) {
-          console.error("[autotel-edge/compose-span-processors:onStart]", err);
-        }
-      }
-    },
-    onEnd(span2) {
-      for (const processor of processors) {
-        try {
-          processor.onEnd(span2);
-        } catch (err) {
-          console.error("[autotel-edge/compose-span-processors:onEnd]", err);
-        }
-      }
-    },
-    async forceFlush() {
-      await Promise.allSettled(
-        processors.map((p) => safe("forceFlush", () => p.forceFlush()))
-      );
-    },
-    async shutdown() {
-      await Promise.allSettled(
-        processors.map((p) => safe("shutdown", () => p.shutdown()))
-      );
-    }
-  };
+	const safe = (label, fn) => Promise.resolve().then(fn).catch((err) => {
+		console.error(`[autotel-edge/compose-span-processors:${label}]`, err);
+	});
+	return {
+		onStart(span, parentContext) {
+			for (const processor of processors) try {
+				processor.onStart(span, parentContext);
+			} catch (err) {
+				console.error("[autotel-edge/compose-span-processors:onStart]", err);
+			}
+		},
+		onEnd(span) {
+			for (const processor of processors) try {
+				processor.onEnd(span);
+			} catch (err) {
+				console.error("[autotel-edge/compose-span-processors:onEnd]", err);
+			}
+		},
+		async forceFlush() {
+			await Promise.allSettled(processors.map((p) => safe("forceFlush", () => p.forceFlush())));
+		},
+		async shutdown() {
+			await Promise.allSettled(processors.map((p) => safe("shutdown", () => p.shutdown())));
+		}
+	};
 }
 
-// src/plugin-runner.ts
+//#endregion
+//#region src/plugin-runner.ts
 function logPluginError(logger, name, hook, error) {
-  logger.error(`[autotel-edge/${name}] ${hook} failed:`, error);
+	logger.error(`[autotel-edge/${name}] ${hook} failed:`, error);
 }
 function definePlugin(plugin) {
-  return plugin;
+	return plugin;
 }
 function createPluginRunner(plugins = [], options = {}) {
-  const errorLogger = options.logger ?? console;
-  const byName = /* @__PURE__ */ new Map();
-  for (const plugin of plugins) {
-    byName.set(plugin.name, plugin);
-  }
-  const list = Array.from(byName.values());
-  const hasEnrich = list.some((p) => typeof p.enrich === "function");
-  const hasDrain = list.some((p) => typeof p.drain === "function");
-  const hasKeep = list.some((p) => typeof p.keep === "function");
-  const hasRequestLifecycle = list.some(
-    (p) => typeof p.onRequestStart === "function" || typeof p.onRequestFinish === "function"
-  );
-  const hasClientLog = list.some((p) => typeof p.onClientLog === "function");
-  const hasExtendLogger = list.some(
-    (p) => typeof p.extendLogger === "function"
-  );
-  return {
-    plugins: list,
-    hasEnrich,
-    hasDrain,
-    hasKeep,
-    hasRequestLifecycle,
-    hasClientLog,
-    hasExtendLogger,
-    applyExtendLogger(logger) {
-      for (const plugin of list) {
-        if (!plugin.extendLogger) continue;
-        try {
-          plugin.extendLogger(logger);
-        } catch (err) {
-          logPluginError(errorLogger, plugin.name, "extendLogger", err);
-        }
-      }
-    },
-    runOnRequestStart(ctx) {
-      for (const plugin of list) {
-        if (!plugin.onRequestStart) continue;
-        try {
-          plugin.onRequestStart(ctx);
-        } catch (err) {
-          logPluginError(errorLogger, plugin.name, "onRequestStart", err);
-        }
-      }
-    },
-    runOnRequestFinish(ctx) {
-      for (const plugin of list) {
-        if (!plugin.onRequestFinish) continue;
-        try {
-          plugin.onRequestFinish(ctx);
-        } catch (err) {
-          logPluginError(errorLogger, plugin.name, "onRequestFinish", err);
-        }
-      }
-    },
-    runOnClientLog(ctx) {
-      for (const plugin of list) {
-        if (!plugin.onClientLog) continue;
-        try {
-          plugin.onClientLog(ctx);
-        } catch (err) {
-          logPluginError(errorLogger, plugin.name, "onClientLog", err);
-        }
-      }
-    },
-    async runSetup(ctx) {
-      for (const plugin of list) {
-        if (!plugin.setup) continue;
-        try {
-          await plugin.setup(ctx);
-        } catch (err) {
-          logPluginError(errorLogger, plugin.name, "setup", err);
-        }
-      }
-    },
-    async runEnrich(ctx) {
-      for (const plugin of list) {
-        if (!plugin.enrich) continue;
-        try {
-          await plugin.enrich(ctx);
-        } catch (err) {
-          logPluginError(errorLogger, plugin.name, "enrich", err);
-        }
-      }
-    },
-    async runDrain(ctx) {
-      const drains = list.filter((p) => typeof p.drain === "function");
-      if (drains.length === 0) return;
-      await Promise.allSettled(
-        drains.map(async (plugin) => {
-          try {
-            await plugin.drain(ctx);
-          } catch (err) {
-            logPluginError(errorLogger, plugin.name, "drain", err);
-          }
-        })
-      );
-    },
-    async runKeep(ctx) {
-      for (const plugin of list) {
-        if (!plugin.keep) continue;
-        try {
-          await plugin.keep(ctx);
-        } catch (err) {
-          logPluginError(errorLogger, plugin.name, "keep", err);
-        }
-      }
-    }
-  };
-}
-var emptyRunner = createPluginRunner([]);
+	const errorLogger = options.logger ?? console;
+	const byName = /* @__PURE__ */ new Map();
+	for (const plugin of plugins) byName.set(plugin.name, plugin);
+	const list = Array.from(byName.values());
+	return {
+		plugins: list,
+		hasEnrich: list.some((p) => typeof p.enrich === "function"),
+		hasDrain: list.some((p) => typeof p.drain === "function"),
+		hasKeep: list.some((p) => typeof p.keep === "function"),
+		hasRequestLifecycle: list.some((p) => typeof p.onRequestStart === "function" || typeof p.onRequestFinish === "function"),
+		hasClientLog: list.some((p) => typeof p.onClientLog === "function"),
+		hasExtendLogger: list.some((p) => typeof p.extendLogger === "function"),
+		applyExtendLogger(logger) {
+			for (const plugin of list) {
+				if (!plugin.extendLogger) continue;
+				try {
+					plugin.extendLogger(logger);
+				} catch (err) {
+					logPluginError(errorLogger, plugin.name, "extendLogger", err);
+				}
+			}
+		},
+		runOnRequestStart(ctx) {
+			for (const plugin of list) {
+				if (!plugin.onRequestStart) continue;
+				try {
+					plugin.onRequestStart(ctx);
+				} catch (err) {
+					logPluginError(errorLogger, plugin.name, "onRequestStart", err);
+				}
+			}
+		},
+		runOnRequestFinish(ctx) {
+			for (const plugin of list) {
+				if (!plugin.onRequestFinish) continue;
+				try {
+					plugin.onRequestFinish(ctx);
+				} catch (err) {
+					logPluginError(errorLogger, plugin.name, "onRequestFinish", err);
+				}
+			}
+		},
+		runOnClientLog(ctx) {
+			for (const plugin of list) {
+				if (!plugin.onClientLog) continue;
+				try {
+					plugin.onClientLog(ctx);
+				} catch (err) {
+					logPluginError(errorLogger, plugin.name, "onClientLog", err);
+				}
+			}
+		},
+		async runSetup(ctx) {
+			for (const plugin of list) {
+				if (!plugin.setup) continue;
+				try {
+					await plugin.setup(ctx);
+				} catch (err) {
+					logPluginError(errorLogger, plugin.name, "setup", err);
+				}
+			}
+		},
+		async runEnrich(ctx) {
+			for (const plugin of list) {
+				if (!plugin.enrich) continue;
+				try {
+					await plugin.enrich(ctx);
+				} catch (err) {
+					logPluginError(errorLogger, plugin.name, "enrich", err);
+				}
+			}
+		},
+		async runDrain(ctx) {
+			const drains = list.filter((p) => typeof p.drain === "function");
+			if (drains.length === 0) return;
+			await Promise.allSettled(drains.map(async (plugin) => {
+				try {
+					await plugin.drain(ctx);
+				} catch (err) {
+					logPluginError(errorLogger, plugin.name, "drain", err);
+				}
+			}));
+		},
+		async runKeep(ctx) {
+			for (const plugin of list) {
+				if (!plugin.keep) continue;
+				try {
+					await plugin.keep(ctx);
+				} catch (err) {
+					logPluginError(errorLogger, plugin.name, "keep", err);
+				}
+			}
+		}
+	};
+}
+const emptyRunner = createPluginRunner([]);
 function getEmptyPluginRunner() {
-  return emptyRunner;
+	return emptyRunner;
 }
 
-// src/middleware-toolkit.ts
+//#endregion
+//#region src/middleware-toolkit.ts
 function matchesRoutePattern(path, pattern) {
-  const regexPattern = pattern.replaceAll(/[.+^${}()|[\]\\]/g, String.raw`\$&`).replaceAll("**", "{{GLOBSTAR}}").replaceAll("*", "[^/]*").replaceAll("{{GLOBSTAR}}", ".*").replaceAll("?", "[^/]");
-  return new RegExp(`^${regexPattern}$`).test(path);
+	const regexPattern = pattern.replaceAll(/[.+^${}()|[\]\\]/g, String.raw`\$&`).replaceAll("**", "{{GLOBSTAR}}").replaceAll("*", "[^/]*").replaceAll("{{GLOBSTAR}}", ".*").replaceAll("?", "[^/]");
+	return new RegExp(`^${regexPattern}$`).test(path);
 }
 function shouldInstrumentPath(path, options = {}) {
-  const { include, exclude } = options;
-  if (exclude && exclude.some((pattern) => matchesRoutePattern(path, pattern))) {
-    return false;
-  }
-  if (!include || include.length === 0) {
-    return true;
-  }
-  return include.some((pattern) => matchesRoutePattern(path, pattern));
+	const { include, exclude } = options;
+	if (exclude && exclude.some((pattern) => matchesRoutePattern(path, pattern))) return false;
+	if (!include || include.length === 0) return true;
+	return include.some((pattern) => matchesRoutePattern(path, pattern));
 }
 function getServiceForPath(path, routes) {
-  if (!routes) return void 0;
-  for (const [pattern, config] of Object.entries(routes)) {
-    if (matchesRoutePattern(path, pattern)) {
-      return config.service;
-    }
-  }
-  return void 0;
+	if (!routes) return void 0;
+	for (const [pattern, config] of Object.entries(routes)) if (matchesRoutePattern(path, pattern)) return config.service;
 }
 async function runMiddlewareFinishPipeline(ctx, options = {}) {
-  const logger = options.logger ?? console;
-  for (const enrich of options.enrichers ?? []) {
-    try {
-      await enrich(ctx);
-    } catch (err) {
-      logger.error("[autotel-edge/middleware] enricher failed:", err);
-    }
-  }
-  const drains = options.drains ?? [];
-  if (drains.length === 0) return;
-  await Promise.allSettled(
-    drains.map(async (drain) => {
-      try {
-        await drain(ctx);
-      } catch (err) {
-        logger.error("[autotel-edge/middleware] drain failed:", err);
-      }
-    })
-  );
+	const logger = options.logger ?? console;
+	for (const enrich of options.enrichers ?? []) try {
+		await enrich(ctx);
+	} catch (err) {
+		logger.error("[autotel-edge/middleware] enricher failed:", err);
+	}
+	const drains = options.drains ?? [];
+	if (drains.length === 0) return;
+	await Promise.allSettled(drains.map(async (drain) => {
+		try {
+			await drain(ctx);
+		} catch (err) {
+			logger.error("[autotel-edge/middleware] drain failed:", err);
+		}
+	}));
 }
 
-export { AsyncLocalStorageContextManager, SpanImpl, WorkerTracer, WorkerTracerProvider, composePostProcessors, composeSpanProcessors, composeSubscribers, createPluginRunner, defineConfig, definePlugin, getEmptyPluginRunner, getServiceForPath, instrument as instrumentFunctions, matchesRoutePattern, runMiddlewareFinishPipeline, shouldInstrumentPath, span, trace3 as trace, withNextSpan, withTracing };
-//# sourceMappingURL=index.js.map
+//#endregion
+export { AsyncLocalStorageContextManager, Buffer, OTLPExporter, SpanImpl, WorkerTracer, WorkerTracerProvider, composePostProcessors, composeSpanProcessors, composeSubscribers, context, createInitialiser, createPluginRunner, defineConfig, definePlugin, getActiveConfig, getEmptyPluginRunner, getExecutionLogger, getServiceForPath, instrument as instrumentFunctions, matchesRoutePattern, parseConfig, parseError, propagation, runMiddlewareFinishPipeline, setConfig, shouldInstrumentPath, span, trace, withNextSpan, withTracing };
 //# sourceMappingURL=index.js.map