@dev.fast/whiteboard 0.0.0-stage → 0.2.0

package/dist/server/desktop-host.js

@@ -0,0 +1,1702 @@
+#!/usr/bin/env node
+import { a as diffFileSummaries, b as resolveRevision, i as diff, x as splitGitPatchFiles } from "../src-CmdiBL20.js";
+import { c as jsonString, i as jsonBoolean, m as isStringValue, n as isJsonObject, p as isObjectValue, s as jsonProperty, u as parseJsonText } from "../src-X9phtB2j.js";
+import { i as SharedReviewStore } from "../client-DFoh50W3.js";
+import { c as ReviewBugReportRequestSchema, l as parseReviewBugReportResponse, o as parseZod, s as ReviewBugReportMetaV2Schema, t as parseReviewCliInstallApplyRequest, v as reviewDiffrSummarizerInputSchema, y as decodeStructuralDiffEvent } from "../src-DnwdaQ2r.js";
+import { _ as invalidateStructuralComparisons, b as installFullDiffr, v as diffrExecutable, y as diffrMissingError } from "../local-data-CxLk75rx.js";
+import { C as resourceReferences, p as documentSchema } from "../stored-document-migration-DHeMpLMb.js";
+import { t as ReviewInputError } from "../input-error-OLgB_h31.js";
+import { A as devReviewHome, P as writePrivateJsonAtomic } from "../s3-config-CAxhO9u_.js";
+import { U as shellQuote, i as reviewInstanceDiscoveryPath, o as reviewLegacyDiscoveryPath } from "../review-home-paths-6zZH-1c9.js";
+import { i as readReviewPackageVersion, t as findReviewPackageRoot } from "../package-paths-B6-zxvIO.js";
+import { c as reviewInstanceIdentity, t as REVIEW_INSTANCE_ENV } from "../desktop-discovery-DBO-PM2V.js";
+import { t as openReviewProfile } from "../profile-4ry2f3AM.js";
+import { r as reviewTelemetryChannel, t as ReviewTelemetry } from "../review-telemetry-DEFnQsQ2.js";
+import { o as REVIEW_TELEMETRY_TABS } from "../request-origin-D_4QIdoN.js";
+import { c as removeLegacyReviewSkills, d as skipCliInstall, i as finishCliInstallUpdate, l as resetCliInstall, n as applyCliInstall, r as declineCliInstall, s as removeCliInstall, t as aliasInstallationToAccount, u as resolveCliInstallStatus } from "../account-alias-DOHN1RSH.js";
+import { a as serverJson, c as recordClientError, d as HttpJsonError, f as ReviewServerError, i as createWhiteboardCore, l as createNodeRequestListener, n as installProcessErrorTelemetry, o as captureSanitizedUiTelemetry, p as GlobalReviewDesktopVerbRelay, r as serverCrashReportPath, s as clientErrorsForSession, t as drainServerCrashReport, u as readBoundedRequestJson } from "../process-error-telemetry-v9e5h6D7.js";
+import { c as readQuerySchemas } from "../authoring-tools-Cr6Kpjsx.js";
+import crypto, { createHash, randomBytes, randomUUID } from "node:crypto";
+import { z } from "zod";
+import fs, { existsSync } from "node:fs";
+import { chmod, copyFile, cp, mkdir, mkdtemp, readFile, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
+import path, { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { pathToFileURL } from "node:url";
+import { Writable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { gzip, gzipSync } from "node:zlib";
+import { createServer } from "node:http";
+import { stringify } from "smol-toml";
+import { Hono } from "hono";
+//#region src/review-bundled-tools.ts
+function reviewToolsRoot(env = process.env) {
+	return path.join(devReviewHome(env), "review-tools");
+}
+async function ensureBundledTool(input) {
+	if (!/^[a-z0-9](?:[a-z0-9._-]*[a-z0-9])?$/.test(input.tool)) throw new Error(`Invalid bundled tool name: ${input.tool}`);
+	const sourcePath = input.sourcePath?.trim();
+	if (!sourcePath) return "no-source";
+	const source = path.resolve(sourcePath);
+	if (!await isExecutableFile(source)) return "no-source";
+	const env = input.env ?? process.env;
+	const platform = reviewToolPlatform();
+	const executable = stagedToolPath(env, input.tool, platform);
+	const destination = path.dirname(executable);
+	const sha256 = await hashFile(source);
+	const identity = {
+		tool: input.tool,
+		platform,
+		sha256
+	};
+	if (installedToolMatches(destination, executable, identity)) return "fresh";
+	await mkdir(path.dirname(destination), {
+		recursive: true,
+		mode: 448
+	});
+	return await withInstallLock(destination, async () => {
+		if (installedToolMatches(destination, executable, identity)) return "fresh";
+		const staging = `${destination}.staging-${process.pid}-${randomBytes(6).toString("hex")}`;
+		await rm(staging, {
+			recursive: true,
+			force: true
+		});
+		await mkdir(staging, {
+			recursive: true,
+			mode: 448
+		});
+		try {
+			const stagedExecutable = path.join(staging, executableName(input.tool, platform));
+			await copyFile(source, stagedExecutable);
+			if (await hashFile(stagedExecutable) !== sha256) throw new Error(`The bundled ${input.tool} source changed while Whiteboard staged it.`);
+			await chmod(stagedExecutable, 493);
+			await writeToolStamp(staging, identity);
+			await rm(destination, {
+				recursive: true,
+				force: true
+			});
+			await rename(staging, destination);
+			return "staged";
+		} finally {
+			await rm(staging, {
+				recursive: true,
+				force: true
+			});
+		}
+	});
+}
+async function ensureBundledRustAnalyzer(input = {}) {
+	const env = input.env ?? process.env;
+	return await ensureBundledTool({
+		tool: "rust-analyzer",
+		sourcePath: env.DEV_FAST_REVIEW_RUST_ANALYZER,
+		env
+	});
+}
+function stagedToolPath(env, tool, platform = reviewToolPlatform()) {
+	return path.join(reviewToolsRoot(env), tool, "bundled", platform, executableName(tool, platform));
+}
+async function withInstallLock(destination, operation) {
+	const lockPath = `${destination}.install-lock`;
+	const deadline = Date.now() + 12e4;
+	while (true) try {
+		await mkdir(lockPath, { mode: 448 });
+		break;
+	} catch (error) {
+		if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
+		if (await stat(lockPath).then((value) => Date.now() - value.mtimeMs).catch(() => 0) > 6e5) {
+			await rm(lockPath, {
+				recursive: true,
+				force: true
+			});
+			continue;
+		}
+		if (Date.now() >= deadline) throw new Error(`Timed out waiting for another Whiteboard process to install ${path.basename(destination)}.`);
+		await setTimeout$1(100);
+	}
+	try {
+		return await operation();
+	} finally {
+		await rm(lockPath, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+function installedToolMatches(destination, executable, identity) {
+	if (!isExecutable(executable)) return false;
+	try {
+		const stamp = parseJsonText(fs.readFileSync(path.join(destination, "review-tool.json"), "utf8"));
+		return isJsonObject(stamp) && stamp.tool === identity.tool && stamp.platform === identity.platform && stamp.sha256 === identity.sha256;
+	} catch {
+		return false;
+	}
+}
+async function writeToolStamp(destination, identity) {
+	await writeFile(path.join(destination, "review-tool.json"), `${JSON.stringify(identity, null, 2)}\n`, {
+		encoding: "utf8",
+		mode: 384
+	});
+}
+function reviewToolPlatform() {
+	return `${process.platform === "darwin" ? "darwin" : process.platform === "linux" ? "linux" : process.platform}-${process.arch}`;
+}
+function executableName(name, platform) {
+	return platform.startsWith("win32-") ? `${name}.exe` : name;
+}
+function isExecutable(filePath) {
+	try {
+		fs.accessSync(filePath, fs.constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function isExecutableFile(filePath) {
+	const metadata = await stat(filePath).catch(() => void 0);
+	return Boolean(metadata?.isFile() && isExecutable(filePath));
+}
+async function hashFile(filePath) {
+	const hash = createHash("sha256");
+	await pipeline(fs.createReadStream(filePath), new Writable({ write(chunk, _encoding, callback) {
+		hash.update(chunk);
+		callback();
+	} }));
+	return hash.digest("hex");
+}
+//#endregion
+//#region src/server/desktop-host-shutdown.ts
+function listenForDesktopHostShutdown(hostProcess, onShutdown, onTelemetrySetting, onStageRustAnalyzer) {
+	const handleMessage = (message) => {
+		if (!isJsonObject(message)) return;
+		const type = jsonProperty(message, "type");
+		if (type === "shutdown") {
+			onShutdown();
+			return;
+		}
+		if (type === "telemetry-setting") {
+			const enabled = jsonBoolean(jsonProperty(message, "enabled"));
+			if (enabled !== void 0) onTelemetrySetting?.(enabled);
+			return;
+		}
+		if (type === "stage-rust-analyzer") {
+			const path = jsonString(jsonProperty(message, "path"));
+			if (path) onStageRustAnalyzer?.(path);
+		}
+	};
+	if (hostProcess.parentPort) {
+		const handleParentMessage = (event) => {
+			handleMessage(event.data);
+		};
+		hostProcess.parentPort.on("message", handleParentMessage);
+		return () => hostProcess.parentPort?.off("message", handleParentMessage);
+	}
+	hostProcess.on("message", handleMessage);
+	return () => hostProcess.off("message", handleMessage);
+}
+//#endregion
+//#region src/review-preferences.ts
+const DEFAULT_REVIEW_PREFERENCES = { scratchpadEnabled: false };
+function reviewPreferencesPath(devHome = devReviewHome()) {
+	return path.join(devHome, "preferences.json");
+}
+/** A missing or unreadable file falls back to the defaults; it never throws. */
+async function readReviewPreferences(devHome) {
+	try {
+		return { scratchpadEnabled: parseScratchpadEnabled(parseJsonText(await readFile(reviewPreferencesPath(devHome), "utf8"))) };
+	} catch {
+		return { ...DEFAULT_REVIEW_PREFERENCES };
+	}
+}
+async function writeReviewPreferences(preferences, devHome) {
+	const next = { scratchpadEnabled: preferences.scratchpadEnabled === true };
+	await writePrivateJsonAtomic(reviewPreferencesPath(devHome), next);
+	return next;
+}
+/** Reads the scratchpad preference; a missing file means off. */
+async function readScratchpadEnabled(devHome) {
+	return (await readReviewPreferences(devHome)).scratchpadEnabled;
+}
+/** Sets the scratchpad preference, keeping the other preferences as they are. */
+async function writeScratchpadEnabled(enabled, devHome) {
+	return (await writeReviewPreferences({
+		...await readReviewPreferences(devHome),
+		scratchpadEnabled: enabled
+	}, devHome)).scratchpadEnabled;
+}
+function parseScratchpadEnabled(raw) {
+	return isJsonObject(raw) && raw.scratchpadEnabled === true;
+}
+//#endregion
+//#region src/server/crash-report.ts
+const CRASH_REPORT_URL = "https://bug.dev.fast/api/v2/crashes";
+const gzipAsync = promisify(gzip);
+/** The Worker's limit on the gzip dump it stores. */
+const DEFAULT_MAX_DUMP_BYTES = 5e7;
+/** Reading a dump this large into memory is not worth it; it can never fit. */
+const MAX_RAW_DUMP_BYTES = 536870912;
+const DUMP_TOO_LARGE = {
+	ok: false,
+	status: 413,
+	error: "Crash dump is too large."
+};
+const UPSTREAM_TIMEOUT_MS$1 = 6e4;
+const version = z.string().regex(/^[0-9A-Za-z.+_-]{1,64}$/);
+/**
+* The envelope keys the Worker's strict crash meta accepts, with the values it
+* accepts. Any other key is dropped, and a value that would not pass is left
+* out rather than failing the whole upload.
+*/
+const CrashEnvelopeSchema = z.object({
+	app_version: version.optional().catch(void 0),
+	cli_version: version.optional().catch(void 0),
+	channel: z.enum([
+		"stable",
+		"preview",
+		"dev"
+	]).optional().catch(void 0),
+	environment: z.enum([
+		"production",
+		"ci",
+		"internal",
+		"e2e",
+		"smoke"
+	]).optional().catch(void 0),
+	surface: z.enum([
+		"desktop",
+		"cli",
+		"headless",
+		"mcp",
+		"api"
+	]).optional().catch(void 0),
+	platform: ReviewBugReportMetaV2Schema.shape.platform.optional().catch(void 0),
+	arch: z.enum([
+		"arm",
+		"arm64",
+		"ia32",
+		"loong64",
+		"mips",
+		"mipsel",
+		"ppc",
+		"ppc64",
+		"riscv64",
+		"s390",
+		"s390x",
+		"x64"
+	]).optional().catch(void 0),
+	os_version: version.optional().catch(void 0),
+	node_major: z.number().int().optional().catch(void 0),
+	ci: z.boolean().optional().catch(void 0),
+	internal: z.boolean().optional().catch(void 0),
+	app_session_id: z.uuid().optional().catch(void 0)
+});
+/** The launch a dump was written during, from Electron main's dump ledger. */
+const CrashLaunchSchema = CrashEnvelopeSchema.pick({
+	app_session_id: true,
+	app_version: true,
+	cli_version: true
+});
+/** The body Electron main posts to `/crash-reports`. */
+const CrashReportRequestSchema = z.object({
+	dump_path: z.string().min(1),
+	crashed_at: z.number().int().nonnegative(),
+	covered: z.boolean(),
+	launch: CrashLaunchSchema.optional()
+});
+/**
+* A dump belongs to the launch that wrote it, not to this one: its session id
+* and versions override the current envelope. Without a matching launch the
+* crashed session is unknown, so its id is left out; the versions stay the
+* current launch's, the best guess there is.
+*/
+function crashedLaunchProperties(launch) {
+	const properties = { app_session_id: launch?.app_session_id };
+	if (!launch) return properties;
+	return {
+		...properties,
+		app_version: launch.app_version,
+		cli_version: launch.cli_version
+	};
+}
+/**
+* Upload one Crashpad minidump with the telemetry envelope as metadata. The
+* caller has already checked the opt-out; this only packs and posts.
+*/
+async function uploadCrashDump(input) {
+	const maxDumpBytes = input.maxDumpBytes ?? DEFAULT_MAX_DUMP_BYTES;
+	if ((await stat(input.dumpPath)).size > MAX_RAW_DUMP_BYTES) return DUMP_TOO_LARGE;
+	const dump = await gzipAsync(await readFile(input.dumpPath), { level: 6 });
+	if (dump.byteLength > maxDumpBytes) return DUMP_TOO_LARGE;
+	const meta = {
+		schema_version: 1,
+		distinct_id: input.distinctId,
+		crashed_at: input.crashedAt,
+		covered: input.covered,
+		dump_bytes: dump.byteLength,
+		dump_sha256: createHash("sha256").update(dump).digest("hex"),
+		...CrashEnvelopeSchema.parse(input.envelope)
+	};
+	const form = new FormData();
+	form.append("meta", JSON.stringify(meta));
+	form.append("dump", new Blob([Uint8Array.from(dump)], { type: "application/gzip" }), "minidump.dmp.gz");
+	try {
+		const response = await (input.fetchImpl ?? fetch)(CRASH_REPORT_URL, {
+			method: "POST",
+			body: form,
+			signal: AbortSignal.timeout(UPSTREAM_TIMEOUT_MS$1)
+		});
+		if (!response.ok) return {
+			ok: false,
+			status: response.status,
+			error: "Crash report service failed."
+		};
+		return { ok: true };
+	} catch (error) {
+		return {
+			ok: false,
+			status: 502,
+			error: error instanceof Error ? error.message : "Crash report service failed."
+		};
+	}
+}
+/**
+* `POST /crash-reports` from Electron main. The server token also reaches the
+* canvas, so only a `.dmp` file whose real path sits inside the Review dump
+* directory is ever read. A dump no live listener covered is counted here as
+* `review_crash`, stamped with its own launch, which the `/telemetry/event`
+* route cannot do: that route stamps the sender's session. Nothing is uploaded
+* when telemetry is off or only printed (the debug sink).
+*/
+async function reportCrashDump(telemetry, request, crashDumpsDir, fetchImpl) {
+	const dumpPath = await dumpInside(request.dump_path, crashDumpsDir);
+	if (!dumpPath) return {
+		status: 403,
+		body: {
+			ok: false,
+			error: "Not a Whiteboard crash dump."
+		}
+	};
+	const launch = crashedLaunchProperties(request.launch);
+	const counted = !request.covered;
+	if (counted) await telemetry.captureEvent("review_crash", {
+		process: "unknown",
+		reason: "minidump",
+		source: "minidump",
+		...launch
+	});
+	if (!await telemetry.sendsEvents()) return {
+		status: 200,
+		body: {
+			ok: true,
+			counted,
+			skipped: "telemetry_disabled"
+		}
+	};
+	const result = await uploadCrashDump({
+		dumpPath,
+		crashedAt: request.crashed_at,
+		covered: request.covered,
+		distinctId: await telemetry.getInstallationId(),
+		envelope: {
+			...await telemetry.envelope(),
+			...launch
+		},
+		fetchImpl
+	});
+	return {
+		status: result.ok ? 200 : result.status ?? 502,
+		body: {
+			...result,
+			counted
+		}
+	};
+}
+async function dumpInside(file, directory) {
+	if (!directory) return void 0;
+	try {
+		const [realFile, realDirectory] = await Promise.all([realpath(file), realpath(directory)]);
+		const relative = path.relative(realDirectory, realFile);
+		if (!realFile.endsWith(".dmp") || !relative || relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) return void 0;
+		return realFile;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/server/diffr-config.ts
+const execFileAsync = promisify(execFile);
+let writes = Promise.resolve();
+let testing = false;
+function serialized(operation) {
+	const next = writes.then(operation, operation);
+	writes = next.catch(() => {});
+	return next;
+}
+async function diffr(args, rootPath, options = {}) {
+	try {
+		const { stdout } = await execFileAsync(diffrExecutable(), args, {
+			cwd: rootPath,
+			maxBuffer: 16777216,
+			signal: options.signal ?? AbortSignal.timeout(3e4),
+			env: options.env ?? process.env
+		});
+		return stdout;
+	} catch (error) {
+		const failure = error;
+		if (failure.code === "ENOENT") throw diffrMissingError();
+		if (failure.name === "AbortError") throw new Error("diffr timed out or was cancelled.");
+		throw new Error("diffr could not complete the operation. Check its configuration and credentials.");
+	}
+}
+async function values(rootPath, reveal = false, signal) {
+	return json(await diffr([
+		"config",
+		"show",
+		"--json",
+		...reveal ? ["--reveal"] : []
+	], rootPath, { signal }));
+}
+function json(output) {
+	try {
+		const parsed = parseJsonText(output);
+		if (isJsonObject(parsed)) return parsed;
+	} catch {}
+	throw new Error("diffr configuration response is malformed.");
+}
+function valueAt(object, key) {
+	let value = object;
+	for (const segment of key.split(".")) value = isJsonObject(value) ? value[segment] : void 0;
+	return value;
+}
+const prefix = "plugins.bundled.summarize";
+function savedProvider(config) {
+	const value = valueAt(config, `${prefix}.provider`);
+	return isStringValue(value) ? value : "";
+}
+function savedEndpoint(config) {
+	const value = valueAt(config, `${prefix}.endpoint`);
+	return isStringValue(value) ? value : "";
+}
+/** Whether a saved key belongs to a different destination than the draft's. */
+function movesKey(config, draft) {
+	return draft.provider !== savedProvider(config) || draft.endpoint !== savedEndpoint(config);
+}
+function environmentKey(providers, id) {
+	return providers.find((provider) => provider.id === id)?.keyVariables.map((name) => process.env[name]).find((key) => !!key);
+}
+function keyOptional(providers, id, endpoint) {
+	return endpoint !== "" && !!providers.find((provider) => provider.id === id)?.keylessCustomEndpoint;
+}
+function strings(value) {
+	return Array.isArray(value) ? value.filter(isStringValue) : [];
+}
+/**
+* What diffr's schema says about summaries: each provider's defaults, and
+* the default prompt with the link its description gives. Nothing when
+* diffr cannot describe its schema: the rest of Settings still works.
+*/
+async function summaryDefaults(rootPath) {
+	let schema;
+	try {
+		schema = json(await diffr(["config", "schema"], rootPath));
+	} catch {
+		return {};
+	}
+	const options = valueAt(schema, "properties.plugins.properties.bundled.properties.summarize.properties");
+	if (!isJsonObject(options)) return {};
+	const option = (name) => isJsonObject(options[name]) ? options[name] : {};
+	const provider = option("provider");
+	const titles = strings(provider["x-enum-titles"]);
+	const models = valueAt(option("model"), "x-default-by.values");
+	const details = valueAt(option("provider_details"), "x-default-by.values");
+	const providers = strings(provider.enum).map((id, index) => {
+		const detail = isJsonObject(details) ? details[id] : void 0;
+		const model = isJsonObject(models) ? models[id] : void 0;
+		const endpoint = isJsonObject(detail) ? detail.endpoint : void 0;
+		return {
+			id,
+			title: titles[index] ?? id,
+			model: isStringValue(model) ? model : "",
+			endpoint: isStringValue(endpoint) ? endpoint : "",
+			keyVariables: isJsonObject(detail) ? strings(detail.key_variables) : [],
+			keylessCustomEndpoint: isJsonObject(detail) && detail.keyless_custom_endpoint === true
+		};
+	});
+	const prompt = option("system_prompt");
+	return {
+		providers,
+		defaultPrompt: isStringValue(prompt.default) ? prompt.default : void 0
+	};
+}
+async function read(rootPath) {
+	const config = await values(rootPath);
+	const defaults = await summaryDefaults(rootPath);
+	const saved = valueAt(config, `${prefix}.api_key`);
+	const credentialSource = isStringValue(saved) && saved.length > 0 ? "config" : environmentKey(defaults.providers ?? [], savedProvider(config)) ? "environment" : "missing";
+	const plugins = config.plugins;
+	if (isJsonObject(plugins)) for (const namespace of Object.values(plugins)) {
+		if (!isJsonObject(namespace)) continue;
+		for (const plugin of Object.values(namespace)) if (isJsonObject(plugin)) delete plugin.api_key;
+	}
+	return {
+		values: config,
+		credentialSource,
+		...defaults
+	};
+}
+function readDiffrConfig(rootPath) {
+	return serialized(() => read(rootPath));
+}
+function diffrConfigValueText(value) {
+	return isStringValue(value) ? value : JSON.stringify(value);
+}
+async function writeSettings(entries, rootPath) {
+	let changed = false;
+	let error;
+	let current = await values(rootPath);
+	try {
+		for (const [key, value] of entries) {
+			if (valueAt(current, key) === value) continue;
+			await diffr([
+				"config",
+				"set",
+				key,
+				diffrConfigValueText(value)
+			], rootPath);
+			changed = true;
+			current = await values(rootPath);
+		}
+	} catch {
+		error = changed ? "Some settings were saved before diffr rejected a change. Check the current values and try again." : "diffr could not save the setting. Check its configuration and the entered value.";
+	} finally {
+		if (changed) invalidateStructuralComparisons();
+	}
+	return {
+		...await read(rootPath),
+		changed,
+		error
+	};
+}
+function setDiffrConfigValue(key, value, rootPath) {
+	if (!/^[A-Za-z0-9_][A-Za-z0-9_-]*(\.[A-Za-z0-9_][A-Za-z0-9_-]*)*$/.test(key)) throw new Error("Invalid diffr config key.");
+	return serialized(() => writeSettings([[key, value]], rootPath));
+}
+function saveDiffrSummarizer(input, rootPath) {
+	const parsed = reviewDiffrSummarizerInputSchema.safeParse(input);
+	if (!parsed.success) throw new Error("Invalid summary settings.");
+	const draft = parsed.data;
+	return serialized(async () => {
+		const current = await read(rootPath);
+		const providers = current.providers ?? [];
+		const moving = movesKey(current.values, draft);
+		const savedKey = current.credentialSource === "config";
+		if (draft.enabled && !draft.apiKey && !(savedKey && !moving) && !environmentKey(providers, draft.provider) && !keyOptional(providers, draft.provider, draft.endpoint)) return {
+			...current,
+			changed: false,
+			error: "Add an API key before enabling summaries."
+		};
+		const entries = [];
+		if (!draft.enabled) entries.push([`${prefix}.enabled`, false]);
+		if (moving && savedKey) entries.push([`${prefix}.api_key`, ""]);
+		entries.push([`${prefix}.provider`, draft.provider]);
+		if (draft.endpoint !== savedEndpoint(current.values) || draft.endpoint && draft.provider !== savedProvider(current.values)) entries.push([`${prefix}.endpoint`, draft.endpoint]);
+		if (draft.apiKey) entries.push([`${prefix}.api_key`, draft.apiKey]);
+		if (draft.systemPrompt.trim() && draft.systemPrompt !== valueAt(current.values, `${prefix}.system_prompt`)) entries.push([`${prefix}.system_prompt`, draft.systemPrompt]);
+		entries.push([`${prefix}.model`, draft.model], [`${prefix}.tests`, draft.tests]);
+		if (draft.enabled) entries.push([`${prefix}.enabled`, true]);
+		return writeSettings(entries, rootPath);
+	});
+}
+async function testDiffrSummarizer(input, rootPath, signal) {
+	const parsed = reviewDiffrSummarizerInputSchema.safeParse(input);
+	if (!parsed.success) throw new Error("Invalid summary settings.");
+	if (testing) throw new Error("A summary test is already running.");
+	testing = true;
+	const timeout = AbortSignal.timeout(6e4);
+	const deadline = signal ? AbortSignal.any([signal, timeout]) : timeout;
+	let directory;
+	try {
+		const config = await serialized(() => values(rootPath, true, deadline));
+		const saved = valueAt(config, prefix);
+		if (!isJsonObject(saved)) throw new Error("The summarizer is not available in this configuration.");
+		const { provider, endpoint, model, systemPrompt } = parsed.data;
+		const providers = (await summaryDefaults(rootPath)).providers ?? [];
+		const variables = providers.find((known) => known.id === provider)?.keyVariables ?? [];
+		const apiKey = parsed.data.apiKey || (!movesKey(config, parsed.data) && isStringValue(saved.api_key) ? saved.api_key : "") || environmentKey(providers, provider);
+		if (!apiKey && !keyOptional(providers, provider, endpoint)) throw new Error("Add an API key to test summaries.");
+		directory = await mkdtemp(join(tmpdir(), "review-summary-"));
+		const options = {
+			...saved,
+			enabled: true,
+			provider,
+			model,
+			...systemPrompt.trim() && { system_prompt: systemPrompt },
+			min_lines: 1,
+			retries: 0,
+			request_timeout_ms: 45e3
+		};
+		delete options.api_key;
+		delete options.provider_details;
+		if (endpoint) options.endpoint = endpoint;
+		else delete options.endpoint;
+		await mkdir(join(directory, "diffr"));
+		await writeFile(join(directory, "diffr", "config.toml"), stringify({
+			version: 1,
+			plugins: {
+				order: ["bundled.summarize"],
+				bundled: { summarize: options }
+			}
+		}), { mode: 384 });
+		const before = join(directory, "before.rs"), after = join(directory, "after.rs");
+		await writeFile(before, "");
+		await writeFile(after, SUMMARY_SAMPLE);
+		const output = await diffr([
+			"--no-index",
+			"--format",
+			"ndjson",
+			"--stream-annotations",
+			"--",
+			before,
+			after
+		], directory, {
+			env: {
+				...process.env,
+				...Object.fromEntries(providers.flatMap((known) => known.keyVariables).map((name) => [name, ""])),
+				...apiKey && variables[0] && { [variables[0]]: apiKey },
+				XDG_CONFIG_HOME: directory
+			},
+			signal: deadline
+		});
+		try {
+			const events = output.trim().split("\n").map(decodeStructuralDiffEvent);
+			const complete = events.at(-1);
+			const annotation = events.flatMap((event) => event.type === "annotations" ? event.annotations : []).find((item) => item.label.trim());
+			if (complete?.type === "complete" && complete.failed === 0 && !complete.aborted && !events.some((event) => (event.type === "annotations" || event.type === "file") && event.error) && annotation) return apiKey ? annotation.label.split(apiKey).join("[redacted]") : annotation.label;
+		} catch {}
+		throw new Error("No summary was produced. Check the API key, model, and network connection.");
+	} finally {
+		testing = false;
+		if (directory) await rm(directory, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+const SUMMARY_SAMPLE = `pub fn count_values(values: &[i32]) -> (i32, i32) {
+    let mut total = 0;
+    let mut count = 0;
+    for value in values {
+        if *value > 0 {
+            total += value;
+            count += 1;
+        }
+    }
+    let average = if count > 0 {
+        total / count
+    } else {
+        0
+    };
+    (count, average)
+}
+`;
+//#endregion
+//#region src/review-diff-files.ts
+async function resolveReviewDiffFiles(input) {
+	const baseRef = input.baseRef?.trim();
+	if (!baseRef) return { files: [] };
+	const headRef = input.headRef?.trim() || void 0;
+	const paths = normalizeDiffPaths(input.paths);
+	if (input.includePatch === false) return {
+		baseRef,
+		headRef,
+		files: await diffFileSummaries({
+			rootPath: input.rootPath,
+			baseRef,
+			headRef,
+			paths
+		})
+	};
+	const stdout = await diff({
+		rootPath: input.rootPath,
+		baseRef,
+		headRef,
+		paths,
+		contextLines: input.contextLines
+	});
+	return {
+		baseRef,
+		headRef,
+		files: splitGitPatchFiles(stdout).map(({ file, patch }) => ({
+			path: file.path,
+			previousPath: file.previousPath,
+			status: file.status,
+			additions: file.additions,
+			deletions: file.deletions,
+			patch
+		})).filter((file) => matchesDiffPath(file, paths))
+	};
+}
+function normalizeDiffPaths(paths) {
+	return [...new Set((paths ?? []).map((path) => path.trim()).filter((path) => path.length > 0))].sort();
+}
+function matchesDiffPath(file, paths) {
+	if (paths.length === 0) return true;
+	const candidates = new Set([file.path, file.previousPath].filter(Boolean));
+	return paths.some((path) => candidates.has(path));
+}
+//#endregion
+//#region src/server/bug-report.ts
+const BUG_REPORT_URL = "https://bug.dev.fast/api/v2/reports";
+const MAX_PAYLOAD_BYTES = 10485760;
+const UPSTREAM_TIMEOUT_MS = 2e4;
+var BugReportUpstreamError = class extends Error {
+	status;
+	constructor(status, message) {
+		super(message);
+		this.status = status;
+		this.name = "BugReportUpstreamError";
+	}
+};
+async function submitReviewBugReport(input) {
+	const cliVersion = readReviewPackageVersion();
+	const attachmentErrors = [];
+	const payload = {
+		schema_version: 4,
+		description: input.report.description,
+		diagnostics: {
+			app_version: input.report.app_version,
+			cli_version: cliVersion,
+			platform: process.platform,
+			app_session_id: input.report.app_session_id,
+			client_error_names: input.clientErrorNames.slice(-20)
+		}
+	};
+	if (input.telemetryEnvelope) payload.diagnostics.telemetry = Object.fromEntries(Object.entries(input.telemetryEnvelope).filter((entry) => entry[1] !== void 0));
+	if (input.report.screenshot) payload.screenshot = input.report.screenshot;
+	let reviewSource;
+	let omittedReviewFiles;
+	let mapSource;
+	let changedFileDiffs;
+	const tasks = [];
+	if (input.report.include_review) tasks.push(input.source.review().then((result) => {
+		reviewSource = result.files;
+		if (result.omitted.length > 0) omittedReviewFiles = result.omitted;
+	}, () => {
+		attachmentErrors.push(unavailable("review"));
+	}));
+	if (input.report.include_map) tasks.push(input.source.map().then((source) => {
+		if (source !== null) mapSource = source;
+	}, () => {
+		attachmentErrors.push(unavailable("map"));
+	}));
+	if (input.report.include_diff) tasks.push(input.source.diff().then((diff) => {
+		changedFileDiffs = diff;
+	}, () => {
+		attachmentErrors.push(unavailable("diff"));
+	}));
+	await Promise.all(tasks);
+	if (reviewSource !== void 0) payload.review = reviewSource;
+	if (omittedReviewFiles !== void 0) payload.diagnostics.review_omitted_files = omittedReviewFiles;
+	if (mapSource !== void 0) payload.map = mapSource;
+	if (changedFileDiffs !== void 0) payload.diff = changedFileDiffs;
+	if (attachmentErrors.length > 0) payload.diagnostics.attachment_errors = attachmentErrors.sort(byAttachment);
+	const response = await (input.fetchImpl ?? fetch)(BUG_REPORT_URL, {
+		method: "POST",
+		body: buildBugReportRequest(payload, {
+			appVersion: input.report.app_version,
+			cliVersion
+		}),
+		signal: AbortSignal.timeout(UPSTREAM_TIMEOUT_MS)
+	}).catch((error) => {
+		throw new BugReportUpstreamError(502, error instanceof Error ? error.message : "Bug report service failed.");
+	});
+	const responseBody = await response.json().catch(() => null);
+	if (!response.ok) throw new BugReportUpstreamError(response.status === 429 || response.status === 413 ? response.status : 502, response.status === 429 ? "Too many reports. Try again later." : response.status === 413 ? "Bug report is too large." : "Bug report service failed.");
+	const result = parseReviewBugReportResponse(responseBody);
+	if (!result.ok) throw new BugReportUpstreamError(502, result.error);
+	return result;
+}
+function buildBugReportRequest(payload, input) {
+	const maxPayloadBytes = input.maxPayloadBytes ?? MAX_PAYLOAD_BYTES;
+	let truncatedDiff = false;
+	let truncatedMap = false;
+	let truncatedScreenshot = false;
+	let payloadBytes = gzipPayload(payload);
+	if (payloadBytes.byteLength > maxPayloadBytes && payload.diff) {
+		delete payload.diff;
+		truncatedDiff = true;
+		payloadBytes = gzipPayload(payload);
+	}
+	if (payloadBytes.byteLength > maxPayloadBytes && payload.map) {
+		delete payload.map;
+		truncatedMap = true;
+		payloadBytes = gzipPayload(payload);
+	}
+	if (payloadBytes.byteLength > maxPayloadBytes && payload.screenshot) {
+		delete payload.screenshot;
+		truncatedScreenshot = true;
+		payloadBytes = gzipPayload(payload);
+	}
+	if (payloadBytes.byteLength > maxPayloadBytes && payload.review) {
+		delete payload.review;
+		payloadBytes = gzipPayload(payload);
+	}
+	if (payloadBytes.byteLength > maxPayloadBytes) throw new BugReportUpstreamError(413, "Bug report is too large.");
+	const meta = {
+		schema_version: 2,
+		description_length: Buffer.byteLength(payload.description),
+		has_review: payload.review !== void 0,
+		has_map: payload.map !== void 0,
+		has_diff: payload.diff !== void 0,
+		has_screenshot: payload.screenshot !== void 0,
+		has_trace: false,
+		payload_bytes: payloadBytes.byteLength,
+		app_version: input.appVersion,
+		cli_version: input.cliVersion,
+		platform: process.platform,
+		truncated_diff: truncatedDiff,
+		truncated_map: truncatedMap,
+		truncated_screenshot: truncatedScreenshot,
+		truncated_trace: false,
+		parts: [{
+			field: "payload",
+			filename: "payload.json.gz",
+			bytes: payloadBytes.byteLength,
+			sha256: sha256Bytes(payloadBytes)
+		}]
+	};
+	if (payload.description.trim().length > 0) meta.description = payload.description;
+	const form = new FormData();
+	form.append("meta", JSON.stringify(meta));
+	form.append("payload", new Blob([Uint8Array.from(payloadBytes)], { type: "application/gzip" }), "payload.json.gz");
+	return form;
+}
+function gzipPayload(payload) {
+	return gzipSync(Buffer.from(JSON.stringify(payload)), { level: 9 });
+}
+function sha256Bytes(bytes) {
+	return createHash("sha256").update(bytes).digest("hex");
+}
+function unavailable(attachment) {
+	return {
+		attachment,
+		error: "unavailable"
+	};
+}
+function byAttachment(left, right) {
+	return left.attachment.localeCompare(right.attachment);
+}
+//#endregion
+//#region src/server/review-api-parsers.ts
+const MIN_REVIEW_TAB_DWELL_MS = 250;
+const MAX_REVIEW_TAB_DWELL_MS = 144e5;
+const APP_SESSION_ID_PATTERN = /^[A-Za-z0-9_-][A-Za-z0-9_.-]{15,127}$/;
+const MAX_BUG_REPORT_DESCRIPTION_BYTES = 65536;
+const MAX_BUG_REPORT_SCREENSHOT_BYTES = 3145728;
+function parseReviewBugReportInput(value) {
+	const parsed = ReviewBugReportRequestSchema.parse(value);
+	if (Buffer.byteLength(parsed.description, "utf8") > MAX_BUG_REPORT_DESCRIPTION_BYTES) throw new HttpJsonError(`description must not exceed ${MAX_BUG_REPORT_DESCRIPTION_BYTES} UTF-8 bytes`, 413);
+	if (parsed.screenshot) {
+		const screenshot = Buffer.from(parsed.screenshot.base64, "base64");
+		if (screenshot.toString("base64") !== parsed.screenshot.base64) throw new HttpJsonError("screenshot.base64 must be valid base64", 400);
+		if (screenshot.byteLength > MAX_BUG_REPORT_SCREENSHOT_BYTES) throw new HttpJsonError(`screenshot must not exceed ${MAX_BUG_REPORT_SCREENSHOT_BYTES} decoded bytes`, 413);
+	}
+	return parsed;
+}
+const ReviewTabTelemetryInputSchema = z.strictObject({
+	tab: z.enum(REVIEW_TELEMETRY_TABS, { error: "must be review, commits, map, files, or trace" }),
+	reason: z.enum([
+		"tab_change",
+		"visibility_hidden",
+		"pagehide",
+		"unmount"
+	], { error: "must be tab_change, visibility_hidden, pagehide, or unmount" }),
+	duration_ms: z.number().int("must be an integer from 250ms to 4h").min(MIN_REVIEW_TAB_DWELL_MS, "must be an integer from 250ms to 4h").max(MAX_REVIEW_TAB_DWELL_MS, "must be an integer from 250ms to 4h"),
+	app_session_id: z.string().regex(APP_SESSION_ID_PATTERN, "must be a valid session id"),
+	document: z.unknown().optional()
+}).transform((event) => ({
+	tab: event.tab,
+	reason: event.reason,
+	durationMs: event.duration_ms,
+	appSessionId: event.app_session_id
+}));
+function requestJsonErrorStatus(cause) {
+	return cause instanceof HttpJsonError ? cause.statusCode : 400;
+}
+function parseReviewTabTelemetryInput(value) {
+	return parseZod(ReviewTabTelemetryInputSchema, value, "Review tab telemetry event");
+}
+//#endregion
+//#region src/server/json-review-reporting.ts
+function jsonReviewBugReportSource(store, snapshot) {
+	return {
+		async review() {
+			return {
+				files: { "review.json": JSON.stringify(snapshot, null, 2) },
+				omitted: []
+			};
+		},
+		async map() {
+			const ids = [...new Set(resourceReferences(snapshot.document).flatMap((block) => block.type === "software_map" ? [block.mapVersionId] : []))];
+			return ids.length ? JSON.stringify(ids.map((id) => JSON.parse(Buffer.from(store.resource(id).data).toString()))) : null;
+		},
+		async diff() {
+			if (!snapshot.pins) return { files: [] };
+			return resolveReviewDiffFiles({
+				rootPath: store.repositoryPath(snapshot.pins.repositoryId),
+				baseRef: snapshot.pins.base,
+				headRef: snapshot.pins.head,
+				includePatch: true
+			});
+		}
+	};
+}
+/** Telemetry and report uploads for a pinned native review. */
+function createJsonReviewReporting(store, telemetry, options = {}) {
+	const { submit = submitReviewBugReport, shared } = options;
+	const app = new Hono();
+	app.onError((error, context) => context.json({
+		ok: false,
+		error: error.message
+	}, error instanceof BugReportUpstreamError ? error.status : error instanceof ReviewInputError ? error.status : requestJsonErrorStatus(error)));
+	app.use("/:id/telemetry/*", async (context, next) => {
+		const id = context.req.param("id");
+		if (id.startsWith("shared-")) {
+			if (!shared) throw new ReviewInputError("Shared review is not available.", 404);
+			shared.get(id);
+		} else store.assertExists(id);
+		await next();
+	});
+	app.post("/:id/telemetry/event", async (c) => {
+		const body = await readBoundedRequestJson(c.req.raw, void 0, {});
+		const payload = isJsonObject(body) ? body : {};
+		const rawContext = isJsonObject(payload.context) ? payload.context : {};
+		await captureSanitizedUiTelemetry(telemetry, c.req.raw, payload.name, payload.properties, recordClientError, payload.error, {
+			...rawContext,
+			reviewUuid: c.req.param("id")
+		}, payload.occurredAt);
+		return c.json({ ok: true });
+	});
+	app.post("/:id/telemetry/tab", async (context) => {
+		const input = await readBoundedRequestJson(context.req.raw, void 0, {}, { allowTextPlain: true });
+		await telemetry.captureTabViewed(parseReviewTabTelemetryInput(input), { reviewUuid: context.req.param("id") });
+		return context.json({ ok: true });
+	});
+	app.post("/:id/telemetry/bug-report", async (context) => {
+		const query = readQuerySchemas.get.parse({ version: context.req.query("version") });
+		const id = context.req.param("id");
+		const imported = id.startsWith("shared-") ? shared?.get(id) : void 0;
+		const snapshot = imported?.snapshot ?? store.read(id, query.version);
+		const report = parseReviewBugReportInput(await readBoundedRequestJson(context.req.raw, 6291456, {}));
+		return context.json(await submit({
+			report,
+			source: imported ? {
+				review: async () => ({
+					files: { "review.json": JSON.stringify(snapshot) },
+					omitted: []
+				}),
+				map: async () => JSON.stringify(imported.presentation.maps),
+				diff: () => jsonReviewBugReportSource(store, snapshot).diff()
+			} : jsonReviewBugReportSource(store, snapshot),
+			clientErrorNames: clientErrorsForSession(report.app_session_id),
+			telemetryEnvelope: await telemetry.envelope().catch(() => void 0)
+		}));
+	});
+	return app;
+}
+//#endregion
+//#region src/server/review-lifecycle-telemetry.ts
+/**
+* Review created, published and revoked, and agent authoring completed, as
+* server events. Authoring is complete at the first publish of a review an
+* agent created through `whiteboard api` or `whiteboard mcp`, timed from the review's
+* creation. Which reviews an agent created is known only to this process, so
+* a server restart between create and publish loses that one completion.
+* Sign-in reports its funnel, and a success calls `onLoggedIn`.
+*/
+function reviewLifecycleTelemetry(telemetry, firstCreatedAt, onLoggedIn, now = Date.now) {
+	const reported = /* @__PURE__ */ new Set();
+	const authoring = /* @__PURE__ */ new Map();
+	const capture = (event, properties, reviewUuid) => void telemetry.captureEvent(event, properties, reviewUuid ? { reviewUuid } : void 0);
+	return {
+		onReviewCreated: ({ reviewId, kind, blocks, via, agentKind }) => {
+			if (reported.has(reviewId)) return;
+			reported.add(reviewId);
+			if (via === "api" || via === "mcp") authoring.set(reviewId, agentKind);
+			const properties = {
+				kind,
+				blocks,
+				via
+			};
+			if (agentKind) properties.agent_kind = agentKind;
+			capture("review_review_created", properties, reviewId);
+		},
+		sharing: {
+			onPublished: ({ reviewId, version }) => {
+				capture("review_review_published", { version }, reviewId);
+				if (!authoring.has(reviewId)) return;
+				const agentKind = authoring.get(reviewId);
+				authoring.delete(reviewId);
+				const createdAt = Date.parse(firstCreatedAt(reviewId) ?? "");
+				if (Number.isNaN(createdAt)) return;
+				const properties = { duration_ms: Math.max(0, now() - createdAt) };
+				if (agentKind) properties.agent_kind = agentKind;
+				capture("review_authoring_completed", properties, reviewId);
+			},
+			onRevoked: () => capture("review_review_revoked"),
+			onLogin: (outcome, reason) => {
+				capture(`review_login_${outcome}`, reason ? { reason } : {});
+				if (outcome === "succeeded") onLoggedIn();
+			}
+		}
+	};
+}
+//#endregion
+//#region src/server/review-open-watchdog.ts
+const OPEN_TIMEOUT_MS = 3e4;
+/**
+* "Opened but never presented" as an explicit event: one timer per
+* presentation from its session start, cleared when the canvas reports it
+* presented or the session ends. Keyed by presentation because a resume starts
+* a new session for the same review.
+*/
+var ReviewOpenWatchdog = class {
+	options;
+	pending = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = options;
+	}
+	started(context) {
+		const id = context.presentationSessionId;
+		this.presented(id);
+		const startedAt = Date.now();
+		const timer = setTimeout(() => {
+			this.pending.delete(id);
+			this.options.onTimeout(context, Date.now() - startedAt);
+		}, OPEN_TIMEOUT_MS);
+		timer.unref?.();
+		this.pending.set(id, timer);
+	}
+	presented(presentationSessionId) {
+		clearTimeout(this.pending.get(presentationSessionId));
+		this.pending.delete(presentationSessionId);
+	}
+	dispose() {
+		for (const timer of this.pending.values()) clearTimeout(timer);
+		this.pending.clear();
+	}
+};
+//#endregion
+//#region src/server/tutorial-service.ts
+const authoredSchema = z.strictObject({
+	title: z.string().min(1),
+	document: documentSchema
+});
+const pinsSchema = z.strictObject({
+	base: z.string().regex(/^[a-f0-9]{40}$/),
+	head: z.string().regex(/^[a-f0-9]{40}$/)
+});
+const stampSchema = z.object({
+	version: z.literal(10),
+	reviewUuid: z.string(),
+	contentHash: z.string()
+});
+async function readTutorialAssets(assetsRoot) {
+	const bytes = await Promise.all([
+		"document.json",
+		"trace.json",
+		"software-map.json",
+		"pins.json"
+	].map((name) => readFile(path.join(assetsRoot, name), "utf8")));
+	return {
+		authored: authoredSchema.parse(JSON.parse(bytes[0])),
+		trace: JSON.parse(bytes[1]),
+		model: JSON.parse(bytes[2]),
+		pins: pinsSchema.parse(JSON.parse(bytes[3])),
+		contentHash: createHash("sha256").update(JSON.stringify(bytes)).digest("hex")
+	};
+}
+/** Create the shipped document through the same strict validation as authored reviews. */
+async function createNativeTutorial(input) {
+	const assets = await readTutorialAssets(input.assetsRoot);
+	const repository = await input.data.register(input.sampleRoot);
+	const pins = await input.data.resolvePins(repository.id, assets.pins.base, assets.pins.head);
+	const aliases = /* @__PURE__ */ new Map();
+	const traceId = randomUUID();
+	await input.data.upload({
+		id: traceId,
+		repositoryId: repository.id,
+		kind: "trace",
+		trace: assets.trace
+	});
+	aliases.set("tutorial-trace", traceId);
+	for (const side of ["base", "head"]) {
+		const id = randomUUID();
+		await input.data.upload({
+			id,
+			repositoryId: repository.id,
+			kind: "map",
+			pins,
+			side,
+			model: assets.model
+		});
+		aliases.set(`tutorial-map-${side}`, id);
+	}
+	for (const block of resourceReferences(assets.authored.document)) {
+		if (block.type === "trace_quote") block.traceId = aliases.get(block.traceId) ?? block.traceId;
+		if (block.type === "software_map") block.mapVersionId = aliases.get(block.mapVersionId) ?? block.mapVersionId;
+	}
+	const result = await input.store.execute({ operation: {
+		type: "create",
+		title: assets.authored.title,
+		target: {
+			kind: "commits",
+			...pins
+		}
+	} }, {
+		document: assets.authored.document,
+		origin: { tutorial: true }
+	});
+	return {
+		snapshot: input.store.read(result.reviewId),
+		contentHash: assets.contentHash
+	};
+}
+function createTutorialService(input) {
+	const tutorialRoot = path.join(devReviewHome(), "tutorial");
+	const sampleRoot = path.join(tutorialRoot, "sample-service");
+	const stampPath = path.join(tutorialRoot, "stamp.json");
+	const assetsRoot = path.join(input.packageRoot, "tutorial");
+	const readStamp = async () => stampSchema.safeParse(await readFile(stampPath, "utf8").then((value) => JSON.parse(value)).catch(() => null)).data;
+	async function find() {
+		try {
+			const stamp = await readStamp();
+			if (!stamp || !input.store.has(stamp.reviewUuid)) return null;
+			const snapshot = input.store.read(stamp.reviewUuid);
+			const assets = await readTutorialAssets(assetsRoot);
+			const [head, base] = await Promise.all([resolveRevision(sampleRoot, "HEAD"), resolveRevision(sampleRoot, "HEAD^")]);
+			return snapshot.origin?.tutorial && stamp.contentHash === assets.contentHash && head && base && snapshot.pins?.head === head.commit && snapshot.pins?.base === base.commit && head.commit === assets.pins.head && base.commit === assets.pins.base ? snapshot : null;
+		} catch {
+			return null;
+		}
+	}
+	async function cleanup() {
+		for (const reviewId of input.store.tutorialIds()) await input.store.execute({ operation: {
+			type: "delete",
+			reviewId
+		} });
+		for (const repository of input.store.repositories()) {
+			const relative = path.relative(tutorialRoot, repository.path);
+			if (relative && !relative.startsWith("..") && !path.isAbsolute(relative)) await input.data.forgetRepository(repository.id);
+		}
+		await rm(tutorialRoot, {
+			recursive: true,
+			force: true,
+			maxRetries: 10
+		});
+	}
+	return {
+		async status() {
+			return {
+				version: 1,
+				reviewUuid: (await find())?.reviewId ?? null
+			};
+		},
+		async referencesReview(id) {
+			return input.store.has(id) && input.store.read(id).origin?.tutorial === true;
+		},
+		async prepare(options) {
+			const current = await find();
+			if (current) return current;
+			await readTutorialAssets(assetsRoot);
+			await options?.beforeReset();
+			await cleanup();
+			await mkdir(tutorialRoot, {
+				recursive: true,
+				mode: 448
+			});
+			const temporaryRoot = path.join(tutorialRoot, `.sample-service-${randomUUID()}`);
+			try {
+				await cp(path.join(assetsRoot, "sample-service"), temporaryRoot, { recursive: true });
+				await cp(path.join(assetsRoot, "git-stub"), path.join(temporaryRoot, ".git"), { recursive: true });
+				await rename(temporaryRoot, sampleRoot);
+				const { snapshot, contentHash } = await createNativeTutorial({
+					assetsRoot,
+					sampleRoot,
+					store: input.store,
+					data: input.data
+				});
+				await writePrivateJsonAtomic(stampPath, {
+					version: 10,
+					reviewUuid: snapshot.reviewId,
+					contentHash
+				});
+				return snapshot;
+			} finally {
+				await rm(temporaryRoot, {
+					recursive: true,
+					force: true
+				});
+			}
+		},
+		cleanup
+	};
+}
+//#endregion
+//#region src/server/desktop-server.ts
+const TUTORIAL_LIFECYCLE_LOCK_KEY = "tutorial-lifecycle";
+function createGlobalReviewServer(input) {
+	const instanceId = input.instanceId ?? crypto.randomUUID();
+	const token = input.token ?? crypto.randomBytes(32).toString("base64url");
+	let boundPort = input.port;
+	const urlForBoundPort = () => `http://127.0.0.1:${boundPort}`;
+	const identity = input.identity ?? {
+		key: "stable",
+		channel: "stable"
+	};
+	const discoveryPaths = input.discoveryPath ? [input.discoveryPath] : identity.key === "stable" ? [reviewInstanceDiscoveryPath("stable"), reviewLegacyDiscoveryPath()] : [reviewInstanceDiscoveryPath(identity.key)];
+	const telemetry = input.telemetry ?? ReviewTelemetry.fromEnv();
+	const relay = input.relay ?? new GlobalReviewDesktopVerbRelay({ maxClients: 1 });
+	const askCliEnv = () => [
+		{
+			name: REVIEW_INSTANCE_ENV,
+			value: identity.key
+		},
+		...process.versions.electron ? [{
+			name: "ELECTRON_RUN_AS_NODE",
+			value: "1"
+		}] : [],
+		...process.env.DEV_REVIEW_HOME ? [{
+			name: "DEV_REVIEW_HOME",
+			value: process.env.DEV_REVIEW_HOME
+		}] : []
+	];
+	const askTools = {
+		mcpServers: () => discovery.cliPath ? [{
+			name: "whiteboard",
+			command: process.execPath,
+			args: [discovery.cliPath, "mcp"],
+			env: askCliEnv()
+		}] : [],
+		cli: () => discovery.cliPath && [
+			...askCliEnv().map(({ name, value }) => `${name}=${shellQuote(value)}`),
+			shellQuote(process.execPath),
+			shellQuote(discovery.cliPath)
+		].join(" ")
+	};
+	const reviewStore = input.reviewStore;
+	const reviewLocks = /* @__PURE__ */ new Map();
+	let appReadyReported = false;
+	const openWatchdog = new ReviewOpenWatchdog({ onTimeout: (context, elapsedMs) => void telemetry.captureEvent("review_open_timeout", { elapsed_ms: elapsedMs }, context) });
+	const tutorial = createTutorialService({
+		packageRoot: input.packageRoot,
+		store: reviewStore,
+		data: input.reviewData
+	});
+	let closing = false;
+	const cliPath = path.join(input.packageRoot, "dist", "cli.js");
+	let scratchpadEnabled = false;
+	const discovery = {
+		version: 3,
+		instanceId,
+		url: urlForBoundPort(),
+		appPid: input.appPid,
+		serverPid: process.pid,
+		token,
+		startedAt: Date.now(),
+		...identity
+	};
+	if (existsSync(cliPath)) {
+		discovery.cliPath = cliPath;
+		discovery.cliVersion = readReviewPackageVersion(pathToFileURL(cliPath).href);
+		if (input.cliRuntimePath && existsSync(input.cliRuntimePath)) discovery.cliRuntimePath = input.cliRuntimePath;
+	}
+	const core = createWhiteboardCore({
+		profile: {
+			store: reviewStore,
+			data: input.reviewData,
+			shared: input.sharedReviews
+		},
+		relay,
+		token,
+		instanceId,
+		scratchpad: () => scratchpadEnabled,
+		status: () => {
+			const { key, channel, checkout, appVersion, cliVersion, instanceId } = discovery;
+			return {
+				key: key ?? null,
+				channel: channel ?? null,
+				checkout: checkout ?? null,
+				appVersion: appVersion ?? null,
+				cliVersion: cliVersion ?? null,
+				instanceId,
+				url: urlForBoundPort(),
+				home: devReviewHome()
+			};
+		},
+		hooks: reviewLifecycleTelemetry(telemetry, (reviewId) => reviewStore.summary(reviewId)?.firstCreatedAt, () => aliasInstallationToAccount(telemetry)),
+		ask: { tools: askTools }
+	});
+	const { app } = core;
+	app.route("/reviews-api", createJsonReviewReporting(input.reviewStore, telemetry, { shared: input.sharedReviews }));
+	app.route("/reviews-api", core.api);
+	app.get("/preferences/scratchpad", () => serverJson(200, { enabled: scratchpadEnabled }));
+	app.put("/preferences/scratchpad", async (context) => {
+		const request = z.object({ enabled: z.boolean() }).safeParse(await readBoundedRequestJson(context.req.raw));
+		if (!request.success) throw new ReviewServerError("enabled must be a boolean.", 400);
+		scratchpadEnabled = await writeScratchpadEnabled(request.data.enabled);
+		if (scratchpadEnabled) await reviewStore.ensureScratchpad();
+		reviewStore.invalidateCatalog();
+		return serverJson(200, { enabled: scratchpadEnabled });
+	});
+	app.post("/app/focus", async () => {
+		const result = await relay.dispatch({
+			name: "focusWindow",
+			args: {}
+		});
+		return serverJson(result.ok ? 200 : 409, result);
+	});
+	app.post("/telemetry/event", async (context) => {
+		try {
+			const body = await readBoundedRequestJson(context.req.raw, void 0, {});
+			const payload = isJsonObject(body) ? body : {};
+			let flushBeforeOptOut = false;
+			if (payload.name === "app_ready") {
+				if (appReadyReported) return serverJson(200, { ok: true });
+				appReadyReported = true;
+			}
+			const eventProperties = isJsonObject(payload.properties) ? { ...payload.properties } : {};
+			if (payload.name === "session_started") {
+				delete eventProperties.source_kind;
+				delete eventProperties.agent_kind;
+				const rawContext = isJsonObject(payload.context) ? payload.context : {};
+				const sourceKind = sessionStartedSourceKind(reviewStore, jsonString(rawContext.reviewUuid));
+				if (sourceKind) eventProperties.source_kind = sourceKind;
+			}
+			await captureSanitizedUiTelemetry(telemetry, context.req.raw, payload.name, eventProperties, (event, eventContext) => {
+				flushBeforeOptOut = event.event === "review_setting_changed" && event.properties.setting === "telemetry_enabled" && event.properties.enabled === false;
+				watchSessionOpen(openWatchdog, event.event, eventContext);
+			}, payload.error, payload.context, payload.occurredAt);
+			if (flushBeforeOptOut) await telemetry.flush(500);
+		} catch (error) {
+			console.error(error);
+		}
+		return serverJson(200, { ok: true });
+	});
+	app.post("/crash-reports", async (context) => {
+		const body = CrashReportRequestSchema.safeParse(await readBoundedRequestJson(context.req.raw));
+		if (!body.success) throw new ReviewServerError("dump_path, crashed_at and covered are required.", 400);
+		const result = await reportCrashDump(telemetry, body.data, input.crashDumpsDir);
+		return serverJson(result.status, result.body);
+	});
+	app.get("/tutorial/status", async () => serverJson(200, await tutorial.status()));
+	app.post("/tutorial/prepare", async () => {
+		const prepared = await withReviewLock(TUTORIAL_LIFECYCLE_LOCK_KEY, prepareTutorialLocked);
+		return serverJson(200, {
+			ok: true,
+			reviewUuid: prepared.reviewId
+		});
+	});
+	app.post("/tutorial/open", async () => {
+		return serverJson(200, await withReviewLock(TUTORIAL_LIFECYCLE_LOCK_KEY, openTutorialLocked));
+	});
+	app.delete("/tutorial", async () => {
+		await withReviewLock(TUTORIAL_LIFECYCLE_LOCK_KEY, deleteTutorialLocked);
+		return serverJson(200, { ok: true });
+	});
+	app.post("/diffr-languages/install", async () => {
+		try {
+			await installFullDiffr();
+			invalidateStructuralComparisons();
+			return serverJson(200, { installed: true });
+		} catch (error) {
+			return serverJson(503, { error: error instanceof Error ? error.message : String(error) });
+		}
+	});
+	app.get("/diffr-config", async () => serverJson(200, await readDiffrConfig()));
+	app.put("/diffr-config", async (context) => {
+		const body = await readBoundedRequestJson(context.req.raw);
+		const key = isJsonObject(body) ? jsonString(body.key) : void 0;
+		const value = isJsonObject(body) ? body.value : void 0;
+		if (key === void 0 || value === void 0) throw new ReviewServerError("key and value are required.", 400);
+		return serverJson(200, await setDiffrConfigValue(key, value));
+	});
+	app.put("/diffr-config/summarizer", async (context) => {
+		const input = reviewDiffrSummarizerInputSchema.safeParse(await readBoundedRequestJson(context.req.raw));
+		if (!input.success) throw new ReviewServerError("Invalid summary settings.", 400);
+		return serverJson(200, await saveDiffrSummarizer(input.data));
+	});
+	app.post("/diffr-config/summarizer/test", async (context) => {
+		const input = reviewDiffrSummarizerInputSchema.safeParse(await readBoundedRequestJson(context.req.raw));
+		if (!input.success) throw new ReviewServerError("Invalid summary settings.", 400);
+		return serverJson(200, { summary: await testDiffrSummarizer(input.data, void 0, context.req.raw.signal) });
+	});
+	app.get("/install/status", async () => serverJson(200, await resolveCliInstallStatus({ packageRoot: input.packageRoot })));
+	app.post("/install/apply", async (context) => {
+		const request = parseReviewCliInstallApplyRequest(await readBoundedRequestJson(context.req.raw));
+		const applyInput = { packageRoot: input.packageRoot };
+		if (request.shim !== void 0) applyInput.shim = request.shim;
+		if (request.autoUpdate) applyInput.autoUpdate = true;
+		if (request.trace !== void 0) applyInput.trace = request.trace;
+		if (discovery.cliPath) applyInput.cliPath = discovery.cliPath;
+		if (discovery.cliRuntimePath) applyInput.cliRuntimePath = discovery.cliRuntimePath;
+		const result = await applyCliInstall(applyInput);
+		const body = {
+			ok: result.code === 0,
+			output: result.output
+		};
+		if (result.shimPath) body.shimPath = result.shimPath;
+		return serverJson(result.code === 0 ? 200 : 500, body);
+	});
+	app.post("/install/remove", async (context) => {
+		const request = parseReviewCliInstallApplyRequest(await readBoundedRequestJson(context.req.raw));
+		const removeInput = {};
+		if (request.shim) removeInput.shim = true;
+		if (request.trace) removeInput.trace = true;
+		const result = await removeCliInstall(removeInput);
+		return serverJson(200, {
+			ok: true,
+			output: result.output
+		});
+	});
+	app.post("/install/legacy-skills/remove", async () => {
+		const { removed } = await removeLegacyReviewSkills();
+		return serverJson(200, {
+			ok: true,
+			removed
+		});
+	});
+	app.post("/install/finish-update", async () => {
+		await finishCliInstallUpdate();
+		return serverJson(200, { ok: true });
+	});
+	app.post("/install/decline", async () => {
+		await declineCliInstall();
+		return serverJson(200, { ok: true });
+	});
+	app.post("/install/skip", async () => {
+		await skipCliInstall();
+		return serverJson(200, { ok: true });
+	});
+	app.post("/install/reset", async () => {
+		await resetCliInstall();
+		return serverJson(200, { ok: true });
+	});
+	const httpServer = createServer(createNodeRequestListener(app));
+	async function prepareTutorialLocked() {
+		return tutorial.prepare();
+	}
+	async function openTutorialLocked() {
+		const snapshot = await prepareTutorialLocked();
+		return {
+			kind: "api",
+			reviewUuid: snapshot.reviewId,
+			title: snapshot.title
+		};
+	}
+	async function deleteTutorialLocked() {
+		await tutorial.cleanup();
+	}
+	async function withReviewLock(reviewUuid, operation) {
+		const previous = reviewLocks.get(reviewUuid) ?? Promise.resolve();
+		let release = () => {};
+		const current = new Promise((resolve) => {
+			release = resolve;
+		});
+		const chain = previous.then(() => current);
+		reviewLocks.set(reviewUuid, chain);
+		await previous;
+		try {
+			return await operation();
+		} finally {
+			release();
+			if (reviewLocks.get(reviewUuid) === chain) reviewLocks.delete(reviewUuid);
+		}
+	}
+	return {
+		discovery,
+		get url() {
+			return urlForBoundPort();
+		},
+		listen: async () => {
+			scratchpadEnabled = await readScratchpadEnabled();
+			boundPort = await listen(httpServer, input.port);
+			discovery.url = urlForBoundPort();
+			for (const discoveryPath of discoveryPaths) await writePrivateJsonAtomic(discoveryPath, discovery);
+		},
+		close: async () => {
+			if (closing) return;
+			closing = true;
+			core.close();
+			for (const discoveryPath of discoveryPaths) await removeMatchingDiscovery(discoveryPath, discovery);
+			relay.close();
+			openWatchdog.dispose();
+			await closeHttpServer(httpServer);
+			await telemetry.shutdown(1500);
+		}
+	};
+}
+function watchSessionOpen(watchdog, event, context) {
+	const reviewUuid = context?.reviewUuid;
+	const presentationSessionId = context?.presentationSessionId;
+	if (!reviewUuid || !presentationSessionId) return;
+	if (event === "review_session_started") watchdog.started({
+		reviewUuid,
+		presentationSessionId
+	});
+	else if (event === "review_review_presented" || event === "review_session_ended") watchdog.presented(presentationSessionId);
+}
+/**
+* `session_started`'s `source_kind`: the opened review's target kind, or
+* `scratchpad` for the one scratchpad. Undefined when the review is gone (a
+* shared review this store never had, or one deleted between open and the
+* event arriving) or was left without a target.
+*/
+function sessionStartedSourceKind(reviewStore, reviewUuid) {
+	if (!reviewUuid) return void 0;
+	try {
+		const snapshot = reviewStore.read(reviewUuid);
+		return snapshot.kind === "scratchpad" ? snapshot.kind : snapshot.target?.kind;
+	} catch {
+		return;
+	}
+}
+function listen(server, port) {
+	return new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(port, "127.0.0.1", () => {
+			server.off("error", reject);
+			const address = server.address();
+			if (!isTcpAddress(address)) {
+				reject(/* @__PURE__ */ new Error("The Whiteboard server did not bind a TCP port."));
+				return;
+			}
+			resolve(address.port);
+		});
+	});
+}
+function closeHttpServer(server) {
+	return new Promise((resolve, reject) => {
+		if (!server.listening) {
+			resolve();
+			return;
+		}
+		server.close((error) => error ? reject(error) : resolve());
+	});
+}
+async function removeMatchingDiscovery(filePath, discovery) {
+	try {
+		const current = JSON.parse(await readFile(filePath, "utf8"));
+		if (isJsonObject(current) && current.instanceId === discovery.instanceId && current.appPid === discovery.appPid) await rm(filePath, { force: true });
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+}
+/** `server.address()` is a string for pipe and socket listeners. */
+function isTcpAddress(address) {
+	return isObjectValue(address);
+}
+//#endregion
+//#region src/server/desktop-host.ts
+async function runDesktopHost(env = process.env) {
+	const port = requiredPort(env.DEV_FAST_REVIEW_SERVER_PORT);
+	const appPid = requiredPositiveInteger(env.DEV_FAST_REVIEW_APP_PID, "DEV_FAST_REVIEW_APP_PID");
+	const packageRoot = findReviewPackageRoot(import.meta.url);
+	const toolingRoot = env.DEV_FAST_REVIEW_TOOLING_ROOT || packageRoot;
+	const telemetryEnv = { ...env };
+	delete telemetryEnv.DEV_FAST_REVIEW_TELEMETRY_DISABLED;
+	const telemetry = ReviewTelemetry.fromEnv(telemetryEnv, { surface: "desktop" });
+	installProcessErrorTelemetry(telemetry, {
+		appSessionId: env.DEV_FAST_REVIEW_APP_SESSION_ID,
+		crashReportPath: serverCrashReportPath(env)
+	});
+	await telemetry.setEnabled(!isEnabledEnvValue(env.DEV_FAST_REVIEW_TELEMETRY_DISABLED));
+	if (reviewTelemetryChannel(env) === "dev") await telemetry.setInternal(true);
+	await telemetry.captureInstallationCreated().catch(() => void 0);
+	await telemetry.reconcileOpenSessions().catch(() => void 0);
+	await drainServerCrashReport(telemetry, serverCrashReportPath(env));
+	const installationId = await telemetry.getInstallationId();
+	delete env.DEV_FAST_REVIEW_TELEMETRY_DISABLED;
+	const serverInput = {
+		appPid,
+		packageRoot,
+		toolingRoot,
+		port,
+		token: env.DEV_FAST_REVIEW_SERVER_TOKEN,
+		instanceId: env.DEV_FAST_REVIEW_INSTANCE_ID,
+		identity: reviewInstanceIdentity(env),
+		telemetry
+	};
+	const home = devReviewHome(env);
+	await mkdir(home, { recursive: true });
+	const local = await openReviewProfile(home, { manageWorkspaces: true });
+	const shared = new SharedReviewStore(path.join(home, "shared-reviews"));
+	shared.connect(local.store, local.data);
+	await shared.load();
+	const server = createGlobalReviewServer({
+		...serverInput,
+		sharedReviews: shared,
+		reviewStore: local.store,
+		reviewData: local.data,
+		cliRuntimePath: env.DEV_FAST_REVIEW_CLI_RUNTIME,
+		crashDumpsDir: env.DEV_FAST_REVIEW_CRASH_DUMPS_DIR
+	});
+	try {
+		await server.listen();
+	} catch (error) {
+		await local?.data.close();
+		await local?.store.close();
+		throw error;
+	}
+	process.stdout.write(`${JSON.stringify({
+		event: "ready",
+		...server.discovery,
+		installationId
+	})}\n`);
+	const stageRustAnalyzer = () => ensureBundledRustAnalyzer({ env }).catch((error) => {
+		const reason = error instanceof Error ? error.message : String(error);
+		process.stderr.write(`[Review tools] Could not stage bundled rust-analyzer: ${reason}\n`);
+	});
+	stageRustAnalyzer();
+	let stopping = null;
+	const stop = () => {
+		if (!stopping) stopping = server.close("app-exit").finally(() => shared.close()).finally(() => local?.data.close()).finally(() => local?.store.close());
+		return stopping;
+	};
+	listenForDesktopHostShutdown(process, () => {
+		stop().then(() => process.exit(0));
+	}, (enabled) => {
+		telemetry.setEnabled(enabled).catch(() => void 0);
+	}, (sourcePath) => {
+		env.DEV_FAST_REVIEW_RUST_ANALYZER = sourcePath;
+		stageRustAnalyzer();
+	});
+	process.once("SIGINT", () => {
+		stop().then(() => process.exit(0));
+	});
+	process.once("SIGTERM", () => {
+		stop().then(() => process.exit(0));
+	});
+}
+function isEnabledEnvValue(value) {
+	return value === "1" || value?.toLowerCase() === "true";
+}
+function requiredPort(value) {
+	const parsed = Number(value);
+	if (!Number.isSafeInteger(parsed) || parsed < 0 || parsed > 65535) throw new Error("DEV_FAST_REVIEW_SERVER_PORT must be a port between 0 and 65535.");
+	return parsed;
+}
+function requiredPositiveInteger(value, name) {
+	const parsed = Number(value);
+	if (!Number.isSafeInteger(parsed) || parsed <= 0) throw new Error(`${name} must be a positive integer.`);
+	return parsed;
+}
+if (process.env.DEV_FAST_REVIEW_DESKTOP_HOST_AUTOSTART !== "0") runDesktopHost().catch((error) => {
+	process.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
+	process.exitCode = 1;
+});
+//#endregion
+export { runDesktopHost };