@dev.fast/whiteboard 0.0.0-stage → 0.2.0

package/dist/src-DnwdaQ2r.js

@@ -0,0 +1,865 @@
+import { n as isJsonObject } from "./src-X9phtB2j.js";
+import { _ as ReviewAgentTraceEventSchema, v as ReviewAgentTraceSessionSchema } from "./src-CGP5ytbV.js";
+import { z } from "zod";
+//#region ../../node_modules/@dev.fast/diffr/dist/contract.js
+/**
+* Mirrors src/protocol/mod.rs and src/pairing.rs. See ../README.md for sync checks.
+* Import only zod: Review embeds this file in generated source.
+* Defaults are omitted, not null. Lines are zero-based, columns are UTF-8 bytes,
+* and ranges are half-open.
+*/
+function structuralPairingSchema(value) {
+	return z.union([
+		z.object({
+			lhs: value,
+			rhs: value
+		}),
+		z.object({
+			lhs: value,
+			rhs: z.never().optional()
+		}),
+		z.object({
+			rhs: value,
+			lhs: z.never().optional()
+		})
+	]);
+}
+const structuralU32 = z.number().int().min(0).max(4294967295);
+const StructuralDiffEventSchema = z.lazy(() => z.union([
+	z.object({
+		type: z.literal("start"),
+		version: structuralU32,
+		lhs: StructuralSnapshotSchema,
+		rhs: StructuralSnapshotSchema,
+		files: z.array(StructuralFileChangeSchema)
+	}),
+	z.object({
+		type: z.literal("file"),
+		file: structuralPairingSchema(StructuralFileRefSchema),
+		visibility: StructuralVisibilitySchema.optional()
+	}).and(StructuralOutcomeSchema),
+	z.object({
+		type: z.literal("annotations"),
+		file: structuralPairingSchema(StructuralFileRefSchema),
+		annotations: z.array(z.object({
+			region_id: structuralU32,
+			label: z.string()
+		})),
+		error: StructuralProblemSchema.optional()
+	}),
+	z.object({
+		type: z.literal("complete"),
+		succeeded: structuralU32,
+		failed: structuralU32,
+		aborted: StructuralProblemSchema.optional()
+	})
+]));
+const StructuralOutcomeSchema = z.lazy(() => z.union([z.object({
+	diff: StructuralDiffSchema,
+	error: z.never().optional()
+}), z.object({
+	error: StructuralProblemSchema,
+	diff: z.never().optional()
+})]));
+const StructuralSnapshotSchema = z.lazy(() => z.union([
+	z.object({
+		type: z.literal("revision"),
+		rev: z.string()
+	}),
+	z.object({ type: z.literal("index") }),
+	z.object({ type: z.literal("working_tree") }),
+	z.object({ type: z.literal("empty_tree") }),
+	z.object({
+		type: z.literal("path"),
+		path: z.string()
+	})
+]));
+const StructuralProblemSchema = z.lazy(() => z.object({
+	code: z.string(),
+	message: z.string()
+}));
+const StructuralFileChangeSchema = z.lazy(() => z.object({
+	file: structuralPairingSchema(StructuralFileRefSchema),
+	status: StructuralFileStatusSchema,
+	tags: z.array(z.string()).optional()
+}));
+const StructuralFileStatusSchema = z.lazy(() => z.union([
+	z.literal("added"),
+	z.literal("deleted"),
+	z.literal("modified"),
+	z.literal("renamed"),
+	z.literal("copied"),
+	z.literal("type_changed")
+]));
+const StructuralFileRefSchema = z.lazy(() => z.object({
+	path: z.string(),
+	oid: z.string(),
+	mode: z.string()
+}));
+const StructuralVisibilitySchema = z.lazy(() => z.object({
+	collapsed: z.boolean().optional(),
+	label: z.string().optional()
+}));
+const structuralRangesSchema = z.array(z.tuple([structuralU32, structuralU32])).refine((ranges) => ranges.every(([start, end], index) => start < end && (index === 0 || ranges[index - 1][1] < start)), "Expected sorted, coalesced, nonempty half-open ranges");
+const StructuralChangesSchema = z.object({
+	base: structuralRangesSchema,
+	head: structuralRangesSchema
+});
+function structuralChangeCounts(changes) {
+	const count = (ranges) => ranges.reduce((sum, [start, end]) => sum + end - start, 0);
+	return {
+		added: count(changes.head),
+		removed: count(changes.base)
+	};
+}
+const StructuralDiffSchema = z.lazy(() => z.union([z.object({
+	type: z.literal("text"),
+	stats: StructuralStatsSchema,
+	structural_changes: StructuralChangesSchema
+}).and(structuralPairingSchema(StructuralSourceSchema)), z.object({ type: z.literal("binary") }).and(structuralPairingSchema(StructuralBinaryRefSchema))]));
+const StructuralSourceSchema = z.lazy(() => z.object({
+	text: z.string(),
+	syntax: z.array(StructuralSyntaxSpanSchema).optional(),
+	regions: z.array(StructuralRegionSchema).optional()
+}));
+const StructuralBinaryRefSchema = z.lazy(() => z.object({ size: z.number().int().nonnegative() }));
+const StructuralSyntaxSpanSchema = z.lazy(() => z.object({
+	line: structuralU32,
+	start_column: structuralU32,
+	end_column: structuralU32,
+	capture: z.string()
+}));
+const StructuralRegionSchema = z.lazy(() => z.object({
+	id: structuralU32,
+	fold_state_id: structuralU32,
+	tags: z.array(z.string()).optional(),
+	visibility: StructuralVisibilitySchema.optional()
+}).and(StructuralSourceRangeSchema).and(StructuralNodeSchema));
+const StructuralNodeSchema = z.lazy(() => z.union([z.object({
+	kind: z.literal("leaf"),
+	alignment_id: structuralU32,
+	changed: z.array(StructuralSpanSchema).optional()
+}), z.object({
+	kind: z.literal("fold"),
+	children: z.array(StructuralRegionSchema)
+})]));
+const StructuralSpanSchema = z.lazy(() => z.object({
+	line: structuralU32,
+	start_column: structuralU32,
+	end_column: structuralU32
+}));
+const StructuralSourceRangeSchema = z.lazy(() => z.object({
+	start: StructuralPosSchema,
+	end: StructuralPosSchema
+}));
+const StructuralPosSchema = z.lazy(() => z.object({
+	line: structuralU32,
+	column: structuralU32
+}));
+const StructuralStatsSchema = z.lazy(() => z.object({
+	textual: StructuralLineCountsSchema,
+	visible: StructuralLineCountsSchema,
+	fallback: StructuralProblemSchema.optional()
+}));
+const StructuralLineCountsSchema = z.lazy(() => z.object({
+	added: structuralU32,
+	removed: structuralU32
+}));
+//#endregion
+//#region ../../node_modules/@dev.fast/diffr/dist/stream.js
+function decodeStructuralDiffEvent(line) {
+	try {
+		return StructuralDiffEventSchema.parse(JSON.parse(line));
+	} catch (cause) {
+		throw new Error("Malformed diffr protocol record.", { cause });
+	}
+}
+//#endregion
+//#region ../review-protocol/src/structural-diff.ts
+const ReviewStructuralDiffErrorSchema = z.object({
+	type: z.literal("error"),
+	message: z.string()
+});
+z.union([StructuralDiffEventSchema, ReviewStructuralDiffErrorSchema]);
+const REVIEW_CLIENT_HEADER = "x-review-client";
+const REVIEW_CLIENT_REMOTE = "remote";
+const requiredString$1 = z.string({ error: "must be a string" }).refine((value) => value.trim().length > 0, "must be a string");
+const stringAllowEmpty = z.string({ error: "must be a string" });
+const positiveInteger = z.number({ error: "must be a positive integer" }).int("must be a positive integer").positive("must be a positive integer");
+const nonNegativeInteger = z.number({ error: "must be a non-negative integer" }).int("must be a non-negative integer").nonnegative("must be a non-negative integer");
+const reviewDiffSideSchema = z.enum(["base", "head"], { error: "must be base or head" });
+const reviewViewSchema = z.enum([
+	"review",
+	"commits",
+	"diff",
+	"map",
+	"trace"
+]);
+const reviewThemeSchema = z.enum(["light", "dark"], { error: "must be light or dark" });
+function urlSchema(output, constraint) {
+	return requiredString$1.transform((value, context) => {
+		let url;
+		try {
+			url = new URL(value);
+		} catch {
+			context.addIssue({
+				code: "custom",
+				message: "must be an absolute URL"
+			});
+			return z.NEVER;
+		}
+		const error = constraint?.(url);
+		if (error) {
+			context.addIssue({
+				code: "custom",
+				message: error
+			});
+			return z.NEVER;
+		}
+		return output === "origin" ? url.origin : url.href;
+	});
+}
+const absoluteUrlSchema = urlSchema("href");
+const loopbackOriginSchema = urlSchema("origin", (url) => url.protocol === "http:" && url.hostname === "127.0.0.1" && url.port ? null : "must use http://127.0.0.1:<port>");
+z.strictObject({
+	serverUrl: loopbackOriginSchema,
+	reviewId: requiredString$1,
+	token: stringAllowEmpty,
+	wasmUrl: absoluteUrlSchema,
+	appVersion: requiredString$1.max(100),
+	theme: reviewThemeSchema,
+	host: z.literal("desktop")
+});
+/** How embedded diffs lay out: base and head side by side, or one column. */
+const REVIEW_DIFF_LAYOUTS = ["split", "unified"];
+const REVIEW_THEME_CHOICES = [
+	"dark",
+	"light",
+	"system"
+];
+const reviewDiffrSummarizerInputSchema = z.object({
+	enabled: z.boolean(),
+	provider: z.string().min(1),
+	model: z.string().trim().min(1),
+	endpoint: z.string().trim(),
+	systemPrompt: z.string(),
+	tests: z.boolean(),
+	apiKey: z.string().optional()
+});
+z.object({
+	values: z.custom(isJsonObject),
+	credentialSource: z.enum([
+		"config",
+		"environment",
+		"missing"
+	]),
+	providers: z.array(z.object({
+		id: z.string(),
+		title: z.string(),
+		model: z.string(),
+		endpoint: z.string(),
+		keyVariables: z.array(z.string()),
+		keylessCustomEndpoint: z.boolean()
+	})).optional(),
+	defaultPrompt: z.string().optional(),
+	changed: z.boolean().optional(),
+	error: z.string().optional()
+});
+const ReviewDesktopDiscoverySchema = z.object({
+	version: z.literal(3, { error: "Unsupported Whiteboard Desktop discovery version" }),
+	instanceId: requiredString$1,
+	url: loopbackOriginSchema,
+	appPid: positiveInteger,
+	serverPid: positiveInteger,
+	token: requiredString$1,
+	startedAt: positiveInteger,
+	cliPath: requiredString$1.optional(),
+	cliVersion: requiredString$1.optional(),
+	cliRuntimePath: requiredString$1.optional(),
+	key: requiredString$1.optional(),
+	channel: z.enum([
+		"stable",
+		"preview",
+		"dev"
+	]).optional(),
+	checkout: requiredString$1.optional(),
+	appPath: requiredString$1.optional(),
+	appVersion: requiredString$1.optional()
+});
+z.strictObject({
+	kind: z.enum([
+		"git",
+		"jj",
+		"none"
+	], { error: "must be git, jj, or none" }),
+	repositoryId: requiredString$1,
+	repositoryPath: requiredString$1,
+	worktreeRoot: requiredString$1
+});
+z.enum([
+	"draft",
+	"awaiting-review",
+	"awaiting-agent-updates",
+	"accepted",
+	"rejected"
+]);
+z.strictObject({
+	kind: z.enum([
+		"git-branch",
+		"git-commit",
+		"jj-bookmark",
+		"jj-change"
+	]),
+	name: requiredString$1
+});
+const ReviewAgentSessionRoleSchema = z.enum([
+	"author",
+	"map-worker",
+	"publisher",
+	"updater",
+	"question"
+]);
+z.strictObject({
+	roles: z.array(ReviewAgentSessionRoleSchema),
+	firstSeenAt: requiredString$1,
+	lastSeenAt: requiredString$1
+});
+z.strictObject({
+	commit: z.string({ error: "must be a 40-hex revision" }).regex(/^[0-9a-f]{40}$/i, "must be a 40-hex revision"),
+	parentCommit: z.string({ error: "must be a 40-hex revision" }).regex(/^[0-9a-f]{40}$/i, "must be a 40-hex revision"),
+	subject: stringAllowEmpty,
+	author: stringAllowEmpty,
+	authoredAt: requiredString$1,
+	fileCount: z.number().int().nonnegative(),
+	additions: z.number().int().nonnegative(),
+	deletions: z.number().int().nonnegative()
+});
+z.strictObject({
+	harness: z.enum([
+		"claude-code",
+		"codex",
+		"opencode",
+		"pi"
+	]),
+	sessionId: requiredString$1
+});
+const ReviewErrorResponseSchema = z.strictObject({
+	ok: z.literal(false),
+	error: requiredString$1,
+	code: requiredString$1.optional(),
+	retryable: z.boolean().optional()
+});
+z.strictObject({
+	kind: z.literal("api"),
+	reviewUuid: z.uuid({ error: "must be a UUID" }),
+	title: stringAllowEmpty
+});
+const ReviewStackLayerSchema = z.strictObject({
+	branch: requiredString$1,
+	pullRequestNumber: positiveInteger,
+	pullRequestUrl: absoluteUrlSchema.nullable(),
+	reviewUuid: z.uuid({ error: "must be a UUID" }).nullable(),
+	reviewTitle: stringAllowEmpty.nullable(),
+	relation: z.enum([
+		"earlier",
+		"current",
+		"later"
+	])
+});
+z.strictObject({ layers: z.array(ReviewStackLayerSchema) });
+const ReviewCliInstallTargetSchema = z.enum([
+	"claude",
+	"codex",
+	"cursor",
+	"opencode",
+	"pi",
+	"omp",
+	"copilot"
+], { error: "must be claude, codex, cursor, opencode, pi, omp, or copilot" });
+const ReviewCliInstallStampSchema = z.object({
+	consent: z.enum([
+		"granted",
+		"declined",
+		"skipped"
+	], { error: "must be granted, declined, or skipped" }),
+	fingerprint: requiredString$1.optional(),
+	shimPath: requiredString$1.optional(),
+	/** The user removed the review command; the shim resync must not reinstall it. */
+	commandDisabled: z.literal(true).optional(),
+	traceManaged: z.boolean().optional(),
+	/** Windows: the directory the install put on the saved user PATH. A running
+	* process keeps its startup PATH, so this is what says new terminals will
+	* find the command. */
+	userPath: requiredString$1.optional(),
+	updatedAt: requiredString$1
+});
+z.strictObject({
+	fingerprint: requiredString$1,
+	stamp: ReviewCliInstallStampSchema.nullable(),
+	/** The stamp fingerprint differs from the running package: rewrite the shim. */
+	stale: z.boolean(),
+	/** A granted stamp without this build's update marker: show the update screen. */
+	updateNeeded: z.boolean(),
+	error: requiredString$1.optional(),
+	shim: z.strictObject({
+		path: requiredString$1,
+		installed: z.boolean(),
+		profileConfigured: z.boolean(),
+		onPath: z.boolean(),
+		/** The Windows installer put this command on PATH; uninstalling Whiteboard removes it. */
+		installer: z.literal(true).optional()
+	}),
+	trace: z.strictObject({
+		enabled: z.boolean(),
+		configured: z.boolean(),
+		autoActivateRepositories: z.boolean(),
+		envPath: requiredString$1,
+		settingsPath: requiredString$1,
+		endpoint: requiredString$1.optional(),
+		bucket: requiredString$1.optional(),
+		region: requiredString$1.optional(),
+		accessKeyIdPrefix: requiredString$1.optional(),
+		verifiedAt: requiredString$1.optional(),
+		error: requiredString$1.optional(),
+		configPath: requiredString$1.optional(),
+		storageMode: z.enum([
+			"s3",
+			"hosted",
+			"none"
+		]).optional(),
+		credentialsSource: z.enum([
+			"profile",
+			"legacy-file",
+			"process-env",
+			"none"
+		]).optional(),
+		captureSource: z.enum(["profile", "settings"]).optional()
+	}),
+	cli: z.strictObject({
+		path: requiredString$1,
+		version: requiredString$1
+	}).nullable(),
+	connect: z.strictObject({
+		command: requiredString$1,
+		args: z.array(z.string()),
+		prompts: z.record(ReviewCliInstallTargetSchema, requiredString$1),
+		plugins: z.record(ReviewCliInstallTargetSchema, z.strictObject({
+			label: requiredString$1,
+			command: requiredString$1.optional(),
+			url: requiredString$1.optional()
+		}))
+	}),
+	legacySkills: z.array(z.strictObject({ path: requiredString$1 }))
+});
+const ReviewCliInstallApplyRequestSchema = z.strictObject({
+	shim: z.boolean().optional(),
+	autoUpdate: z.boolean().optional(),
+	trace: z.union([z.literal(true), z.strictObject({
+		endpoint: requiredString$1.optional(),
+		bucket: requiredString$1.optional(),
+		key: requiredString$1.optional(),
+		secret: requiredString$1.optional(),
+		region: requiredString$1.optional()
+	})]).optional()
+});
+z.strictObject({
+	ok: z.boolean(),
+	output: stringAllowEmpty,
+	shimPath: requiredString$1.optional()
+});
+const ReviewDiffFileSchema = z.strictObject({
+	path: requiredString$1,
+	previousPath: requiredString$1.optional(),
+	status: z.enum([
+		"added",
+		"modified",
+		"deleted",
+		"renamed",
+		"unchanged"
+	]),
+	additions: nonNegativeInteger,
+	deletions: nonNegativeInteger,
+	/** Git reports no line counts: the file's contents are binary. */
+	binary: z.literal(true).optional(),
+	patch: requiredString$1.optional()
+});
+z.strictObject({
+	includePatch: z.boolean().optional(),
+	paths: z.array(z.string()).optional(),
+	commit: z.string({ error: "must be a 40-hex revision" }).regex(/^[0-9a-f]{40}$/i, "must be a 40-hex revision").optional()
+});
+z.discriminatedUnion("ok", [z.strictObject({
+	ok: z.literal(true),
+	baseRef: requiredString$1.optional(),
+	headRef: requiredString$1.optional(),
+	files: z.array(ReviewDiffFileSchema)
+}), ReviewErrorResponseSchema]);
+z.strictObject({
+	path: requiredString$1,
+	side: reviewDiffSideSchema,
+	commit: z.string({ error: "must be a 40-hex revision" }).regex(/^[0-9a-f]{40}$/i, "must be a 40-hex revision").optional()
+});
+z.union([
+	z.strictObject({
+		ok: z.literal(true),
+		content: stringAllowEmpty,
+		truncated: z.boolean().optional()
+	}),
+	z.strictObject({
+		ok: z.literal(true),
+		absent: z.literal(true)
+	}),
+	z.strictObject({
+		ok: z.literal(true),
+		binary: z.literal(true)
+	}),
+	ReviewErrorResponseSchema
+]);
+const ReviewRangeSchema = z.strictObject({
+	fromLine: positiveInteger,
+	toLine: positiveInteger
+}).superRefine((range, context) => {
+	if (range.toLine < range.fromLine) context.addIssue({
+		code: "custom",
+		message: "must be >= fromLine",
+		path: ["toLine"]
+	});
+});
+const ReviewOpenEditorSchema = z.strictObject({
+	path: requiredString$1,
+	scheme: requiredString$1
+});
+const ReviewEditorSelectionSchema = z.strictObject({
+	path: requiredString$1,
+	startLine: positiveInteger,
+	startColumn: positiveInteger,
+	endLine: positiveInteger,
+	endColumn: positiveInteger
+});
+z.strictObject({
+	openEditors: z.array(ReviewOpenEditorSchema),
+	activeEditor: ReviewOpenEditorSchema.nullable(),
+	selection: ReviewEditorSelectionSchema.nullable()
+});
+const revealArgsSchema = z.strictObject({
+	path: requiredString$1,
+	startLine: positiveInteger,
+	endLine: positiveInteger,
+	side: reviewDiffSideSchema.optional(),
+	pins: z.strictObject({
+		repositoryId: requiredString$1,
+		head: requiredString$1,
+		base: requiredString$1.optional()
+	}).optional(),
+	highlight: z.boolean().optional(),
+	preserveFocus: z.boolean().optional()
+}).superRefine((args, context) => {
+	if (args.endLine < args.startLine) context.addIssue({
+		code: "custom",
+		message: "must be >= args.startLine",
+		path: ["endLine"]
+	});
+});
+/** The one scratchpad's fixed review id. */
+const SCRATCHPAD_REVIEW_ID = "scratchpad";
+const apiReviewIdSchema = z.union([
+	z.uuid(),
+	z.string().regex(/^shared-[a-f0-9]{64}$/),
+	z.literal(SCRATCHPAD_REVIEW_ID)
+]);
+const ReviewVerbRequestSchema = z.discriminatedUnion("name", [
+	z.strictObject({
+		name: z.literal("authoringCapabilities"),
+		args: z.strictObject({})
+	}),
+	z.strictObject({
+		name: z.literal("joinDiscord"),
+		args: z.strictObject({})
+	}),
+	z.strictObject({
+		name: z.literal("showReviewView"),
+		args: z.strictObject({ view: reviewViewSchema })
+	}),
+	z.strictObject({
+		name: z.literal("openSourceTree"),
+		args: z.strictObject({})
+	}),
+	z.strictObject({
+		name: z.literal("openDiff"),
+		args: z.strictObject({
+			path: requiredString$1,
+			previousPath: requiredString$1.optional()
+		})
+	}),
+	z.strictObject({
+		name: z.literal("reveal"),
+		args: revealArgsSchema
+	}),
+	z.strictObject({
+		name: z.literal("focusWindow"),
+		args: z.strictObject({})
+	}),
+	z.strictObject({
+		name: z.literal("captureScreenshot"),
+		args: z.strictObject({})
+	}),
+	z.strictObject({
+		name: z.literal("openReviewRevision"),
+		args: z.strictObject({
+			revision: z.string().regex(/^[0-9a-f]{40}$/).optional(),
+			sealedAt: positiveInteger.optional()
+		})
+	}),
+	z.strictObject({
+		name: z.literal("openReview"),
+		args: z.strictObject({
+			reviewUuid: apiReviewIdSchema,
+			active: z.boolean()
+		})
+	}),
+	z.strictObject({
+		name: z.literal("openApiReview"),
+		args: z.strictObject({
+			reviewId: apiReviewIdSchema,
+			title: requiredString$1
+		})
+	})
+]);
+const ReviewVerbResponseSchema = z.discriminatedUnion("ok", [z.strictObject({
+	ok: z.literal(true),
+	result: z.unknown().optional()
+}), ReviewErrorResponseSchema]);
+z.strictObject({
+	event: z.literal("desktop-verb"),
+	id: requiredString$1,
+	request: ReviewVerbRequestSchema
+});
+const ReviewDesktopVerbResultSchema = z.strictObject({
+	id: requiredString$1,
+	response: ReviewVerbResponseSchema
+});
+const ReviewSelectedDiffSchema = z.strictObject({
+	oldPath: z.string(),
+	newPath: z.string(),
+	oldStart: z.number().int().nonnegative(),
+	newStart: z.number().int().nonnegative(),
+	rows: z.array(z.strictObject({
+		kind: z.enum([
+			"unchanged",
+			"added",
+			"deleted"
+		]),
+		text: z.string()
+	}))
+});
+const ReviewApiSelectionSourceSchema = z.strictObject({
+	reviewId: requiredString$1,
+	version: z.number().int().nonnegative(),
+	commit: requiredString$1.optional(),
+	pins: z.strictObject({
+		repositoryId: requiredString$1,
+		head: requiredString$1,
+		base: requiredString$1.optional()
+	}).optional()
+});
+z.discriminatedUnion("event", [
+	z.strictObject({
+		event: z.literal("editorSelectionChanged"),
+		reviewId: requiredString$1,
+		apiSource: ReviewApiSelectionSourceSchema.optional(),
+		anchor: z.object({
+			x: z.number(),
+			y: z.number()
+		}).optional(),
+		path: requiredString$1,
+		range: ReviewRangeSchema,
+		sideContext: reviewDiffSideSchema,
+		isEmpty: z.boolean(),
+		selectedDiff: ReviewSelectedDiffSchema.optional()
+	}),
+	z.strictObject({
+		event: z.literal("themeChanged"),
+		theme: reviewThemeSchema
+	}),
+	z.strictObject({
+		event: z.literal("showReviewView"),
+		view: reviewViewSchema
+	})
+]);
+z.discriminatedUnion("ok", [z.strictObject({
+	ok: z.literal(true),
+	configured: z.boolean().default(true),
+	storage: z.enum([
+		"s3",
+		"hosted",
+		"none"
+	]).optional(),
+	sources: z.array(z.enum(["s3", "hosted"])).optional(),
+	storageError: requiredString$1.optional(),
+	sessions: z.array(ReviewAgentTraceSessionSchema)
+}), ReviewErrorResponseSchema]);
+z.discriminatedUnion("ok", [z.strictObject({
+	ok: z.literal(true),
+	parserVersion: requiredString$1,
+	session: ReviewAgentTraceSessionSchema,
+	trace: stringAllowEmpty.nullable().optional(),
+	cacheStatus: z.enum([
+		"current",
+		"offline",
+		"stale"
+	]).optional(),
+	subagents: z.array(requiredString$1).default([]),
+	title: z.string().nullable(),
+	startedAt: z.string().nullable(),
+	endedAt: z.string().nullable(),
+	activeMs: z.number().nullable(),
+	userTurns: z.number(),
+	toolCalls: z.number(),
+	events: z.array(ReviewAgentTraceEventSchema)
+}), ReviewErrorResponseSchema]);
+//#endregion
+//#region ../review-protocol/src/bug-report.ts
+const requiredString = z.string({ error: "must be a string" }).refine((value) => value.trim().length > 0, "must be a string");
+const ReviewBugReportRequestSchema = z.strictObject({
+	description: z.string(),
+	include_review: z.boolean(),
+	include_map: z.boolean(),
+	include_diff: z.boolean(),
+	/** @deprecated Ignored: reports never attach an agent trace. */
+	include_trace: z.boolean().optional(),
+	screenshot: z.strictObject({
+		mime: z.literal("image/jpeg"),
+		base64: z.string()
+	}).optional(),
+	app_session_id: requiredString.min(16).max(128).regex(/^[A-Za-z0-9_-][A-Za-z0-9_.-]*$/),
+	app_version: requiredString.max(100)
+});
+const compressedPartBytes = z.number().int().positive().max(1e8);
+const compressedSha256 = z.string().regex(/^[a-f0-9]{64}$/);
+const ReviewBugReportPartSchema = z.discriminatedUnion("field", [z.strictObject({
+	field: z.literal("payload"),
+	filename: z.literal("payload.json.gz"),
+	bytes: compressedPartBytes,
+	sha256: compressedSha256
+}), z.strictObject({
+	field: z.literal("trace"),
+	filename: z.string().regex(/^trace-(0|[1-9]\d?)\.jsonl\.gz$/),
+	bytes: compressedPartBytes,
+	sha256: compressedSha256,
+	session_id: requiredString.max(128)
+})]);
+const ReviewBugReportMetaV2Schema = z.strictObject({
+	schema_version: z.literal(2),
+	description_length: z.number().int().nonnegative().max(65536),
+	description: z.string().refine((value) => new TextEncoder().encode(value).byteLength <= 65536, "must not exceed 65,536 UTF-8 bytes").optional(),
+	has_review: z.boolean(),
+	has_map: z.boolean(),
+	has_diff: z.boolean(),
+	has_screenshot: z.boolean(),
+	has_trace: z.boolean(),
+	trace_harness: z.enum([
+		"claude-code",
+		"codex",
+		"opencode",
+		"pi"
+	]).optional(),
+	payload_bytes: z.number().int().positive().max(10485760),
+	app_version: requiredString.max(100),
+	cli_version: requiredString.max(100),
+	platform: z.enum([
+		"aix",
+		"android",
+		"darwin",
+		"freebsd",
+		"haiku",
+		"linux",
+		"openbsd",
+		"sunos",
+		"win32",
+		"cygwin",
+		"netbsd"
+	]),
+	truncated_diff: z.boolean(),
+	truncated_map: z.boolean(),
+	truncated_screenshot: z.boolean(),
+	truncated_trace: z.boolean(),
+	parts: z.array(ReviewBugReportPartSchema).min(1).max(34)
+}).superRefine((meta, context) => {
+	if (meta.description !== void 0 && new TextEncoder().encode(meta.description).byteLength !== meta.description_length) context.addIssue({
+		code: "custom",
+		path: ["description_length"],
+		message: "must match the description UTF-8 byte length"
+	});
+	const [first, ...traces] = meta.parts;
+	const validOrder = first?.field === "payload" && traces.every((part, index) => part.field === "trace" && part.filename === `trace-${index}.jsonl.gz`);
+	const sessionIds = traces.map((part) => part.field === "trace" ? part.session_id : "");
+	if (!validOrder || new Set(sessionIds).size !== sessionIds.length) context.addIssue({
+		code: "custom",
+		path: ["parts"],
+		message: "must list the payload then trace-<n> parts in order"
+	});
+	if (meta.has_trace !== traces.length > 0) context.addIssue({
+		code: "custom",
+		path: ["has_trace"],
+		message: "must match the presence of trace parts"
+	});
+	if (meta.has_trace !== (meta.trace_harness !== void 0)) context.addIssue({
+		code: "custom",
+		path: ["trace_harness"],
+		message: "must be present only when the report has a trace"
+	});
+	if (!meta.has_trace && meta.truncated_trace) context.addIssue({
+		code: "custom",
+		path: ["truncated_trace"],
+		message: "must be false when the report has no trace"
+	});
+	if (meta.parts[0]?.bytes !== meta.payload_bytes) context.addIssue({
+		code: "custom",
+		path: ["payload_bytes"],
+		message: "must match the payload part size"
+	});
+});
+const ReviewBugReportResponseSchema = z.discriminatedUnion("ok", [z.strictObject({
+	ok: z.literal(true),
+	report_id: z.uuid(),
+	short_id: requiredString.length(12)
+}), z.strictObject({
+	ok: z.literal(false),
+	error: requiredString
+})]);
+function parseReviewBugReportResponse(value) {
+	return ReviewBugReportResponseSchema.parse(value);
+}
+//#endregion
+//#region ../review-protocol/src/index.ts
+function parseReviewDesktopDiscovery(value) {
+	return parseZod(ReviewDesktopDiscoverySchema, value);
+}
+function parseReviewCliInstallApplyRequest(value) {
+	return parseZod(ReviewCliInstallApplyRequestSchema, value);
+}
+function parseReviewDesktopVerbResult(value) {
+	return parseZod(ReviewDesktopVerbResultSchema, value);
+}
+function parseReviewVerbRequest(value) {
+	return parseZod(ReviewVerbRequestSchema, value);
+}
+function parseReviewVerbResponse(value) {
+	return parseZod(ReviewVerbResponseSchema, value);
+}
+function parseZod(schema, value, label, prefixPath = false) {
+	const result = schema.safeParse(value);
+	if (result.success) return result.data;
+	const issue = result.error.issues[0];
+	const issuePath = formatIssuePath(issue?.path ?? []);
+	const path = prefixPath && label ? issuePath ? `${label}.${issuePath}` : label : issuePath || label;
+	throw new Error(`${path ? `${path} ` : ""}${issue?.message ?? "Invalid input"}`);
+}
+function formatIssuePath(path) {
+	let output = "";
+	for (const segment of path) if (Number.isInteger(segment)) output += `[${String(segment)}]`;
+	else output += `${output ? "." : ""}${String(segment)}`;
+	return output;
+}
+//#endregion
+export { SCRATCHPAD_REVIEW_ID as _, parseReviewVerbResponse as a, structuralChangeCounts as b, ReviewBugReportRequestSchema as c, REVIEW_CLIENT_REMOTE as d, REVIEW_DIFF_LAYOUTS as f, ReviewSelectedDiffSchema as g, ReviewCliInstallStampSchema as h, parseReviewVerbRequest as i, parseReviewBugReportResponse as l, ReviewApiSelectionSourceSchema as m, parseReviewDesktopDiscovery as n, parseZod as o, REVIEW_THEME_CHOICES as p, parseReviewDesktopVerbResult as r, ReviewBugReportMetaV2Schema as s, parseReviewCliInstallApplyRequest as t, REVIEW_CLIENT_HEADER as u, reviewDiffrSummarizerInputSchema as v, decodeStructuralDiffEvent as y };