react-doctor 0.9.9 → 0.9.10

package/dist/{record-metric-b5KUd2XK.js → record-metric-CuPtdZfm.js}

@@ -1,5 +1,5 @@
 
-!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]="7a30c6de-c50d-5b71-9d8e-6351828a4d0f")}catch(e){}}();
+!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]="599070ce-0811-563a-970f-41af76d61e8f")}catch(e){}}();
 import { n as __require, r as __toESM$1, t as __commonJSMin$1 } from "./chunk-q7NCDQ7-.js";
 import { createRequire } from "node:module";
 import * as NodeChildProcess from "node:child_process";
@@ -24,7 +24,6 @@ import { PassThrough } from "node:stream";
 import { convertToTSX } from "@astrojs/compiler/sync";
 import { STATUS_CODES } from "node:http";
 import { gzipSync } from "node:zlib";
-import * as Sentry from "@sentry/node";
 import { performance as performance$1 } from "node:perf_hooks";
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.102/node_modules/effect/dist/Pipeable.js
 /**
@@ -1175,7 +1174,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.
 *
@@ -1350,7 +1349,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);
 };
 /**
@@ -1431,7 +1430,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();
@@ -2657,7 +2656,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 */
@@ -2686,7 +2685,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 */
@@ -2746,7 +2745,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) {
@@ -2868,9 +2867,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);
@@ -2883,7 +2882,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)})`;
@@ -2920,7 +2919,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 */
@@ -2935,9 +2934,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: (_) => _
@@ -2954,7 +2953,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)})`;
@@ -2974,7 +2973,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)})`;
@@ -2988,7 +2987,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 */
@@ -4223,6 +4222,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);
@@ -4388,12 +4418,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);
@@ -4436,7 +4466,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.
 *
@@ -4476,14 +4506,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.
 *
@@ -4514,7 +4544,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;
@@ -4585,7 +4615,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.
 *
@@ -4673,7 +4703,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;
@@ -4746,7 +4776,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.
 *
@@ -4768,7 +4798,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
 /**
@@ -4937,7 +4967,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.
 *
@@ -4976,7 +5006,7 @@ const makeUnsafe$7 = (mapUnsafe) => {
 };
 const Proto$13 = {
 	...PipeInspectableProto,
-	[TypeId$35]: { _Services: (_) => _ },
+	[TypeId$36]: { _Services: (_) => _ },
 	toJSON() {
 		return {
 			_id: "Context",
@@ -5028,7 +5058,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`.
 *
@@ -5364,7 +5394,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) => {
@@ -5474,8 +5504,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));
@@ -5539,7 +5569,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;
@@ -5571,7 +5601,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);
 	},
@@ -5627,7 +5657,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
@@ -5649,7 +5679,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).
 *
@@ -5684,7 +5714,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;
 	}
@@ -6453,39 +6483,6 @@ var ParentSpan = class extends Service()(ParentSpanKey) {};
 */
 const make$33 = (options) => options;
 /**
-* Creates an `ExternalSpan` from trace and span identifiers, defaulting
-* `sampled` to `true` and annotations to an empty context when they are not
-* provided.
-*
-* **Example** (Creating an external span)
-*
-* ```ts
-* import { Effect, Tracer } from "effect"
-*
-* // Create an external span from another tracing system
-* const span = Tracer.externalSpan({
-*   spanId: "span-abc-123",
-*   traceId: "trace-xyz-789",
-*   sampled: true
-* })
-*
-* // Use the external span as a parent
-* const program = Effect.succeed("Hello").pipe(
-*   Effect.withSpan("child-operation", { parent: span })
-* )
-* ```
-*
-* @category constructors
-* @since 2.0.0
-*/
-const externalSpan = (options) => ({
-	_tag: "ExternalSpan",
-	spanId: options.spanId,
-	traceId: options.traceId,
-	sampled: options.sampled ?? true,
-	annotations: options.annotations ?? empty$8()
-});
-/**
 * Context reference for disabling trace propagation.
 *
 * **When to use**
@@ -6750,7 +6747,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 */
@@ -7180,7 +7177,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));
 }));
@@ -7540,6 +7537,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) => {
@@ -7566,7 +7565,7 @@ 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() {
@@ -8293,10 +8292,8 @@ const makeLatchUnsafe = (open) => new Latch(open ?? false);
 /** @internal */
 const makeLatch = (open) => sync$2(() => makeLatchUnsafe(open));
 /** @internal */
-const withTracer$1 = /* @__PURE__ */ dual(2, (effect, tracer) => provideService$3(effect, Tracer, tracer));
-/** @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",
@@ -8304,8 +8301,8 @@ const NoopSpanProto = {
 	sampled: false,
 	status: {
 		_tag: "Ended",
-		startTime: bigint0,
-		endTime: bigint0,
+		startTime: bigint0$1,
+		endTime: bigint0$1,
 		exit: exitVoid
 	},
 	attributes: /* @__PURE__ */ new Map(),
@@ -8355,6 +8352,8 @@ const makeSpanUnsafe = (fiber, name, options) => {
 	}
 	return span;
 };
+/** @internal */
+const makeSpan$2 = (name, options) => withFiber$1((fiber) => succeed$5(makeSpanUnsafe(fiber, name, options)));
 const provideSpanStackFrame = (name, stack) => {
 	stack = typeof stack === "function" ? stack : constUndefined;
 	return updateService(CurrentStackFrame, (parent) => ({
@@ -8738,6 +8737,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:
 *
@@ -9909,14 +9940,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
@@ -10572,6 +10603,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
@@ -10734,7 +10809,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.
 *
@@ -10839,11 +10914,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);
 	},
@@ -11088,7 +11163,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.
 *
@@ -11113,7 +11188,7 @@ const CurrentMetadata = /* @__PURE__ */ Reference("effect/Schedule/CurrentMetada
 	elapsedSincePrevious: 0
 }) });
 const ScheduleProto = {
-	[TypeId$30]: {
+	[TypeId$31]: {
 		_Out: identity,
 		_In: identity,
 		_Env: identity
@@ -11142,7 +11217,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.
 *
@@ -11607,6 +11682,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**
@@ -11633,6 +11756,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.
@@ -11709,6 +12174,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
 /**
@@ -13733,6 +14233,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**
@@ -14337,27 +14861,6 @@ const forever = forever$2;
 */
 const repeat = repeat$1;
 /**
-* Provides a tracer to an effect.
-*
-* **Example** (Providing a tracer)
-*
-* ```ts
-* import { Effect } from "effect"
-*
-* const program = Effect.gen(function*() {
-*   yield* Effect.log("Using tracer")
-*   return "completed"
-* })
-*
-* // withTracer provides a tracer to the effect context
-* // const traced = Effect.withTracer(program, customTracer)
-* ```
-*
-* @category tracing
-* @since 2.0.0
-*/
-const withTracer = withTracer$1;
-/**
 * Enables or disables tracing for spans created by the given effect.
 *
 * **Details**
@@ -14407,6 +14910,31 @@ const withTracerEnabled = withTracerEnabled$1;
 */
 const annotateCurrentSpan = annotateCurrentSpan$1;
 /**
+* Creates a new tracing span and returns it without managing its lifetime.
+*
+* **Details**
+*
+* The span is not added to the current span stack and is not ended
+* automatically. Use `withSpan`, `useSpan`, or `makeSpanScoped` when the span
+* should be installed as context or closed automatically.
+*
+* **Example** (Creating a span manually)
+*
+* ```ts
+* import { Effect } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const span = yield* Effect.makeSpan("my-operation")
+*   yield* Effect.log("Operation in progress")
+*   return "completed"
+* })
+* ```
+*
+* @category tracing
+* @since 2.0.0
+*/
+const makeSpan$1 = makeSpan$2;
+/**
 * Create a new span for tracing, and automatically close it when the effect
 * completes.
 *
@@ -56655,7 +57183,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.
 *
@@ -59943,7 +60471,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) => {
@@ -60775,6 +61303,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.
@@ -60804,6 +61863,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
 /**
@@ -61763,7 +62834,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;
@@ -63847,6 +64918,12 @@ const REACT_ROUTER_CAPABILITY_THRESHOLDS = [
 	}
 ];
 const SCORE_API_URL = "https://www.react.doctor/api/score";
+const AXIOM_DEFAULT_DOMAIN = "https://api.axiom.co";
+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 ENTERPRISE_CONTACT_URL = "https://react.doctor/enterprise";
 const SHARE_BASE_URL = "https://react.doctor/share";
 const CI_URL = "https://react.doctor/ci";
@@ -64121,7 +65198,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";
@@ -68354,11 +69431,304 @@ const restoreLegacyThrow = (effect) => effect.pipe(catchReasons("ReactDoctorErro
 	ProjectNotFound: (reason) => die(new ProjectNotFoundError(reason.directory)),
 	AmbiguousProject: (reason) => die(new AmbiguousProjectError(reason.directory, [...reason.candidates]))
 }, (_reason, error) => die(error)));
+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:
 *
@@ -68374,7 +69744,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;
@@ -68386,6 +69756,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.
 */
@@ -73828,149 +75277,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";
@@ -76050,7 +77356,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;
 	} }));
 };
@@ -76164,14 +77470,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,
@@ -77133,7 +78431,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,
@@ -78080,9 +79378,32 @@ const CI_TRUST_COMPANIES = "PayPal, Rippling, and Alibaba";
 const MINIMUM_VTE_VERSION_FOR_HYPERLINKS = 5e3;
 const INTERNAL_ERROR_JSON_FALLBACK = "{\"schemaVersion\":3,\"version\":\"unknown\",\"ok\":false,\"directory\":\"\",\"mode\":\"full\",\"diff\":null,\"projects\":[],\"diagnostics\":[],\"summary\":{\"errorCount\":0,\"warningCount\":0,\"affectedFileCount\":0,\"totalDiagnosticCount\":0,\"score\":null,\"scoreLabel\":null},\"elapsedMilliseconds\":0,\"error\":{\"message\":\"Internal error\",\"name\":\"Error\",\"chain\":[]}}\n";
 const SENTRY_DSN = "https://f253d570240a59b8dbd77b7a548ef133@o4510226365743104.ingest.us.sentry.io/4511487817809920";
+const AXIOM_INGEST_TOKEN = "xaat-31b59107-855d-4917-8fab-6dc29fb459ce";
+const NANOSECONDS_PER_MILLISECOND = 1000000n;
+const AXIOM_TRACES_DATASET = "react-doctor";
+const AXIOM_METRICS_DATASET = "react-doctor-metrics";
 const SENTRY_RELEASE_PREFIX = "react-doctor";
 const SENTRY_FLUSH_TIMEOUT_MS = 2e3;
-const NANOSECONDS_PER_SECOND = 1000000000n;
+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",
@@ -78182,7 +79503,7 @@ const makeNoopConsole = () => ({
 });
 //#endregion
 //#region src/cli/utils/version.ts
-const VERSION = "0.9.9";
+const VERSION = "0.9.10";
 //#endregion
 //#region src/cli/utils/json-mode.ts
 let context = null;
@@ -78274,10 +79595,12 @@ const getRunId = () => {
 };
 //#endregion
 //#region src/cli/utils/build-run-context.ts
+const LSP_COMMAND = "experimental-lsp";
 const ROOT_SUBCOMMANDS = new Set([
 	"design",
 	"install",
-	"setup"
+	"setup",
+	LSP_COMMAND
 ]);
 const detectInvokedVia = () => {
 	const userAgent = process.env.npm_config_user_agent;
@@ -78288,7 +79611,8 @@ const detectNodeMajor = () => {
 	const major = Number.parseInt(process.versions.node.split(".", 1)[0] ?? "", 10);
 	return Number.isNaN(major) ? 0 : major;
 };
-const detectOrigin = () => {
+const detectOrigin = (userArguments) => {
+	if (detectCommand(userArguments) === LSP_COMMAND) return "lsp";
 	if (isGitHookEnvironment()) return "git-hook";
 	if (isCodingAgentEnvironment()) return "agent";
 	if (isCiEnvironment()) return "ci";
@@ -78315,7 +79639,7 @@ const buildRunContext = () => {
 	return {
 		version: VERSION,
 		runId: getRunId(),
-		origin: detectOrigin(),
+		origin: detectOrigin(userArguments),
 		command: detectCommand(userArguments),
 		argv: scrubSensitivePaths(userArguments.join(" ")),
 		cwd: scrubSensitivePaths(process.cwd()),
@@ -78424,6 +79748,31 @@ const buildSentryScope = (runContext = buildRunContext()) => {
 	};
 };
 //#endregion
+//#region src/cli/utils/is-env-flag-enabled.ts
+const isEnvFlagEnabled = (value) => value === "1" || value?.toLowerCase() === "true";
+//#endregion
+//#region src/cli/utils/is-telemetry-enabled.ts
+/**
+* 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 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/to-span-attributes.ts
 /**
 * Converts a Sentry tag map (which permits `null`/`undefined` to denote an
@@ -78438,38 +79787,48 @@ const toSpanAttributes = (tags) => {
 };
 //#endregion
 //#region src/cli/utils/record-metric.ts
-const withRunAttributes = (attributes) => ({
-	...toSpanAttributes(buildSentryScope().tags),
-	...toSpanAttributes(attributes ?? {})
-});
+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 Sentry counter. A guarded, swallow-on-throw no-op unless the CLI's
-* Sentry SDK is live, so it's inert under `--no-score`, tests, and the
-* programmatic `@react-doctor/api` library (none of which initialize Sentry).
-* Metrics flow independently of performance tracing, so counters are still
-* recorded when `SENTRY_TRACES_SAMPLE_RATE=0`.
+* 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 (!Sentry.isInitialized()) return;
+	if (!isTelemetryEnabled()) return;
 	try {
-		Sentry.metrics.count(name, value, { attributes: withRunAttributes(attributes) });
+		counter(name).pipe(withAttributes(withRunAttributes(attributes))).updateUnsafe(value, empty$8());
 	} catch {}
 };
 /**
-* Emits a Sentry distribution (value ranges — durations, sizes, scores). Same
-* gating and run-attribute handling as {@link recordCount}.
+* 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 (!Sentry.isInitialized()) return;
+	if (!isTelemetryEnabled()) return;
 	try {
-		Sentry.metrics.distribution(name, value, {
-			unit: options.unit,
-			attributes: withRunAttributes(options.attributes)
-		});
+		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
-export { Files as $, withTracer as $n, hashFileContents as $t, STAGED_SNAPSHOT_ADDITIONAL_CONFIG_FILENAMES as A, summarizeDiagnostics as An, clearConfigCache as At, isCiOrCodingAgentEnvironment as B, Diagnostic as Bn, filterSourceFiles as Bt, RUN_GIT_MAX_BUFFER_BYTES as C, resolveReactDoctorCacheDir as Cn, SupplyChain as Ct, SENTRY_FLUSH_TIMEOUT_MS as D, runInspect as Dn, buildSkippedChecks as Dt, SENTRY_DSN as E, restoreLegacyThrow as En, buildRuleDocsUrl as Et, isGitHookEnvironment as F, Console as Fn, createOxlintSpawnSlots as Ft, COMPILER_CLEANUP_BUCKET as G, promise as Gn, getCategoryImpact as Gt, CANONICAL_DISCORD_URL as H, gen as Hn, formatErrorChain as Ht, isDebugFlagEnabled as I, error as In, detectAiTrainingEnvironment as It, Config as J, runPromise as Jn, getDiffInfo as Jt, COMPILER_CLEANUP_RULE_KEYS as K, provide as Kn, getChangedLineRanges as Kt, ACTION_INPUT_ENVIRONMENT_VARIABLES as L, info as Ln, discoverReactSubprojects as Lt, TUI_REPORT_DETAIL_WIDTH_FRACTION as M, toRelativePath as Mn, computeConfigFingerprint as Mt, CliInputError as N, validateConfigTypes as Nn, computeDiagnosticDelta as Nt, SENTRY_RELEASE_PREFIX as O, scrubSensitivePaths as On, calculateScore as Ot, isNonInteractiveEnvironment as P, yieldToEventLoop as Pn, createNodeReadFileLinesSync as Pt, ENTERPRISE_CONTACT_URL as Q, void_ as Qn, hasReactRuntime as Qt, detectRunnerOs as R, log as Rn, filterDiagnosticsForSurface as Rt, REACT_DOCTOR_CONFIG_PROJECT_NAME as S, resolveLintBatchOrdering as Sn, StagedFiles as St, SCAN_RESULT_CACHE_MAX_HASHED_FILE_SIZE_BYTES as T, resolveScanTarget as Tn, buildJsonReport as Tt, CANONICAL_GITHUB_URL as U, map$3 as Un, formatReactDoctorError as Ut, isCodingAgentEnvironment as V, decodeUnknownSync as Vn, findLegacyConfig as Vt, CI_URL as W, orElseSucceed as Wn, getBaselineDiffPlan as Wt, DOCS_URL as X, sync as Xn, groupBy as Xt, DIAGNOSTIC_CATEGORY_BUCKETS as Y, runSync as Yn, getEquivalentRuleKeys as Yt, DeadCode as Z, try_ as Zn, hasPublishedFixRecipe as Zt, CI_TRUST_COMPANIES as _, mergeReactDoctorConfigs as _n, SHARE_BASE_URL as _t, buildSentryProjectContext as a, isPathInsideDirectory as an, externalSpan as ar, LEGACY_CONFIG_FILENAME as at, MINIMUM_VTE_VERSION_FOR_HYPERLINKS as b, remainingDeadlineBudgetMs as bn, Score as bt, enableJsonMode as c, isReactDoctorError as cn, MILLISECONDS_PER_SECOND as ct, setJsonReportMode as d, layerOtlp as dn, OxlintConcurrency as dt, highlighter as en, mergeAll$1 as er, GITHUB_ACTIONS_SETUP_URL as et, writeJsonErrorReport as f, listSourceFiles as fn, OxlintSpawnSlots as ft, BASELINE_FILES_TEMP_DIR_PREFIX as g, materializeSourceTree as gn, Reporter as gt, makeNoopConsole as h, mapWithConcurrency as hn, Project as ht, buildSentryScope as i, isMonorepoRoot as in, ParentSpan as ir, JSX_FILE_PATTERN as it, TUI_REPORT_COMPACT_MAX_ROWS as j, toCanonicalPath as jn, collectSourceFileCountsByDirectory as jt, STAGED_FILES_TEMP_DIR_PREFIX as k, setColorEnabled as kn, canonicalizeUserRuleKey as kt, isJsonModeActive as l, isSameRuleKey as ln, NodeResolver as lt, VERSION as m, loadConfigWithSource as mn, Progress as mt, recordDistribution as n, isErrnoException as nn, succeed$3 as nr, Git as nt, setSentryProjectInfo as o, isPlainObject as on, make$33 as or, LintPartialFailures as ot, writeJsonReport as p, listWorkspacePackages as pn, PerFileLintCacheEnabled as pt, CONFIG_SCHEMA_URL as q, provideService$2 as qn, getDiagnosticRuleIdentity as qt, toSpanAttributes as r, isFile as rn, isSuccess as rr, HTML_FILE_PATTERN as rt, getRunId as s, isProjectDiscoveryError as sn, isSome as sr, Linter as st, recordCount as t, isDirectory as tn, provide$2 as tr, GIT_SHOW_MAX_BUFFER_BYTES as tt, setJsonReportDirectory as u, isScanComplete as un, OXLINT_NODE_REQUIREMENT as ut, GH_DEFAULT_BRANCH_PROBE_TIMEOUT_MS as v, messageFromUnknown as vn, SKILL_NAME as vt, SCAN_RESULT_CACHE_FILENAME as w, resolveScanConcurrency as wn, atomicWriteJson as wt, NANOSECONDS_PER_SECOND as x, resolveGithubActionsScoreMetadata as xn, SidecarLintCacheEnabled as xt, METRIC as y, redactSensitiveText as yn, STAGED_FILES_PROJECT_CONFIG_FILENAMES as yt, isCiEnvironment as z, warn$1 as zn, filterPathsOutsideDirectories as zt };
+export { CONFIG_SCHEMA_URL as $, orElseSucceed as $n, getCategoryImpact as $t, SCAN_RESULT_CACHE_MAX_HASHED_FILE_SIZE_BYTES as A, resolveReactDoctorCacheDir as An, anonymizeInPlace as At, isGitHookEnvironment as B, validateConfigTypes as Bn, computeConfigFingerprint as Bt, GH_DEFAULT_BRANCH_PROBE_TIMEOUT_MS as C, mapWithConcurrency as Cn, SHARE_BASE_URL as Ct, REACT_DOCTOR_CONFIG_PROJECT_NAME as D, remainingDeadlineBudgetMs as Dn, SidecarLintCacheEnabled as Dt, NANOSECONDS_PER_MILLISECOND as E, messageFromUnknown as En, Score as Et, STAGED_SNAPSHOT_ADDITIONAL_CONFIG_FILENAMES as F, scrubSensitivePaths as Fn, buildSkippedChecks as Ft, isCiOrCodingAgentEnvironment as G, log as Gn, discoverReactSubprojects as Gt, ACTION_INPUT_ENVIRONMENT_VARIABLES as H, Console as Hn, createNodeReadFileLinesSync as Ht, TUI_REPORT_COMPACT_MAX_ROWS as I, setColorEnabled as In, calculateScore as It, CANONICAL_DISCORD_URL as J, decodeUnknownSync as Jn, filterSourceFiles as Jt, isCodingAgentEnvironment as K, warn$1 as Kn, filterDiagnosticsForSurface as Kt, TUI_REPORT_DETAIL_WIDTH_FRACTION as L, summarizeDiagnostics as Ln, canonicalizeUserRuleKey as Lt, SENTRY_FLUSH_TIMEOUT_MS as M, resolveScanTarget as Mn, atomicWriteJson as Mt, SENTRY_RELEASE_PREFIX as N, restoreLegacyThrow as Nn, buildJsonReport as Nt, RUN_GIT_MAX_BUFFER_BYTES as O, resolveGithubActionsScoreMetadata as On, StagedFiles as Ot, STAGED_FILES_TEMP_DIR_PREFIX as P, runInspect as Pn, buildRuleDocsUrl as Pt, COMPILER_CLEANUP_RULE_KEYS as Q, map$3 as Qn, getBaselineDiffPlan as Qt, CliInputError as R, toCanonicalPath as Rn, clearConfigCache as Rt, CI_TRUST_COMPANIES as S, loadConfigWithSource as Sn, Reporter as St, MINIMUM_VTE_VERSION_FOR_HYPERLINKS as T, mergeReactDoctorConfigs as Tn, STAGED_FILES_PROJECT_CONFIG_FILENAMES as Tt, detectRunnerOs as U, error as Un, createOxlintSpawnSlots as Ut, isDebugFlagEnabled as V, yieldToEventLoop as Vn, computeDiagnosticDelta as Vt, isCiEnvironment as W, info as Wn, detectAiTrainingEnvironment as Wt, CI_URL as X, gen as Xn, formatErrorChain as Xt, CANONICAL_GITHUB_URL as Y, make$30 as Yn, findLegacyConfig as Yt, COMPILER_CLEANUP_BUCKET as Z, makeSpan$1 as Zn, formatReactDoctorError as Zt, makeNoopConsole as _, isSameRuleKey as _n, ParentSpan as _r, OxlintConcurrency as _t, isEnvFlagEnabled as a, hasPublishedFixRecipe as an, runSync as ar, Files as at, AXIOM_TRACES_DATASET as b, listSourceFiles as bn, Progress as bt, setSentryProjectInfo as c, highlighter as cn, void_ as cr, Git as ct, isJsonModeActive as d, isFile as dn, provide$2 as dr, LEGACY_CONFIG_FILENAME as dt, getChangedLineRanges as en, promise as er, Config as et, setJsonReportDirectory as f, isMonorepoRoot as fn, succeed$3 as fr, LintPartialFailures as ft, VERSION as g, isReactDoctorError as gn, void_$1 as gr, OXLINT_NODE_REQUIREMENT as gt, writeJsonReport as h, isProjectDiscoveryError as hn, fail$5 as hr, NodeResolver as ht, isTelemetryEnabled as i, groupBy as in, runPromise as ir, ENTERPRISE_CONTACT_URL as it, SENTRY_DSN as j, resolveScanConcurrency as jn, anonymizeText as jt, SCAN_RESULT_CACHE_FILENAME as k, resolveLintBatchOrdering as kn, SupplyChain as kt, getRunId as l, isDirectory as ln, buildWithScope as lr, HTML_FILE_PATTERN as lt, writeJsonErrorReport as m, isPlainObject as mn, makeUnsafe$5 as mr, MILLISECONDS_PER_SECOND as mt, recordDistribution as n, getDiffInfo as nn, provideContext as nr, DOCS_URL as nt, buildSentryScope as o, hasReactRuntime as on, sync as or, GITHUB_ACTIONS_SETUP_URL as ot, setJsonReportMode as p, isPathInsideDirectory as pn, close as pr, Linter as pt, AXIOM_DEFAULT_DOMAIN as q, Diagnostic as qn, filterPathsOutsideDirectories as qt, toSpanAttributes as r, getEquivalentRuleKeys as rn, provideService$2 as rr, DeadCode as rt, buildSentryProjectContext as s, hashFileContents as sn, try_ as sr, GIT_SHOW_MAX_BUFFER_BYTES as st, recordCount as t, getDiagnosticRuleIdentity as tn, provide as tr, DIAGNOSTIC_CATEGORY_BUCKETS as tt, enableJsonMode as u, isErrnoException as un, mergeAll$1 as ur, JSX_FILE_PATTERN as ut, AXIOM_INGEST_TOKEN as v, isScanComplete as vn, OxlintSpawnSlots as vt, METRIC as w, materializeSourceTree as wn, SKILL_NAME as wt, BASELINE_FILES_TEMP_DIR_PREFIX as x, listWorkspacePackages as xn, Project as xt, AXIOM_METRICS_DATASET as y, layerObservability as yn, PerFileLintCacheEnabled as yt, isNonInteractiveEnvironment as z, toRelativePath as zn, collectSourceFileCountsByDirectory as zt };
 
-//# sourceMappingURL=record-metric-b5KUd2XK.js.map
-//# debugId=7a30c6de-c50d-5b71-9d8e-6351828a4d0f
+//# sourceMappingURL=record-metric-CuPtdZfm.js.map
+//# debugId=599070ce-0811-563a-970f-41af76d61e8f