react-doctor 0.9.9 → 0.9.10-dev.3bb84fb

package/dist/lsp.js

@@ -1199,7 +1199,7 @@ const random = (self) => {
 * @category hashing
 * @since 2.0.0
 */
-const combine = /* @__PURE__ */ dual(2, (self, b) => self * 53 ^ b);
+const combine$1 = /* @__PURE__ */ dual(2, (self, b) => self * 53 ^ b);
 /**
 * Applies bit manipulation techniques to optimize a hash value.
 *
@@ -1374,7 +1374,7 @@ const string$2 = (str) => {
 */
 const structureKeys = (o, keys) => {
 	let h = 12289;
-	for (const key of keys) h ^= combine(hash(key), hash(o[key]));
+	for (const key of keys) h ^= combine$1(hash(key), hash(o[key]));
 	return optimize(h);
 };
 /**
@@ -1455,7 +1455,7 @@ const iterableWith = (seed, f) => (iter) => {
 * @since 2.0.0
 */
 const array = /* @__PURE__ */ iterableWith(6151, hash);
-const hashMap = /* @__PURE__ */ iterableWith(/* @__PURE__ */ string$2("Map"), ([k, v]) => combine(hash(k), hash(v)));
+const hashMap = /* @__PURE__ */ iterableWith(/* @__PURE__ */ string$2("Map"), ([k, v]) => combine$1(hash(k), hash(v)));
 const hashSet = /* @__PURE__ */ iterableWith(/* @__PURE__ */ string$2("Set"), hash);
 const randomHashCache = /* @__PURE__ */ new WeakMap();
 const hashCache = /* @__PURE__ */ new WeakMap();
@@ -2681,7 +2681,7 @@ var Fail = class extends ReasonBase {
 		return isFailReason$1(that) && equals$2(this.error, that.error) && equals$2(this.annotations, that.annotations);
 	}
 	[symbol$1]() {
-		return combine(string$2(this._tag))(combine(hash(this.error))(hash(this.annotations)));
+		return combine$1(string$2(this._tag))(combine$1(hash(this.error))(hash(this.annotations)));
 	}
 };
 /** @internal */
@@ -2710,7 +2710,7 @@ var Die = class extends ReasonBase {
 		return isDieReason(that) && equals$2(this.defect, that.defect) && equals$2(this.annotations, that.annotations);
 	}
 	[symbol$1]() {
-		return combine(string$2(this._tag))(combine(hash(this.defect))(hash(this.annotations)));
+		return combine$1(string$2(this._tag))(combine$1(hash(this.defect))(hash(this.annotations)));
 	}
 };
 /** @internal */
@@ -2770,7 +2770,7 @@ const makeExit = (options) => {
 			return isExit(that) && that._tag === this._tag && equals$2(this[args], that[args]);
 		},
 		[symbol$1]() {
-			return combine(string$2(options.op), hash(this[args]));
+			return combine$1(string$2(options.op), hash(this[args]));
 		}
 	};
 	return function(value) {
@@ -2892,9 +2892,9 @@ const done$2 = (value) => {
 /**
 * @since 2.0.0
 */
-const TypeId$38 = "~effect/data/Option";
+const TypeId$39 = "~effect/data/Option";
 const CommonProto$1 = {
-	[TypeId$38]: { _A: (_) => _ },
+	[TypeId$39]: { _A: (_) => _ },
 	...PipeInspectableProto,
 	[Symbol.iterator]() {
 		return new SingleShotGen(this);
@@ -2907,7 +2907,7 @@ const SomeProto = /* @__PURE__ */ Object.defineProperty(/* @__PURE__ */ Object.a
 		return isOption(that) && isSome$1(that) && equals$2(this.value, that.value);
 	},
 	[symbol$1]() {
-		return combine(hash(this._tag))(hash(this.value));
+		return combine$1(hash(this._tag))(hash(this.value));
 	},
 	toString() {
 		return `some(${format$1(this.value)})`;
@@ -2944,7 +2944,7 @@ const NoneProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(Co
 	}
 });
 /** @internal */
-const isOption = (input) => hasProperty(input, TypeId$38);
+const isOption = (input) => hasProperty(input, TypeId$39);
 /** @internal */
 const isNone$1 = (fa) => fa._tag === "None";
 /** @internal */
@@ -2959,9 +2959,9 @@ const some$1 = (value) => {
 };
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.102/node_modules/effect/dist/internal/result.js
-const TypeId$37 = "~effect/data/Result";
+const TypeId$38 = "~effect/data/Result";
 const CommonProto = {
-	[TypeId$37]: {
+	[TypeId$38]: {
 		/* v8 ignore next 2 */
 		_A: (_) => _,
 		_E: (_) => _
@@ -2978,7 +2978,7 @@ const SuccessProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create
 		return isResult(that) && isSuccess$2(that) && equals$2(this.success, that.success);
 	},
 	[symbol$1]() {
-		return combine(hash(this._tag))(hash(this.success));
+		return combine$1(hash(this._tag))(hash(this.success));
 	},
 	toString() {
 		return `success(${format$1(this.success)})`;
@@ -2998,7 +2998,7 @@ const FailureProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create
 		return isResult(that) && isFailure$2(that) && equals$2(this.failure, that.failure);
 	},
 	[symbol$1]() {
-		return combine(hash(this._tag))(hash(this.failure));
+		return combine$1(hash(this._tag))(hash(this.failure));
 	},
 	toString() {
 		return `failure(${format$1(this.failure)})`;
@@ -3012,7 +3012,7 @@ const FailureProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create
 	}
 });
 /** @internal */
-const isResult = (input) => hasProperty(input, TypeId$37);
+const isResult = (input) => hasProperty(input, TypeId$38);
 /** @internal */
 const isFailure$2 = (result) => result._tag === "Failure";
 /** @internal */
@@ -4247,6 +4247,37 @@ const isArrayNonEmpty = isArrayNonEmpty$1;
 * @since 4.0.0
 */
 const isReadonlyArrayNonEmpty = isArrayNonEmpty$1;
+/**
+* Sorts an array by the given `Order`, returning a new array.
+*
+* **When to use**
+*
+* Use to sort an array using a single `Order` comparator.
+*
+* **Details**
+*
+* Preserves `NonEmptyArray` in the return type. Use `sortWith` to sort by a
+* derived key, or `sortBy` for multi-key sorting.
+*
+* **Example** (Sorting numbers)
+*
+* ```ts
+* import { Array, Order } from "effect"
+*
+* console.log(Array.sort([3, 1, 4, 1, 5], Order.Number)) // [1, 1, 3, 4, 5]
+* ```
+*
+* @see {@link sortWith} — sort by a mapping function
+* @see {@link sortBy} — sort by multiple orders
+*
+* @category sorting
+* @since 2.0.0
+*/
+const sort$1 = /* @__PURE__ */ dual(2, (self, O) => {
+	const out = Array$1.from(self);
+	out.sort(O);
+	return out;
+});
 const hashBucketsAdd = (buckets, value) => {
 	const hash$5 = hash(value);
 	const bucket = buckets.get(hash$5);
@@ -4412,12 +4443,12 @@ const dedupe = (self) => {
 *
 * @since 2.0.0
 */
-const TypeId$36 = "~effect/BigDecimal";
+const TypeId$37 = "~effect/BigDecimal";
 const BigDecimalProto = {
-	[TypeId$36]: TypeId$36,
+	[TypeId$37]: TypeId$37,
 	[symbol$1]() {
 		const normalized = normalize(this);
-		return combine(hash(normalized.value), number$1(normalized.scale));
+		return combine$1(hash(normalized.value), number$1(normalized.scale));
 	},
 	[symbol](that) {
 		return isBigDecimal(that) && equals$1(this, that);
@@ -4460,7 +4491,7 @@ const BigDecimalProto = {
 * @category guards
 * @since 2.0.0
 */
-const isBigDecimal = (u) => hasProperty(u, TypeId$36);
+const isBigDecimal = (u) => hasProperty(u, TypeId$37);
 /**
 * Creates a `BigDecimal` from a `bigint` value and a scale.
 *
@@ -4500,14 +4531,14 @@ const make$36 = (value, scale) => {
 * @internal
 */
 const makeNormalizedUnsafe = (value, scale) => {
-	if (value !== bigint0$2 && value % bigint10 === bigint0$2) throw new RangeError("Value must be normalized");
+	if (value !== bigint0$3 && value % bigint10 === bigint0$3) throw new RangeError("Value must be normalized");
 	const o = make$36(value, scale);
 	o.normalized = o;
 	return o;
 };
-const bigint0$2 = /* @__PURE__ */ BigInt(0);
+const bigint0$3 = /* @__PURE__ */ BigInt(0);
 const bigint10 = /* @__PURE__ */ BigInt(10);
-const zero$1 = /* @__PURE__ */ makeNormalizedUnsafe(bigint0$2, 0);
+const zero$1 = /* @__PURE__ */ makeNormalizedUnsafe(bigint0$3, 0);
 /**
 * Normalizes a given `BigDecimal` by removing trailing zeros.
 *
@@ -4538,7 +4569,7 @@ const zero$1 = /* @__PURE__ */ makeNormalizedUnsafe(bigint0$2, 0);
 * @since 2.0.0
 */
 const normalize = (self) => {
-	if (self.normalized === void 0) if (self.value === bigint0$2) self.normalized = zero$1;
+	if (self.normalized === void 0) if (self.value === bigint0$3) self.normalized = zero$1;
 	else {
 		const digits = `${self.value}`;
 		let trail = 0;
@@ -4609,7 +4640,7 @@ const scale = /* @__PURE__ */ dual(2, (self, scale) => {
 * @category math
 * @since 2.0.0
 */
-const abs = (n) => n.value < bigint0$2 ? make$36(-n.value, n.scale) : n;
+const abs = (n) => n.value < bigint0$3 ? make$36(-n.value, n.scale) : n;
 /**
 * Provides an `Equivalence` instance for `BigDecimal` that determines equality between BigDecimal values.
 *
@@ -4697,7 +4728,7 @@ const equals$1 = /* @__PURE__ */ dual(2, (self, that) => Equivalence$5(self, tha
 const format = (n) => {
 	const normalized = normalize(n);
 	if (Math.abs(normalized.scale) >= 16) return toExponential(normalized);
-	const negative = normalized.value < bigint0$2;
+	const negative = normalized.value < bigint0$3;
 	const absolute = negative ? `${normalized.value}`.substring(1) : `${normalized.value}`;
 	let before;
 	let after;
@@ -4770,7 +4801,7 @@ const toExponential = (n) => {
 * @category predicates
 * @since 2.0.0
 */
-const isZero$1 = (n) => n.value === bigint0$2;
+const isZero$1 = (n) => n.value === bigint0$3;
 /**
 * Checks whether a given `BigDecimal` is negative.
 *
@@ -4792,7 +4823,7 @@ const isZero$1 = (n) => n.value === bigint0$2;
 * @category predicates
 * @since 2.0.0
 */
-const isNegative = (n) => n.value < bigint0$2;
+const isNegative = (n) => n.value < bigint0$3;
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.102/node_modules/effect/dist/Effectable.js
 /**
@@ -4961,7 +4992,7 @@ const ServiceProto = {
 	}
 };
 const ReferenceTypeId = "~effect/Context/Reference";
-const TypeId$35 = "~effect/Context";
+const TypeId$36 = "~effect/Context";
 /**
 * Creates a `Context` from an existing service map.
 *
@@ -5000,7 +5031,7 @@ const makeUnsafe$7 = (mapUnsafe) => {
 };
 const Proto$13 = {
 	...PipeInspectableProto,
-	[TypeId$35]: { _Services: (_) => _ },
+	[TypeId$36]: { _Services: (_) => _ },
 	toJSON() {
 		return {
 			_id: "Context",
@@ -5052,7 +5083,7 @@ const Proto$13 = {
 * @category guards
 * @since 2.0.0
 */
-const isContext = (u) => hasProperty(u, TypeId$35);
+const isContext = (u) => hasProperty(u, TypeId$36);
 /**
 * Checks whether the provided argument is a `Reference`.
 *
@@ -5388,7 +5419,7 @@ const getOption = /* @__PURE__ */ dual(2, (self, service) => {
 * @category combining
 * @since 2.0.0
 */
-const merge$3 = /* @__PURE__ */ dual(2, (self, that) => {
+const merge$4 = /* @__PURE__ */ dual(2, (self, that) => {
 	if (self.mapUnsafe.size === 0) return that;
 	if (that.mapUnsafe.size === 0) return self;
 	return withMapUnsafe(self, (map) => {
@@ -5498,8 +5529,8 @@ const withMapUnsafe = (self, f) => {
 const Reference = Service;
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.102/node_modules/effect/dist/Duration.js
-const TypeId$34 = "~effect/time/Duration";
-const bigint0$1 = /* @__PURE__ */ BigInt(0);
+const TypeId$35 = "~effect/time/Duration";
+const bigint0$2 = /* @__PURE__ */ BigInt(0);
 const bigint1 = /* @__PURE__ */ BigInt(1);
 const bigint1e3 = /* @__PURE__ */ BigInt(1e3);
 const roundTiesAwayFromZero = (input) => BigInt(input < 0 ? Math.ceil(input - .5) : Math.floor(input + .5));
@@ -5563,7 +5594,7 @@ const fromInputUnsafe = (input) => {
 		}
 		case "object": {
 			if (input === null) break;
-			if (TypeId$34 in input) return input;
+			if (TypeId$35 in input) return input;
 			if (Array.isArray(input)) {
 				if (input.length !== 2 || !input.every(isNumber)) return invalid(input);
 				if (Number.isNaN(input[0]) || Number.isNaN(input[1])) return zero;
@@ -5595,7 +5626,7 @@ const zeroDurationValue = {
 const infinityDurationValue = { _tag: "Infinity" };
 const negativeInfinityDurationValue = { _tag: "NegativeInfinity" };
 const DurationProto = {
-	[TypeId$34]: TypeId$34,
+	[TypeId$35]: TypeId$35,
 	[symbol$1]() {
 		return structure(this.value);
 	},
@@ -5651,7 +5682,7 @@ const make$34 = (input) => {
 		_tag: "Millis",
 		millis: input
 	};
-	else if (input === bigint0$1) duration.value = zeroDurationValue;
+	else if (input === bigint0$2) duration.value = zeroDurationValue;
 	else duration.value = {
 		_tag: "Nanos",
 		nanos: input
@@ -5673,7 +5704,7 @@ const make$34 = (input) => {
 * @category guards
 * @since 2.0.0
 */
-const isDuration = (u) => hasProperty(u, TypeId$34);
+const isDuration = (u) => hasProperty(u, TypeId$35);
 /**
 * Checks whether a Duration is finite (not infinite).
 *
@@ -5708,7 +5739,7 @@ const isFinite$1 = (self) => self.value._tag !== "Infinity" && self.value._tag !
 const isZero = (self) => {
 	switch (self.value._tag) {
 		case "Millis": return self.value.millis === 0;
-		case "Nanos": return self.value.nanos === bigint0$1;
+		case "Nanos": return self.value.nanos === bigint0$2;
 		case "Infinity":
 		case "NegativeInfinity": return false;
 	}
@@ -6741,7 +6772,7 @@ var Interrupt = class extends ReasonBase {
 		return isInterruptReason(that) && this.fiberId === that.fiberId && this.annotations === that.annotations;
 	}
 	[symbol$1]() {
-		return combine(string$2(`${this._tag}:${this.fiberId}`))(random(this.annotations));
+		return combine$1(string$2(`${this._tag}:${this.fiberId}`))(random(this.annotations));
 	}
 };
 /** @internal */
@@ -7171,7 +7202,7 @@ const fiberInterrupt = (self) => withFiber$1((fiber) => fiberInterruptAs(self, f
 /** @internal */
 const fiberInterruptAs = /* @__PURE__ */ dual((args) => hasProperty(args[0], FiberTypeId), (self, fiberId, annotations) => withFiber$1((parent) => {
 	let ann = fiberStackAnnotations(parent);
-	ann = ann && annotations ? merge$3(ann, annotations) : ann ?? annotations;
+	ann = ann && annotations ? merge$4(ann, annotations) : ann ?? annotations;
 	self.interruptUnsafe(fiberId, ann);
 	return asVoid$1(fiberAwait(self));
 }));
@@ -7531,6 +7562,8 @@ const exitAsVoidAll = (exits) => {
 	return failures.length === 0 ? exitVoid : exitFailCause(causeFromReasons(failures));
 };
 /** @internal */
+const service$1 = (service) => service;
+/** @internal */
 const serviceOption$1 = (service) => withFiber$1((fiber) => succeed$5(getOption(fiber.context, service)));
 /** @internal */
 const updateContext$1 = /* @__PURE__ */ dual(2, (self, f) => withFiber$1((fiber) => {
@@ -7550,14 +7583,14 @@ const updateService = /* @__PURE__ */ dual(3, (self, service, f) => updateContex
 	return add(s, service, next);
 }));
 /** @internal */
-const context$1 = () => getContext;
+const context$2 = () => getContext;
 const getContext = /* @__PURE__ */ withFiber$1((fiber) => succeed$5(fiber.context));
 /** @internal */
 const contextWith$1 = (f) => withFiber$1((fiber) => f(fiber.context));
 /** @internal */
 const provideContext$1 = /* @__PURE__ */ dual(2, (self, context) => {
 	if (effectIsExit(self)) return self;
-	return updateContext$1(self, merge$3(context));
+	return updateContext$1(self, merge$4(context));
 });
 /** @internal */
 const provideService$3 = function() {
@@ -8285,7 +8318,7 @@ const makeLatchUnsafe = (open) => new Latch(open ?? false);
 const makeLatch = (open) => sync$2(() => makeLatchUnsafe(open));
 /** @internal */
 const withTracerEnabled$1 = /* @__PURE__ */ provideService$3(TracerEnabled);
-const bigint0 = /* @__PURE__ */ BigInt(0);
+const bigint0$1 = /* @__PURE__ */ BigInt(0);
 const NoopSpanProto = {
 	_tag: "Span",
 	spanId: "noop",
@@ -8293,8 +8326,8 @@ const NoopSpanProto = {
 	sampled: false,
 	status: {
 		_tag: "Ended",
-		startTime: bigint0,
-		endTime: bigint0,
+		startTime: bigint0$1,
+		endTime: bigint0$1,
 		exit: exitVoid
 	},
 	attributes: /* @__PURE__ */ new Map(),
@@ -8727,6 +8760,38 @@ const hasInterruptsOnly = hasInterruptsOnly$1;
 */
 const map$4 = causeMap;
 /**
+* Merges two causes into a single cause whose `reasons` array is the union
+* of both inputs (de-duplicated by value equality).
+*
+* **When to use**
+*
+* Use to merge independent causes into one structured failure value.
+*
+* **Details**
+*
+* - Combining with `empty` returns the other cause unchanged.
+* - If the result is structurally equal to `self`, `self` is returned
+*   (referential shortcut).
+*
+* **Example** (Combining two causes)
+*
+* ```ts
+* import { Cause } from "effect"
+*
+* const cause1 = Cause.fail("error1")
+* const cause2 = Cause.fail("error2")
+* const combined = Cause.combine(cause1, cause2)
+* console.log(combined.reasons.length) // 2
+* ```
+*
+* @see {@link fromReasons} — build a cause from an array of reasons
+* @see {@link empty} for the identity cause used when combining
+*
+* @category combining
+* @since 4.0.0
+*/
+const combine = causeCombine;
+/**
 * Collapses a `Cause` into a single `unknown` value, picking the "most
 * important" failure in this order:
 *
@@ -9898,14 +9963,14 @@ const forkUnsafe = scopeForkUnsafe;
 const close = scopeClose;
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.102/node_modules/effect/dist/Layer.js
-const TypeId$32 = "~effect/Layer";
+const TypeId$33 = "~effect/Layer";
 const MemoMapTypeId = "~effect/Layer/MemoMap";
 const memoMapReuse = (entry, scope) => {
 	entry.observers++;
 	return andThen$1(scopeAddFinalizerExit(scope, (exit) => entry.finalizer(exit)), entry.effect);
 };
 const LayerProto = {
-	[TypeId$32]: {
+	[TypeId$33]: {
 		_ROut: identity,
 		_E: identity,
 		_RIn: identity
@@ -10561,6 +10626,50 @@ const mergeAllEffect = (layers, memoMap, scope) => {
 * @since 2.0.0
 */
 const mergeAll$1 = (...layers) => fromBuild((memoMap, scope) => mergeAllEffect(layers, memoMap, scope));
+/**
+* Merges this layer with another layer concurrently, producing a new layer with
+* combined input, error, and output types.
+*
+* **When to use**
+*
+* Use to combine an existing `Layer` with another `Layer` or an array of
+* layers while preserving pipeline style.
+*
+* **Details**
+*
+* This is a binary version of `mergeAll` that merges exactly two layers or one
+* layer with an array of layers. The layers are built concurrently and their
+* outputs are combined.
+*
+* **Example** (Merging two layers)
+*
+* ```ts
+* import { Context, Effect, Layer } from "effect"
+*
+* class Database extends Context.Service<Database, {
+*   readonly query: (sql: string) => Effect.Effect<string>
+* }>()("Database") {}
+*
+* class Logger extends Context.Service<Logger, {
+*   readonly log: (msg: string) => Effect.Effect<void>
+* }>()("Logger") {}
+*
+* const dbLayer = Layer.succeed(Database, {
+*   query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
+* })
+* const loggerLayer = Layer.succeed(Logger, {
+*   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
+* })
+*
+* const mergedLayer = Layer.merge(dbLayer, loggerLayer)
+* ```
+*
+* @see {@link mergeAll} for merging several layers at once
+*
+* @category zipping
+* @since 2.0.0
+*/
+const merge$3 = /* @__PURE__ */ dual(2, (self, that) => mergeAll$1(self, ...Array.isArray(that) ? that : [that]));
 const provideWith = (self, that, f) => fromBuild((memoMap, scope) => flatMap$4(Array.isArray(that) ? mergeAllEffect(that, memoMap, scope) : that.build(memoMap, scope), (context) => self.build(memoMap, scope).pipe(provideContext$1(context), map$5((merged) => f(merged, context)))));
 /**
 * Feeds the output services of the dependency layer into the requirements of
@@ -10723,7 +10832,7 @@ const provide$2 = /* @__PURE__ */ dual(2, (self, that) => provideWith(self, that
 * @category providing services
 * @since 2.0.0
 */
-const provideMerge = /* @__PURE__ */ dual(2, (self, that) => provideWith(self, that, (self, that) => merge$3(that, self)));
+const provideMerge = /* @__PURE__ */ dual(2, (self, that) => provideWith(self, that, (self, that) => merge$4(that, self)));
 /**
 * Constructs a layer dynamically based on the output of this layer.
 *
@@ -10828,11 +10937,11 @@ const Clock = ClockRef;
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.102/node_modules/effect/dist/internal/dateTime.js
 /** @internal */
-const TypeId$31 = "~effect/time/DateTime";
+const TypeId$32 = "~effect/time/DateTime";
 /** @internal */
 const TimeZoneTypeId = "~effect/time/DateTime/TimeZone";
 const Proto$12 = {
-	[TypeId$31]: TypeId$31,
+	[TypeId$32]: TypeId$32,
 	pipe() {
 		return pipeArguments(this, arguments);
 	},
@@ -11077,7 +11186,7 @@ const matchEffect$1 = /* @__PURE__ */ dual(2, (self, options) => matchCauseEffec
 }));
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.102/node_modules/effect/dist/Schedule.js
-const TypeId$30 = "~effect/Schedule";
+const TypeId$31 = "~effect/Schedule";
 /**
 * Context reference containing metadata for the currently running schedule step.
 *
@@ -11102,7 +11211,7 @@ const CurrentMetadata = /* @__PURE__ */ Reference("effect/Schedule/CurrentMetada
 	elapsedSincePrevious: 0
 }) });
 const ScheduleProto = {
-	[TypeId$30]: {
+	[TypeId$31]: {
 		_Out: identity,
 		_In: identity,
 		_Env: identity
@@ -11131,7 +11240,7 @@ const ScheduleProto = {
 * @category guards
 * @since 2.0.0
 */
-const isSchedule = (u) => hasProperty(u, TypeId$30);
+const isSchedule = (u) => hasProperty(u, TypeId$31);
 /**
 * Creates a Schedule from a step function that returns a Pull.
 *
@@ -11596,6 +11705,54 @@ const buildFromOptions = (options) => {
 	return schedule;
 };
 /**
+* Context reference for metric attributes applied from the current Effect
+* context.
+*
+* **When to use**
+*
+* Use to provide default attributes that should be merged into metric updates
+* and reads in a scoped part of a program.
+*
+* **Details**
+*
+* The default value is an empty attribute set. Metric reads and updates merge
+* these contextual attributes with the metric's own attributes to select the
+* metric series being accessed.
+*
+* **Example** (Providing current metric attributes)
+*
+* ```ts
+* import { Data, Effect, Metric } from "effect"
+*
+* class AttributesError extends Data.TaggedError("AttributesError")<{
+*   readonly operation: string
+* }> {}
+*
+* const program = Effect.gen(function*() {
+*   // Access current metric attributes
+*   const attributes = yield* Metric.CurrentMetricAttributes
+*   console.log("Current attributes:", attributes)
+*
+*   // Set new attributes context
+*   const newAttributes = { service: "api", version: "1.0" }
+*   const result = yield* Effect.provideService(
+*     Effect.gen(function*() {
+*       const updatedAttributes = yield* Metric.CurrentMetricAttributes
+*       return updatedAttributes
+*     }),
+*     Metric.CurrentMetricAttributes,
+*     newAttributes
+*   )
+*
+*   return result
+* })
+* ```
+*
+* @category references
+* @since 4.0.0
+*/
+const CurrentMetricAttributes = /* @__PURE__ */ Reference("effect/Metric/CurrentMetricAttributes", { defaultValue: () => ({}) });
+/**
 * Context reference for the metric registry in the current context.
 *
 * **When to use**
@@ -11622,6 +11779,348 @@ const buildFromOptions = (options) => {
 * @since 4.0.0
 */
 const MetricRegistry = /* @__PURE__ */ Reference("~effect/observability/Metric/MetricRegistryKey", { defaultValue: () => /* @__PURE__ */ new Map() });
+const TypeId$30 = "~effect/observability/Metric";
+var Metric$ = class {
+	[TypeId$30] = TypeId$30;
+	#metadataCache = /* @__PURE__ */ new WeakMap();
+	#metadata;
+	id;
+	description;
+	attributes;
+	constructor(id, description, attributes) {
+		this.id = id;
+		this.description = description;
+		this.attributes = attributes;
+	}
+	valueUnsafe(context) {
+		return this.hook(context).get(context);
+	}
+	modifyUnsafe(input, context) {
+		return this.hook(context).modify(input, context);
+	}
+	updateUnsafe(input, context) {
+		return this.hook(context).update(input, context);
+	}
+	hook(context) {
+		const extraAttributes = get$4(context, CurrentMetricAttributes);
+		if (Object.keys(extraAttributes).length === 0) {
+			if (isNotUndefined(this.#metadata)) return this.#metadata.hooks;
+			this.#metadata = this.getOrCreate(context, this.attributes);
+			return this.#metadata.hooks;
+		}
+		const mergedAttributes = mergeAttributes(this.attributes, extraAttributes);
+		let metadata = this.#metadataCache.get(mergedAttributes);
+		if (isNotUndefined(metadata)) return metadata.hooks;
+		metadata = this.getOrCreate(context, mergedAttributes);
+		this.#metadataCache.set(mergedAttributes, metadata);
+		return metadata.hooks;
+	}
+	getOrCreate(context, attributes) {
+		const key = makeKey(this, attributes);
+		const registry = get$4(context, MetricRegistry);
+		if (registry.has(key)) return registry.get(key);
+		const hooks = this.createHooks();
+		const meta = {
+			id: this.id,
+			type: this.type,
+			description: this.description,
+			attributes: attributesToRecord(attributes),
+			hooks
+		};
+		registry.set(key, meta);
+		return meta;
+	}
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+};
+const bigint0 = /* @__PURE__ */ BigInt(0);
+var CounterMetric = class extends Metric$ {
+	type = "Counter";
+	#bigint;
+	#incremental;
+	constructor(id, options) {
+		super(id, options?.description, attributesToRecord(options?.attributes));
+		this.#bigint = options?.bigint ?? false;
+		this.#incremental = options?.incremental ?? false;
+	}
+	createHooks() {
+		let count = this.#bigint ? bigint0 : 0;
+		const canUpdate = this.#incremental ? this.#bigint ? (value) => value >= bigint0 : (value) => value >= 0 : (_value) => true;
+		const update = (value) => {
+			if (canUpdate(value)) count = count + value;
+		};
+		return makeHooks(() => ({
+			count,
+			incremental: this.#incremental
+		}), update);
+	}
+};
+var HistogramMetric = class extends Metric$ {
+	type = "Histogram";
+	#boundaries;
+	constructor(id, options) {
+		super(id, options?.description, attributesToRecord(options?.attributes));
+		this.#boundaries = options.boundaries;
+	}
+	createHooks() {
+		const bounds = this.#boundaries;
+		const size = bounds.length;
+		const values = new Uint32Array(size + 1);
+		const boundaries = new Float64Array(size);
+		let count = 0;
+		let sum = 0;
+		let min = Number.MAX_VALUE;
+		let max = -Number.MAX_VALUE;
+		map$6(sort$1(bounds, Number$5), (n, i) => {
+			boundaries[i] = n;
+		});
+		const update = (value) => {
+			let from = 0;
+			let to = size;
+			while (from !== to) {
+				const mid = Math.floor(from + (to - from) / 2);
+				if (value <= boundaries[mid]) to = mid;
+				else from = mid;
+				if (to === from + 1) if (value <= boundaries[from]) to = from;
+				else from = to;
+			}
+			values[from] = values[from] + 1;
+			count = count + 1;
+			sum = sum + value;
+			if (value < min) min = value;
+			if (value > max) max = value;
+		};
+		const getBuckets = () => {
+			const builder = allocate(size);
+			let cumulated = 0;
+			for (let i = 0; i < size; i++) {
+				const boundary = boundaries[i];
+				const value = values[i];
+				cumulated = cumulated + value;
+				builder[i] = [boundary, cumulated];
+			}
+			return builder;
+		};
+		return makeHooks(() => ({
+			buckets: getBuckets(),
+			count,
+			min,
+			max,
+			sum
+		}), update);
+	}
+};
+var MetricTransform = class extends Metric$ {
+	type;
+	metric;
+	valueUnsafe;
+	updateUnsafe;
+	modifyUnsafe;
+	constructor(metric, valueUnsafe, updateUnsafe, modifyUnsafe) {
+		super(metric.id, metric.description, metric.attributes);
+		this.metric = metric;
+		this.valueUnsafe = valueUnsafe;
+		this.updateUnsafe = updateUnsafe;
+		this.modifyUnsafe = modifyUnsafe;
+		this.type = metric.type;
+	}
+	createHooks() {
+		return this.metric.createHooks();
+	}
+};
+/**
+* Represents a Counter metric that tracks cumulative numerical values over
+* time. Counters can be incremented and decremented and provide a running total
+* of changes.
+*
+* **Details**
+*
+* The optional `description` describes the counter, and `attributes` attach
+* dimensions to it. Set `bigint` to create a counter that accepts `bigint`
+* inputs. Set `incremental` to `true` to create a counter that can only ever be
+* incremented.
+*
+* **Example** (Creating counter metrics)
+*
+* ```ts
+* import { Data, Effect, Metric } from "effect"
+*
+* class CounterError extends Data.TaggedError("CounterError")<{
+*   readonly operation: string
+* }> {}
+*
+* const program = Effect.gen(function*() {
+*   // Create a basic counter for tracking requests
+*   const requestCounter = Metric.counter("http_requests_total", {
+*     description: "Total number of HTTP requests processed"
+*   })
+*
+*   // Create an incremental-only counter for events
+*   const eventCounter = Metric.counter("events_processed", {
+*     description: "Events processed (increment only)",
+*     incremental: true
+*   })
+*
+*   // Create a bigint counter for large values
+*   const bytesCounter = Metric.counter("bytes_transferred", {
+*     description: "Total bytes transferred",
+*     bigint: true,
+*     attributes: { service: "file-transfer" }
+*   })
+*
+*   // Update counters with values
+*   yield* Metric.update(requestCounter, 1) // Increment by 1
+*   yield* Metric.update(requestCounter, 5) // Increment by 5 (total: 6)
+*   yield* Metric.update(eventCounter, 1) // Increment by 1
+*   yield* Metric.update(bytesCounter, 1024n) // Add 1024 bytes
+*
+*   // Get current counter values
+*   const requestValue = yield* Metric.value(requestCounter)
+*   const eventValue = yield* Metric.value(eventCounter)
+*   const bytesValue = yield* Metric.value(bytesCounter)
+*
+*   return { requestValue, eventValue, bytesValue }
+* })
+* ```
+*
+* @category constructors
+* @since 2.0.0
+*/
+const counter = (name, options) => new CounterMetric(name, options);
+/**
+* Represents a `Histogram` metric that records observations into buckets.
+*
+* **When to use**
+*
+* Use when you need a metric for measuring the distribution of values within a
+* range.
+*
+* **Details**
+*
+* The optional `description` describes the histogram, and `attributes` attach
+* dimensions to it. The required `boundaries` option defines the histogram
+* bucket boundaries.
+*
+* **Example** (Creating histogram metrics)
+*
+* ```ts
+* import { Data, Effect, Metric } from "effect"
+*
+* class HistogramError extends Data.TaggedError("HistogramError")<{
+*   readonly operation: string
+* }> {}
+*
+* const program = Effect.gen(function*() {
+*   // Create a histogram for API response times
+*   const responseTimeHistogram = Metric.histogram("api_response_time", {
+*     description: "Distribution of API response times in milliseconds",
+*     boundaries: Metric.linearBoundaries({ start: 0, width: 50, count: 10 })
+*     // Creates buckets: 0-50ms, 50-100ms, 100-150ms, ..., 400-450ms, 450ms+
+*   })
+*
+*   // Create a histogram for request payload sizes
+*   const payloadSizeHistogram = Metric.histogram("payload_size", {
+*     description: "Distribution of request payload sizes in KB",
+*     boundaries: Metric.exponentialBoundaries({ start: 1, factor: 2, count: 8 }),
+*     // Creates exponential buckets: 1KB, 2KB, 4KB, 8KB, 16KB, 32KB, 64KB, 128KB+
+*     attributes: { service: "api-gateway" }
+*   })
+*
+*   // Create a histogram with custom boundaries
+*   const customHistogram = Metric.histogram("custom_metric", {
+*     description: "Custom distribution metric",
+*     boundaries: [0.1, 0.5, 1, 2.5, 5, 10, 25, 50, 100]
+*   })
+*
+*   // Record various response times
+*   yield* Metric.update(responseTimeHistogram, 25) // Goes in 0-50ms bucket
+*   yield* Metric.update(responseTimeHistogram, 75) // Goes in 50-100ms bucket
+*   yield* Metric.update(responseTimeHistogram, 125) // Goes in 100-150ms bucket
+*   yield* Metric.update(responseTimeHistogram, 200) // Goes in 150-200ms bucket
+*   yield* Metric.update(responseTimeHistogram, 75) // Another 50-100ms
+*
+*   // Record payload sizes
+*   yield* Metric.update(payloadSizeHistogram, 3) // Goes in 2-4KB bucket
+*   yield* Metric.update(payloadSizeHistogram, 15) // Goes in 8-16KB bucket
+*   yield* Metric.update(payloadSizeHistogram, 0.5) // Goes in 0-1KB bucket
+*
+*   // Get histogram state with distribution data
+*   const responseTimeState = yield* Metric.value(responseTimeHistogram)
+*   const payloadSizeState = yield* Metric.value(payloadSizeHistogram)
+*
+*   // responseTimeState will contain:
+*   // - buckets: [[50, 1], [100, 3], [150, 4], [200, 5], ...]
+*   // - count: 5, min: 25, max: 200, sum: 500
+*   // - Useful for calculating percentiles, averages, etc.
+*
+*   return { responseTimeState, payloadSizeState }
+* })
+* ```
+*
+* @category constructors
+* @since 2.0.0
+*/
+const histogram = (name, options) => new HistogramMetric(name, options);
+/**
+* Returns a new metric that applies the specified attributes to all operations.
+*
+* **Details**
+*
+* Attributes are key-value pairs that provide additional context for metrics,
+* enabling filtering, grouping, and more detailed analysis. Each combination
+* of attribute values creates a separate metric series.
+*
+* **Example** (Applying metric attributes)
+*
+* ```ts
+* import { Effect, Metric } from "effect"
+*
+* const requestCounter = Metric.counter("http_requests_total", {
+*   description: "Total HTTP requests"
+* })
+*
+* // Create tagged versions of the metric
+* const getRequests = Metric.withAttributes(requestCounter, {
+*   method: "GET",
+*   endpoint: "/api/users"
+* })
+*
+* const postRequests = Metric.withAttributes(requestCounter, {
+*   method: "POST",
+*   endpoint: "/api/users"
+* })
+*
+* const program = Effect.gen(function*() {
+*   // These will be tracked as separate metric series
+*   yield* Metric.update(getRequests, 1) // http_requests_total{method="GET", endpoint="/api/users"}
+*   yield* Metric.update(postRequests, 1) // http_requests_total{method="POST", endpoint="/api/users"}
+*   yield* Metric.update(getRequests, 1) // Increments the GET counter
+*
+*   // You can also chain attributes
+*   const taggedMetric = requestCounter.pipe(
+*     Metric.withAttributes({ service: "user-api" }),
+*     Metric.withAttributes({ version: "v1" })
+*   )
+*
+*   yield* Metric.update(taggedMetric, 1) // http_requests_total{service="user-api", version="v1"}
+* })
+*
+* // When taking snapshots, each attribute combination appears as a separate metric
+* const viewMetrics = Effect.gen(function*() {
+*   const snapshots = yield* Metric.snapshot
+*   for (const metric of snapshots) {
+*     if (metric.id === "http_requests_total") {
+*       console.log(`${metric.id}`, metric.attributes, metric.state)
+*     }
+*   }
+* })
+* ```
+*
+* @category Attributes
+* @since 4.0.0
+*/
+const withAttributes = /* @__PURE__ */ dual(2, (self, attributes) => new MetricTransform(self, (context) => self.valueUnsafe(addAttributesToContext(context, attributes)), (input, context) => self.updateUnsafe(input, addAttributesToContext(context, attributes)), (input, context) => self.modifyUnsafe(input, addAttributesToContext(context, attributes))));
 /**
 * Captures a snapshot of all registered metrics synchronously using the provided
 * service context.
@@ -11698,6 +12197,41 @@ const snapshotUnsafe = (context) => {
 		state: hooks.get(context)
 	}));
 };
+function makeKey(metric, attributes) {
+	let key = `${metric.type}:${metric.id}`;
+	if (isNotUndefined(metric.description)) key += `:${metric.description}`;
+	if (isNotUndefined(attributes)) key += `:${serializeAttributes(attributes)}`;
+	return key;
+}
+function makeHooks(get, update, modify) {
+	return {
+		get,
+		update,
+		modify: modify ?? update
+	};
+}
+function serializeAttributes(attributes) {
+	return serializeEntries(Array.isArray(attributes) ? attributes : Object.entries(attributes));
+}
+function serializeEntries(entries) {
+	return entries.map(([key, value]) => `${key}=${value}`).join(",");
+}
+function mergeAttributes(self, other) {
+	return {
+		...attributesToRecord(self),
+		...attributesToRecord(other)
+	};
+}
+function attributesToRecord(attributes) {
+	if (isNotUndefined(attributes) && Array.isArray(attributes)) return attributes.reduce((acc, [key, value]) => {
+		assignProperty(acc, key, value);
+		return acc;
+	}, {});
+	return attributes;
+}
+function addAttributesToContext(context, attributes) {
+	return add(context, CurrentMetricAttributes, mergeAttributes(get$4(context, CurrentMetricAttributes), attributes));
+}
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.102/node_modules/effect/dist/Effect.js
 /**
@@ -13589,7 +14123,7 @@ const matchEffect = matchEffect$2;
 * @category environment
 * @since 2.0.0
 */
-const context = context$1;
+const context$1 = context$2;
 /**
 * Transforms the current context using the provided function.
 *
@@ -13722,6 +14256,30 @@ const provide = provide$1;
 */
 const provideContext = provideContext$1;
 /**
+* Accesses a service from the context.
+*
+* **Example** (Accessing a required service)
+*
+* ```ts
+* import { Context, Effect } from "effect"
+*
+* interface Database {
+*   readonly query: (sql: string) => Effect.Effect<string>
+* }
+*
+* const Database = Context.Service<Database>("Database")
+*
+* const program = Effect.gen(function*() {
+*   const db = yield* Effect.service(Database)
+*   return yield* db.query("SELECT * FROM users")
+* })
+* ```
+*
+* @category context
+* @since 4.0.0
+*/
+const service = service$1;
+/**
 * Optionally accesses a service from the environment.
 *
 * **When to use**
@@ -54752,7 +55310,7 @@ const mapEffectConcurrent = (self, f, options) => fromTransformBracket(fnUntrace
 	const concurrencyN = options.concurrency === "unbounded" ? Number.MAX_SAFE_INTEGER : options.concurrency;
 	const queue = yield* bounded(0);
 	yield* addFinalizer(forkedScope, shutdown(queue));
-	const runFork = runForkWith(yield* context());
+	const runFork = runForkWith(yield* context$1());
 	const trackFiber = runIn(forkedScope);
 	if (options.unordered) {
 		const semaphore = makeUnsafe$2(concurrencyN);
@@ -56623,7 +57181,7 @@ const flatten = /* @__PURE__ */ dual((args) => isStream(args[0]), (self, options
 * @category sequencing
 * @since 2.0.0
 */
-const concat = /* @__PURE__ */ dual(2, (self, that) => flatten(fromArray([self, that])));
+const concat$1 = /* @__PURE__ */ dual(2, (self, that) => flatten(fromArray([self, that])));
 /**
 * Merges two streams, emitting elements from both as they arrive.
 *
@@ -57102,7 +57660,7 @@ const toReadableStreamWith = /* @__PURE__ */ dual((args) => isStream(args[0]), (
 * @category destructors
 * @since 2.0.0
 */
-const toReadableStreamEffect = /* @__PURE__ */ dual((args) => isStream(args[0]), (self, options) => map$3(context(), (context) => toReadableStreamWith(self, context, options)));
+const toReadableStreamEffect = /* @__PURE__ */ dual((args) => isStream(args[0]), (self, options) => map$3(context$1(), (context) => toReadableStreamWith(self, context, options)));
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.102/node_modules/effect/dist/FileSystem.js
 /**
@@ -59911,7 +60469,7 @@ const SpanNameGenerator = /* @__PURE__ */ Reference("effect/http/HttpClient/Span
 * @category layers
 * @since 4.0.0
 */
-const layerMergedContext = (effect$2) => effect(HttpClient)(contextWith((context) => map$3(effect$2, (client) => transformResponse(client, updateContext((input) => merge$3(context, input))))));
+const layerMergedContext = (effect$2) => effect(HttpClient)(contextWith((context) => map$3(effect$2, (client) => transformResponse(client, updateContext((input) => merge$4(context, input))))));
 const responseRegistry = /* @__PURE__ */ (() => {
 	if ("FinalizationRegistry" in globalThis && globalThis.FinalizationRegistry) {
 		const registry = /* @__PURE__ */ new FinalizationRegistry((controller) => {
@@ -60452,7 +61010,7 @@ const runImpl = (self, effect, options) => withFiber((parent) => {
 * @category combinators
 * @since 2.0.0
 */
-const runtime = (self) => () => map$3(context(), (services) => {
+const runtime = (self) => () => map$3(context$1(), (services) => {
 	const runFork = runForkWith(services);
 	return (effect, options) => {
 		if (self.state._tag === "Closed") return constInterruptedFiber();
@@ -60574,7 +61132,7 @@ const layerFlusher = /* @__PURE__ */ sync$1(Flusher, () => {
 * @since 4.0.0
 */
 const make$8 = /* @__PURE__ */ fnUntraced(function* (options) {
-	const services = yield* context();
+	const services = yield* context$1();
 	const clock = get$4(services, Clock);
 	const scope = get$4(services, Scope);
 	const exportInterval = max(fromInputUnsafe(options.exportInterval), zero);
@@ -60743,6 +61301,537 @@ const unknownToAttributeValue = (value) => {
 	}
 };
 //#endregion
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.102/node_modules/effect/dist/unstable/observability/internal/protobuf.js
+/**
+* Low-level protobuf wire format encoding utilities.
+*
+* Protobuf wire types:
+* - 0: Varint (int32, int64, uint32, uint64, sint32, sint64, bool, enum)
+* - 1: 64-bit (fixed64, sfixed64, double)
+* - 2: Length-delimited (string, bytes, embedded messages, packed repeated fields)
+* - 5: 32-bit (fixed32, sfixed32, float)
+*/
+const WireType = {
+	Varint: 0,
+	Fixed64: 1,
+	LengthDelimited: 2,
+	Fixed32: 5
+};
+/**
+* Encodes a field tag (field number + wire type)
+*/
+const encodeTag = (fieldNumber, wireType) => fieldNumber << 3 | wireType;
+/**
+* Encodes a varint (variable-length integer)
+*
+* @internal
+*/
+const encodeVarint = (value) => {
+	const bytes = [];
+	let n = typeof value === "bigint" ? value : BigInt(value);
+	while (n > BigInt(127)) {
+		bytes.push(Number(n & BigInt(127)) | 128);
+		n >>= BigInt(7);
+	}
+	bytes.push(Number(n));
+	return new Uint8Array(bytes);
+};
+/**
+* Encodes a 64-bit fixed value (little-endian)
+*
+* @internal
+*/
+const encodeFixed64 = (value) => {
+	const bytes = new Uint8Array(8);
+	new DataView(bytes.buffer).setBigUint64(0, value, true);
+	return bytes;
+};
+/**
+* Encodes a 32-bit fixed value (little-endian)
+*
+* @internal
+*/
+const encodeFixed32 = (value) => {
+	const bytes = new Uint8Array(4);
+	new DataView(bytes.buffer).setUint32(0, value, true);
+	return bytes;
+};
+/**
+* Encodes a double (64-bit float, little-endian)
+*
+* @internal
+*/
+const encodeDouble = (value) => {
+	const bytes = new Uint8Array(8);
+	new DataView(bytes.buffer).setFloat64(0, value, true);
+	return bytes;
+};
+/**
+* Encodes a string to UTF-8 bytes
+*
+* @internal
+*/
+const encodeString = (value) => new TextEncoder().encode(value);
+/**
+* Encodes bytes as a hex string to Uint8Array
+*
+* @internal
+*/
+const encodeHexBytes = (hex) => {
+	const bytes = new Uint8Array(hex.length / 2);
+	for (let i = 0; i < hex.length; i += 2) bytes[i / 2] = parseInt(hex.slice(i, i + 2), 16);
+	return bytes;
+};
+/**
+* Concatenates multiple Uint8Arrays
+*
+* @internal
+*/
+const concat = (...arrays) => {
+	const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+	const result = new Uint8Array(totalLength);
+	let offset = 0;
+	for (const arr of arrays) {
+		result.set(arr, offset);
+		offset += arr.length;
+	}
+	return result;
+};
+/**
+* Encodes a varint field
+*
+* @internal
+*/
+const varintField = (fieldNumber, value) => concat(encodeVarint(encodeTag(fieldNumber, WireType.Varint)), encodeVarint(value));
+/**
+* Encodes a bool field
+*
+* @internal
+*/
+const boolField = (fieldNumber, value) => varintField(fieldNumber, value ? 1 : 0);
+/**
+* Encodes a fixed64 field
+*
+* @internal
+*/
+const fixed64Field = (fieldNumber, value) => concat(encodeVarint(encodeTag(fieldNumber, WireType.Fixed64)), encodeFixed64(value));
+/**
+* Encodes a fixed32 field
+*
+* @internal
+*/
+const fixed32Field = (fieldNumber, value) => concat(encodeVarint(encodeTag(fieldNumber, WireType.Fixed32)), encodeFixed32(value));
+/**
+* Encodes a double field
+*
+* @internal
+*/
+const doubleField = (fieldNumber, value) => concat(encodeVarint(encodeTag(fieldNumber, WireType.Fixed64)), encodeDouble(value));
+/**
+* Encodes a length-delimited field (bytes, string, embedded message)
+*
+* @internal
+*/
+const lengthDelimitedField = (fieldNumber, value) => concat(encodeVarint(encodeTag(fieldNumber, WireType.LengthDelimited)), encodeVarint(value.length), value);
+/**
+* Encodes a string field
+*
+* @internal
+*/
+const stringField = (fieldNumber, value) => lengthDelimitedField(fieldNumber, encodeString(value));
+/**
+* Encodes a bytes field from hex string
+*
+* @internal
+*/
+const bytesFieldFromHex = (fieldNumber, hex) => lengthDelimitedField(fieldNumber, encodeHexBytes(hex));
+/**
+* Encodes an embedded message field
+*
+* @internal
+*/
+const messageField = (fieldNumber, message) => lengthDelimitedField(fieldNumber, message);
+/**
+* Encodes repeated fields
+*
+* @internal
+*/
+const repeatedField = (fieldNumber, values, encode) => concat(...values.map((v) => messageField(fieldNumber, encode(v))));
+/**
+* Helper to conditionally encode a string field if non-empty
+*
+* @internal
+*/
+const optionalStringField = (fieldNumber, value) => value !== void 0 && value !== "" ? stringField(fieldNumber, value) : new Uint8Array(0);
+//#endregion
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.102/node_modules/effect/dist/unstable/observability/internal/otlpProtobuf.js
+/**
+* OTLP Protobuf encoding for traces, metrics, and logs.
+*
+* Implements the protobuf wire format according to:
+* https://github.com/open-telemetry/opentelemetry-proto
+*/
+/**
+* Encodes an AnyValue message.
+*
+* message AnyValue {
+*   oneof value {
+*     string string_value = 1;
+*     bool bool_value = 2;
+*     int64 int_value = 3;
+*     double double_value = 4;
+*     ArrayValue array_value = 5;
+*     KeyValueList kvlist_value = 6;
+*     bytes bytes_value = 7;
+*   }
+* }
+*
+* @internal
+*/
+const encodeAnyValue = (value) => {
+	if (value.stringValue !== void 0 && value.stringValue !== null) return stringField(1, value.stringValue);
+	if (value.boolValue !== void 0 && value.boolValue !== null) return boolField(2, value.boolValue);
+	if (value.intValue !== void 0 && value.intValue !== null) return varintField(3, BigInt(value.intValue));
+	if (value.doubleValue !== void 0 && value.doubleValue !== null) return doubleField(4, value.doubleValue);
+	if (value.arrayValue !== void 0) return messageField(5, encodeArrayValue(value.arrayValue));
+	if (value.kvlistValue !== void 0) return messageField(6, encodeKeyValueList(value.kvlistValue));
+	if (value.bytesValue !== void 0) return lengthDelimitedField(7, value.bytesValue);
+	return new Uint8Array(0);
+};
+/**
+* Encodes an ArrayValue message.
+*
+* message ArrayValue {
+*   repeated AnyValue values = 1;
+* }
+*
+* @internal
+*/
+const encodeArrayValue = (value) => repeatedField(1, value.values, encodeAnyValue);
+/**
+* Encodes a KeyValueList message.
+*
+* message KeyValueList {
+*   repeated KeyValue values = 1;
+* }
+*
+* @internal
+*/
+const encodeKeyValueList = (value) => repeatedField(1, value.values, encodeKeyValue);
+/**
+* Encodes a KeyValue message.
+*
+* message KeyValue {
+*   string key = 1;
+*   AnyValue value = 2;
+* }
+*
+* @internal
+*/
+const encodeKeyValue = (kv) => concat(stringField(1, kv.key), messageField(2, encodeAnyValue(kv.value)));
+/**
+* Encodes an InstrumentationScope message.
+*
+* message InstrumentationScope {
+*   string name = 1;
+*   string version = 2;
+*   repeated KeyValue attributes = 3;
+*   uint32 dropped_attributes_count = 4;
+* }
+*
+* @internal
+*/
+const encodeInstrumentationScope = (scope) => concat(stringField(1, scope.name), optionalStringField(2, scope.version), scope.attributes ? repeatedField(3, scope.attributes, encodeKeyValue) : new Uint8Array(0), scope.droppedAttributesCount ? varintField(4, scope.droppedAttributesCount) : new Uint8Array(0));
+/**
+* Encodes a Resource message.
+*
+* message Resource {
+*   repeated KeyValue attributes = 1;
+*   uint32 dropped_attributes_count = 2;
+* }
+*
+* @internal
+*/
+const encodeResource = (resource) => concat(repeatedField(1, resource.attributes, encodeKeyValue), resource.droppedAttributesCount > 0 ? varintField(2, resource.droppedAttributesCount) : new Uint8Array(0));
+/**
+* Encodes a Status message.
+*
+* message Status {
+*   string message = 2;
+*   StatusCode code = 3;
+* }
+*
+* @internal
+*/
+const encodeStatus = (status) => concat(optionalStringField(2, status.message), varintField(3, status.code));
+/**
+* Encodes an Event message.
+*
+* message Event {
+*   fixed64 time_unix_nano = 1;
+*   string name = 2;
+*   repeated KeyValue attributes = 3;
+*   uint32 dropped_attributes_count = 4;
+* }
+*
+* @internal
+*/
+const encodeEvent = (event) => concat(fixed64Field(1, BigInt(event.timeUnixNano)), stringField(2, event.name), repeatedField(3, event.attributes, encodeKeyValue), event.droppedAttributesCount > 0 ? varintField(4, event.droppedAttributesCount) : new Uint8Array(0));
+/**
+* Encodes a Link message.
+*
+* message Link {
+*   bytes trace_id = 1;
+*   bytes span_id = 2;
+*   string trace_state = 3;
+*   repeated KeyValue attributes = 4;
+*   uint32 dropped_attributes_count = 5;
+*   fixed32 flags = 6;
+* }
+*
+* @internal
+*/
+const encodeLink = (link) => concat(bytesFieldFromHex(1, link.traceId), bytesFieldFromHex(2, link.spanId), optionalStringField(3, link.traceState), repeatedField(4, link.attributes, encodeKeyValue), link.droppedAttributesCount > 0 ? varintField(5, link.droppedAttributesCount) : new Uint8Array(0), link.flags !== void 0 ? fixed32Field(6, link.flags) : new Uint8Array(0));
+/**
+* Encodes a Span message.
+*
+* message Span {
+*   bytes trace_id = 1;
+*   bytes span_id = 2;
+*   string trace_state = 3;
+*   bytes parent_span_id = 4;
+*   string name = 5;
+*   SpanKind kind = 6;
+*   fixed64 start_time_unix_nano = 7;
+*   fixed64 end_time_unix_nano = 8;
+*   repeated KeyValue attributes = 9;
+*   uint32 dropped_attributes_count = 10;
+*   repeated Event events = 11;
+*   uint32 dropped_events_count = 12;
+*   repeated Link links = 13;
+*   uint32 dropped_links_count = 14;
+*   Status status = 15;
+*   fixed32 flags = 16;
+* }
+*
+* @internal
+*/
+const encodeSpan = (span) => concat(bytesFieldFromHex(1, span.traceId), bytesFieldFromHex(2, span.spanId), optionalStringField(3, span.traceState), span.parentSpanId !== void 0 ? bytesFieldFromHex(4, span.parentSpanId) : new Uint8Array(0), stringField(5, span.name), varintField(6, span.kind), fixed64Field(7, BigInt(span.startTimeUnixNano)), fixed64Field(8, BigInt(span.endTimeUnixNano)), repeatedField(9, span.attributes, encodeKeyValue), span.droppedAttributesCount > 0 ? varintField(10, span.droppedAttributesCount) : new Uint8Array(0), repeatedField(11, span.events, encodeEvent), span.droppedEventsCount > 0 ? varintField(12, span.droppedEventsCount) : new Uint8Array(0), repeatedField(13, span.links, encodeLink), span.droppedLinksCount > 0 ? varintField(14, span.droppedLinksCount) : new Uint8Array(0), messageField(15, encodeStatus(span.status)), span.flags !== void 0 ? fixed32Field(16, span.flags) : new Uint8Array(0));
+/**
+* Encodes a ScopeSpans message.
+*
+* message ScopeSpans {
+*   InstrumentationScope scope = 1;
+*   repeated Span spans = 2;
+*   string schema_url = 3;
+* }
+*
+* @internal
+*/
+const encodeScopeSpans = (scopeSpans) => concat(messageField(1, encodeInstrumentationScope(scopeSpans.scope)), repeatedField(2, scopeSpans.spans, encodeSpan), optionalStringField(3, scopeSpans.schemaUrl));
+/**
+* Encodes a ResourceSpans message.
+*
+* message ResourceSpans {
+*   Resource resource = 1;
+*   repeated ScopeSpans scope_spans = 2;
+*   string schema_url = 3;
+* }
+*
+* @internal
+*/
+const encodeResourceSpans = (resourceSpans) => concat(messageField(1, encodeResource(resourceSpans.resource)), repeatedField(2, resourceSpans.scopeSpans, encodeScopeSpans), optionalStringField(3, resourceSpans.schemaUrl));
+/**
+* Encodes a TracesData message (top-level export request).
+*
+* message TracesData {
+*   repeated ResourceSpans resource_spans = 1;
+* }
+*
+* @internal
+*/
+const encodeTracesData = (tracesData) => repeatedField(1, tracesData.resourceSpans, encodeResourceSpans);
+/**
+* Encodes a NumberDataPoint message.
+*
+* message NumberDataPoint {
+*   repeated KeyValue attributes = 7;
+*   fixed64 start_time_unix_nano = 2;
+*   fixed64 time_unix_nano = 3;
+*   oneof value {
+*     double as_double = 4;
+*     sfixed64 as_int = 6;
+*   }
+*   repeated Exemplar exemplars = 5;
+*   uint32 flags = 8;
+* }
+*
+* @internal
+*/
+const encodeNumberDataPoint = (point) => concat(fixed64Field(2, BigInt(point.startTimeUnixNano)), fixed64Field(3, BigInt(point.timeUnixNano)), point.asDouble !== void 0 ? doubleField(4, point.asDouble) : new Uint8Array(0), point.asInt !== void 0 ? fixed64Field(6, BigInt(point.asInt)) : new Uint8Array(0), repeatedField(7, point.attributes, encodeKeyValue), point.flags !== void 0 ? varintField(8, point.flags) : new Uint8Array(0));
+/**
+* Encodes a HistogramDataPoint message.
+*
+* message HistogramDataPoint {
+*   repeated KeyValue attributes = 9;
+*   fixed64 start_time_unix_nano = 2;
+*   fixed64 time_unix_nano = 3;
+*   fixed64 count = 4;
+*   optional double sum = 5;
+*   repeated fixed64 bucket_counts = 6;
+*   repeated double explicit_bounds = 7;
+*   optional double min = 11;
+*   optional double max = 12;
+*   uint32 flags = 10;
+* }
+*
+* @internal
+*/
+const encodeHistogramDataPoint = (point) => {
+	const bucketCountsEncoded = concat(...point.bucketCounts.map((count) => fixed64Field(6, BigInt(count))));
+	const explicitBoundsEncoded = concat(...point.explicitBounds.map((bound) => doubleField(7, bound)));
+	return concat(fixed64Field(2, BigInt(point.startTimeUnixNano)), fixed64Field(3, BigInt(point.timeUnixNano)), fixed64Field(4, BigInt(point.count)), point.sum !== void 0 ? doubleField(5, point.sum) : new Uint8Array(0), bucketCountsEncoded, explicitBoundsEncoded, repeatedField(9, point.attributes, encodeKeyValue), point.flags !== void 0 ? varintField(10, point.flags) : new Uint8Array(0), point.min !== void 0 ? doubleField(11, point.min) : new Uint8Array(0), point.max !== void 0 ? doubleField(12, point.max) : new Uint8Array(0));
+};
+/**
+* Encodes a Gauge message.
+*
+* message Gauge {
+*   repeated NumberDataPoint data_points = 1;
+* }
+*
+* @internal
+*/
+const encodeGauge = (gauge) => repeatedField(1, gauge.dataPoints, encodeNumberDataPoint);
+/**
+* Encodes a Sum message.
+*
+* message Sum {
+*   repeated NumberDataPoint data_points = 1;
+*   AggregationTemporality aggregation_temporality = 2;
+*   bool is_monotonic = 3;
+* }
+*
+* @internal
+*/
+const encodeSum = (sum) => concat(repeatedField(1, sum.dataPoints, encodeNumberDataPoint), varintField(2, sum.aggregationTemporality), boolField(3, sum.isMonotonic));
+/**
+* Encodes a Histogram message.
+*
+* message Histogram {
+*   repeated HistogramDataPoint data_points = 1;
+*   AggregationTemporality aggregation_temporality = 2;
+* }
+*
+* @internal
+*/
+const encodeHistogram = (histogram) => concat(repeatedField(1, histogram.dataPoints, encodeHistogramDataPoint), varintField(2, histogram.aggregationTemporality));
+/**
+* Encodes a Metric message.
+*
+* message Metric {
+*   string name = 1;
+*   string description = 2;
+*   string unit = 3;
+*   oneof data {
+*     Gauge gauge = 5;
+*     Sum sum = 7;
+*     Histogram histogram = 9;
+*     ExponentialHistogram exponential_histogram = 10;
+*     Summary summary = 11;
+*   }
+* }
+*
+* @internal
+*/
+const encodeMetric = (metric) => concat(stringField(1, metric.name), optionalStringField(2, metric.description), optionalStringField(3, metric.unit), metric.gauge !== void 0 ? messageField(5, encodeGauge(metric.gauge)) : new Uint8Array(0), metric.sum !== void 0 ? messageField(7, encodeSum(metric.sum)) : new Uint8Array(0), metric.histogram !== void 0 ? messageField(9, encodeHistogram(metric.histogram)) : new Uint8Array(0));
+/**
+* Encodes a ScopeMetrics message.
+*
+* message ScopeMetrics {
+*   InstrumentationScope scope = 1;
+*   repeated Metric metrics = 2;
+*   string schema_url = 3;
+* }
+*
+* @internal
+*/
+const encodeScopeMetrics = (scopeMetrics) => concat(messageField(1, encodeInstrumentationScope(scopeMetrics.scope)), repeatedField(2, scopeMetrics.metrics, encodeMetric), optionalStringField(3, scopeMetrics.schemaUrl));
+/**
+* Encodes a ResourceMetrics message.
+*
+* message ResourceMetrics {
+*   Resource resource = 1;
+*   repeated ScopeMetrics scope_metrics = 2;
+*   string schema_url = 3;
+* }
+*
+* @internal
+*/
+const encodeResourceMetrics = (resourceMetrics) => concat(messageField(1, encodeResource(resourceMetrics.resource)), repeatedField(2, resourceMetrics.scopeMetrics, encodeScopeMetrics), optionalStringField(3, resourceMetrics.schemaUrl));
+/**
+* Encodes a MetricsData message (top-level export request).
+*
+* message MetricsData {
+*   repeated ResourceMetrics resource_metrics = 1;
+* }
+*
+* @internal
+*/
+const encodeMetricsData = (metricsData) => repeatedField(1, metricsData.resourceMetrics, encodeResourceMetrics);
+/**
+* Encodes a LogRecord message.
+*
+* message LogRecord {
+*   fixed64 time_unix_nano = 1;
+*   fixed64 observed_time_unix_nano = 11;
+*   SeverityNumber severity_number = 2;
+*   string severity_text = 3;
+*   AnyValue body = 5;
+*   repeated KeyValue attributes = 6;
+*   uint32 dropped_attributes_count = 7;
+*   fixed32 flags = 8;
+*   bytes trace_id = 9;
+*   bytes span_id = 10;
+* }
+*
+* @internal
+*/
+const encodeLogRecord = (record) => concat(fixed64Field(1, BigInt(record.timeUnixNano)), record.severityNumber !== void 0 ? varintField(2, record.severityNumber) : new Uint8Array(0), optionalStringField(3, record.severityText), record.body !== void 0 ? messageField(5, encodeAnyValue(record.body)) : new Uint8Array(0), repeatedField(6, record.attributes, encodeKeyValue), record.droppedAttributesCount !== void 0 && record.droppedAttributesCount > 0 ? varintField(7, record.droppedAttributesCount) : new Uint8Array(0), record.flags !== void 0 ? fixed32Field(8, record.flags) : new Uint8Array(0), record.traceId !== void 0 && record.traceId !== "" ? bytesFieldFromHex(9, record.traceId) : new Uint8Array(0), record.spanId !== void 0 && record.spanId !== "" ? bytesFieldFromHex(10, record.spanId) : new Uint8Array(0), record.observedTimeUnixNano !== void 0 ? fixed64Field(11, BigInt(record.observedTimeUnixNano)) : new Uint8Array(0));
+/**
+* Encodes a ScopeLogs message.
+*
+* message ScopeLogs {
+*   InstrumentationScope scope = 1;
+*   repeated LogRecord log_records = 2;
+*   string schema_url = 3;
+* }
+*
+* @internal
+*/
+const encodeScopeLogs = (scopeLogs) => concat(messageField(1, encodeInstrumentationScope(scopeLogs.scope)), repeatedField(2, scopeLogs.logRecords, encodeLogRecord), optionalStringField(3, scopeLogs.schemaUrl));
+/**
+* Encodes a ResourceLogs message.
+*
+* message ResourceLogs {
+*   Resource resource = 1;
+*   repeated ScopeLogs scope_logs = 2;
+*   string schema_url = 3;
+* }
+*
+* @internal
+*/
+const encodeResourceLogs = (resourceLogs) => concat(messageField(1, encodeResource(resourceLogs.resource)), repeatedField(2, resourceLogs.scopeLogs, encodeScopeLogs), optionalStringField(3, resourceLogs.schemaUrl));
+/**
+* Encodes a LogsData message (top-level export request).
+*
+* message LogsData {
+*   repeated ResourceLogs resource_logs = 1;
+* }
+*
+* @internal
+*/
+const encodeLogsData = (logsData) => repeatedField(1, logsData.resourceLogs, encodeResourceLogs);
+//#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.102/node_modules/effect/dist/unstable/observability/OtlpSerialization.js
 /**
 * Serializes OTLP payloads into HTTP request bodies.
@@ -60772,6 +61861,18 @@ const layerJson$1 = /* @__PURE__ */ succeed$3(OtlpSerialization, {
 	metrics: (metrics) => jsonUnsafe(metrics),
 	logs: (logs) => jsonUnsafe(logs)
 });
+/**
+* Provides `OtlpSerialization` using protobuf-encoded OTLP bodies with the
+* `application/x-protobuf` content type.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layerProtobuf = /* @__PURE__ */ succeed$3(OtlpSerialization, {
+	traces: (spans) => uint8Array(encodeTracesData(spans), "application/x-protobuf"),
+	metrics: (metrics) => uint8Array(encodeMetricsData(metrics), "application/x-protobuf"),
+	logs: (logs) => uint8Array(encodeLogsData(logs), "application/x-protobuf")
+});
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.102/node_modules/effect/dist/unstable/observability/OtlpLogger.js
 /**
@@ -60944,7 +62045,7 @@ const make$5 = /* @__PURE__ */ fnUntraced(function* (options) {
 	const temporality = options.temporality ?? "cumulative";
 	const resource = yield* fromConfig(options.resource);
 	const metricsScope = { name: serviceNameUnsafe(resource) };
-	const services = yield* context();
+	const services = yield* context$1();
 	let previousExportTimeNanos = startTimeNanos;
 	const previousCounterState = /* @__PURE__ */ new Map();
 	const previousHistogramState = /* @__PURE__ */ new Map();
@@ -61662,7 +62763,7 @@ const TypeId$1 = "~effect/Cache";
 */
 const makeWith = (lookup, options) => contextWith$1((context) => {
 	const self = Object.create(Proto$1);
-	self.lookup = (key) => updateContext$1(lookup(key), (input) => merge$3(context, input));
+	self.lookup = (key) => updateContext$1(lookup(key), (input) => merge$4(context, input));
 	self.map = make$20();
 	self.capacity = options.capacity;
 	self.timeToLive = options.timeToLive ? (exit, key) => fromInputUnsafe(options.timeToLive(exit, key)) : defaultTimeToLive;
@@ -63745,6 +64846,11 @@ const REACT_ROUTER_CAPABILITY_THRESHOLDS = [
 	}
 ];
 const SCORE_API_URL = "https://www.react.doctor/api/score";
+const AXIOM_TRACES_PATH = "/v1/traces";
+const AXIOM_METRICS_PATH = "/v1/metrics";
+const AXIOM_DATASET_HEADER = "X-Axiom-Dataset";
+const AXIOM_METRICS_DATASET_HEADER = "x-axiom-metrics-dataset";
+const TELEMETRY_SHUTDOWN_TIMEOUT_MS = 1e3;
 const FETCH_TIMEOUT_MS = 1e4;
 const GITHUB_VIEWER_PERMISSION_TIMEOUT_MS = 2e3;
 const SPAWN_ARGS_MAX_LENGTH_CHARS = 24e3;
@@ -64007,7 +65113,7 @@ const SOCKET_FREE_USER_AGENT = "react-doctor-supply-chain";
 const FILE_LINT_CACHE_FILENAME = "file-lint-cache.json";
 const FILE_LINT_CACHE_MAX_FILE_COUNT = 5e4;
 const SIDECAR_LINT_CACHE_FILENAME = "sidecar-lint-cache.json";
-const CORE_PACKAGE_VERSION = "0.9.9";
+const CORE_PACKAGE_VERSION = "0.9.10";
 const DEAD_CODE_CACHE_FILENAME = "dead-code-cache.json";
 const DEAD_CODE_SUMMARY_CACHE_FILENAME = "dead-code-summaries.json";
 const SUPPLY_CHAIN_PLUGIN = "socket";
@@ -68224,11 +69330,304 @@ var ReactDoctorError = class extends TaggedErrorClass()("ReactDoctorError", { re
 };
 const isSplittableReactDoctorError = (error) => error instanceof ReactDoctorError && error.reason._tag === "OxlintBatchExceeded";
 const isReactDoctorError = (error) => error instanceof ReactDoctorError;
+const REDACTED_PLACEHOLDER = "<redacted>";
+const KEEP_PREFIX = `$1${REDACTED_PLACEHOLDER}`;
+const KNOWN_SECRET_RULES = [
+	{
+		pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
+		replacement: REDACTED_PLACEHOLDER
+	},
+	{
+		pattern: /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g,
+		replacement: REDACTED_PLACEHOLDER
+	},
+	{
+		pattern: /(?<=:\/\/)[^\s/:@]+:[^\s/@]+(?=@)/g,
+		replacement: REDACTED_PLACEHOLDER
+	},
+	{
+		pattern: /\b(AKIA|AGPA|AIDA|AROA|AIPA|ANPA|ANVA|ASIA|A3T[A-Z0-9])[0-9A-Z]{16,}/g,
+		replacement: KEEP_PREFIX
+	},
+	{
+		pattern: /\b(gh[pousr]_)[A-Za-z0-9]{36,}/g,
+		replacement: KEEP_PREFIX
+	},
+	{
+		pattern: /\b(github_pat_)[A-Za-z0-9_]{22,}/g,
+		replacement: KEEP_PREFIX
+	},
+	{
+		pattern: /\b(glpat-)[A-Za-z0-9_-]{20,}/g,
+		replacement: KEEP_PREFIX
+	},
+	{
+		pattern: /\b(xox[baprs]-)[A-Za-z0-9-]{10,}/g,
+		replacement: KEEP_PREFIX
+	},
+	{
+		pattern: /(?<=hooks\.slack\.com\/services\/)[A-Za-z0-9/+_-]{20,}/g,
+		replacement: REDACTED_PLACEHOLDER
+	},
+	{
+		pattern: /\b((?:sk|rk)_(?:live|test)_)[0-9A-Za-z]{10,}/g,
+		replacement: KEEP_PREFIX
+	},
+	{
+		pattern: /\b(sk-(?:proj-|ant-)?)[A-Za-z0-9_-]{20,}/g,
+		replacement: KEEP_PREFIX
+	},
+	{
+		pattern: /\b(AIza)[0-9A-Za-z_-]{35,}/g,
+		replacement: KEEP_PREFIX
+	},
+	{
+		pattern: /\b(ya29\.)[0-9A-Za-z_-]{20,}/g,
+		replacement: KEEP_PREFIX
+	},
+	{
+		pattern: /\b(npm_)[A-Za-z0-9]{36,}/g,
+		replacement: KEEP_PREFIX
+	},
+	{
+		pattern: /\b(SG\.)[A-Za-z0-9_-]{22,}\.[A-Za-z0-9_-]{43,}/g,
+		replacement: KEEP_PREFIX
+	},
+	{
+		pattern: /\b(SK)[0-9a-fA-F]{32,}/g,
+		replacement: KEEP_PREFIX
+	},
+	{
+		pattern: /\b(dop_v1_)[a-f0-9]{64,}/g,
+		replacement: KEEP_PREFIX
+	},
+	{
+		pattern: /\b(shp(?:at|ca|pa|ss)_)[a-fA-F0-9]{32,}/g,
+		replacement: KEEP_PREFIX
+	},
+	{
+		pattern: /\b(sq0[a-z]{3}-)[0-9A-Za-z_-]{22,}/g,
+		replacement: KEEP_PREFIX
+	},
+	{
+		pattern: /\b([0-9]{8,10}:AA)[0-9A-Za-z_-]{32,}/g,
+		replacement: KEEP_PREFIX
+	},
+	{
+		pattern: /(?<=\bBearer\s)[A-Za-z0-9._~+/=-]{16,}/g,
+		replacement: REDACTED_PLACEHOLDER
+	},
+	{
+		pattern: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g,
+		replacement: REDACTED_PLACEHOLDER
+	}
+];
+const CANDIDATE_TOKEN_PATTERN = /[A-Za-z0-9_][A-Za-z0-9_-]*/g;
+const HEX_DIGEST_PATTERN = /^(?:[0-9a-f]{32}|[0-9a-f]{40}|[0-9a-f]{64})$/;
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const HAS_LETTER_PATTERN = /[A-Za-z]/;
+const HAS_DIGIT_PATTERN = /[0-9]/;
+const shannonEntropyBits = (value) => {
+	const counts = /* @__PURE__ */ new Map();
+	for (const char of value) counts.set(char, (counts.get(char) ?? 0) + 1);
+	let bits = 0;
+	for (const count of counts.values()) {
+		const probability = count / value.length;
+		bits -= probability * Math.log2(probability);
+	}
+	return bits;
+};
+const looksLikeHighEntropySecret = (token) => {
+	if (token.length < 32) return false;
+	if (!HAS_LETTER_PATTERN.test(token) || !HAS_DIGIT_PATTERN.test(token)) return false;
+	if (HEX_DIGEST_PATTERN.test(token) || UUID_PATTERN.test(token)) return false;
+	return shannonEntropyBits(token) >= 3;
+};
+const redactHighEntropyTokens = (text) => text.replace(CANDIDATE_TOKEN_PATTERN, (token) => looksLikeHighEntropySecret(token) ? REDACTED_PLACEHOLDER : token);
+/**
+* Masks API keys, tokens, private keys, credentialed URLs, and emails
+* found anywhere inside a free-text string, returning the scrubbed text.
+* Applied to every diagnostic's `message` / `help` at construction time
+* so secrets never reach the terminal, the JSON report, or the score
+* API — react-doctor must never echo or transmit a user's secrets.
+*
+* Provider tokens keep their non-secret, type-identifying prefix (e.g.
+* `sk_live_<redacted>`, `ghp_<redacted>`, `AKIA<redacted>`) so the leaked
+* credential's type stays visible; structural or unknown-format secrets
+* with no meaningful prefix are masked whole.
+*
+* Runs the high-precision known-shape detectors first, then a generic
+* entropy-gated sweep for unknown-format secrets. Idempotent: the inert
+* `<redacted>` placeholder matches none of the detectors and is too
+* short for the generic sweep, so re-running leaves the text unchanged.
+*
+* Accepts `unknown` on purpose: callers feed it diagnostic `message` /
+* `help` that originate from oxlint JSON, which is only shape-checked at
+* the top level (the per-field `string` types are assumed, not validated).
+* A malformed non-string value returns `""` instead of throwing on
+* `.replace`, so one bad diagnostic can't abort parsing the whole batch.
+*/
+const redactSensitiveText = (text) => {
+	if (typeof text !== "string" || text === "") return "";
+	let redacted = text;
+	for (const rule of KNOWN_SECRET_RULES) redacted = redacted.replace(rule.pattern, rule.replacement);
+	return redactHighEntropyTokens(redacted);
+};
+const HOME_DIRECTORY = os.homedir();
+const USER_HOME_PATTERNS = [/[A-Za-z]:[\\/]Users[\\/][^\\/]+/gi, /(?:\/Users\/|\/home\/)[^/\\]+/gi];
+const scrubSensitivePaths = (text) => {
+	let scrubbed = text;
+	if (HOME_DIRECTORY.length > 1) scrubbed = scrubbed.split(HOME_DIRECTORY).join("~");
+	for (const pattern of USER_HOME_PATTERNS) scrubbed = scrubbed.replace(pattern, "~");
+	return scrubbed;
+};
+/**
+* Free-text fields can carry both a home-directory path (the OS username) and a
+* secret/email echoed from user code, so run both scrubbers: strip the username
+* from paths, then mask any known credential/PII shape. Shared by the Sentry
+* event scrubber ({@link scrubSentryEvent}), the metric emitter, and the
+* scrubbing tracer that guards everything bound for OTLP.
+*/
+const anonymizeText = (text) => redactSensitiveText(scrubSensitivePaths(text));
+/**
+* Recursively rewrites every string within an arbitrary value (object / array /
+* primitive) through {@link anonymizeText}, mutating in place. Used to sweep the
+* unstructured corners of a Sentry payload (event contexts/extra/tags, breadcrumb
+* data, span attributes, metric attributes) where a path or secret could hide.
+*/
+const anonymizeInPlace = (value) => {
+	if (Array.isArray(value)) {
+		for (let index = 0; index < value.length; index += 1) {
+			const item = value[index];
+			if (typeof item === "string") value[index] = anonymizeText(item);
+			else anonymizeInPlace(item);
+		}
+		return;
+	}
+	if (!isPlainObject(value)) return;
+	for (const key of Object.keys(value)) {
+		const inner = value[key];
+		if (typeof inner === "string") value[key] = anonymizeText(inner);
+		else anonymizeInPlace(inner);
+	}
+};
+const scrubValue = (value) => typeof value === "string" ? anonymizeText(value) : value;
+/**
+* Anonymizes the failure a span ended with.
+*
+* The OTLP tracer runs `Cause.prettyErrors` over the exit and exports each
+* result as `exception.type` / `exception.message` / `exception.stacktrace`.
+* Stack traces are full of absolute paths, so a failing scan would ship the
+* user's home directory even though every attribute and event is scrubbed —
+* this is the one route into the payload that doesn't go through
+* `span.attribute`.
+*
+* Interrupt-only causes are left alone: the exporter emits a fixed
+* "Interrupted" label for them and never touches the error text.
+*/
+const scrubExit = (exit) => {
+	if (isSuccess(exit) || hasInterruptsOnly(exit.cause)) return exit;
+	const errors = prettyErrors(exit.cause);
+	if (errors.length === 0) return exit;
+	return failCause$3(errors.map((error) => {
+		const anonymized = new Error(anonymizeText(error.message));
+		anonymized.name = anonymizeText(error.name);
+		anonymized.stack = error.stack === void 0 ? void 0 : anonymizeText(error.stack);
+		return fail$6(anonymized);
+	}).reduce((left, right) => combine(left, right)));
+};
+const scrubAttributes = (attributes) => {
+	if (!attributes) return attributes;
+	const scrubbed = {};
+	for (const [key, value] of Object.entries(attributes)) scrubbed[key] = scrubValue(value);
+	return scrubbed;
+};
+/**
+* Wraps a {@link Tracer.Span} so every value that reaches the exporter has been
+* run through {@link anonymizeText} first.
+*
+* Delegation is explicit rather than prototype-based: the wrapper forwards each
+* method to the real span, so the exporter keeps tracking the span it created
+* and no call depends on `this` binding surviving the indirection.
+*/
+const wrapSpan = (span) => ({
+	_tag: "Span",
+	get name() {
+		return span.name;
+	},
+	get spanId() {
+		return span.spanId;
+	},
+	get traceId() {
+		return span.traceId;
+	},
+	get parent() {
+		return span.parent;
+	},
+	get annotations() {
+		return span.annotations;
+	},
+	get status() {
+		return span.status;
+	},
+	get attributes() {
+		return span.attributes;
+	},
+	get links() {
+		return span.links;
+	},
+	get sampled() {
+		return span.sampled;
+	},
+	get kind() {
+		return span.kind;
+	},
+	end: (endTime, exit) => {
+		span.end(endTime, scrubExit(exit));
+	},
+	attribute: (key, value) => {
+		span.attribute(key, scrubValue(value));
+	},
+	event: (name, startTime, attributes) => {
+		span.event(anonymizeText(name), startTime, scrubAttributes(attributes));
+	},
+	addLinks: (links) => {
+		span.addLinks(links);
+	}
+});
+/**
+* Wraps a tracer so span names, attributes, and event payloads are anonymized
+* on the way to the exporter.
+*
+* This is the OTLP replacement for Sentry's `beforeSendTransaction` hook. OTLP
+* exporters have no equivalent interception point, so without this the only
+* thing standing between a raw filesystem path and the wire would be every
+* individual call site remembering to scrub — which is exactly the guarantee
+* the Sentry scrubber existed to stop relying on. Call sites should still scrub
+* at the source; this is the backstop for the ones that don't, including any
+* added later.
+*/
+const makeScrubbingTracer = (underlying) => make$33({
+	span: (options) => wrapSpan(underlying.span({
+		...options,
+		name: anonymizeText(options.name)
+	})),
+	...underlying.context ? { context: underlying.context } : {}
+});
 const TRACER_PROJECT_NAME = "react-doctor";
+/**
+* Replaces an exporter layer's `Tracer` with a scrubbing wrapper around it.
+*
+* OTLP has no `beforeSend`-style interception point, so this is the one place
+* every exported span is guaranteed to pass through. Applied to the telemetry
+* layers rather than to individual call sites so an attribute added later can't
+* quietly bypass it.
+*/
+const withScrubbedSpans = (exporter) => effect(Tracer, map$3(service(Tracer), makeScrubbingTracer)).pipe(provideMerge(exporter));
 const OTEL_ENDPOINT = string("REACT_DOCTOR_OTLP_ENDPOINT").pipe(option);
 const OTEL_AUTH_HEADER = redacted("REACT_DOCTOR_OTLP_AUTH_HEADER").pipe(option);
 /**
-* Opt-in OpenTelemetry layer. The default `Effect.fn(...)` spans
+* Bring-your-own OpenTelemetry layer. The default `Effect.fn(...)` spans
 * already populate the in-process tracer; this layer plugs an OTLP
 * HTTP exporter into the runtime when the user opts in via:
 *
@@ -68244,7 +69643,7 @@ const OTEL_AUTH_HEADER = redacted("REACT_DOCTOR_OTLP_AUTH_HEADER").pipe(option);
 * inspect / diagnose orchestrators always run, this layer just
 * dictates whether the spans they emit get shipped to a backend.
 */
-const layerOtlp = unwrap$3(gen(function* () {
+const layerUserOtlp = unwrap$3(gen(function* () {
 	const endpoint = yield* OTEL_ENDPOINT;
 	const authHeader = yield* OTEL_AUTH_HEADER;
 	if (endpoint._tag === "None" || authHeader._tag === "None") return empty$7;
@@ -68256,6 +69655,85 @@ const layerOtlp = unwrap$3(gen(function* () {
 	}).pipe(provide$2(layer$8));
 }).pipe(orDie));
 /**
+* First-party telemetry export to Axiom.
+*
+* Composes the tracer and metrics exporters by hand rather than using
+* `Otlp.layer`, because Axiom routes each signal to a different dataset via a
+* different header (see `AXIOM_DATASET_HEADER` / `AXIOM_METRICS_DATASET_HEADER`)
+* and `Otlp.layer` passes one `headers` object to every signal. Logs are
+* deliberately not wired up — nothing in the engine emits `Effect.log` as
+* telemetry today.
+*
+* Serialization is protobuf, not JSON: Axiom's `/v1/metrics` accepts
+* `application/x-protobuf` only. `layerProtobuf` ships with Effect and pulls in
+* no extra dependency.
+*
+* Traces and metrics are exposed as separate layers so each signal's exporter
+* can be reasoned about on its own, and `layerObservability` merges them for the
+* normal case. Whichever you use, build it **exactly once per process**:
+* Effect's delta-temporality bookkeeping lives on the metrics exporter
+* instance, so a second one starts with no previous state and re-reports every
+* counter's full value as its delta — double-counting everything.
+*/
+const buildResource = (options) => ({
+	serviceName: TRACER_PROJECT_NAME,
+	serviceVersion: options.serviceVersion
+});
+const buildAuthorization = (options) => `Bearer ${value(options.token)}`;
+const normalizeDomain = (domain) => {
+	let end = domain.length;
+	while (end > 0 && domain.charCodeAt(end - 1) === 47) end -= 1;
+	return domain.slice(0, end);
+};
+const layerAxiomTraces = (options) => layer$4({
+	url: `${normalizeDomain(options.domain)}${AXIOM_TRACES_PATH}`,
+	resource: buildResource(options),
+	headers: {
+		Authorization: buildAuthorization(options),
+		[AXIOM_DATASET_HEADER]: options.tracesDataset
+	},
+	exportInterval: options.exportIntervalMs ?? 6e5,
+	shutdownTimeout: TELEMETRY_SHUTDOWN_TIMEOUT_MS
+}).pipe(provide$2(layerProtobuf), provide$2(layer$8), withScrubbedSpans);
+/**
+* Metrics exporter. Instantiate **once per process** — see the double-counting
+* note above. Delta temporality is still the right choice for a short-lived CLI:
+* cumulative reports totals since a fixed start time, which for a process that
+* lives a few seconds is just the run total reported against a meaningless
+* window.
+*/
+const layerAxiomMetrics = (options) => layer$5({
+	url: `${normalizeDomain(options.domain)}${AXIOM_METRICS_PATH}`,
+	resource: buildResource(options),
+	headers: {
+		Authorization: buildAuthorization(options),
+		[AXIOM_METRICS_DATASET_HEADER]: options.metricsDataset
+	},
+	exportInterval: options.exportIntervalMs ?? 6e5,
+	shutdownTimeout: TELEMETRY_SHUTDOWN_TIMEOUT_MS,
+	temporality: "delta"
+}).pipe(provide$2(layerProtobuf), provide$2(layer$8));
+/**
+* The first-party telemetry layer: spans and metrics together.
+*
+* A user-configured OTLP endpoint wins over first-party Axiom: Effect has one
+* `Tracer` reference, so the two are mutually exclusive, and someone who went to
+* the trouble of pointing React Doctor at their own collector meant it.
+* Passing `null` (or omitting options) disables first-party export entirely,
+* which is how `--no-telemetry` and every library consumer stay silent.
+*
+* Build this **once per process** and share the resulting context — see
+* `telemetry-runtime.ts`. Effect keeps delta-temporality state on the metrics
+* exporter instance, so a second build starts with no previous snapshot and
+* re-reports every counter's full value, doubling every metric.
+*/
+const layerObservability = (options = null) => unwrap$3(gen(function* () {
+	const endpoint = yield* OTEL_ENDPOINT;
+	const authHeader = yield* OTEL_AUTH_HEADER;
+	if (endpoint._tag !== "None" && authHeader._tag !== "None") return layerUserOtlp;
+	return options === null ? empty$7 : merge$3(layerAxiomTraces(options), layerAxiomMetrics(options));
+}).pipe(orDie));
+/**
 * Read a positive-millisecond timeout from an env var, falling back to
 * `defaultMs` when the var is unset, non-finite, or not strictly positive.
 */
@@ -73606,149 +75084,6 @@ const mapPreparedSourceLabels = (labels, preparedSourceMap) => {
 	}
 	return mappedLabels;
 };
-const REDACTED_PLACEHOLDER = "<redacted>";
-const KEEP_PREFIX = `$1${REDACTED_PLACEHOLDER}`;
-const KNOWN_SECRET_RULES = [
-	{
-		pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
-		replacement: REDACTED_PLACEHOLDER
-	},
-	{
-		pattern: /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g,
-		replacement: REDACTED_PLACEHOLDER
-	},
-	{
-		pattern: /(?<=:\/\/)[^\s/:@]+:[^\s/@]+(?=@)/g,
-		replacement: REDACTED_PLACEHOLDER
-	},
-	{
-		pattern: /\b(AKIA|AGPA|AIDA|AROA|AIPA|ANPA|ANVA|ASIA|A3T[A-Z0-9])[0-9A-Z]{16,}/g,
-		replacement: KEEP_PREFIX
-	},
-	{
-		pattern: /\b(gh[pousr]_)[A-Za-z0-9]{36,}/g,
-		replacement: KEEP_PREFIX
-	},
-	{
-		pattern: /\b(github_pat_)[A-Za-z0-9_]{22,}/g,
-		replacement: KEEP_PREFIX
-	},
-	{
-		pattern: /\b(glpat-)[A-Za-z0-9_-]{20,}/g,
-		replacement: KEEP_PREFIX
-	},
-	{
-		pattern: /\b(xox[baprs]-)[A-Za-z0-9-]{10,}/g,
-		replacement: KEEP_PREFIX
-	},
-	{
-		pattern: /(?<=hooks\.slack\.com\/services\/)[A-Za-z0-9/+_-]{20,}/g,
-		replacement: REDACTED_PLACEHOLDER
-	},
-	{
-		pattern: /\b((?:sk|rk)_(?:live|test)_)[0-9A-Za-z]{10,}/g,
-		replacement: KEEP_PREFIX
-	},
-	{
-		pattern: /\b(sk-(?:proj-|ant-)?)[A-Za-z0-9_-]{20,}/g,
-		replacement: KEEP_PREFIX
-	},
-	{
-		pattern: /\b(AIza)[0-9A-Za-z_-]{35,}/g,
-		replacement: KEEP_PREFIX
-	},
-	{
-		pattern: /\b(ya29\.)[0-9A-Za-z_-]{20,}/g,
-		replacement: KEEP_PREFIX
-	},
-	{
-		pattern: /\b(npm_)[A-Za-z0-9]{36,}/g,
-		replacement: KEEP_PREFIX
-	},
-	{
-		pattern: /\b(SG\.)[A-Za-z0-9_-]{22,}\.[A-Za-z0-9_-]{43,}/g,
-		replacement: KEEP_PREFIX
-	},
-	{
-		pattern: /\b(SK)[0-9a-fA-F]{32,}/g,
-		replacement: KEEP_PREFIX
-	},
-	{
-		pattern: /\b(dop_v1_)[a-f0-9]{64,}/g,
-		replacement: KEEP_PREFIX
-	},
-	{
-		pattern: /\b(shp(?:at|ca|pa|ss)_)[a-fA-F0-9]{32,}/g,
-		replacement: KEEP_PREFIX
-	},
-	{
-		pattern: /\b(sq0[a-z]{3}-)[0-9A-Za-z_-]{22,}/g,
-		replacement: KEEP_PREFIX
-	},
-	{
-		pattern: /\b([0-9]{8,10}:AA)[0-9A-Za-z_-]{32,}/g,
-		replacement: KEEP_PREFIX
-	},
-	{
-		pattern: /(?<=\bBearer\s)[A-Za-z0-9._~+/=-]{16,}/g,
-		replacement: REDACTED_PLACEHOLDER
-	},
-	{
-		pattern: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g,
-		replacement: REDACTED_PLACEHOLDER
-	}
-];
-const CANDIDATE_TOKEN_PATTERN = /[A-Za-z0-9_][A-Za-z0-9_-]*/g;
-const HEX_DIGEST_PATTERN = /^(?:[0-9a-f]{32}|[0-9a-f]{40}|[0-9a-f]{64})$/;
-const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-const HAS_LETTER_PATTERN = /[A-Za-z]/;
-const HAS_DIGIT_PATTERN = /[0-9]/;
-const shannonEntropyBits = (value) => {
-	const counts = /* @__PURE__ */ new Map();
-	for (const char of value) counts.set(char, (counts.get(char) ?? 0) + 1);
-	let bits = 0;
-	for (const count of counts.values()) {
-		const probability = count / value.length;
-		bits -= probability * Math.log2(probability);
-	}
-	return bits;
-};
-const looksLikeHighEntropySecret = (token) => {
-	if (token.length < 32) return false;
-	if (!HAS_LETTER_PATTERN.test(token) || !HAS_DIGIT_PATTERN.test(token)) return false;
-	if (HEX_DIGEST_PATTERN.test(token) || UUID_PATTERN.test(token)) return false;
-	return shannonEntropyBits(token) >= 3;
-};
-const redactHighEntropyTokens = (text) => text.replace(CANDIDATE_TOKEN_PATTERN, (token) => looksLikeHighEntropySecret(token) ? REDACTED_PLACEHOLDER : token);
-/**
-* Masks API keys, tokens, private keys, credentialed URLs, and emails
-* found anywhere inside a free-text string, returning the scrubbed text.
-* Applied to every diagnostic's `message` / `help` at construction time
-* so secrets never reach the terminal, the JSON report, or the score
-* API — react-doctor must never echo or transmit a user's secrets.
-*
-* Provider tokens keep their non-secret, type-identifying prefix (e.g.
-* `sk_live_<redacted>`, `ghp_<redacted>`, `AKIA<redacted>`) so the leaked
-* credential's type stays visible; structural or unknown-format secrets
-* with no meaningful prefix are masked whole.
-*
-* Runs the high-precision known-shape detectors first, then a generic
-* entropy-gated sweep for unknown-format secrets. Idempotent: the inert
-* `<redacted>` placeholder matches none of the detectors and is too
-* short for the generic sweep, so re-running leaves the text unchanged.
-*
-* Accepts `unknown` on purpose: callers feed it diagnostic `message` /
-* `help` that originate from oxlint JSON, which is only shape-checked at
-* the top level (the per-field `string` types are assumed, not validated).
-* A malformed non-string value returns `""` instead of throwing on
-* `.replace`, so one bad diagnostic can't abort parsing the whole batch.
-*/
-const redactSensitiveText = (text) => {
-	if (typeof text !== "string" || text === "") return "";
-	let redacted = text;
-	for (const rule of KNOWN_SECRET_RULES) redacted = redacted.replace(rule.pattern, rule.replacement);
-	return redactHighEntropyTokens(redacted);
-};
 const REACT_MODULE_SOURCE = "react";
 const REQUIRE_IDENTIFIER = "require";
 const USE_IDENTIFIER = "use";
@@ -75828,7 +77163,7 @@ var Linter = class Linter extends Service()("react-doctor/Linter") {
 	static layerComposite = (backends) => succeed$3(Linter, Linter.of({ run: (input) => {
 		if (backends.length === 0) return empty$4;
 		let diagnostics = backends[0].run(input);
-		for (let index = 1; index < backends.length; index++) diagnostics = diagnostics.pipe(concat(backends[index].run(input)));
+		for (let index = 1; index < backends.length; index++) diagnostics = diagnostics.pipe(concat$1(backends[index].run(input)));
 		return diagnostics;
 	} }));
 };
@@ -75942,14 +77277,6 @@ var Reporter = class Reporter extends Service()("react-doctor/Reporter") {
 		});
 	}));
 };
-const HOME_DIRECTORY = os.homedir();
-const USER_HOME_PATTERNS = [/[A-Za-z]:[\\/]Users[\\/][^\\/]+/gi, /(?:\/Users\/|\/home\/)[^/\\]+/gi];
-const scrubSensitivePaths = (text) => {
-	let scrubbed = text;
-	if (HOME_DIRECTORY.length > 1) scrubbed = scrubbed.split(HOME_DIRECTORY).join("~");
-	for (const pattern of USER_HOME_PATTERNS) scrubbed = scrubbed.replace(pattern, "~");
-	return scrubbed;
-};
 const ScoreApiResponseSchema = Struct({
 	score: Number$1,
 	label: String$1,
@@ -76911,7 +78238,7 @@ const runInspect = (input, hooks = {}) => gen(function* () {
 		suppressedRuleCounts: transform.summarizeSuppressions()
 	};
 }).pipe(withSpan("runInspect", { attributes: {
-	"inspect.directory": input.directory,
+	"inspect.directory": scrubSensitivePaths(input.directory),
 	"inspect.includePathCount": input.includePaths.length,
 	"inspect.runDeadCode": input.runDeadCode,
 	"inspect.isCi": input.isCi,
@@ -77210,7 +78537,7 @@ const runEditorScanEffect = (input) => gen(function* () {
 		skipExplicitIncludePathFilter: true
 	}).pipe(provide(layers))));
 }).pipe(withSpan("runEditorScan"));
-const runEditorScan = (input) => runPromise(runEditorScanEffect(input).pipe(provide(layerOtlp)));
+const runEditorScan = (input) => runPromise(runEditorScanEffect(input).pipe(provide(layerUserOtlp)));
 const lookupOwnRule = (rule) => Object.hasOwn(REACT_DOCTOR_RULE_REGISTRY, rule) ? REACT_DOCTOR_RULE_REGISTRY[rule] : void 0;
 /**
 * Returns presentation metadata for `<plugin>/<rule>`, or `null` when the
@@ -77250,7 +78577,7 @@ const computeConfigFingerprint = (projectDirectory, version) => {
 /** Display name used in client-facing messages and progress titles. */
 const SERVER_DISPLAY_NAME = "React Doctor";
 /** Server version reported in `serverInfo`; injected at build, `dev` from source. */
-const SERVER_VERSION = "0.9.9";
+const SERVER_VERSION = "0.9.10";
 /** `Diagnostic.source` shown next to every published diagnostic. */
 const DIAGNOSTIC_SOURCE = "react-doctor";
 /**
@@ -78956,7 +80283,29 @@ const startLanguageServer$1 = (options = {}) => {
 	installProcessGuards(connection);
 	createServer(connection, options);
 };
+const NANOSECONDS_PER_MILLISECOND = 1000000n;
+const LSP_TELEMETRY_EXPORT_INTERVAL_MS = 6e4;
 const SENTRY_FLUSH_TIMEOUT_MS = 2e3;
+const METRIC_DISTRIBUTION_BOUNDARIES = [
+	0,
+	1,
+	2,
+	5,
+	10,
+	25,
+	50,
+	100,
+	250,
+	500,
+	1e3,
+	2500,
+	5e3,
+	1e4,
+	3e4,
+	6e4,
+	3e5,
+	6e5
+];
 const METRIC = {
 	cliInvoked: "cli.invoked",
 	cliError: "cli.error",
@@ -79028,36 +80377,399 @@ const toCategoryKey = (category) => category.toLowerCase().replace(/[^a-z0-9]+/g
 //#region src/cli/utils/is-env-flag-enabled.ts
 const isEnvFlagEnabled = (value) => value === "1" || value?.toLowerCase() === "true";
 //#endregion
-//#region src/cli/utils/anonymize-text.ts
+//#region src/cli/utils/is-telemetry-enabled.ts
 /**
-* Free-text fields can carry both a home-directory path (the OS username) and a
-* secret/email echoed from user code, so run both scrubbers: strip the username
-* from paths, then mask any known credential/PII shape. Shared by the Sentry
-* event scrubber ({@link scrubSentryEvent}) and metric scrubber
-* ({@link scrubSentryMetric}).
+* Whether this process may emit telemetry of any kind — Sentry crash reports and
+* Axiom traces/metrics alike.
+*
+* Reads raw `process.argv` rather than parsed Commander options because the
+* decision is needed before the CLI parses its arguments (Sentry initializes as
+* the first statement of `cli/index.ts`).
+*
+* `REACT_DOCTOR_NO_TELEMETRY` was previously honored only by the language
+* server. It applies to the CLI too, which is what lets this repo's own tooling
+* — the benchmark harness and the delta-audit runner — keep their scans out of
+* production telemetry now that disabling Sentry alone no longer silences
+* everything.
 */
-const anonymizeText = (text) => redactSensitiveText(scrubSensitivePaths(text));
+const isTelemetryEnabled = () => {
+	if (process.argv.includes("--no-score") || process.argv.includes("--no-telemetry")) return false;
+	if (isEnvFlagEnabled(process.env.REACT_DOCTOR_NO_TELEMETRY)) return false;
+	if (process.env.VITEST || process.env.NODE_ENV === "test") return false;
+	return true;
+};
+//#endregion
+//#region src/cli/utils/is-ci-environment.ts
+const CI_ENVIRONMENT_VARIABLES = [
+	"GITHUB_ACTIONS",
+	"GITLAB_CI",
+	"CIRCLECI"
+];
+const CI_PROVIDER_BY_ENVIRONMENT_VARIABLE = [
+	["GITHUB_ACTIONS", "github-actions"],
+	["GITLAB_CI", "gitlab-ci"],
+	["CIRCLECI", "circleci"],
+	["BUILDKITE", "buildkite"],
+	["JENKINS_URL", "jenkins"],
+	["TF_BUILD", "azure-pipelines"],
+	["CODEBUILD_BUILD_ID", "aws-codebuild"],
+	["TEAMCITY_VERSION", "teamcity"],
+	["BITBUCKET_BUILD_NUMBER", "bitbucket"],
+	["TRAVIS", "travis"],
+	["DRONE", "drone"],
+	["SEMAPHORE", "semaphore"],
+	["APPVEYOR", "appveyor"],
+	["HARNESS_BUILD_ID", "harness"],
+	["BUDDY", "buddy"],
+	["CF_BUILD_ID", "codefresh"],
+	["NETLIFY", "netlify"],
+	["RAILWAY_SERVICE_ID", "railway"],
+	["VERCEL", "vercel"],
+	["CM_BUILD_ID", "codemagic"],
+	["PROW_JOB_ID", "prow"],
+	["AGOLA_GIT_REF", "agola"],
+	["CIRRUS_CI", "cirrus-ci"],
+	["BLACKSMITH_STICKYDISK_TOKEN", "blacksmith"],
+	["WARPBUILD_RUNNER_VERIFICATION_TOKEN", "warpbuild"],
+	["NSC_CACHE_PATH", "namespace"],
+	["UBICLOUD_CACHE_URL", "ubicloud"],
+	["RENDER", "render"],
+	["FLY_APP_NAME", "fly-io"]
+];
+const GITHUB_ACTION_MARKER_ENVIRONMENT_VARIABLE = "REACT_DOCTOR_GITHUB_ACTION";
+const CODING_AGENT_BY_ENVIRONMENT_VARIABLE = [
+	["CLAUDECODE", "claude-code"],
+	["CLAUDE_CODE", "claude-code"],
+	["CURSOR_AGENT", "cursor"],
+	["CODEX_CI", "codex"],
+	["CODEX_SANDBOX", "codex"],
+	["CODEX_SANDBOX_NETWORK_DISABLED", "codex"],
+	["OPENCODE", "opencode"],
+	["GOOSE_TERMINAL", "goose"],
+	["AMP_THREAD_ID", "amp"],
+	["CLINE_ACTIVE", "cline"],
+	["AUGMENT_AGENT", "augment"],
+	["TRAE_AI_SHELL_ID", "trae-ai"]
+];
+const GENERIC_CODING_AGENT_ENVIRONMENT_VARIABLES = ["AGENT_SESSION_ID", "AGENT_THREAD_ID"];
+const CODING_AGENT_ENVIRONMENT_VALUE_VARIABLES = ["AGENT"];
+const CODING_AGENT_ENVIRONMENT_VALUES = { AGENT: ["amp", "goose"] };
+[...CODING_AGENT_BY_ENVIRONMENT_VARIABLE.map(([environmentVariable]) => environmentVariable), ...GENERIC_CODING_AGENT_ENVIRONMENT_VARIABLES];
+const FALSY_CI_FLAG_VALUES = new Set([
+	"",
+	"0",
+	"false"
+]);
+const isCiFlagSet = (value) => value !== void 0 && !FALSY_CI_FLAG_VALUES.has(value.toLowerCase());
+const isCiEnvironment = (env = process.env) => CI_ENVIRONMENT_VARIABLES.some((environmentVariable) => Boolean(env[environmentVariable])) || isCiFlagSet(env.CI);
+const detectCiProvider = () => {
+	for (const [environmentVariable, provider] of CI_PROVIDER_BY_ENVIRONMENT_VARIABLE) if (process.env[environmentVariable]) return provider;
+	return isCiFlagSet(process.env.CI) ? "unknown" : null;
+};
+const isOfficialGithubAction = () => Boolean(process.env[GITHUB_ACTION_MARKER_ENVIRONMENT_VARIABLE]);
+const detectCiEventName = () => process.env.GITHUB_EVENT_NAME?.trim() || null;
+const detectCodingAgentFromValue = () => {
+	for (const environmentVariable of CODING_AGENT_ENVIRONMENT_VALUE_VARIABLES) {
+		const value = process.env[environmentVariable]?.toLowerCase();
+		if (value && CODING_AGENT_ENVIRONMENT_VALUES[environmentVariable].includes(value)) return value;
+	}
+	return null;
+};
+const detectCodingAgent = () => {
+	for (const [environmentVariable, agent] of CODING_AGENT_BY_ENVIRONMENT_VARIABLE) if (process.env[environmentVariable]) return agent;
+	const agentFromValue = detectCodingAgentFromValue();
+	if (agentFromValue) return agentFromValue;
+	if (GENERIC_CODING_AGENT_ENVIRONMENT_VARIABLES.some((environmentVariable) => process.env[environmentVariable])) return "unknown";
+	return null;
+};
+const isCodingAgentEnvironment = () => detectCodingAgent() !== null;
+//#endregion
+//#region src/cli/utils/detect-terminal-kind.ts
+const TERMINAL_BY_TERM_PROGRAM = [
+	["vscode", "vscode"],
+	["iTerm.app", "iterm"],
+	["Apple_Terminal", "apple-terminal"],
+	["WezTerm", "wezterm"],
+	["ghostty", "ghostty"],
+	["Hyper", "hyper"],
+	["Tabby", "tabby"],
+	["rio", "rio"]
+];
 /**
-* Recursively rewrites every string within an arbitrary value (object / array /
-* primitive) through {@link anonymizeText}, mutating in place. Used to sweep the
-* unstructured corners of a Sentry payload (event contexts/extra/tags, breadcrumb
-* data, span attributes, metric attributes) where a path or secret could hide.
+* Best-effort label for the terminal emulator / editor hosting the CLI,
+* derived from terminal-identity env vars. Recorded as the `terminalKind` run
+* tag so we can see where React Doctor is actually run (nvim, VS Code, iTerm,
+* …) — the split Sentry can't otherwise see. Low-cardinality and free of any
+* username/path/secret, so it's safe as a tag. Editor terminals (nvim/vim)
+* win over the outer emulator because that's the surface a user is reading in;
+* "ci" marks a run with no interactive terminal; "unknown" when nothing matches.
+*/
+const detectTerminalKind = (env = process.env) => {
+	if (env.NVIM) return "neovim";
+	if (env.VIM_TERMINAL) return "vim";
+	const termProgram = env.TERM_PROGRAM;
+	if (termProgram) {
+		for (const [marker, label] of TERMINAL_BY_TERM_PROGRAM) if (termProgram === marker) return label;
+	}
+	if (env.KITTY_WINDOW_ID || env.TERM === "xterm-kitty") return "kitty";
+	if (env.WT_SESSION) return "windows-terminal";
+	if (env.ALACRITTY_WINDOW_ID || env.TERM === "alacritty") return "alacritty";
+	if (env.VTE_VERSION) return "vte";
+	if (env.TMUX) return "tmux";
+	if (isCiEnvironment(env)) return "ci";
+	return "unknown";
+};
+//#endregion
+//#region src/cli/utils/is-debug-flag.ts
+/**
+* Whether the user passed `--debug` (surface the run's Sentry trace id, and
+* force performance tracing on so there's a trace to surface). Read straight
+* from argv rather than Commander's parsed flags because `initializeSentry()`
+* runs before Commander parses — the same reason `shouldEnableSentry()` reads
+* `--no-score` from argv. Sharing this one reader keeps the init-time sampling
+* override and the end-of-run print in agreement.
 */
-const anonymizeInPlace = (value) => {
-	if (Array.isArray(value)) {
-		for (let index = 0; index < value.length; index += 1) {
-			const item = value[index];
-			if (typeof item === "string") value[index] = anonymizeText(item);
-			else anonymizeInPlace(item);
-		}
-		return;
+const isDebugFlagEnabled = (argv = process.argv) => argv.includes("--debug");
+//#endregion
+//#region src/cli/utils/is-git-hook-environment.ts
+const isGitHookEnvironment = () => Boolean(process.env.GIT_DIR);
+//#endregion
+//#region src/cli/utils/is-non-interactive-environment.ts
+const NON_INTERACTIVE_ENVIRONMENT_VARIABLES = [
+	"CI",
+	"GITHUB_ACTIONS",
+	"GITLAB_CI",
+	"BUILDKITE",
+	"JENKINS_URL",
+	"TF_BUILD",
+	"CODEBUILD_BUILD_ID",
+	"TEAMCITY_VERSION",
+	"BITBUCKET_BUILD_NUMBER",
+	"CIRCLECI",
+	"TRAVIS",
+	"DRONE",
+	"GIT_DIR"
+];
+const isNonInteractiveEnvironment = () => NON_INTERACTIVE_ENVIRONMENT_VARIABLES.some((envVariable) => Boolean(process.env[envVariable])) || isCodingAgentEnvironment();
+//#endregion
+//#region src/cli/utils/version.ts
+const VERSION = process.env.VERSION ?? "0.0.0";
+//#endregion
+//#region src/cli/utils/json-mode.ts
+let context = null;
+const isJsonModeActive = () => context !== null;
+//#endregion
+//#region src/cli/utils/run-id.ts
+let cachedRunId;
+const getRunId = () => {
+	cachedRunId ??= randomUUID();
+	return cachedRunId;
+};
+//#endregion
+//#region src/cli/utils/build-run-context.ts
+const LSP_COMMAND = "experimental-lsp";
+const ROOT_SUBCOMMANDS = new Set([
+	"design",
+	"install",
+	"setup",
+	LSP_COMMAND
+]);
+const detectInvokedVia = () => {
+	const userAgent = process.env.npm_config_user_agent;
+	if (!userAgent) return "unknown";
+	return userAgent.split("/", 1)[0]?.trim() || "unknown";
+};
+const detectNodeMajor = () => {
+	const major = Number.parseInt(process.versions.node.split(".", 1)[0] ?? "", 10);
+	return Number.isNaN(major) ? 0 : major;
+};
+const detectOrigin = (userArguments) => {
+	if (detectCommand(userArguments) === LSP_COMMAND) return "lsp";
+	if (isGitHookEnvironment()) return "git-hook";
+	if (isCodingAgentEnvironment()) return "agent";
+	if (isCiEnvironment()) return "ci";
+	return "cli";
+};
+const detectCommand = (userArguments) => {
+	for (const argument of userArguments) {
+		if (argument === "--") break;
+		if (argument.startsWith("-")) continue;
+		return ROOT_SUBCOMMANDS.has(argument) ? argument : "inspect";
+	}
+	return "inspect";
+};
+/**
+* Snapshot of the current invocation, attached to Sentry events as the
+* `run` context to make crashes triage-able (which version, platform,
+* CI/agent, how it was invoked). Every field is cheap, synchronous, and
+* safe to read at any point — cwd reads fall back, env reads are
+* booleans — so it's rebuilt lazily at capture time when runtime-only
+* signals like `jsonMode` are finally known.
+*/
+const buildRunContext = () => {
+	const userArguments = process.argv.slice(2);
+	return {
+		version: VERSION,
+		runId: getRunId(),
+		origin: detectOrigin(userArguments),
+		command: detectCommand(userArguments),
+		argv: scrubSensitivePaths(userArguments.join(" ")),
+		cwd: scrubSensitivePaths(process.cwd()),
+		node: process.version,
+		nodeMajor: detectNodeMajor(),
+		platform: process.platform,
+		arch: process.arch,
+		ci: isCiEnvironment(),
+		ciProvider: detectCiProvider(),
+		eventName: detectCiEventName(),
+		viaAction: isOfficialGithubAction(),
+		codingAgent: detectCodingAgent(),
+		interactive: !isNonInteractiveEnvironment(),
+		terminalKind: detectTerminalKind(),
+		jsonMode: isJsonModeActive(),
+		debug: isDebugFlagEnabled(),
+		invokedVia: detectInvokedVia(),
+		lintBatchOrdering: resolveLintBatchOrdering()
+	};
+};
+//#endregion
+//#region src/cli/utils/build-sentry-project-context.ts
+/**
+* Projects the {@link ProjectInfo} we already detect during a scan into the
+* Sentry scope shape: a handful of searchable `project.*` tags plus the
+* anonymous project *shape* as a `project` context block. Lets crash/transaction
+* triage answer "which kind of project hit this?" (framework, React/Expo
+* version, TypeScript, size) without sending source code — and deliberately
+* omits `projectName` and `rootDirectory`, the two identifying fields, so the
+* project can't be tied back to a specific company/repo.
+*/
+const buildSentryProjectContext = (projectInfo) => ({
+	tags: {
+		"project.framework": projectInfo.framework,
+		"project.reactMajor": projectInfo.reactMajorVersion,
+		"project.typescript": projectInfo.hasTypeScript,
+		"project.reactCompiler": projectInfo.hasReactCompiler,
+		"project.expo": projectInfo.expoVersion !== null,
+		"project.reactNative": projectInfo.hasReactNativeWorkspace
+	},
+	context: {
+		framework: projectInfo.framework,
+		reactVersion: projectInfo.reactVersion,
+		reactMajorVersion: projectInfo.reactMajorVersion,
+		hasTypeScript: projectInfo.hasTypeScript,
+		hasReactCompiler: projectInfo.hasReactCompiler,
+		tanstackQueryVersion: projectInfo.tanstackQueryVersion,
+		mobxVersion: projectInfo.mobxVersion,
+		styledComponentsVersion: projectInfo.styledComponentsVersion,
+		tailwindVersion: projectInfo.tailwindVersion,
+		zodVersion: projectInfo.zodVersion,
+		preactVersion: projectInfo.preactVersion,
+		hasReactNativeWorkspace: projectInfo.hasReactNativeWorkspace,
+		expoVersion: projectInfo.expoVersion,
+		hasReanimated: projectInfo.hasReanimated,
+		sourceFileCount: projectInfo.sourceFileCount
 	}
-	if (!isPlainObject(value)) return;
-	for (const key of Object.keys(value)) {
-		const inner = value[key];
-		if (typeof inner === "string") value[key] = anonymizeText(inner);
-		else anonymizeInPlace(inner);
+});
+let currentProjectInfo = null;
+const getSentryProjectInfo = () => currentProjectInfo;
+//#endregion
+//#region src/cli/utils/build-sentry-scope.ts
+/**
+* Projects a {@link RunContext} snapshot (plus the current run's
+* {@link getSentryProjectInfo project info}, when a scan has discovered it) into
+* the Sentry scope shape — the searchable `tags` that make crashes/transactions
+* filterable (which command, origin, CI provider, coding agent, Node major,
+* package manager, project framework/React major) plus the full `run` and
+* `project` context blocks for deep triage.
+*
+* Shared by `instrument.ts` (seeded as `initialScope` so *every* event,
+* including performance transactions, carries it) and `report-error.ts` (a
+* capture-time refresh, since runtime-only signals like `jsonMode` and the
+* scanned project are only known once a command has begun).
+*/
+const buildSentryScope = (runContext = buildRunContext()) => {
+	const tags = {
+		origin: runContext.origin,
+		command: runContext.command,
+		ci: runContext.ci,
+		ciProvider: runContext.ciProvider,
+		eventName: runContext.eventName,
+		viaAction: runContext.viaAction,
+		codingAgent: runContext.codingAgent,
+		interactive: runContext.interactive,
+		terminalKind: runContext.terminalKind,
+		jsonMode: runContext.jsonMode,
+		debug: runContext.debug,
+		invokedVia: runContext.invokedVia,
+		nodeMajor: runContext.nodeMajor,
+		lintBatchOrdering: runContext.lintBatchOrdering
+	};
+	const contexts = { run: { ...runContext } };
+	const projectInfo = getSentryProjectInfo();
+	if (projectInfo) {
+		const project = buildSentryProjectContext(projectInfo);
+		Object.assign(tags, project.tags);
+		contexts.project = project.context;
 	}
+	return {
+		tags,
+		contexts
+	};
+};
+//#endregion
+//#region src/cli/utils/to-span-attributes.ts
+/**
+* Converts a Sentry tag map (which permits `null`/`undefined` to denote an
+* absent signal) into Sentry/OTel span attributes, which only accept primitives.
+* Missing values are dropped rather than coerced, so an absent signal doesn't
+* become a misleading `"null"` or `"undefined"` attribute.
+*/
+const toSpanAttributes = (tags) => {
+	const attributes = {};
+	for (const [key, value] of Object.entries(tags)) if (value != null) attributes[key] = value;
+	return attributes;
+};
+//#endregion
+//#region src/cli/utils/record-metric.ts
+const withRunAttributes = (attributes) => {
+	const merged = {
+		...toSpanAttributes(buildSentryScope().tags),
+		...toSpanAttributes(attributes ?? {})
+	};
+	const stringified = {};
+	for (const [key, value] of Object.entries(merged)) stringified[key] = typeof value === "string" ? anonymizeText(value) : String(value);
+	return stringified;
+};
+/**
+* Emits a counter into Effect's metric registry, where the OTLP exporter picks
+* it up at flush time.
+*
+* A guarded, swallow-on-throw no-op unless telemetry is enabled, so it's inert
+* under `--no-score` / `--no-telemetry`, in tests, and for the programmatic
+* `@react-doctor/api` library. Counters are independent of trace sampling, so
+* they are still recorded when tracing is off.
+*/
+const recordCount = (name, value = 1, attributes) => {
+	if (!isTelemetryEnabled()) return;
+	try {
+		counter(name).pipe(withAttributes(withRunAttributes(attributes))).updateUnsafe(value, empty$8());
+	} catch {}
+};
+/**
+* Emits a distribution (value ranges — durations, sizes, scores). Same gating
+* and run-attribute handling as {@link recordCount}.
+*
+* `unit` is recorded as an attribute rather than as OTLP metric metadata:
+* Effect's histogram carries no unit field, and keeping the millisecond/count
+* distinction queryable matters more than where it is stored.
+*/
+const recordDistribution = (name, value, options = {}) => {
+	if (!isTelemetryEnabled()) return;
+	try {
+		const attributes = withRunAttributes(options.attributes);
+		if (options.unit) attributes.unit = options.unit;
+		histogram(name, { boundaries: METRIC_DISTRIBUTION_BOUNDARIES }).pipe(withAttributes(attributes)).updateUnsafe(value, empty$8());
+	} catch {}
 };
 //#endregion
 //#region src/cli/utils/scrub-sentry-event.ts
@@ -79108,29 +80820,112 @@ const scrubSentryEvent = (event) => {
 	}
 };
 //#endregion
-//#region src/cli/utils/scrub-sentry-metric.ts
-/**
-* Anonymizes a Sentry metric before it leaves the machine, mirroring
-* {@link scrubSentryEvent}. Drops the `server.address` default attribute (the
-* hostname) and scrubs home-directory paths + known secrets/emails from every
-* remaining attribute value (metric names are our own constants, so they're
-* left intact to avoid splitting a series). Returns `null` on any failure so an
-* un-anonymized metric is never sent. Wired into `beforeSendMetric`.
-*/
-const scrubSentryMetric = (metric) => {
+//#region src/cli/utils/resolve-axiom-telemetry-options.ts
+/**
+* Resolves the credentials for first-party Axiom export, or `null` when this
+* process must not emit telemetry.
+*
+* Core deliberately does not read these itself — keeping the token on the CLI
+* side is what makes `@react-doctor/api` silent by construction rather than by a
+* runtime guard.
+*
+* Returning `null` for an empty token means an unconfigured build (or a
+* contributor's checkout without the token baked in) simply doesn't export,
+* instead of sending unauthenticated requests to Axiom on every run.
+*
+* The overrides are `REACT_DOCTOR_`-prefixed rather than the bare `AXIOM_TOKEN`
+* / `AXIOM_DATASET` names Axiom's own tooling uses. Those are common in the
+* environment of anyone who already runs Axiom, and reading them here would
+* silently redirect React Doctor's telemetry into an unrelated account — or
+* fail against a dataset that isn't shaped for it — without the user ever
+* asking for that.
+*/
+const resolveAxiomTelemetryOptions = () => {
+	if (!isTelemetryEnabled()) return null;
+	const token = process.env.REACT_DOCTOR_AXIOM_TOKEN || "xaat-31b59107-855d-4917-8fab-6dc29fb459ce";
+	if (!token) return null;
+	return {
+		token: make$30(token),
+		domain: process.env.REACT_DOCTOR_AXIOM_DOMAIN || "https://api.axiom.co",
+		tracesDataset: process.env.REACT_DOCTOR_AXIOM_DATASET || "react-doctor",
+		metricsDataset: process.env.REACT_DOCTOR_AXIOM_METRICS_DATASET || "react-doctor-metrics",
+		serviceVersion: VERSION
+	};
+};
+//#endregion
+//#region src/cli/utils/telemetry-runtime.ts
+const isUserOtlpConfigured = () => Boolean(process.env.REACT_DOCTOR_OTLP_ENDPOINT) && Boolean(process.env.REACT_DOCTOR_OTLP_AUTH_HEADER);
+let telemetryScope = null;
+let telemetryContext = null;
+let isBuilt = false;
+let pendingShutdown = null;
+/**
+* Builds the telemetry layer once and hands back its context.
+*
+* The CLI is an imperative shell around several separate `Effect.runPromise`
+* calls — the scan program, the renderer, and the run root span all run
+* independently. Providing a fresh layer to each would create a separate set of
+* OTLP exporters per program: each holds its own span buffer and its own
+* shutdown flush, so exit latency would multiply, the root span would land in a
+* different export than its children, and — because Effect tracks
+* delta-temporality state per exporter instance — every counter would be
+* re-reported in full by each new metrics exporter.
+*
+* Building into a long-lived scope instead means one tracer and one metrics
+* exporter shared by all of them: child spans nest under the run span natively,
+* with no `ExternalSpan` stitching, and one flush at exit ships both signals.
+*
+* Returns `null` when telemetry is disabled or unconfigured, which is what keeps
+* `--no-telemetry` and unconfigured builds from opening a scope at all.
+*
+* `exportIntervalMs` lets a long-running process (the language server) ship
+* telemetry periodically instead of only at shutdown.
+*/
+const getTelemetryContext = (overrides = {}) => {
+	if (isBuilt) return telemetryContext;
+	isBuilt = true;
+	if (!isTelemetryEnabled()) return null;
+	const options = resolveAxiomTelemetryOptions();
+	if (options === null && !isUserOtlpConfigured()) return null;
 	try {
-		if (metric.attributes) {
-			delete metric.attributes["server.address"];
-			anonymizeInPlace(metric.attributes);
-		}
-		return metric;
+		const scope = makeUnsafe$5();
+		telemetryContext = runSync(buildWithScope(layerObservability(options === null ? null : {
+			...options,
+			...overrides
+		}), scope));
+		telemetryScope = scope;
 	} catch {
-		return null;
+		telemetryContext = null;
+		telemetryScope = null;
 	}
+	return telemetryContext;
+};
+/**
+* Closes the telemetry scope, which is what ships buffered spans and metrics.
+*
+* Both exporters flush during scope finalization, bounded by
+* `TELEMETRY_SHUTDOWN_TIMEOUT_MS`. Because the scope is built once and shared,
+* there is exactly one of each exporter per process — which is what keeps
+* metrics honest: Effect tracks delta-temporality state on the exporter
+* instance, so a second one would start with no previous snapshot and re-report
+* every counter's full value, doubling every metric.
+*
+* Memoized for the same reason: several exit paths can fire (a `--debug` user
+* error flushes, then the top-level catch flushes again), and repeat callers
+* must await the original shutdown rather than start a second one.
+*
+* Swallows failures so telemetry can never mask the user's result.
+*/
+const shutdownTelemetry = async () => {
+	if (pendingShutdown !== null) return pendingShutdown;
+	getTelemetryContext();
+	const scope = telemetryScope;
+	if (scope === null) return;
+	telemetryScope = null;
+	telemetryContext = null;
+	pendingShutdown = runPromise(close(scope, void_$1)).catch(() => {});
+	return pendingShutdown;
 };
-//#endregion
-//#region src/cli/utils/version.ts
-const VERSION = process.env.VERSION ?? "0.0.0";
 //#endregion
 //#region src/cli/utils/sentry-config.ts
 /**
@@ -79159,57 +80954,49 @@ const resolveSentryRelease = () => process.env.SENTRY_RELEASE || `react-doctor@$
 * overridable via the standard `SENTRY_ENVIRONMENT` env var.
 */
 const resolveSentryEnvironment = () => process.env.SENTRY_ENVIRONMENT || (isDevVersion(VERSION) ? "development" : "production");
-/**
-* Performance-tracing sample rate in `[0, 1]`. Reads `SENTRY_TRACES_SAMPLE_RATE`
-* (set to `0` to disable tracing) and falls back to
-* {@link SENTRY_DEFAULT_TRACES_SAMPLE_RATE}. Invalid / out-of-range values fall
-* back to the default rather than silently disabling tracing.
-*/
-const resolveTracesSampleRate = () => {
-	const raw = process.env.SENTRY_TRACES_SAMPLE_RATE;
-	if (raw === void 0 || raw.trim() === "") return 1;
-	const parsed = Number(raw);
-	if (Number.isNaN(parsed) || parsed < 0 || parsed > 1) return 1;
-	return parsed;
-};
 //#endregion
 //#region src/lsp-telemetry.ts
 /**
-* Sentry telemetry for the editor language server (`react-doctor
-* experimental-lsp`). Mirrors the CLI's model — a per-scan wide-event span
-* (op `lsp.scan`) plus Application Metrics counters/distributions — but with
-* an LSP-appropriate scope instead of the CLI run context, since the daemon
-* isn't a one-shot command. Shares the CLI's DSN, release, and the
-* anonymization scrubbers, so editor telemetry honors the same privacy
-* contract (no IP, no paths/secrets).
+* Telemetry for the editor language server (`react-doctor experimental-lsp`).
+* Mirrors the CLI's model — a per-scan wide-event span plus counters and
+* distributions to Axiom, with crashes to Sentry — but with an LSP-appropriate
+* scope instead of the CLI run context, since the daemon isn't a one-shot
+* command. Shares the CLI's DSN, release, and the anonymization scrubbers, so
+* editor telemetry honors the same privacy contract (no IP, no paths/secrets).
 *
-* Every emit is a guarded, swallow-on-throw no-op unless Sentry is live, so a
+* Every emit is a guarded, swallow-on-throw no-op unless telemetry is live, so a
 * telemetry failure (or an opted-out / test run) can never disrupt the editor
 * session.
+*
+* Unlike the one-shot CLI, this process can run for hours, so its exporters use
+* a short periodic interval — telemetry ships while the editor session is alive
+* rather than only when the server shuts down (which it may never cleanly do).
 */
-let lspTracesSampleRate = 0;
 const nodeMajorVersion = () => Number.parseInt(process.versions.node.split(".", 1)[0] ?? "", 10) || 0;
-const shouldEnableLspTelemetry = () => {
-	if (isEnvFlagEnabled(process.env.REACT_DOCTOR_NO_TELEMETRY)) return false;
-	if (process.argv.includes("--no-telemetry") || process.argv.includes("--no-score")) return false;
-	if (process.env.VITEST || process.env.NODE_ENV === "test") return false;
-	return true;
-};
-/** Whether wide-event spans will actually be recorded (Sentry live + sampling on). */
-const isLspTracingEnabled = () => Sentry.isInitialized() && lspTracesSampleRate > 0;
+/**
+* Opens the shared telemetry runtime with the daemon's periodic export
+* interval. Called at startup rather than lazily from the first scan: session
+* metrics are recorded before any scan completes, and if the editor kills the
+* server before one does, a runtime that was never built means those counters
+* are never exported.
+*/
+const getLspTelemetryContext = () => getTelemetryContext({ exportIntervalMs: LSP_TELEMETRY_EXPORT_INTERVAL_MS });
 /**
 * Initializes Sentry for the language server. Safe to call once at startup; a
 * no-op when already initialized or when telemetry is opted out / disabled.
+*
+* Performance tracing is off — the `lsp.scan` wide event is an Effect span
+* exported to Axiom, and Effect has a single `Tracer` reference.
 */
 const initializeLspSentry = (serverVersion) => {
-	if (Sentry.isInitialized() || !shouldEnableLspTelemetry()) return;
-	lspTracesSampleRate = resolveTracesSampleRate();
+	if (Sentry.isInitialized() || !isTelemetryEnabled()) return;
+	getLspTelemetryContext();
 	Sentry.init({
 		dsn: process.env.SENTRY_DSN || "https://f253d570240a59b8dbd77b7a548ef133@o4510226365743104.ingest.us.sentry.io/4511487817809920",
 		release: resolveSentryRelease(),
 		environment: resolveSentryEnvironment(),
 		sendDefaultPii: false,
-		tracesSampleRate: lspTracesSampleRate,
+		tracesSampleRate: 0,
 		debug: isEnvFlagEnabled(process.env.SENTRY_DEBUG),
 		initialScope: {
 			tags: {
@@ -79226,9 +81013,7 @@ const initializeLspSentry = (serverVersion) => {
 				arch: process.arch
 			} }
 		},
-		beforeSend: (event) => scrubSentryEvent(event),
-		beforeSendTransaction: (event) => scrubSentryEvent(event),
-		beforeSendMetric: (metric) => scrubSentryMetric(metric)
+		beforeSend: (event) => scrubSentryEvent(event)
 	});
 };
 /**
@@ -79254,36 +81039,45 @@ const buildLspScanEventAttributes = (scan) => {
 	return attributes;
 };
 const emitSessionStart = (session) => {
-	if (!Sentry.isInitialized()) return;
-	try {
-		Sentry.metrics.count(METRIC.lspSessionStarted, 1, { attributes: {
-			nodeMajor: session.nodeMajor,
-			projectCount: session.projectCount,
-			workspaceFolderCount: session.workspaceFolderCount,
-			scanOnType: session.scanOnType,
-			lintAvailable: session.lintAvailable
-		} });
-	} catch {}
+	recordCount(METRIC.lspSessionStarted, 1, {
+		nodeMajor: session.nodeMajor,
+		projectCount: session.projectCount,
+		workspaceFolderCount: session.workspaceFolderCount,
+		scanOnType: session.scanOnType,
+		lintAvailable: session.lintAvailable
+	});
 };
 const emitWorkspaceScan = (scan) => {
-	if (!Sentry.isInitialized()) return;
+	recordCount(METRIC.lspScanCompleted, 1, {
+		trigger: scan.trigger,
+		lintDegraded: scan.lintDegraded
+	});
+	recordDistribution(METRIC.lspScanDuration, scan.durationMs, {
+		unit: "millisecond",
+		attributes: { trigger: scan.trigger }
+	});
+	recordDistribution(METRIC.lspScanDiagnostics, scan.totalDiagnostics, { attributes: { trigger: scan.trigger } });
+	const telemetryContext = getLspTelemetryContext();
+	if (telemetryContext === null) return;
 	try {
-		Sentry.metrics.count(METRIC.lspScanCompleted, 1, { attributes: {
-			trigger: scan.trigger,
-			lintDegraded: scan.lintDegraded
-		} });
-		Sentry.metrics.distribution(METRIC.lspScanDuration, scan.durationMs, {
-			unit: "millisecond",
-			attributes: { trigger: scan.trigger }
-		});
-		Sentry.metrics.distribution(METRIC.lspScanDiagnostics, scan.totalDiagnostics, { attributes: { trigger: scan.trigger } });
-		if (isLspTracingEnabled()) Sentry.startInactiveSpan({
+		const tracer = get$4(telemetryContext, Tracer);
+		const startTime = BigInt(scan.startedAtEpochMs) * NANOSECONDS_PER_MILLISECOND;
+		const span = tracer.span({
 			name: "react-doctor experimental-lsp scan",
-			op: "lsp.scan",
-			forceTransaction: true,
-			startTime: new Date(scan.startedAtEpochMs),
-			attributes: buildLspScanEventAttributes(scan)
-		}).end();
+			parent: none(),
+			annotations: empty$8(),
+			links: [],
+			startTime,
+			kind: "internal",
+			root: true,
+			sampled: true
+		});
+		const attributes = {
+			...toSpanAttributes(buildSentryScope().tags),
+			...buildLspScanEventAttributes(scan)
+		};
+		for (const [key, value] of Object.entries(attributes)) span.attribute(key, value);
+		span.end(startTime + BigInt(scan.durationMs) * NANOSECONDS_PER_MILLISECOND, void_$1);
 	} catch {}
 };
 /** Builds the {@link Telemetry} sink the server drives. */
@@ -79291,6 +81085,7 @@ const createLspTelemetry = () => ({
 	recordSessionStart: emitSessionStart,
 	recordWorkspaceScan: emitWorkspaceScan,
 	flush: async () => {
+		await shutdownTelemetry();
 		if (!Sentry.isInitialized()) return;
 		try {
 			await Sentry.flush(SENTRY_FLUSH_TIMEOUT_MS);
@@ -79315,5 +81110,5 @@ const startLanguageServer = () => {
 };
 //#endregion
 export { startLanguageServer };
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="e0c59048-6e96-5cb2-8646-a3208057e466")}catch(e){}}();
-//# debugId=e0c59048-6e96-5cb2-8646-a3208057e466
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="ff73316d-2f43-5645-89f2-a0eb447f3e2e")}catch(e){}}();
+//# debugId=ff73316d-2f43-5645-89f2-a0eb447f3e2e