react-doctor 0.9.12-dev.28a1a9f → 0.9.12-dev.6416370

package/dist/with-run-span-BxZf1cDB.js

@@ -0,0 +1,110 @@
+
+!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]="3331ff49-b86d-575b-8721-fada0c83b956")}catch(e){}}();
+import { D as NANOSECONDS_PER_MILLISECOND, In as provideContext, Xn as void_, Yn as fail, c as setSentryProjectInfo, jn as makeSpan, o as buildSentryScope, r as toSpanAttributes, s as buildSentryProjectContext, zn as runSync } from "./record-metric-DKzjNui-.js";
+import { t as getTelemetryContext } from "./telemetry-runtime-DlKLQN-9.js";
+import { i as setActiveRunTrace, r as recordRunTraceId } from "./active-run-trace-dlIZeEvb.js";
+//#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 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 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 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 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
+* 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.
+*/
+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";
+	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(options.mapErrorForSpan?.(error) ?? error));
+		throw error;
+	}
+};
+/**
+* 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).
+*/
+const recordSentryProjectContext = (projectInfo, rootSpan, options = {}) => {
+	if (options.concurrentScan !== true) setSentryProjectInfo(projectInfo);
+	if (rootSpan === void 0) return;
+	for (const [key, value] of Object.entries(toSpanAttributes(buildSentryProjectContext(projectInfo).tags))) rootSpan.attribute(key, value);
+};
+//#endregion
+export { resetSentryRunState as n, withRunSpan as r, recordSentryProjectContext as t };
+
+//# sourceMappingURL=with-run-span-BxZf1cDB.js.map
+//# debugId=3331ff49-b86d-575b-8721-fada0c83b956

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-doctor",
-  "version": "0.9.12-dev.28a1a9f",
+  "version": "0.9.12-dev.6416370",
   "description": "Your agent writes bad React. This catches it",
   "keywords": [
     "accessibility",
@@ -62,11 +62,12 @@
     "oxc-parser": "^0.144.0",
     "oxc-resolver": "^11.24.2",
     "oxlint": ">=1.78.0 <1.79.0",
+    "playwright-core": "^1.62.1",
     "prompts": "^2.4.2",
     "typescript": ">=5.0.4 <6",
     "yaml": "^2.9.0",
     "yoga-layout": "~3.2.1",
-    "oxlint-plugin-react-doctor": "0.9.12-dev.28a1a9f"
+    "oxlint-plugin-react-doctor": "0.9.12-dev.6416370"
   },
   "devDependencies": {
     "@types/babel__code-frame": "^7.27.0",
@@ -79,8 +80,8 @@
     "ora": "^9.4.0",
     "react": "19.2.5",
     "react-devtools-core": "^7.0.1",
-    "@react-doctor/core": "0.9.12",
-    "@react-doctor/api": "0.9.12"
+    "@react-doctor/api": "0.9.12",
+    "@react-doctor/core": "0.9.12"
   },
   "engines": {
     "node": "^20.19.0 || >=22.13.0"