@dev.fast/whiteboard 0.0.0-stage → 0.2.1-preview.20261005.98

package/dist/review-telemetry-DEFnQsQ2.js

@@ -0,0 +1,1195 @@
+import { c as jsonString, l as jsonValueSchema, o as jsonObject, u as parseJsonText } from "./src-X9phtB2j.js";
+import "./src-DnwdaQ2r.js";
+import { A as devReviewHome, D as processIsAlive, M as writeFileAtomic, O as withFileLock } from "./s3-config-CAxhO9u_.js";
+import "./review-home-paths-6zZH-1c9.js";
+import { i as readReviewPackageVersion, t as findReviewPackageRoot } from "./package-paths-B6-zxvIO.js";
+import "./request-origin-D_4QIdoN.js";
+import { createHmac, randomUUID } from "node:crypto";
+import { z } from "zod";
+import { existsSync, readFileSync, rmSync } from "node:fs";
+import { readFile, readdir, rm } from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { valid } from "semver";
+//#region src/agent-session-ref.ts
+const AUTHORING_AGENT_SESSION_ENV = "DEV_FAST_AGENT_SESSION";
+function parseAuthoringSessionKey(value) {
+	const separator = value?.indexOf(":") ?? -1;
+	if (!value || separator < 1 || separator === value.length - 1) return;
+	const harness = value.slice(0, separator);
+	const sessionId = value.slice(separator + 1);
+	return isReviewAgentHarness(harness) ? {
+		harness,
+		sessionId
+	} : void 0;
+}
+function resolveAuthoringSessionRef(env) {
+	const hosted = readEnvValue(env[AUTHORING_AGENT_SESSION_ENV]);
+	if (hosted) {
+		const ref = parseAuthoringSessionKey(hosted);
+		if (!ref) throw new Error(`${AUTHORING_AGENT_SESSION_ENV} has an invalid authoring session reference.`);
+		return ref;
+	}
+	const codexThreadId = readEnvValue(env.CODEX_THREAD_ID);
+	if (codexThreadId) return {
+		harness: "codex",
+		sessionId: codexThreadId
+	};
+	const claudeSessionId = readEnvValue(env.CLAUDE_CODE_SESSION_ID) ?? readEnvValue(env.CLAUDE_SESSION_ID);
+	if (claudeSessionId) return {
+		harness: "claude-code",
+		sessionId: claudeSessionId
+	};
+	const piSessionId = readEnvValue(env.PI_SESSION_ID);
+	if (piSessionId) return {
+		harness: "pi",
+		sessionId: piSessionId
+	};
+}
+function isReviewAgentHarness(value) {
+	return value === "claude-code" || value === "codex" || value === "opencode" || value === "pi";
+}
+function readEnvValue(value) {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : void 0;
+}
+//#endregion
+//#region src/exception-telemetry.ts
+const FRAME_PATTERN = /^(.+):(\d+):(\d+)$/;
+/** Processes that run on Node rather than in a browser renderer. */
+const NODE_PROCESSES = /* @__PURE__ */ new Set(["main", "server"]);
+/** Written by apps/review-desktop/scripts/upload-source-maps.mjs. */
+const CHUNK_ID_MANIFEST = "review-chunk-ids.json";
+const CHUNK_ID_PATTERN = /^[0-9a-f-]{36}$/;
+/** The entry is `<app>/review-runtime/dist/server/desktop-host.js`. */
+function readChunkIds(serverEntry) {
+	if (!serverEntry) return /* @__PURE__ */ new Map();
+	try {
+		const manifest = jsonObject(parseJsonText(readFileSync(path.resolve(path.dirname(serverEntry), "../../../out", CHUNK_ID_MANIFEST), "utf8")));
+		return new Map(Object.entries(manifest ?? {}).flatMap(([file, id]) => {
+			const chunkId = jsonString(id);
+			return chunkId && CHUNK_ID_PATTERN.test(chunkId) ? [[file, chunkId]] : [];
+		}));
+	} catch {
+		return /* @__PURE__ */ new Map();
+	}
+}
+function exceptionProperties(properties, chunkIds = /* @__PURE__ */ new Map()) {
+	const type = jsonString(properties.error_name);
+	const hash = jsonString(properties.message_hash);
+	if (type === void 0 && hash === void 0) return void 0;
+	const platform = NODE_PROCESSES.has(jsonString(properties.error_process) ?? "") ? "node:javascript" : "web:javascript";
+	const frames = (jsonString(properties.frames) ?? "").split("|").flatMap((frame) => parseFrame(frame, platform, chunkIds));
+	const exception = {
+		$exception_level: "error",
+		$exception_list: [{
+			type: type ?? "Error",
+			value: jsonString(properties.message) ?? (hash ? `[message withheld] ${hash}` : "[message withheld]"),
+			mechanism: {
+				handled: true,
+				synthetic: false
+			},
+			stacktrace: {
+				type: "raw",
+				frames
+			}
+		}]
+	};
+	const resolvable = frames.length > 0 && frames.every((frame) => frame.chunk_id);
+	return hash === void 0 || resolvable ? exception : {
+		...exception,
+		$exception_fingerprint: hash
+	};
+}
+function parseFrame(frame, platform, chunkIds) {
+	const match = FRAME_PATTERN.exec(frame);
+	if (!match) return [];
+	const parsed = {
+		platform,
+		filename: match[1],
+		lineno: Number(match[2]),
+		colno: Number(match[3]),
+		function: "?",
+		in_app: true
+	};
+	const chunkId = chunkIds.get(match[1]);
+	if (chunkId) parsed.chunk_id = chunkId;
+	return [parsed];
+}
+const DEFAULT_POSTHOG_HOST = "https://us.i.posthog.com";
+const DEFAULT_CAPTURE_TIMEOUT_MS = 1e3;
+const QUEUE_LIMIT = 1e3;
+const BATCH_LIMIT = 50;
+const QUEUE_MAX_AGE_MS = 6048e5;
+const FLUSH_DELAY_MS = 5e3;
+const MAX_BACKOFF_MS = 36e5;
+const DROPPED_FILE = "dropped.json";
+const DROP_REASONS = [
+	"queue_full",
+	"expired",
+	"corrupt",
+	"permanent_rejection",
+	"storage_failure"
+];
+/** The dropped-event tally as this module wrote it to disk. */
+const droppedCountsSchema = z.partialRecord(z.enum(DROP_REASONS), z.number());
+var PostHogCaptureClient = class PostHogCaptureClient {
+	apiKey;
+	batchUrl;
+	fetchImpl;
+	timeoutMs;
+	timeoutSignal;
+	queueDir;
+	now;
+	idFactory;
+	memoryDrops = {};
+	flushTimer;
+	queuedSinceFlush = 0;
+	defaultProperties = {};
+	constructor(options = {}) {
+		this.apiKey = options.apiKey?.trim() || void 0;
+		this.batchUrl = `${normalizeHost(options.host)}/batch/`;
+		this.fetchImpl = options.fetch ?? globalThis.fetch?.bind(globalThis);
+		this.timeoutMs = options.timeoutMs ?? DEFAULT_CAPTURE_TIMEOUT_MS;
+		this.timeoutSignal = options.timeoutSignal ?? ((timeoutMs) => AbortSignal.timeout(timeoutMs));
+		this.queueDir = options.queueDir;
+		this.now = options.now ?? Date.now;
+		this.idFactory = options.idFactory ?? randomUUID;
+	}
+	static fromEnv(env = process.env, options = {}) {
+		const reviewHome = devReviewHome(env);
+		return new PostHogCaptureClient({
+			...options,
+			apiKey: nonEmpty$1(env["PROGRESSIVE_REVIEW_POSTHOG_KEY"]) ?? nonEmpty$1(env.DEV_FAST_POSTHOG_KEY) ?? nonEmpty$1(env.POSTHOG_KEY) ?? void 0,
+			host: nonEmpty$1(env["PROGRESSIVE_REVIEW_POSTHOG_HOST"]) ?? nonEmpty$1(env.DEV_FAST_POSTHOG_HOST) ?? nonEmpty$1(env.POSTHOG_HOST),
+			queueDir: path.join(reviewHome, "telemetry", "events")
+		});
+	}
+	get enabled() {
+		return Boolean(this.apiKey && this.fetchImpl);
+	}
+	/** Properties for events the client emits itself, such as drop diagnostics. */
+	setDefaultProperties(properties) {
+		this.defaultProperties = { ...properties };
+	}
+	async capture(input) {
+		if (!this.enabled) return;
+		const uuid = this.idFactory();
+		const queued = {
+			uuid,
+			event: input.event,
+			distinctId: input.distinctId,
+			properties: compactProperties(input.properties ?? {}),
+			createdAt: input.timestamp ?? this.now(),
+			attempts: 0,
+			nextAttemptAt: 0
+		};
+		if (!this.queueDir) {
+			await this.sendBatch([queued]);
+			return;
+		}
+		try {
+			writeFileAtomic(path.join(this.queueDir, `${queued.createdAt}-${uuid}.json`), `${JSON.stringify(queued)}\n`, "utf8");
+			this.queuedSinceFlush += 1;
+			this.scheduleFlush(this.queuedSinceFlush >= BATCH_LIMIT ? 0 : FLUSH_DELAY_MS);
+		} catch {
+			this.incrementMemoryDrop("storage_failure");
+			throw new Error("Could not store a telemetry event");
+		}
+	}
+	async discard() {
+		this.clearFlushTimer();
+		if (!this.queueDir) return;
+		await withFileLock(path.join(this.queueDir, ".flush.lock"), {
+			retryMs: 10,
+			staleMs: 3e4,
+			timeoutMs: 1e3,
+			unownedGraceMs: 1e3,
+			heartbeatMs: 5e3
+		}, async () => {
+			const files = await readdir(this.queueDir).catch(() => []);
+			await Promise.all(files.filter((file) => file.endsWith(".json")).map((file) => rm(path.join(this.queueDir, file), { force: true })));
+			this.queuedSinceFlush = 0;
+			this.memoryDrops = {};
+		});
+	}
+	async flush(deadlineMs = DEFAULT_CAPTURE_TIMEOUT_MS) {
+		if (!this.enabled || !this.queueDir) return;
+		this.clearFlushTimer();
+		const startedAt = this.now();
+		if (!(await withFileLock(path.join(this.queueDir, ".flush.lock"), {
+			retryMs: 10,
+			staleMs: 3e4,
+			timeoutMs: Math.min(100, Math.max(0, deadlineMs)),
+			unownedGraceMs: 1e3,
+			heartbeatMs: 5e3
+		}, async () => {
+			let result;
+			do
+				result = await this.flushBatchLocked(deadlineMs, startedAt);
+			while (result.state === "more" && this.now() - startedAt < deadlineMs);
+			if (result.state === "more") this.scheduleFlush(0);
+			if ("nextRetryAt" in result && result.nextRetryAt !== void 0) this.scheduleFlush(Math.max(0, result.nextRetryAt - this.now()));
+		}).catch(() => ({ acquired: false }))).acquired) this.scheduleFlush(FLUSH_DELAY_MS);
+	}
+	async shutdown(deadlineMs = DEFAULT_CAPTURE_TIMEOUT_MS) {
+		this.clearFlushTimer();
+		await this.flush(deadlineMs);
+	}
+	async flushBatchLocked(deadlineMs, startedAt) {
+		const queueDir = this.queueDir;
+		const now = this.now();
+		const fileNames = (await readdir(queueDir).catch(() => [])).filter((name) => name.endsWith(".json") && name !== DROPPED_FILE).sort();
+		const drops = mergeDropCounts(await this.readDroppedCounts(), this.memoryDrops);
+		this.memoryDrops = {};
+		const overflow = Math.max(0, fileNames.length - QUEUE_LIMIT);
+		const retainedNames = fileNames.slice(overflow);
+		for (const fileName of fileNames.slice(0, overflow)) await rm(path.join(queueDir, fileName), { force: true });
+		addDrop(drops, "queue_full", overflow);
+		const eligible = [];
+		let hasMoreEligible = false;
+		let nextRetryAt;
+		for (const fileName of retainedNames) {
+			const filePath = path.join(queueDir, fileName);
+			const event = await readQueuedEvent(filePath);
+			if (!event) {
+				await rm(filePath, { force: true });
+				addDrop(drops, "corrupt", 1);
+				continue;
+			}
+			if (now - event.createdAt > QUEUE_MAX_AGE_MS) {
+				await rm(filePath, { force: true });
+				addDrop(drops, "expired", 1);
+				continue;
+			}
+			if (event.nextAttemptAt <= now) {
+				if (eligible.length < BATCH_LIMIT) eligible.push({
+					fileName,
+					event
+				});
+				else hasMoreEligible = true;
+			} else nextRetryAt = Math.min(nextRetryAt ?? Infinity, event.nextAttemptAt);
+		}
+		await this.writeDroppedCounts(drops);
+		if (eligible.length === 0) {
+			this.queuedSinceFlush = 0;
+			return doneResult(nextRetryAt);
+		}
+		const diagnostics = await this.queueDropDiagnostics(drops, eligible[0].event.distinctId, now);
+		const sentEligible = [...diagnostics, ...eligible].slice(0, BATCH_LIMIT);
+		hasMoreEligible ||= sentEligible.length < diagnostics.length + eligible.length;
+		const batch = sentEligible.map(({ event }) => event);
+		const remainingMs = Math.max(1, deadlineMs - (this.now() - startedAt));
+		const result = await this.sendBatch(batch, remainingMs);
+		if (result === "success") {
+			await Promise.all(sentEligible.map(({ fileName }) => rm(path.join(queueDir, fileName), { force: true })));
+			this.queuedSinceFlush = 0;
+			return hasMoreEligible ? { state: "more" } : doneResult(nextRetryAt);
+		}
+		if (result === "permanent") {
+			await Promise.all(sentEligible.map(({ fileName }) => rm(path.join(queueDir, fileName), { force: true })));
+			await this.writeDroppedCounts({ permanent_rejection: sentEligible.length });
+			this.queuedSinceFlush = 0;
+			return hasMoreEligible ? { state: "more" } : doneResult(nextRetryAt);
+		}
+		let retryAt = Infinity;
+		for (const { fileName, event } of sentEligible) {
+			const attempts = event.attempts + 1;
+			const eventRetryAt = now + retryDelay(attempts);
+			retryAt = Math.min(retryAt, eventRetryAt);
+			writeFileAtomic(path.join(queueDir, fileName), `${JSON.stringify({
+				...event,
+				attempts,
+				nextAttemptAt: eventRetryAt
+			})}\n`, "utf8");
+		}
+		return {
+			state: "retry",
+			nextRetryAt: retryAt
+		};
+	}
+	async sendBatch(events, timeoutMs = this.timeoutMs) {
+		if (!this.apiKey || !this.fetchImpl || events.length === 0) return "success";
+		try {
+			const response = await this.fetchImpl(this.batchUrl, {
+				method: "POST",
+				headers: { "content-type": "application/json" },
+				body: JSON.stringify({
+					api_key: this.apiKey,
+					batch: events.map((event) => ({
+						uuid: event.uuid,
+						event: event.event,
+						properties: {
+							$process_person_profile: false,
+							...compactProperties(event.properties ?? {}),
+							distinct_id: event.distinctId
+						},
+						timestamp: new Date(event.createdAt).toISOString()
+					}))
+				}),
+				signal: this.timeoutSignal(Math.min(this.timeoutMs, timeoutMs))
+			});
+			if (response.ok) return "success";
+			if (response.status === 408 || response.status === 429 || response.status >= 500) return "transient";
+			return "permanent";
+		} catch {
+			return "transient";
+		}
+	}
+	/**
+	* Turns the pending drop tally into queued events, each with its own uuid,
+	* and clears the tally. A diagnostic then retries like any event, so a
+	* batch resent after a lost response cannot count a drop twice.
+	*/
+	async queueDropDiagnostics(drops, distinctId, now) {
+		const queueDir = this.queueDir;
+		const diagnostics = DROP_REASONS.flatMap((reason) => {
+			const count = drops[reason];
+			if (count === void 0 || count <= 0) return [];
+			const uuid = this.idFactory();
+			const event = {
+				uuid,
+				event: "review_telemetry_dropped",
+				distinctId,
+				properties: compactProperties({
+					...this.defaultProperties,
+					reason,
+					count
+				}),
+				createdAt: now,
+				attempts: 0,
+				nextAttemptAt: 0
+			};
+			return [{
+				fileName: `${now}-${uuid}.json`,
+				event
+			}];
+		});
+		if (diagnostics.length === 0) return [];
+		for (const { fileName, event } of diagnostics) writeFileAtomic(path.join(queueDir, fileName), `${JSON.stringify(event)}\n`, "utf8");
+		await rm(path.join(queueDir, DROPPED_FILE), { force: true });
+		return diagnostics;
+	}
+	scheduleFlush(delayMs) {
+		if (!this.queueDir || this.flushTimer) return;
+		this.flushTimer = setTimeout(() => {
+			this.flushTimer = void 0;
+			this.flush();
+		}, delayMs);
+		this.flushTimer.unref?.();
+	}
+	clearFlushTimer() {
+		if (this.flushTimer) clearTimeout(this.flushTimer);
+		this.flushTimer = void 0;
+	}
+	incrementMemoryDrop(reason) {
+		this.memoryDrops[reason] = (this.memoryDrops[reason] ?? 0) + 1;
+	}
+	async readDroppedCounts() {
+		if (!this.queueDir) return {};
+		return readFile(path.join(this.queueDir, DROPPED_FILE), "utf8").then((value) => {
+			const parsed = droppedCountsSchema.safeParse(parseJsonText(value));
+			return parsed.success ? parsed.data : {};
+		}).catch(() => ({}));
+	}
+	async writeDroppedCounts(drops) {
+		if (!this.queueDir) return;
+		const compact = Object.fromEntries(Object.entries(drops).filter(([, count]) => Number(count) > 0));
+		if (Object.keys(compact).length === 0) return;
+		writeFileAtomic(path.join(this.queueDir, DROPPED_FILE), `${JSON.stringify(compact)}\n`, "utf8");
+	}
+};
+function doneResult(nextRetryAt) {
+	const result = { state: "done" };
+	if (nextRetryAt) result.nextRetryAt = nextRetryAt;
+	return result;
+}
+/** A queued event as this module wrote it to disk. */
+const QueuedPostHogEventSchema = z.object({
+	uuid: z.string().min(1).optional(),
+	event: z.string(),
+	distinctId: z.string(),
+	properties: z.record(z.string(), jsonValueSchema).optional(),
+	createdAt: z.number(),
+	attempts: z.number(),
+	nextAttemptAt: z.number()
+});
+async function readQueuedEvent(filePath) {
+	try {
+		const parsed = QueuedPostHogEventSchema.safeParse(parseJsonText(await readFile(filePath, "utf8")));
+		return parsed.success ? parsed.data : void 0;
+	} catch {
+		return;
+	}
+}
+function mergeDropCounts(left, right) {
+	const merged = { ...left };
+	for (const reason of DROP_REASONS) {
+		const count = right[reason];
+		if (count !== void 0) addDrop(merged, reason, count);
+	}
+	return merged;
+}
+function addDrop(drops, reason, count) {
+	if (count > 0) drops[reason] = (drops[reason] ?? 0) + count;
+}
+function retryDelay(attempts) {
+	const base = Math.min(MAX_BACKOFF_MS, 1e3 * 2 ** Math.min(attempts - 1, 12));
+	return Math.round(base * (.75 + Math.random() * .5));
+}
+function normalizeHost(host) {
+	return (host?.trim() || DEFAULT_POSTHOG_HOST).replace(/\/+$/, "");
+}
+function nonEmpty$1(value) {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : void 0;
+}
+function compactProperties(properties) {
+	return Object.fromEntries(Object.entries(properties).filter((entry) => entry[1] !== void 0));
+}
+//#endregion
+//#region src/telemetry-config.ts
+/** Set by Electron main from product.json `quality`; `dev` for an unpackaged run. */
+const REVIEW_CHANNEL_ENV = "DEV_FAST_REVIEW_CHANNEL";
+/** Set by the e2e harness (`e2e`) and the packaged smoke scripts (`smoke`). */
+const REVIEW_TELEMETRY_ENV_ENV = "DEV_FAST_REVIEW_TELEMETRY_ENV";
+const CHANNELS = [
+	"stable",
+	"preview",
+	"dev"
+];
+/**
+* PostHog groups events into sessions by `$session_id` and accepts only a
+* UUIDv7 there, so only a v7 app session id doubles as one.
+*/
+const uuidV7Schema = z.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
+function isUuidV7(value) {
+	return uuidV7Schema.safeParse(value).success;
+}
+function reviewTelemetryChannel(env) {
+	const value = env[REVIEW_CHANNEL_ENV]?.trim();
+	return CHANNELS.includes(value) ? value : "stable";
+}
+/**
+* First match wins: a harness declares itself, then CI, then a dev.fast
+* checkout or a persisted internal marker, else a real user.
+*/
+function reviewTelemetryEnvironment(env, config) {
+	const harness = env[REVIEW_TELEMETRY_ENV_ENV]?.trim();
+	if (harness === "e2e" || harness === "smoke") return harness;
+	if (env.CI) return "ci";
+	if (isInternalTelemetry(env, config)) return "internal";
+	return "production";
+}
+const TELEMETRY_CONFIG_RELATIVE_PATH = path.join("telemetry", "progressive-review.json");
+const PREVIEW_TELEMETRY_CONFIG_RELATIVE_PATH = path.join("telemetry", "progressive-review.preview.json");
+const LEGACY_APP_TELEMETRY_CONFIG_RELATIVE_PATH = path.join("telemetry", "install.json");
+function reviewTelemetryConfigPath(env = process.env) {
+	return path.join(devReviewHome(env), reviewTelemetryChannel(env) === "preview" ? PREVIEW_TELEMETRY_CONFIG_RELATIVE_PATH : TELEMETRY_CONFIG_RELATIVE_PATH);
+}
+function legacyAppTelemetryConfigPath(env = process.env) {
+	return path.join(devReviewHome(env), LEGACY_APP_TELEMETRY_CONFIG_RELATIVE_PATH);
+}
+function isTelemetryOptedOut(env, config) {
+	if (isEnabledEnvValue$1(env.VITEST) || env.NODE_ENV === "test") return true;
+	if (config?.enabled === false) return true;
+	return [
+		env.DO_NOT_TRACK,
+		env.DNT,
+		env.PROGRESSIVE_REVIEW_TELEMETRY_DISABLED,
+		env.DEV_FAST_TELEMETRY_DISABLED,
+		env.DEV_FAST_PROGRESSIVE_REVIEW_TELEMETRY_DISABLED,
+		env.DEV_FAST_REVIEW_TELEMETRY_DISABLED
+	].some(isEnabledEnvValue$1);
+}
+/**
+* The on-disk install config as a hand-edited or older file may hold it: only
+* the installation id is required, and a malformed optional field reads as
+* absent.
+*/
+const storedTelemetryInstallConfigSchema = z.looseObject({
+	installationId: z.string().min(1),
+	createdAt: z.iso.datetime({ offset: true }).optional().catch(void 0),
+	installationCreatedSent: z.boolean().optional().catch(void 0),
+	firstReviewPresentedSent: z.boolean().optional().catch(void 0),
+	enabled: z.boolean().optional().catch(void 0),
+	internal: z.boolean().optional().catch(void 0),
+	accountAlias: z.string().min(1).optional().catch(void 0)
+});
+function normalizeTelemetryInstallConfig(parsed, now) {
+	const stored = storedTelemetryInstallConfigSchema.safeParse(parsed);
+	if (!stored.success) return void 0;
+	const config = {
+		installationId: stored.data.installationId,
+		createdAt: stored.data.createdAt ?? now().toISOString(),
+		installationCreatedSent: stored.data.installationCreatedSent === true,
+		firstReviewPresentedSent: stored.data.firstReviewPresentedSent === true,
+		enabled: stored.data.enabled !== false,
+		internal: stored.data.internal === true
+	};
+	if (stored.data.accountAlias) config.accountAlias = stored.data.accountAlias;
+	return config;
+}
+/**
+* Whether normalizing changed a field an older or hand-edited file lacked, so
+* the config must be written back once: a backfilled `createdAt` has to stay
+* the first-seen time rather than move with every read.
+*/
+function telemetryInstallConfigNeedsWrite(parsed, config) {
+	const stored = storedTelemetryInstallConfigSchema.safeParse(parsed).data;
+	return stored?.internal !== config.internal || stored?.createdAt !== config.createdAt;
+}
+const DAY_MS = 864e5;
+/** Whole days since the install was created; 0 for a clock set back. */
+function installAgeDays(config, now) {
+	const createdAt = Date.parse(config.createdAt);
+	if (Number.isNaN(createdAt)) return 0;
+	return Math.max(0, Math.floor((now.getTime() - createdAt) / DAY_MS));
+}
+function createTelemetryInstallConfig(installationId, now) {
+	return {
+		installationId,
+		createdAt: now().toISOString(),
+		installationCreatedSent: false,
+		firstReviewPresentedSent: false,
+		enabled: true,
+		internal: false
+	};
+}
+function isEnabledEnvValue$1(value) {
+	return value === "1" || value?.toLowerCase() === "true";
+}
+let cachedWorkspaceCheckout;
+function isWorkspaceCheckout() {
+	if (cachedWorkspaceCheckout !== void 0) return cachedWorkspaceCheckout;
+	try {
+		const packageRoot = findReviewPackageRoot();
+		if (packageRoot.split(path.sep).includes("node_modules")) {
+			cachedWorkspaceCheckout = false;
+			return cachedWorkspaceCheckout;
+		}
+		let dir = packageRoot;
+		while (true) {
+			if (existsSync(path.join(dir, "pnpm-workspace.yaml"))) {
+				cachedWorkspaceCheckout = true;
+				return cachedWorkspaceCheckout;
+			}
+			const parent = path.dirname(dir);
+			if (parent === dir) break;
+			dir = parent;
+		}
+		cachedWorkspaceCheckout = false;
+	} catch {
+		cachedWorkspaceCheckout = false;
+	}
+	return cachedWorkspaceCheckout;
+}
+/**
+* Whether telemetry from this process should carry `internal: true` so
+* partner-facing dashboards can exclude it. The environment overrides a
+* stored true marker, which overrides workspace detection.
+*/
+function isInternalTelemetry(env, config) {
+	if (env.PROGRESSIVE_REVIEW_TELEMETRY_INTERNAL === "1") return true;
+	if (env.PROGRESSIVE_REVIEW_TELEMETRY_INTERNAL === "0") return false;
+	if (config?.internal === true) return true;
+	return isWorkspaceCheckout();
+}
+//#endregion
+//#region src/session-markers.ts
+/**
+* The envelope fields of the launch that opened a session which a later
+* launch may not share. An abnormal end carries them so it counts against
+* the launch that died, not the one that reported it. Closed values only.
+*/
+const launchEnvelopeSchema = z.object({
+	app_version: z.string().min(1).optional(),
+	cli_version: z.string().min(1),
+	version: z.string().min(1),
+	channel: z.enum([
+		"stable",
+		"preview",
+		"dev"
+	]),
+	environment: z.enum([
+		"production",
+		"ci",
+		"internal",
+		"e2e",
+		"smoke"
+	]),
+	surface: z.enum([
+		"desktop",
+		"cli",
+		"headless",
+		"mcp",
+		"api"
+	]),
+	node_major: z.number().int(),
+	arch: z.string().min(1),
+	os_version: z.string().min(1),
+	ci: z.boolean(),
+	internal: z.boolean(),
+	$session_id: uuidV7Schema.optional(),
+	install_age_days: z.number().int().nonnegative().optional()
+});
+/** Picks the launch fields out of an event envelope; undefined if malformed. */
+function launchEnvelope(properties) {
+	return launchEnvelopeSchema.safeParse(properties).data;
+}
+const markersSchema = z.array(z.object({
+	presentationSessionId: z.string().min(1),
+	reviewUuid: z.string().min(1),
+	startedAt: z.number(),
+	appSessionId: z.string().min(1).optional(),
+	ownerPid: z.number().int().positive().optional(),
+	envelope: launchEnvelopeSchema.optional().catch(void 0)
+}));
+/** Per channel, like the telemetry config: each channel has its own identity. */
+function openSessionMarkersPath(env) {
+	return path.join(devReviewHome(env), "telemetry", reviewTelemetryChannel(env) === "preview" ? "open-sessions.preview.json" : "open-sessions.json");
+}
+function readMarkers(file) {
+	try {
+		const parsed = markersSchema.safeParse(parseJsonText(readFileSync(file, "utf8")));
+		return parsed.success ? parsed.data : [];
+	} catch {
+		return [];
+	}
+}
+function writeMarkers(file, markers) {
+	writeFileAtomic(file, `${JSON.stringify(markers)}\n`, "utf8");
+}
+function recordOpenSession(file, marker) {
+	writeMarkers(file, [...readMarkers(file).filter((existing) => existing.presentationSessionId !== marker.presentationSessionId), marker]);
+}
+function clearOpenSession(file, presentationSessionId) {
+	if (!existsSync(file)) return;
+	writeMarkers(file, readMarkers(file).filter((marker) => marker.presentationSessionId !== presentationSessionId));
+}
+/** Reads every marker and deletes the file. */
+function takeOpenSessions(file) {
+	const markers = readMarkers(file);
+	rmSync(file, { force: true });
+	return markers;
+}
+//#endregion
+//#region src/telemetry-debug-sink.ts
+/**
+* The debug sink, or `undefined` when the switch is off. The sink replaces the
+* PostHog client: a developer run never reaches the production project.
+*/
+function createTelemetryDebugSink(env, output = process.stderr) {
+	if (!isEnabledEnvValue(env.DEV_FAST_REVIEW_TELEMETRY_DEBUG)) return void 0;
+	return {
+		enabled: true,
+		ignoresOptOut: true,
+		capture(input) {
+			try {
+				output.write(`[review-telemetry] ${JSON.stringify(input)}\n`);
+			} catch {}
+			return Promise.resolve();
+		}
+	};
+}
+function isEnabledEnvValue(value) {
+	return value === "1" || value?.toLowerCase() === "true";
+}
+//#endregion
+//#region src/review-telemetry.ts
+const REVIEW_APP_VERSION_ENV = "DEV_FAST_REVIEW_APP_VERSION";
+const REVIEW_APP_SESSION_ID_ENV = "DEV_FAST_REVIEW_APP_SESSION_ID";
+const REVIEW_SERVER_ENTRY_ENV = "DEV_FAST_REVIEW_SERVER_ENTRY";
+/**
+* A fixed namespace, not the installation id: a key per install would give
+* every install a different alias for one account and defeat the linking.
+* The hash is one-way; the account id itself is never sent.
+*/
+const ACCOUNT_ALIAS_KEY = "dev.fast.review.telemetry.account.v1";
+/** `gh_` + the first 16 bytes of HMAC-SHA256(namespace, account id). */
+function accountAlias(accountId) {
+	return `gh_${createHmac("sha256", ACCOUNT_ALIAS_KEY).update(accountId).digest().subarray(0, 16).toString("base64url")}`;
+}
+/** A tool name is program-owned, but only an identifier is ever sent. */
+const TOOL_NAME_PATTERN = /^[a-z][a-z0-9_]{0,39}$/;
+const sharedInstallConfigs = /* @__PURE__ */ new Map();
+/**
+* Announcements the debug sink printed without persisting, keyed by install
+* config path and field, so each prints once per process.
+*/
+const printedAnnouncements = /* @__PURE__ */ new Set();
+var ReviewTelemetry = class ReviewTelemetry {
+	captureClient;
+	env;
+	installConfigPath;
+	legacyInstallConfigPath;
+	openSessionMarkersPath;
+	openSessionOwnerPid;
+	idFactory;
+	commandRunIdFactory;
+	now;
+	surface;
+	packageVersion;
+	desktopVersion;
+	installConfig;
+	chunkIds;
+	constructor(options = {}) {
+		this.env = options.env ?? process.env;
+		this.captureClient = options.captureClient ?? createTelemetryDebugSink(this.env) ?? (options.fetch ? directCaptureClient(this.env, options.fetch, options.timeoutMs) : PostHogCaptureClient.fromEnv(this.env));
+		this.installConfigPath = options.installConfigPath ?? reviewTelemetryConfigPath(this.env);
+		this.legacyInstallConfigPath = options.legacyInstallConfigPath ?? legacyAppTelemetryConfigPath(this.env);
+		this.openSessionMarkersPath = options.openSessionMarkersPath ?? openSessionMarkersPath(this.env);
+		this.openSessionOwnerPid = options.openSessionOwnerPid ?? process.ppid;
+		this.commandRunIdFactory = options.randomUUID ?? randomUUID;
+		this.idFactory = options.idFactory ?? this.commandRunIdFactory;
+		this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+		this.surface = options.surface ?? "cli";
+		this.packageVersion = readReviewPackageVersion(import.meta.url);
+	}
+	static fromEnv(env = process.env, options = {}) {
+		return new ReviewTelemetry({
+			...options,
+			env
+		});
+	}
+	async getInstallationId() {
+		return (await this.loadInstallConfig()).installationId;
+	}
+	createCommandRunId() {
+		return this.commandRunIdFactory();
+	}
+	/** Sets the surface for every later event, envelope included. */
+	setSurface(surface) {
+		this.surface = surface;
+	}
+	/**
+	* Records the release of the Desktop this process reached, for `app_version`
+	* on every later event. A process Desktop launched already has it in its env.
+	*/
+	setDesktopVersion(version) {
+		const value = nonEmpty(version);
+		this.desktopVersion = value && valid(value) ? value : void 0;
+	}
+	async setEnabled(enabled) {
+		await this.withConfigLock(async () => {
+			const config = await this.readOrCreateInstallConfig();
+			config.enabled = enabled;
+			this.writeInstallConfig(config);
+			this.installConfig = config;
+			sharedInstallConfigs.set(this.installConfigPath, config);
+		}, 5e3);
+		if (!enabled) {
+			await this.captureClient.discard?.().catch(() => void 0);
+			await this.lockOpenSessions(() => rmSync(this.openSessionMarkersPath, { force: true }));
+		}
+	}
+	async setInternal(internal) {
+		await this.withConfigLock(async () => {
+			const config = await this.readOrCreateInstallConfig();
+			config.internal = internal;
+			this.writeInstallConfig(config);
+			this.installConfig = config;
+			sharedInstallConfigs.set(this.installConfigPath, config);
+		}, 5e3);
+	}
+	/**
+	* Whether events leave this machine right now: a real client, no opt-out.
+	* The debug sink prints instead of sending, so it answers false.
+	*/
+	async sendsEvents() {
+		if (this.captureClient.ignoresOptOut) return false;
+		return this.isEnabled();
+	}
+	/** The common properties every event carries; bug reports embed them. */
+	async envelope() {
+		return this.commonProperties(await this.loadInstallConfig());
+	}
+	async captureInstallationCreated() {
+		await this.announceOnce("installationCreatedSent", true, async (config) => {
+			await this.captureClient.capture({
+				event: "review_installation_created",
+				distinctId: config.installationId,
+				properties: await this.commonProperties(config)
+			});
+		});
+	}
+	/**
+	* Link this installation to a signed-in account by a one-way hash, so
+	* several installs by one person count as one; the raw account id never
+	* leaves this process. Once per installation: the first account wins. A
+	* later login to another account sends nothing, because a second alias
+	* would merge two accounts, and every later install of either, into one
+	* PostHog person. The account is looked up only when an alias would be
+	* sent, so a login with telemetry off makes no network call.
+	*/
+	async captureAccountAlias(lookupAccountId) {
+		if (!await this.isEnabled() || this.installConfig?.accountAlias) return;
+		const alias = accountAlias(await lookupAccountId());
+		await this.announceOnce("accountAlias", alias, async (config) => {
+			await this.captureClient.capture({
+				event: "$create_alias",
+				distinctId: config.installationId,
+				properties: {
+					...await this.commonProperties(config),
+					alias,
+					$process_person_profile: true
+				}
+			});
+		});
+	}
+	/**
+	* Sends an event exactly once per installation, guarded by a persisted
+	* install config field that `value` fills. The field is persisted before
+	* the send completes: under-counting
+	* is recoverable, announcing twice is not. A printed event is not a sent
+	* event, so the debug sink leaves the field alone (it still always sends,
+	* ignoring opt-out as today) and only remembers the announcement for the
+	* life of the process.
+	*/
+	async announceOnce(field, value, send) {
+		if (!this.captureClient.enabled || this.optedOut()) return;
+		await this.withConfigLock(async () => {
+			const config = await this.readOrCreateInstallConfig();
+			this.installConfig = config;
+			sharedInstallConfigs.set(this.installConfigPath, config);
+			if (this.optedOut(config) || config[field]) return;
+			if (this.captureClient.ignoresOptOut) {
+				const printed = `${this.installConfigPath}\0${field}`;
+				if (printedAnnouncements.has(printed)) return;
+				printedAnnouncements.add(printed);
+			} else {
+				config[field] = value;
+				this.writeInstallConfig(config);
+			}
+			await send(config);
+		});
+	}
+	async captureCommandSucceeded(input) {
+		await this.captureCommandEvent("review_command_succeeded", input);
+	}
+	async captureCommandFailed(input) {
+		await this.captureCommandEvent("review_command_failed", input);
+	}
+	async captureCommandStarted(input) {
+		const properties = {
+			command_path: input.command,
+			command_run_id: input.commandRunId,
+			agent_kind: this.sessionAgent()
+		};
+		await this.captureEvent("review_command_started", properties);
+	}
+	async captureToolCalled(call) {
+		const properties = {
+			tool: TOOL_NAME_PATTERN.test(call.tool) ? call.tool : "other",
+			via: call.via,
+			ok: call.ok,
+			duration_ms: Math.max(0, Math.round(call.durationMs)),
+			agent_kind: call.agentKind ?? this.sessionAgent()
+		};
+		if (!call.ok && call.errorName) properties.error_name = call.errorName;
+		if (!call.ok && call.errorCategory) properties.error_category = call.errorCategory;
+		await this.captureEvent("review_mcp_tool_called", properties);
+	}
+	/**
+	* A tab dwell period ended. Time on the files tab is also the diff dwell,
+	* so it doubles as `review_diff_viewed` without a second client beacon.
+	*/
+	async captureTabViewed(event, context) {
+		await this.captureEvent("review_tab_viewed", {
+			tab: event.tab,
+			duration_ms: event.durationMs,
+			reason: event.reason,
+			source: "review_app",
+			app_session_id: event.appSessionId
+		}, context);
+		if (event.tab !== "files") return;
+		await this.captureEvent("review_diff_viewed", {
+			duration_ms: event.durationMs,
+			source: "review_app",
+			app_session_id: event.appSessionId
+		}, context);
+	}
+	/**
+	* A session start leaves a marker until its end arrives, so a session the
+	* process never closed can be reported as abnormal on the next launch. The
+	* marker is cleared before the end is sent: a lost marker for a sent end
+	* is harmless, a stale one would report the session ended twice.
+	*/
+	async captureUiEvent(event, properties, context, occurredAt = this.now().getTime()) {
+		const reviewUuid = context?.reviewUuid;
+		const presentationSessionId = context?.presentationSessionId;
+		const inSession = reviewUuid && presentationSessionId;
+		if (inSession && event === "review_session_started") {
+			const marker = {
+				presentationSessionId,
+				reviewUuid,
+				startedAt: this.now().getTime(),
+				ownerPid: this.openSessionOwnerPid
+			};
+			const appSessionId = nonEmpty(properties.app_session_id?.toString());
+			if (appSessionId) marker.appSessionId = appSessionId;
+			if (await this.isEnabled()) {
+				const envelope = launchEnvelope(await this.envelope().catch(() => ({})));
+				if (envelope) marker.envelope = envelope;
+				await this.lockOpenSessions(() => recordOpenSession(this.openSessionMarkersPath, marker));
+			}
+		} else if (inSession && event === "review_session_ended") await this.updateOpenSessions(() => clearOpenSession(this.openSessionMarkersPath, presentationSessionId));
+		await this.captureEvent(event, {
+			source: "review_app",
+			...properties
+		}, context, occurredAt);
+		if (inSession && event === "review_review_presented") await this.captureFirstReviewPresented(context).catch(() => void 0);
+		if (event !== "review_client_error") return;
+		const exception = exceptionProperties(properties, this.chunkIds ??= readChunkIds(this.env[REVIEW_SERVER_ENTRY_ENV]));
+		if (!exception) return;
+		await this.captureEvent("$exception", {
+			source: "review_app",
+			...properties,
+			...exception
+		}, context);
+	}
+	/**
+	* Reports sessions an earlier app launch never closed as abnormal ends.
+	* Sessions of the current launch survive a server restart untouched. Call
+	* once at startup.
+	*/
+	async reconcileOpenSessions() {
+		const currentAppSessionId = nonEmpty(this.env[REVIEW_APP_SESSION_ID_ENV]);
+		const ended = [];
+		await this.updateOpenSessions(() => {
+			for (const marker of takeOpenSessions(this.openSessionMarkersPath)) if (currentAppSessionId !== void 0 && marker.appSessionId === currentAppSessionId || marker.ownerPid !== void 0 && processIsAlive(marker.ownerPid)) recordOpenSession(this.openSessionMarkersPath, marker);
+			else ended.push(marker);
+		});
+		for (const marker of ended) {
+			const outcome = "abnormal";
+			const properties = {
+				...marker.envelope && {
+					app_version: void 0,
+					...marker.envelope
+				},
+				source: "review_app",
+				outcome,
+				app_session_id: marker.appSessionId
+			};
+			await this.captureEvent("review_session_ended", properties, {
+				reviewUuid: marker.reviewUuid,
+				presentationSessionId: marker.presentationSessionId
+			});
+		}
+	}
+	/**
+	* `occurredAt` defaults to the call, before any await: config and marker
+	* locks must not reorder events that happened in order.
+	*/
+	async captureEvent(event, properties = {}, context, occurredAt = this.now().getTime()) {
+		await this.withTelemetry(async (config) => {
+			const common = await this.commonProperties(config);
+			this.captureClient.setDefaultProperties?.(common);
+			await this.captureClient.capture({
+				event,
+				distinctId: config.installationId,
+				properties: withSessionId({
+					...common,
+					...properties,
+					...correlationProperties(config.installationId, context)
+				}),
+				timestamp: occurredAt
+			});
+		});
+	}
+	async captureFirstReviewPresented(context) {
+		await this.announceOnce("firstReviewPresentedSent", true, async () => {
+			await this.captureEvent("review_first_review_presented", { source: "review_app" }, context);
+		});
+	}
+	/**
+	* Marker I/O is best effort, skipped entirely when telemetry is off, and
+	* locked because concurrent Desktops share the file.
+	*/
+	async updateOpenSessions(update) {
+		if (!await this.isEnabled()) return;
+		await this.lockOpenSessions(update);
+	}
+	async lockOpenSessions(update) {
+		try {
+			await withFileLock(`${this.openSessionMarkersPath}.lock`, {
+				retryMs: 10,
+				staleMs: 3e4,
+				timeoutMs: 250,
+				unownedGraceMs: 1e3,
+				heartbeatMs: 5e3
+			}, async () => update());
+		} catch {}
+	}
+	async flush(deadlineMs = 1e3) {
+		if (!await this.isEnabled()) return;
+		await this.captureClient.flush?.(deadlineMs).catch(() => void 0);
+	}
+	async shutdown(deadlineMs = 1e3) {
+		if (!await this.isEnabled()) return;
+		await this.captureClient.shutdown?.(deadlineMs).catch(() => void 0);
+	}
+	async captureCommandEvent(event, input) {
+		const properties = {
+			command_path: input.command,
+			exit_code: input.exitCode
+		};
+		if (input.durationMs !== void 0) properties.duration_ms = input.durationMs;
+		Object.assign(properties, input.properties);
+		properties.command_run_id = input.commandRunId;
+		if (input.errorName) properties.error_name = input.errorName;
+		if (input.errorCategory) properties.error_category = input.errorCategory;
+		await this.captureEvent(event, properties);
+	}
+	async withTelemetry(fn) {
+		if (!this.captureClient.enabled || this.optedOut()) return;
+		try {
+			const config = await this.loadInstallConfig();
+			if (this.optedOut(config)) return;
+			await fn(config);
+		} catch {}
+	}
+	async loadInstallConfig() {
+		const shared = sharedInstallConfigs.get(this.installConfigPath);
+		if (shared) {
+			this.installConfig = shared;
+			return shared;
+		}
+		if (this.installConfig) return this.installConfig;
+		await this.withConfigLock(async () => {
+			this.installConfig = await this.readOrCreateInstallConfig();
+			sharedInstallConfigs.set(this.installConfigPath, this.installConfig);
+		});
+		return this.installConfig ?? createTelemetryInstallConfig(this.idFactory(), this.now);
+	}
+	optedOut(config) {
+		if (this.captureClient.ignoresOptOut) return false;
+		return isTelemetryOptedOut(this.env, config);
+	}
+	async isEnabled() {
+		if (!this.captureClient.enabled || this.optedOut()) return false;
+		try {
+			const parsed = parseJsonText(await readFile(this.installConfigPath, "utf8"));
+			const config = normalizeTelemetryInstallConfig(parsed, this.now);
+			if (!config) return true;
+			if (!telemetryInstallConfigNeedsWrite(parsed, config)) {
+				this.installConfig = config;
+				sharedInstallConfigs.set(this.installConfigPath, config);
+			}
+			return !this.optedOut(config);
+		} catch {
+			return true;
+		}
+	}
+	async readOrCreateInstallConfig() {
+		try {
+			const parsed = parseJsonText(await readFile(this.installConfigPath, "utf8"));
+			const config = normalizeTelemetryInstallConfig(parsed, this.now);
+			if (config) {
+				if (telemetryInstallConfigNeedsWrite(parsed, config)) try {
+					this.writeInstallConfig(config);
+				} catch {}
+				return config;
+			}
+		} catch {}
+		const legacyInstallId = reviewTelemetryChannel(this.env) === "preview" ? void 0 : await this.readLegacyInstallId();
+		const config = createTelemetryInstallConfig(legacyInstallId ?? this.idFactory(), this.now);
+		if (legacyInstallId) config.installationCreatedSent = true;
+		this.writeInstallConfig(config);
+		return config;
+	}
+	async readLegacyInstallId() {
+		try {
+			const installId = jsonString(jsonObject(parseJsonText(await readFile(this.legacyInstallConfigPath, "utf8")))?.installId);
+			return installId ? installId : void 0;
+		} catch {
+			return;
+		}
+	}
+	writeInstallConfig(config) {
+		writeFileAtomic(this.installConfigPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+	}
+	async withConfigLock(operation, timeoutMs = 250) {
+		if (!(await withFileLock(`${this.installConfigPath}.lock`, {
+			retryMs: 10,
+			staleMs: 3e4,
+			timeoutMs,
+			unownedGraceMs: 1e3,
+			heartbeatMs: 5e3
+		}, operation)).acquired) throw new Error("Timed out while updating the telemetry configuration");
+	}
+	async commonProperties(config) {
+		const appVersion = reviewAppVersion(this.env) ?? this.desktopVersion;
+		const appSessionId = nonEmpty(this.env[REVIEW_APP_SESSION_ID_ENV]);
+		const properties = {
+			cli_version: this.packageVersion,
+			version: this.packageVersion,
+			channel: reviewTelemetryChannel(this.env),
+			environment: reviewTelemetryEnvironment(this.env, config),
+			surface: this.surface,
+			node_major: Number(process.versions.node.split(".", 1)[0]),
+			platform: process.platform,
+			arch: process.arch,
+			os_version: os.release(),
+			ci: Boolean(this.env.CI),
+			internal: isInternalTelemetry(this.env, config),
+			install_age_days: installAgeDays(config, this.now()),
+			$process_person_profile: config.accountAlias !== void 0
+		};
+		if (appVersion) properties.app_version = appVersion;
+		if (appSessionId) properties.app_session_id = appSessionId;
+		return withSessionId(properties);
+	}
+	sessionAgent() {
+		return reviewSessionAgent(this.env);
+	}
+};
+/** The agent harness this process runs under, from its session environment. */
+function reviewSessionAgent(env) {
+	const harness = resolveAuthoringSessionRef(env)?.harness;
+	if (harness === "codex") return "codex";
+	if (harness === "claude-code") return "claude";
+	if (harness === "pi") return "pi";
+	return "other";
+}
+/**
+* `$session_id` always mirrors the event's final `app_session_id`, which an
+* event may override (a recovered end carries the launch that died). An id
+* that is not a UUIDv7, such as a canvas's own fallback id or one from a
+* launch before v7 ids, leaves `$session_id` out.
+*/
+function withSessionId(properties) {
+	const { $session_id: _stale, ...rest } = properties;
+	return isUuidV7(rest.app_session_id) ? {
+		...rest,
+		$session_id: rest.app_session_id
+	} : rest;
+}
+function correlationProperties(installationId, context) {
+	const properties = {};
+	if (!context) return properties;
+	if (context.reviewUuid) properties.review_id = opaqueCorrelationId("rv_", installationId, "review", context.reviewUuid);
+	if (context.presentationSessionId) properties.presentation_id = opaqueCorrelationId("pr_", installationId, "presentation", context.presentationSessionId);
+	return properties;
+}
+function opaqueCorrelationId(prefix, installationId, namespace, value) {
+	return `${prefix}${createHmac("sha256", installationId).update(`dev.fast.review.telemetry.v1\0${namespace}\0${value}`).digest().subarray(0, 16).toString("base64url")}`;
+}
+function directCaptureClient(env, fetchImpl, timeoutMs) {
+	return new PostHogCaptureClient({
+		apiKey: nonEmpty(env["PROGRESSIVE_REVIEW_POSTHOG_KEY"]) ?? nonEmpty(env.DEV_FAST_POSTHOG_KEY) ?? nonEmpty(env.POSTHOG_KEY) ?? void 0,
+		host: nonEmpty(env["PROGRESSIVE_REVIEW_POSTHOG_HOST"]) ?? nonEmpty(env.DEV_FAST_POSTHOG_HOST) ?? nonEmpty(env.POSTHOG_HOST),
+		fetch: fetchImpl,
+		timeoutMs
+	});
+}
+function nonEmpty(value) {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : void 0;
+}
+function reviewAppVersion(env) {
+	const value = nonEmpty(env[REVIEW_APP_VERSION_ENV]);
+	return value && valid(value) ? value : void 0;
+}
+//#endregion
+export { reviewSessionAgent as n, reviewTelemetryChannel as r, ReviewTelemetry as t };