react-doctor 0.9.9 → 0.9.10

package/dist/{should-fail-scan-gate-Bif6gnI9.js → should-fail-scan-gate-B5XfdAMg.js}

@@ -1,12 +1,12 @@
 
-!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]="c4293bd1-fbc8-59a4-8a5f-0fc1e2e1624c")}catch(e){}}();
-import { $ as Files, $n as withTracer, $t as hashFileContents, An as summarizeDiagnostics, B as isCiOrCodingAgentEnvironment, Bn as Diagnostic, Bt as filterSourceFiles, Cn as resolveReactDoctorCacheDir, Ct as SupplyChain, Dn as runInspect, Dt as buildSkippedChecks, En as restoreLegacyThrow, Et as buildRuleDocsUrl, Fn as Console, Ft as createOxlintSpawnSlots, Gn as promise, Hn as gen, In as error, J as Config, Jn as runPromise, Kn as provide, L as ACTION_INPUT_ENVIRONMENT_VARIABLES, Lt as discoverReactSubprojects, Mt as computeConfigFingerprint, N as CliInputError, Nt as computeDiagnosticDelta, Ot as calculateScore, P as isNonInteractiveEnvironment, Pn as yieldToEventLoop, Pt as createNodeReadFileLinesSync, Q as ENTERPRISE_CONTACT_URL, R as detectRunnerOs, Rn as log, Rt as filterDiagnosticsForSurface, Sn as resolveLintBatchOrdering, Tn as resolveScanTarget, Un as map, Vn as decodeUnknownSync, W as CI_URL, Wn as orElseSucceed, Xn as sync, Xt as groupBy, Y as DIAGNOSTIC_CATEGORY_BUCKETS, Yn as runSync, Z as DeadCode, Zn as try_, Zt as hasPublishedFixRecipe, _n as mergeReactDoctorConfigs, _t as SHARE_BASE_URL, a as buildSentryProjectContext, ar as externalSpan, bt as Score, cn as isReactDoctorError, ct as MILLISECONDS_PER_SECOND, dn as layerOtlp, dt as OxlintConcurrency, en as highlighter, er as mergeAll, fn as listSourceFiles, ft as OxlintSpawnSlots, g as BASELINE_FILES_TEMP_DIR_PREFIX, gn as materializeSourceTree, gt as Reporter, h as makeNoopConsole, hn as mapWithConcurrency, ht as Project, i as buildSentryScope, in as isMonorepoRoot, ir as ParentSpan, it as JSX_FILE_PATTERN, jt as collectSourceFileCountsByDirectory, kt as canonicalizeUserRuleKey, l as isJsonModeActive, lt as NodeResolver, m as VERSION, mt as Progress, n as recordDistribution, nr as succeed, nt as Git, o as setSentryProjectInfo, or as make, ot as LintPartialFailures, pn as listWorkspacePackages, pt as PerFileLintCacheEnabled, qn as provideService, qt as getDiagnosticRuleIdentity, r as toSpanAttributes, rn as isFile, rr as isSuccess, rt as HTML_FILE_PATTERN, s as getRunId, sr as isSome, st as Linter, t as recordCount, tn as isDirectory, tt as GIT_SHOW_MAX_BUFFER_BYTES, un as isScanComplete, ut as OXLINT_NODE_REQUIREMENT, w as SCAN_RESULT_CACHE_FILENAME, wn as resolveScanConcurrency, wt as atomicWriteJson, x as NANOSECONDS_PER_SECOND, xn as resolveGithubActionsScoreMetadata, xt as SidecarLintCacheEnabled, y as METRIC, z as isCiEnvironment, zn as warn, zt as filterPathsOutsideDirectories } from "./record-metric-b5KUd2XK.js";
-import { n as buildFooterLinkLines, o as isSentryTracingEnabled, r as activeScanAbortRegistry, t as buildSectionDivider } from "./build-section-divider-rq_KQONI.js";
-import { a as setActiveRunTrace, i as recordRunTraceId } from "./unref-stdin-DTLx8HEf.js";
-import { D as getPackageJsonPath, L as cliLogger, O as isRecord, P as runGit, a as installReactDoctorScriptStep, c as spinner, n as findNearestPackageDirectory, o as isSpinnerSilent, s as setSpinnerSilent } from "./install-doctor-script-BEIl1lby.js";
-import { d as detectDefaultBranch, l as prompts, r as installReactDoctorWorkflow, u as isCommandAvailable } from "./install-github-workflow-Cun64Fxh.js";
-import { a as isValidBlockingLevel, c as openWorkflowPullRequest, l as stageWorkflowFile, o as pickBlockingLevel, u as toForwardSlashes } from "./resolve-scope-pjSIB8ZY.js";
-import { h as detectAvailableAgents, t as reportWorkflowResult } from "./report-workflow-result-CjrL22OD.js";
+!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]="64dd164d-d176-539f-b7f8-b4217a0009df")}catch(e){}}();
+import { $n as orElseSucceed, An as resolveReactDoctorCacheDir, Bt as computeConfigFingerprint, Cn as mapWithConcurrency, Ct as SHARE_BASE_URL, Dt as SidecarLintCacheEnabled, E as NANOSECONDS_PER_MILLISECOND, Et as Score, Ft as buildSkippedChecks, G as isCiOrCodingAgentEnvironment, Gn as log, Gt as discoverReactSubprojects, H as ACTION_INPUT_ENVIRONMENT_VARIABLES, Hn as Console, Ht as createNodeReadFileLinesSync, It as calculateScore, Jn as decodeUnknownSync, Jt as filterSourceFiles, Kn as warn, Kt as filterDiagnosticsForSurface, Ln as summarizeDiagnostics, Lt as canonicalizeUserRuleKey, Mn as resolveScanTarget, Mt as atomicWriteJson, Nn as restoreLegacyThrow, On as resolveGithubActionsScoreMetadata, Pn as runInspect, Pt as buildRuleDocsUrl, Qn as map, R as CliInputError, St as Reporter, Tn as mergeReactDoctorConfigs, U as detectRunnerOs, Un as error, Ut as createOxlintSpawnSlots, Vn as yieldToEventLoop, Vt as computeDiagnosticDelta, W as isCiEnvironment, X as CI_URL, Xn as gen, Zn as makeSpan, _ as makeNoopConsole, _r as ParentSpan, _t as OxlintConcurrency, an as hasPublishedFixRecipe, ar as runSync, at as Files, bn as listSourceFiles, bt as Progress, c as setSentryProjectInfo, cn as highlighter, ct as Git, d as isJsonModeActive, dn as isFile, er as promise, et as Config, fn as isMonorepoRoot, fr as succeed, ft as LintPartialFailures, g as VERSION, gn as isReactDoctorError, gr as void_, gt as OXLINT_NODE_REQUIREMENT, hr as fail, ht as NodeResolver, in as groupBy, ir as runPromise, it as ENTERPRISE_CONTACT_URL, jn as resolveScanConcurrency, k as SCAN_RESULT_CACHE_FILENAME, kn as resolveLintBatchOrdering, kt as SupplyChain, l as getRunId, ln as isDirectory, lt as HTML_FILE_PATTERN, mt as MILLISECONDS_PER_SECOND, n as recordDistribution, nr as provideContext, o as buildSentryScope, or as sync, pt as Linter, qn as Diagnostic, qt as filterPathsOutsideDirectories, r as toSpanAttributes, rr as provideService, rt as DeadCode, s as buildSentryProjectContext, sn as hashFileContents, sr as try_, st as GIT_SHOW_MAX_BUFFER_BYTES, t as recordCount, tn as getDiagnosticRuleIdentity, tr as provide, tt as DIAGNOSTIC_CATEGORY_BUCKETS, ur as mergeAll, ut as JSX_FILE_PATTERN, vn as isScanComplete, vt as OxlintSpawnSlots, w as METRIC, wn as materializeSourceTree, x as BASELINE_FILES_TEMP_DIR_PREFIX, xn as listWorkspacePackages, xt as Project, yt as PerFileLintCacheEnabled, z as isNonInteractiveEnvironment, zt as collectSourceFileCountsByDirectory } from "./record-metric-CuPtdZfm.js";
+import { a as setActiveRunTrace, i as recordRunTraceId, o as getTelemetryContext } from "./unref-stdin-D0Lq28Bk.js";
+import { n as buildFooterLinkLines, r as activeScanAbortRegistry, t as buildSectionDivider } from "./build-section-divider-BBuZ20p0.js";
+import { D as getPackageJsonPath, L as cliLogger, O as isRecord, P as runGit, a as installReactDoctorScriptStep, c as spinner, n as findNearestPackageDirectory, o as isSpinnerSilent, s as setSpinnerSilent } from "./install-doctor-script-BM5NC98v.js";
+import { d as detectDefaultBranch, l as prompts, r as installReactDoctorWorkflow, u as isCommandAvailable } from "./install-github-workflow-L48jbG9d.js";
+import { a as isValidBlockingLevel, c as openWorkflowPullRequest, l as stageWorkflowFile, o as pickBlockingLevel, u as toForwardSlashes } from "./resolve-scope-BGBQcbGi.js";
+import { h as detectAvailableAgents, t as reportWorkflowResult } from "./report-workflow-result-W-amAB4Z.js";
 import { createRequire } from "node:module";
 import { spawn } from "node:child_process";
 import * as path$1 from "node:path";
@@ -16,132 +16,30 @@ import fs, { mkdtempSync, rmSync } from "node:fs";
 import crypto, { randomUUID } from "node:crypto";
 import ts from "typescript";
 import { tmpdir } from "node:os";
-import * as Sentry from "@sentry/node";
 import { performance } from "node:perf_hooks";
 import { codeFrameColumns } from "@babel/code-frame";
-//#region src/cli/utils/sentry-tracer.ts
-const toHrTime = (epochNanoseconds) => [Number(epochNanoseconds / NANOSECONDS_PER_SECOND), Number(epochNanoseconds % NANOSECONDS_PER_SECOND)];
-const SPAN_KIND_TO_OTEL = {
-	internal: 0,
-	server: 1,
-	client: 2,
-	producer: 3,
-	consumer: 4
-};
-const toSentryAttributeValue = (value) => {
-	if (value === null || value === void 0) return void 0;
-	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
-	return String(value);
-};
-const normalizeAttributes = (attributes) => {
-	const normalized = {};
-	if (!attributes) return normalized;
-	for (const [key, value] of Object.entries(attributes)) normalized[key] = toSentryAttributeValue(value);
-	return normalized;
-};
-const isSentryBackedSpan = (span) => span._tag === "Span" && "sentrySpan" in span;
-const spanContextFor = (span) => isSentryBackedSpan(span) ? span.sentrySpan.spanContext() : {
-	traceId: span.traceId,
-	spanId: span.spanId,
-	traceFlags: span.sampled ? 1 : 0
-};
-/**
-* Builds an Effect {@link Tracer.Tracer} that materializes every Effect span
-* (`Effect.withSpan(...)` / `Effect.fn("Service.method")`) as a child Sentry
-* span, producing one unified per-run trace in Sentry. The CLI already
-* instruments `runInspect` and each core service method, so this bridge lights
-* all of that up in Sentry for free.
-*
-* `rootSpan` is the active per-run transaction; Effect spans without an Effect
-* parent attach to it, so nesting is correct even if async-context propagation
-* is interrupted by Effect's fiber scheduler. Provided to a program via
-* `Effect.withTracer(...)`.
-*/
-const makeSentryTracer = (rootSpan, startInactiveSpan = Sentry.startInactiveSpan) => make({ span: (options) => {
-	const parentSpan = isSome(options.parent) && isSentryBackedSpan(options.parent.value) ? options.parent.value.sentrySpan : rootSpan;
-	const sentrySpan = startInactiveSpan({
-		name: options.name,
-		startTime: toHrTime(options.startTime),
-		parentSpan,
-		kind: SPAN_KIND_TO_OTEL[options.kind]
-	});
-	const { traceId, spanId } = sentrySpan.spanContext();
-	const attributes = /* @__PURE__ */ new Map();
-	let status = {
-		_tag: "Started",
-		startTime: options.startTime
-	};
-	return {
-		_tag: "Span",
-		sentrySpan,
-		name: options.name,
-		spanId,
-		traceId,
-		parent: options.parent,
-		annotations: options.annotations,
-		links: options.links,
-		sampled: options.sampled,
-		kind: options.kind,
-		get status() {
-			return status;
-		},
-		get attributes() {
-			return attributes;
-		},
-		end: (endTime, exit) => {
-			status = {
-				_tag: "Ended",
-				startTime: options.startTime,
-				endTime,
-				exit
-			};
-			sentrySpan.setStatus({ code: isSuccess(exit) ? 1 : 2 });
-			sentrySpan.end(toHrTime(endTime));
-		},
-		attribute: (key, value) => {
-			attributes.set(key, value);
-			sentrySpan.setAttribute(key, toSentryAttributeValue(value));
-		},
-		event: (name, startTime, eventAttributes) => {
-			sentrySpan.addEvent(name, normalizeAttributes(eventAttributes), toHrTime(startTime));
-		},
-		addLinks: (links) => {
-			for (const link of links) sentrySpan.addLink({
-				context: spanContextFor(link.span),
-				attributes: normalizeAttributes(link.attributes)
-			});
-		}
-	};
-} });
-//#endregion
 //#region src/cli/utils/apply-observability.ts
-const isOtlpExportConfigured = () => Boolean(process.env.REACT_DOCTOR_OTLP_ENDPOINT) && Boolean(process.env.REACT_DOCTOR_OTLP_AUTH_HEADER);
-const externalSpanFrom = (sentrySpan) => {
-	const { traceId, spanId, traceFlags } = sentrySpan.spanContext();
-	return externalSpan({
-		traceId,
-		spanId,
-		sampled: (traceFlags & 1) === 1
-	});
-};
 /**
-* Installs the tracing backend for the inspect program. Effect's tracer is a
-* single reference, so the backends are mutually exclusive — we pick by
-* precedence:
+* Installs the tracing backend for the inspect program.
+*
+* Both the run root span and this program draw their tracer from the same
+* shared telemetry context, so the scan's spans (`runInspect`, every
+* `Service.method`) nest under the run span natively — no cross-backend
+* `ExternalSpan` stitching, and one exporter with one flush.
+*
+* The backend itself is chosen inside `layerObservability`: a user-configured
+* `REACT_DOCTOR_OTLP_*` endpoint wins over first-party Axiom, since Effect has a
+* single `Tracer` reference and someone who pointed React Doctor at their own
+* collector meant it.
 *
-* 1. **User OTLP backend** (`REACT_DOCTOR_OTLP_*` set) wins; we additionally
-*    parent the Effect trace under the active Sentry trace via an
-*    `ExternalSpan` so a trace exported to the user's backend shares its
-*    `trace_id` with the corresponding Sentry trace.
-* 2. **Sentry tracing active** (and no user OTLP): route Effect's existing
-*    span instrumentation straight into Sentry as one unified per-run trace.
-* 3. **Neither**: provide the (no-op) OTLP layer, leaving Effect's native
-*    in-memory tracer — identical to the prior default behavior.
+* A pass-through when telemetry is off, leaving Effect's native in-memory
+* tracer — identical to the prior default behavior.
 */
-const applyObservability = (program, rootSentrySpan) => {
-	if (isOtlpExportConfigured()) return (rootSentrySpan ? program.pipe(provideService(ParentSpan, externalSpanFrom(rootSentrySpan))) : program).pipe(provide(layerOtlp));
-	if (rootSentrySpan) return program.pipe(withTracer(makeSentryTracer(rootSentrySpan)));
-	return program.pipe(provide(layerOtlp));
+const applyObservability = (program, rootSpan) => {
+	const telemetryContext = getTelemetryContext();
+	if (telemetryContext === null) return program;
+	const withBackend = program.pipe(provideContext(telemetryContext));
+	return rootSpan === void 0 ? withBackend : withBackend.pipe(provideService(ParentSpan, rootSpan));
 };
 //#endregion
 //#region src/cli/utils/build-runtime-layers.ts
@@ -201,81 +99,105 @@ const buildRuntimeLayers = (input) => {
 	return input.oxlintSpawnSlots === void 0 ? layersWithConcurrency : mergeAll(layersWithConcurrency, succeed(OxlintSpawnSlots, input.oxlintSpawnSlots));
 };
 //#endregion
-//#region src/cli/utils/with-sentry-run-span.ts
+//#region src/cli/utils/with-run-span.ts
+/**
+* Ends the run span without letting a telemetry failure change the run's
+* outcome — the invariant every other emit site here already holds.
+*
+* The failure path is the reason this matters most: a throw from `end` there
+* would replace the user's original scan error, so a project-config mistake
+* could surface as an exporter stack trace, be reclassified as a crash, and get
+* reported as one.
+*/
+const endSpanSafely = (span, exit) => {
+	try {
+		span.end(BigInt(Date.now()) * NANOSECONDS_PER_MILLISECOND, exit);
+	} catch {}
+};
 /**
-* Clears the module-level run-scoped Sentry state — the current scanned project
-* and the active run trace. `inspect()` calls this at the start of every run and
-* again after a clean one, so a prior or just-finished scan can't attach its
-* project tags / trace to a later run or to a non-scan error (e.g.
+* Clears the module-level run-scoped telemetry state — the current scanned
+* project and the active run trace. `inspect()` calls this at the start of every
+* run and again after a clean one, so a prior or just-finished scan can't attach
+* its project tags / trace to a later run or to a non-scan error (e.g.
 * inspectAction's post-loop finalize/handoff steps). A thrown scan error skips
 * the post-run reset, leaving the state for the command catch to attribute and
 * link the crash. Concurrent batch members (`concurrentScan`) never touch this
-* state — they neither write nor reset it. Safe to call when Sentry is off (the
-* refs are read only when an event is built).
+* state — they neither write nor reset it. Safe to call when telemetry is off
+* (the refs are read only when an event is built).
 */
 const resetSentryRunState = () => {
 	setSentryProjectInfo(null);
 	setActiveRunTrace(null);
 };
 /**
-* Runs an inspect invocation inside a Sentry root span (transaction) so each
-* `react-doctor` run is a first-class trace with timing and the run snapshot as
-* attributes. The span is handed to `run` so the Effect→Sentry tracer bridge
-* can parent its spans under it.
+* Runs an inspect invocation inside a root span so each `react-doctor` run is a
+* first-class trace with timing and the run snapshot as attributes. The span is
+* handed to `run` so the scan's Effect spans parent under it and so the wide
+* event can be stamped onto it once the outcome is known.
 *
-* A no-op pass-through when Sentry performance tracing is off (Sentry disabled,
-* `--no-score`, tests, or `SENTRY_TRACES_SAMPLE_RATE=0`) — `run` receives
-* `undefined` and no transaction is created, so there's no added exit latency.
+* A no-op pass-through when telemetry is off (`--no-telemetry`, tests, or an
+* unconfigured build) — `run` receives `undefined` and no span is created, so
+* there's no added exit latency.
+*
+* The span is created against the shared telemetry context rather than a
+* freshly-provided layer, so it lives in the same tracer as the scan program's
+* spans; see `telemetry-runtime.ts` for why that matters. It is started and
+* ended manually because the body it wraps is a promise-returning imperative
+* function, not an Effect — the same shape the Sentry inactive span had.
 *
 * While the span runs, its trace context is recorded as the active run trace so
 * `reportErrorToSentry` can attach a crash thrown during the scan back to this
-* transaction's trace (errors surface in the command catch, after the span has
-* ended). `inspect()` owns clearing it (and the scanned project): it resets the
-* state right after a clean run and at the start of the next one, so the trace
-* is never attached to a non-scan error; on a thrown error the state is left in
-* place for the command catch, then the process exits.
+* trace (errors surface in the command catch, after the span has ended).
 *
-* A `concurrentScan` (one member of the CLI's multi-project pool) still gets
-* its own root span, but skips recording the active run trace — the module-
-* level handle has single-scan semantics, and overlapping writers would link a
-* crash to an arbitrary sibling's trace.
+* A `concurrentScan` (one member of the CLI's multi-project pool) still gets its
+* own root span, but skips recording the active run trace — the module-level
+* handle has single-scan semantics, and overlapping writers would link a crash
+* to an arbitrary sibling's trace.
 */
-const withSentryRunSpan = (run, options = {}) => {
-	if (!isSentryTracingEnabled()) return run(void 0);
+const withRunSpan = async (run, options = {}) => {
+	const telemetryContext = getTelemetryContext();
+	if (telemetryContext === null) return run(void 0);
 	const { tags } = buildSentryScope();
 	const command = typeof tags.command === "string" ? tags.command : "inspect";
-	return Sentry.startSpan({
-		name: `react-doctor ${command}`,
-		op: "cli.inspect",
-		attributes: toSpanAttributes(tags)
-	}, (rootSpan) => {
-		const spanContext = rootSpan.spanContext();
-		recordRunTraceId(spanContext.traceId);
-		if (options.concurrentScan !== true) setActiveRunTrace({
-			traceId: spanContext.traceId,
-			spanId: spanContext.spanId,
-			sampled: (spanContext.traceFlags & 1) === 1
-		});
-		return run(rootSpan);
+	let rootSpan;
+	try {
+		rootSpan = runSync(makeSpan(`react-doctor ${command}`, { attributes: toSpanAttributes(tags) }).pipe(provideContext(telemetryContext)));
+	} catch {
+		return run(void 0);
+	}
+	recordRunTraceId(rootSpan.traceId);
+	if (options.concurrentScan !== true) setActiveRunTrace({
+		traceId: rootSpan.traceId,
+		spanId: rootSpan.spanId,
+		sampled: rootSpan.sampled
 	});
+	try {
+		const result = await run(rootSpan);
+		endSpanSafely(rootSpan, void_);
+		return result;
+	} catch (error) {
+		endSpanSafely(rootSpan, fail(error));
+		throw error;
+	}
 };
 /**
-* Records the scanned project (discovered in the `beforeLint` hook) for Sentry:
-* remembers it for the lazy error-capture path (`buildSentryScope` folds it into
-* exception events) and, when tracing is live, sets it as attributes on the
-* run's root span so the transaction/trace carries the project shape too.
-* Always cheap — the span attribute set is skipped when `rootSpan` is absent
-* (tracing off), and storing the info is a plain assignment.
+* Records the scanned project (discovered in the `beforeLint` hook): remembers
+* it for the lazy Sentry error-capture path (`buildSentryScope` folds it into
+* exception events) and for per-emit metric attributes, and sets it on the run's
+* root span so the trace carries the project shape too. Always cheap — the span
+* attributes are skipped when `rootSpan` is absent (telemetry off), and storing
+* the info is a plain assignment.
 *
-* A `concurrentScan` only sets the span attributes: the module-level project
-* ref has single-scan semantics, and overlapping writers would stamp events
-* and metrics with an arbitrary sibling's project. Wide events keep full
-* attribution (they ride the span); per-emit metrics simply omit the project
-* shape during a concurrent batch (absent, never wrong).
+* A `concurrentScan` only sets the span attributes: the module-level project ref
+* has single-scan semantics, and overlapping writers would stamp events and
+* metrics with an arbitrary sibling's project. Wide events keep full attribution
+* (they ride the span); per-emit metrics simply omit the project shape during a
+* concurrent batch (absent, never wrong).
 */
 const recordSentryProjectContext = (projectInfo, rootSpan, options = {}) => {
 	if (options.concurrentScan !== true) setSentryProjectInfo(projectInfo);
-	rootSpan?.setAttributes(toSpanAttributes(buildSentryProjectContext(projectInfo).tags));
+	if (rootSpan === void 0) return;
+	for (const [key, value] of Object.entries(toSpanAttributes(buildSentryProjectContext(projectInfo).tags))) rootSpan.attribute(key, value);
 };
 //#endregion
 //#region src/cli/utils/diagnostic-grouping.ts
@@ -1187,7 +1109,7 @@ const buildRunEventAttributes = (input) => toSpanAttributes({
 const recordRunEvent = (rootSpan, input) => {
 	if (!rootSpan) return;
 	try {
-		rootSpan.setAttributes(buildRunEventAttributes(input));
+		for (const [key, value] of Object.entries(buildRunEventAttributes(input))) rootSpan.attribute(key, value);
 	} catch {}
 };
 //#endregion
@@ -1738,7 +1660,7 @@ const renderAndRecordScan = async (input) => {
 		userConfig: input.payload.userConfig,
 		suppressedRuleCounts: input.payload.suppressedRuleCounts ?? []
 	});
-	recordRunEvent(input.rootSentrySpan, {
+	recordRunEvent(input.rootSpan, {
 		...buildRunEventConfig(input.options, input.payload.userConfig, resolvedWorkerCount),
 		result,
 		mode: input.scanMode,
@@ -2298,7 +2220,7 @@ const createScanResultCacheLifecycle = (input) => {
 	return {
 		replay: () => {
 			if (cachedPayload === null) return null;
-			recordSentryProjectContext(cachedPayload.project, input.rootSentrySpan, { concurrentScan: input.options.concurrentScan });
+			recordSentryProjectContext(cachedPayload.project, input.rootSpan, { concurrentScan: input.options.concurrentScan });
 			recordCount(METRIC.projectDetected, 1);
 			const isDiffMode = input.options.includePaths.length > 0;
 			const baselineDegraded = Boolean(input.options.baseline) && isDiffMode && cachedPayload.baselineDelta === void 0;
@@ -2306,7 +2228,7 @@ const createScanResultCacheLifecycle = (input) => {
 				payload: cachedPayload,
 				options: input.options,
 				startTime: input.startTime,
-				rootSentrySpan: input.rootSentrySpan,
+				rootSpan: input.rootSpan,
 				scanMode: cachedPayload.baselineDelta ? "baseline" : isDiffMode ? "diff" : "full",
 				baselineDegraded,
 				wholeRepoCacheHit: true
@@ -2318,7 +2240,7 @@ const createScanResultCacheLifecycle = (input) => {
 				payload: completion.payload,
 				options: input.options,
 				startTime: input.startTime,
-				rootSentrySpan: input.rootSentrySpan,
+				rootSpan: input.rootSpan,
 				scanMode: completion.scanMode,
 				baselineDegraded: completion.baselineDegraded,
 				wholeRepoCacheHit: false,
@@ -2355,11 +2277,11 @@ const inspectWithOxlintRuntime = async (directory, inputOptions, oxlintRuntime)
 	const wasSpinnerSilent = isSpinnerSilent();
 	if (ownsSpinnerSilence) setSpinnerSilent(true);
 	try {
-		const result = await withSentryRunSpan(async (rootSentrySpan) => {
+		const result = await withRunSpan(async (rootSpan) => {
 			try {
-				return await runInspectWithRuntime(scanDirectory, options, userConfig, hasConfigOverride, configSourceDirectory, startTime, deadlineEpochMs, rootSentrySpan, oxlintRuntime);
+				return await runInspectWithRuntime(scanDirectory, options, userConfig, hasConfigOverride, configSourceDirectory, startTime, deadlineEpochMs, rootSpan, oxlintRuntime);
 			} catch (error) {
-				recordRunEvent(rootSentrySpan, {
+				recordRunEvent(rootSpan, {
 					...buildRunEventConfig(options, userConfig),
 					mode: options.includePaths.length > 0 ? "diff" : "full",
 					error
@@ -2393,7 +2315,7 @@ const createInvocationInspect = (requestedOxlintConcurrency) => {
 	};
 };
 const inspect = async (directory, inputOptions = {}) => createInvocationInspect(inputOptions.concurrency)(directory, inputOptions);
-const runInspectWithRuntime = async (directory, options, userConfig, hasConfigOverride, configSourceDirectory, startTime, deadlineEpochMs, rootSentrySpan, oxlintRuntime) => {
+const runInspectWithRuntime = async (directory, options, userConfig, hasConfigOverride, configSourceDirectory, startTime, deadlineEpochMs, rootSpan, oxlintRuntime) => {
 	const isDiffMode = options.includePaths.length > 0;
 	const resolvedNodeBinaryPath = await resolveOxlintNode(options.lint, options.scoreOnly || options.silent);
 	const lintBindingMissing = options.lint && !resolvedNodeBinaryPath;
@@ -2407,7 +2329,7 @@ const runInspectWithRuntime = async (directory, options, userConfig, hasConfigOv
 		resolvedNodeBinaryPath,
 		invocationState: oxlintRuntime.scanResultCacheInvocationState,
 		startTime,
-		rootSentrySpan
+		rootSpan
 	});
 	const cachedResult = scanResultCacheLifecycle.replay();
 	if (cachedResult !== null) return cachedResult;
@@ -2451,10 +2373,10 @@ const runInspectWithRuntime = async (directory, options, userConfig, hasConfigOv
 		excludedProjectDirectories: options.excludedProjectDirectories,
 		retainExcludedProjectDeadCodeDiagnostics: options.retainExcludedProjectDeadCodeDiagnostics
 	}, { beforeLint: (projectInfo) => sync(() => {
-		recordSentryProjectContext(projectInfo, rootSentrySpan, { concurrentScan: options.concurrentScan });
+		recordSentryProjectContext(projectInfo, rootSpan, { concurrentScan: options.concurrentScan });
 		recordCount(METRIC.projectDetected, 1);
 	}) });
-	const output = await runPromise(restoreLegacyThrow(applyObservability(options.silent ? program.pipe(provide(layers), provideService(Console, silentConsole)) : program.pipe(provide(layers)), rootSentrySpan)), { signal: oxlintRuntime.abortSignal });
+	const output = await runPromise(restoreLegacyThrow(applyObservability(options.silent ? program.pipe(provide(layers), provideService(Console, silentConsole)) : program.pipe(provide(layers)), rootSpan)), { signal: oxlintRuntime.abortSignal });
 	const didLintFail = lintBindingMissing || output.didLintFail;
 	const lintFailureReason = lintBindingMissing ? `oxlint native binding not found for Node ${process.version}; expected one matching ${OXLINT_NODE_REQUIREMENT}` : output.lintFailureReason;
 	if (!options.scoreOnly && !options.uiLayers && !lintBindingMissing && output.didLintFail && lintFailureReason !== null) if (output.lintFailureReasonKind === "native-binding-missing") runSync(log(highlighter.gray(`  Upgrade to Node ${OXLINT_NODE_REQUIREMENT} or run: npx -p oxlint@latest react-doctor@latest`)));
@@ -3071,5 +2993,5 @@ const shouldFailScanGate = (input) => {
 //#endregion
 export { resolveMergeBaseRef as A, buildEmptyReportMessage as B, copyToClipboard as C, deduplicateProjectScans as D, collectProjectSourceFileCounts as E, printDiagnosticsDump as F, formatLearnMoreLine as G, buildRulePriorityMap as H, formatDiagnosticSite as I, hasIncompleteScoreAnalysis as L, pluralize as M, formatElapsedTime as N, createInvocationInspect as O, printFooter as P, filterDiagnosticsByCategories as R, CLI_AGENT_BINARIES as S, buildHandoffPayload as T, buildSortedRuleGroups as U, hasLintHardFailure as V, formatFixRecipeLine as W, resolveCliInspectOptions as _, projectManifestChanged as a, setUpGitHubActions as b, selectProjects as c, resolveProjectChangedLineRanges as d, resolveProjectDiffIncludePaths as f, resolveWorkspaceDeadCodeOwner as g, retryMissingProjectScores as h, validateModeFlags as i, printHeadlessReport as j, inspect as k, buildCodeFrame as l, resolveProjectRelativeDirectory as m, formatSkippedProjectsMessage as n, partitionProjectScanOutcomes as o, resolveProjectSourceFilePaths as p, validateIncludeUntrackedScope as r, discoverWorkspacePackages as s, shouldFailScanGate as t, resolveProjectScan as u, filterScansForSurface as v, launchCliAgent as w, detectLaunchableAgents as x, countUniqueScannedFiles as y, buildNoScoreMessage as z };
 
-//# sourceMappingURL=should-fail-scan-gate-Bif6gnI9.js.map
-//# debugId=c4293bd1-fbc8-59a4-8a5f-0fc1e2e1624c
+//# sourceMappingURL=should-fail-scan-gate-B5XfdAMg.js.map
+//# debugId=64dd164d-d176-539f-b7f8-b4217a0009df

package/dist/{should-skip-prompts-Q3cS356Z.js → should-skip-prompts-DaBGPwa3.js}

@@ -1,10 +1,10 @@
 
-!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]="c3bf0df5-99dc-53b4-833b-a4de60a0f821")}catch(e){}}();
-import { P as isNonInteractiveEnvironment } from "./record-metric-b5KUd2XK.js";
+!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]="b49fd4c3-3be0-52f6-9e01-f9bef8d28fc1")}catch(e){}}();
+import { z as isNonInteractiveEnvironment } from "./record-metric-CuPtdZfm.js";
 //#region src/cli/utils/should-skip-prompts.ts
 const shouldSkipPrompts = (input = {}) => Boolean(input.yes) || Boolean(input.json) || isNonInteractiveEnvironment() || !process.stdin.isTTY;
 //#endregion
 export { shouldSkipPrompts as t };
 
-//# sourceMappingURL=should-skip-prompts-Q3cS356Z.js.map
-//# debugId=c3bf0df5-99dc-53b4-833b-a4de60a0f821
+//# sourceMappingURL=should-skip-prompts-DaBGPwa3.js.map
+//# debugId=b49fd4c3-3be0-52f6-9e01-f9bef8d28fc1

package/dist/{unref-stdin-DTLx8HEf.js → unref-stdin-D0Lq28Bk.js}

@@ -1,6 +1,6 @@
 
-!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]="42719bad-9cd7-5a1f-ad59-9a375ea67f01")}catch(e){}}();
-import { N as CliInputError, cn as isReactDoctorError, nn as isErrnoException, sn as isProjectDiscoveryError, vn as messageFromUnknown } from "./record-metric-b5KUd2XK.js";
+!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]="c98da11e-f692-57c2-842b-457b988f926b")}catch(e){}}();
+import { En as messageFromUnknown, R as CliInputError, Yn as make, ar as runSync, g as VERSION, gn as isReactDoctorError, gr as void_, hn as isProjectDiscoveryError, i as isTelemetryEnabled, ir as runPromise, lr as buildWithScope, mr as makeUnsafe, pr as close, un as isErrnoException, yn as layerObservability } from "./record-metric-CuPtdZfm.js";
 //#region src/cli/utils/is-environment-error.ts
 const ENVIRONMENT_ERROR_CODES = new Set([
 	"EACCES",
@@ -96,6 +96,113 @@ const formatEnvironmentError = (error) => {
 */
 const isExpectedUserError = (error) => error instanceof CliInputError || isProjectDiscoveryError(error) || isEnvironmentError(error) || isReactDoctorError(error) && (error.reason._tag === "GitBaseBranchInvalid" || error.reason._tag === "GitBaseBranchMissing");
 //#endregion
+//#region src/cli/utils/resolve-axiom-telemetry-options.ts
+/**
+* Resolves the credentials for first-party Axiom export, or `null` when this
+* process must not emit telemetry.
+*
+* Core deliberately does not read these itself — keeping the token on the CLI
+* side is what makes `@react-doctor/api` silent by construction rather than by a
+* runtime guard.
+*
+* Returning `null` for an empty token means an unconfigured build (or a
+* contributor's checkout without the token baked in) simply doesn't export,
+* instead of sending unauthenticated requests to Axiom on every run.
+*
+* The overrides are `REACT_DOCTOR_`-prefixed rather than the bare `AXIOM_TOKEN`
+* / `AXIOM_DATASET` names Axiom's own tooling uses. Those are common in the
+* environment of anyone who already runs Axiom, and reading them here would
+* silently redirect React Doctor's telemetry into an unrelated account — or
+* fail against a dataset that isn't shaped for it — without the user ever
+* asking for that.
+*/
+const resolveAxiomTelemetryOptions = () => {
+	if (!isTelemetryEnabled()) return null;
+	const token = process.env.REACT_DOCTOR_AXIOM_TOKEN || "xaat-31b59107-855d-4917-8fab-6dc29fb459ce";
+	if (!token) return null;
+	return {
+		token: make(token),
+		domain: process.env.REACT_DOCTOR_AXIOM_DOMAIN || "https://api.axiom.co",
+		tracesDataset: process.env.REACT_DOCTOR_AXIOM_DATASET || "react-doctor",
+		metricsDataset: process.env.REACT_DOCTOR_AXIOM_METRICS_DATASET || "react-doctor-metrics",
+		serviceVersion: VERSION
+	};
+};
+//#endregion
+//#region src/cli/utils/telemetry-runtime.ts
+const isUserOtlpConfigured = () => Boolean(process.env.REACT_DOCTOR_OTLP_ENDPOINT) && Boolean(process.env.REACT_DOCTOR_OTLP_AUTH_HEADER);
+let telemetryScope = null;
+let telemetryContext = null;
+let isBuilt = false;
+let pendingShutdown = null;
+/**
+* Builds the telemetry layer once and hands back its context.
+*
+* The CLI is an imperative shell around several separate `Effect.runPromise`
+* calls — the scan program, the renderer, and the run root span all run
+* independently. Providing a fresh layer to each would create a separate set of
+* OTLP exporters per program: each holds its own span buffer and its own
+* shutdown flush, so exit latency would multiply, the root span would land in a
+* different export than its children, and — because Effect tracks
+* delta-temporality state per exporter instance — every counter would be
+* re-reported in full by each new metrics exporter.
+*
+* Building into a long-lived scope instead means one tracer and one metrics
+* exporter shared by all of them: child spans nest under the run span natively,
+* with no `ExternalSpan` stitching, and one flush at exit ships both signals.
+*
+* Returns `null` when telemetry is disabled or unconfigured, which is what keeps
+* `--no-telemetry` and unconfigured builds from opening a scope at all.
+*
+* `exportIntervalMs` lets a long-running process (the language server) ship
+* telemetry periodically instead of only at shutdown.
+*/
+const getTelemetryContext = (overrides = {}) => {
+	if (isBuilt) return telemetryContext;
+	isBuilt = true;
+	if (!isTelemetryEnabled()) return null;
+	const options = resolveAxiomTelemetryOptions();
+	if (options === null && !isUserOtlpConfigured()) return null;
+	try {
+		const scope = makeUnsafe();
+		telemetryContext = runSync(buildWithScope(layerObservability(options === null ? null : {
+			...options,
+			...overrides
+		}), scope));
+		telemetryScope = scope;
+	} catch {
+		telemetryContext = null;
+		telemetryScope = null;
+	}
+	return telemetryContext;
+};
+/**
+* Closes the telemetry scope, which is what ships buffered spans and metrics.
+*
+* Both exporters flush during scope finalization, bounded by
+* `TELEMETRY_SHUTDOWN_TIMEOUT_MS`. Because the scope is built once and shared,
+* there is exactly one of each exporter per process — which is what keeps
+* metrics honest: Effect tracks delta-temporality state on the exporter
+* instance, so a second one would start with no previous snapshot and re-report
+* every counter's full value, doubling every metric.
+*
+* Memoized for the same reason: several exit paths can fire (a `--debug` user
+* error flushes, then the top-level catch flushes again), and repeat callers
+* must await the original shutdown rather than start a second one.
+*
+* Swallows failures so telemetry can never mask the user's result.
+*/
+const shutdownTelemetry = async () => {
+	if (pendingShutdown !== null) return pendingShutdown;
+	getTelemetryContext();
+	const scope = telemetryScope;
+	if (scope === null) return;
+	telemetryScope = null;
+	telemetryContext = null;
+	pendingShutdown = runPromise(close(scope, void_)).catch(() => {});
+	return pendingShutdown;
+};
+//#endregion
 //#region src/cli/utils/active-run-trace.ts
 let activeRunTrace = null;
 const setActiveRunTrace = (trace) => {
@@ -114,7 +221,7 @@ const unrefStdin = () => {
 	process.stdin.unref?.();
 };
 //#endregion
-export { setActiveRunTrace as a, isEnvironmentError as c, recordRunTraceId as i, getActiveRunTrace as n, isExpectedUserError as o, getLastRunTraceId as r, formatEnvironmentError as s, unrefStdin as t };
+export { setActiveRunTrace as a, isExpectedUserError as c, recordRunTraceId as i, formatEnvironmentError as l, getActiveRunTrace as n, getTelemetryContext as o, getLastRunTraceId as r, shutdownTelemetry as s, unrefStdin as t, isEnvironmentError as u };
 
-//# sourceMappingURL=unref-stdin-DTLx8HEf.js.map
-//# debugId=42719bad-9cd7-5a1f-ad59-9a375ea67f01
+//# sourceMappingURL=unref-stdin-D0Lq28Bk.js.map
+//# debugId=c98da11e-f692-57c2-842b-457b988f926b

package/dist/{version-BrAILQSv.js → version-CyVLelBf.js}

@@ -1,6 +1,6 @@
 
-!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]="0a1824b7-507b-51ce-b1ff-2df461594ab9")}catch(e){}}();
-import { m as VERSION, t as recordCount, y as METRIC } from "./record-metric-b5KUd2XK.js";
+!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]="10cef2d6-6244-5897-b951-7d7d9bdbf476")}catch(e){}}();
+import { g as VERSION, t as recordCount, w as METRIC } from "./record-metric-CuPtdZfm.js";
 //#region src/cli/commands/version.ts
 /**
 * oclif-style version line. 12-factor CLI Apps (#3, "What version am I
@@ -17,5 +17,5 @@ const versionAction = () => {
 //#endregion
 export { versionAction };
 
-//# sourceMappingURL=version-BrAILQSv.js.map
-//# debugId=0a1824b7-507b-51ce-b1ff-2df461594ab9
+//# sourceMappingURL=version-CyVLelBf.js.map
+//# debugId=10cef2d6-6244-5897-b951-7d7d9bdbf476

package/dist/{why-DB_XpRpg.js → why-nfPQ3AAq.js}

@@ -1,6 +1,6 @@
 
-!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]="5bfd30e1-2aa9-5ce3-9146-943cbecf3f6b")}catch(e){}}();
-import { t as inspectAction } from "./inspect-CGCfCxoM.js";
+!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]="79c662d0-5f1b-5d94-b632-bd6ea77829b7")}catch(e){}}();
+import { t as inspectAction } from "./inspect-BQapfOJX.js";
 //#region src/cli/commands/why.ts
 /**
 * `why <file:line>` — explains why a rule fired (or why a suppression didn't
@@ -17,5 +17,5 @@ const whyAction = async (location, options) => {
 //#endregion
 export { whyAction };
 
-//# sourceMappingURL=why-DB_XpRpg.js.map
-//# debugId=5bfd30e1-2aa9-5ce3-9146-943cbecf3f6b
+//# sourceMappingURL=why-nfPQ3AAq.js.map
+//# debugId=79c662d0-5f1b-5d94-b632-bd6ea77829b7