@dev.fast/whiteboard 0.4.0 → 0.4.1-preview.20261026.138

package/dist/{client-p9WB8Sj0.js → import-Bwvf9Wos.js}

@@ -1,29 +1,21 @@
-import { f as gitAt } from "./src-X9ZebeOD.js";
-import { n as isJsonObject, u as parseJsonText } from "./src-X9phtB2j.js";
-import "./src-DYHVzX3b.js";
-import { f as sourceAnchors } from "./lens-selection-9byzEgvU.js";
-import { B as resourceReferences, D as boardRepositoryId, I as pinsSchema, J as checkReferences, K as sourceReferences, R as readsAtBoardPins, S as anchorPins, b as textIncludesQuote, c as traceSchema, et as lensSchema, j as elements, k as documentSchema, lt as parseMarkdown, n as migrateStoredDocument, r as migrateStoredLenses, s as softwareModelDataSchema, st as markdownNodes, t as liftFileLenses, tt as lensSelections, u as pullRequestUrl, z as resourceReference } from "./stored-document-migration-DEt8iwem.js";
+import { f as gitAt } from "./src-DXnn7RrI.js";
+import { u as parseJsonText } from "./src-X9phtB2j.js";
+import { _ as scopedCoverage, f as sourceAnchors, h as emptyCoverage, i as anchorSelection, l as resolveDiffSelection, m as coverageSources, n as SelectionUnavailableError, o as comparisonKey, u as selectionKey, v as subtractIntervals, y as unionIntervals } from "./lens-selection-EuZdag4Q.js";
+import { $ as UNCATEGORIZED_LENS_ID, B as readsAtBoardPins, H as resourceReferences, J as sourceReferences, N as elements, R as pinsSchema, V as resourceReference, X as checkReferences, b as textIncludesQuote, c as traceSchema, dt as parseMarkdown, j as documentSchema, k as boardRepositoryId, lt as markdownNodes, n as migrateStoredDocument, nt as lensSchema, ot as fileLineRangeSchema, q as selectionReferences, r as migrateStoredLenses, rt as lensSelections, s as softwareModelDataSchema, t as liftFileLenses, u as pullRequestUrl, w as anchorPins, x as textualRows } from "./stored-document-migration-CwmTwTb8.js";
 import { t as ReviewInputError } from "./input-error-OLgB_h31.js";
 import { createHash, randomUUID } from "node:crypto";
 import { z } from "zod";
+import path, { posix } from "node:path";
 import { existsSync } from "node:fs";
 import { mkdir, mkdtemp, readFile, readdir, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
-import path from "node:path";
 import { tmpdir } from "node:os";
 //#region ../review-share-protocol/src/index.ts
-const SHARE_FORMAT = "review-share/1";
-const MAX_SHARE_MANIFEST_BYTES = 2097152;
-const MAX_SHARE_OBJECT_BYTES = 33554432;
-const MAX_SHARE_OBJECTS = 2048;
-const objectIdSchema = z.string().regex(/^[a-f0-9]{64}$/);
+const SHARE_FORMAT = "review-share/2";
+/** UTF-8 bytes of a bundle's JSON, as uploaded and as stored. */
+const MAX_SHARE_BYTES = 16777216;
 const shareIdSchema = z.uuid();
 const capabilitySchema = z.string().regex(/^[A-Za-z0-9_-]{43}$/);
-const shareObjectSchema = z.strictObject({
-	id: objectIdSchema,
-	size: z.number().int().min(0).max(MAX_SHARE_OBJECT_BYTES),
-	sha256: objectIdSchema
-}).refine((object) => object.id === object.sha256, "Object ID must match its digest.");
-z.string().min(1).max(4096).refine((file) => !file.startsWith("/") && !file.includes("\\") && !/[\u0000-\u001f\u007f]/.test(file) && file.split("/").every((part) => part !== "" && part !== "." && part !== ".."), "Use a repository-relative file path.");
+const sharePathSchema = z.string().min(1).max(4096).refine((file) => !file.startsWith("/") && !file.includes("\\") && !/[\u0000-\u001f\u007f]/.test(file) && file.split("/").every((part) => part !== "" && part !== "." && part !== ".."), "Use a repository-relative file path.");
 /** The published identity is independent of the author's credential transport. */
 function normalizeGitHubRemote(remote) {
 	const url = new URL(remote.trim().replace(/^git@github\.com:/, "https://github.com/"));
@@ -39,56 +31,53 @@ const gitHubRepositoryUrlSchema = z.string().refine((value) => {
 		return false;
 	}
 }, "Use a canonical GitHub HTTPS repository URL without credentials.");
-const shareManifestSchema = z.strictObject({
+const commitSchema = z.string().regex(/^[a-f0-9]{40}([a-f0-9]{24})?$/);
+const sideSchema = z.enum(["base", "head"]);
+/** An excerpt is the lines a board references. */
+const shareSourceSchema = z.discriminatedUnion("kind", [z.strictObject({
+	kind: z.literal("excerpt"),
+	file: sharePathSchema,
+	commit: commitSchema,
+	fromLine: z.number().int().positive(),
+	lines: z.array(z.string()).min(1)
+})]);
+const lineRangeSchema = z.strictObject({
+	side: sideSchema,
+	file: sharePathSchema,
+	fromLine: z.number().int().positive(),
+	toLine: z.number().int().positive(),
+	pins: z.strictObject({
+		repositoryId: z.string(),
+		head: z.string(),
+		base: z.string().optional()
+	}).optional()
+});
+const shareBundleSchema = z.strictObject({
 	format: z.literal(SHARE_FORMAT),
 	reviewId: z.string().min(1).max(256),
 	version: z.number().int().nonnegative(),
 	title: z.string().min(1).max(4096),
-	snapshot: objectIdSchema,
-	presentation: objectIdSchema,
-	objects: z.array(shareObjectSchema).min(2).max(MAX_SHARE_OBJECTS),
-	resources: z.array(z.strictObject({
-		id: z.string().min(1).max(256),
-		kind: z.enum([
-			"image",
-			"trace",
-			"map"
-		]),
-		mimeType: z.enum(["image/png", "application/json"]),
-		object: objectIdSchema
-	})).max(MAX_SHARE_OBJECTS),
+	/** Validated against the document schema by the reader. */
+	snapshot: z.record(z.string(), z.unknown()),
+	images: z.record(z.string(), z.strictObject({ png: z.base64() })),
+	traces: z.record(z.string(), z.unknown()),
+	maps: z.record(z.string(), z.unknown()),
+	commits: z.array(z.unknown()),
+	/** Each reference's lines, resolved where the board was shared. */
+	selections: z.record(z.string(), z.array(lineRangeSchema)),
+	sources: z.array(shareSourceSchema),
 	repository: z.strictObject({ cloneUrl: gitHubRepositoryUrlSchema }).optional()
-}).superRefine((manifest, context) => {
-	const ids = new Set(manifest.objects.map((object) => object.id));
-	const fail = (message) => context.addIssue({
-		code: "custom",
-		message
-	});
-	if (ids.size !== manifest.objects.length) fail("Duplicate object ID.");
-	if (manifest.objects.reduce((size, object) => size + object.size, 0) > 134217728) fail("Share exceeds the total byte limit.");
-	for (const id of [
-		manifest.snapshot,
-		manifest.presentation,
-		...manifest.resources.map((resource) => resource.object)
-	]) if (!ids.has(id)) fail("Reference to an undeclared object.");
-	if (new Set(manifest.resources.map((resource) => resource.id)).size !== manifest.resources.length) fail("Duplicate resource ID.");
-	for (const resource of manifest.resources) if (resource.kind === "image" !== (resource.mimeType === "image/png")) fail("Resource MIME type does not match its kind.");
 });
 z.strictObject({
 	requestId: z.uuid(),
-	manifest: z.strictObject({
-		sha256: objectIdSchema,
-		size: z.number().int().positive().max(MAX_SHARE_MANIFEST_BYTES)
-	})
+	bundle: shareBundleSchema
 });
 function parseShareLink(value) {
 	const url = new URL(value);
-	if (url.protocol !== "https:" || url.username || url.password || url.search) throw new Error("Use an HTTPS Review share link.");
-	const match = /^\/s\/([^/]+)$/.exec(url.pathname);
+	if (url.protocol !== "https:" || url.username || url.password || url.hash || [...url.searchParams.keys()].some((key) => key !== "app")) throw new Error("Use an HTTPS Whiteboard share link.");
 	return {
 		origin: url.origin,
-		shareId: shareIdSchema.parse(match?.[1]),
-		capability: capabilitySchema.parse(url.hash.slice(1))
+		capability: capabilitySchema.parse(/^\/s\/([^/]+)$/.exec(url.pathname)?.[1])
 	};
 }
 //#endregion
@@ -119,16 +108,251 @@ async function readBoundedStream(stream, limit) {
 	}
 }
 //#endregion
-//#region src/sharing/export.ts
-function digestBytes(bytes) {
-	return createHash("sha256").update(bytes).digest("hex");
+//#region src/review-api/file-lenses.ts
+/** Subtract authored coverage, independently of viewed state. */
+function uncategorizedSources(files, sources) {
+	return files.flatMap((file) => {
+		const covered = scopedCoverage(file, sources);
+		return coverageSources(file, {
+			base: subtractIntervals(file.changed.base, covered.base),
+			head: subtractIntervals(file.changed.head, covered.head)
+		});
+	});
+}
+/** Resolve all targets into one union; a whole-file range subsumes narrower ranges. */
+function resolveFileLens(lens, files, fileSources, resolve) {
+	const targets = lens.targets;
+	const selected = targets.flatMap((target) => target.kind === "ranges" ? target.sources.flatMap((source) => resolve(anchorSelection(source))) : files.filter((file) => matchesFileLens(target.patterns, file)).flatMap((file) => fileSources.get(file.path) ?? []));
+	const groups = /* @__PURE__ */ new Map();
+	for (const source of selected) {
+		const key = JSON.stringify([source.side, source.file]);
+		const group = groups.get(key) ?? [];
+		group.push(source);
+		groups.set(key, group);
+	}
+	const sources = [...groups.values()].flatMap((group) => unionIntervals(group.map((source) => [source.fromLine - 1, source.toLine])).map(([start, end]) => ({
+		...group[0],
+		fromLine: start + 1,
+		toLine: end
+	})));
+	return {
+		sources,
+		fileCount: new Set(sources.map((source) => files.find((file) => source.file === (source.side === "base" ? file.previousPath ?? file.path : file.path))?.path ?? source.file)).size,
+		wholeFiles: targets.every((target) => target.kind === "files")
+	};
+}
+/** Evaluate authored patterns against the changed-file list, never the filesystem. */
+function matchesFileLens(patterns, file) {
+	return patterns.some((pattern) => {
+		const normalized = pattern.startsWith("./") ? pattern.slice(2) : pattern;
+		return [file.path, file.previousPath].some((path) => path !== void 0 && (path === normalized || posix.matchesGlob(path, normalized)));
+	});
 }
+//#endregion
+//#region src/review-api/review-progress.ts
+/** Older clients still send `mode`. */
+const legacyModeSchema = z.unknown().optional();
+const progressUpdateSchema = z.strictObject({
+	mode: legacyModeSchema,
+	version: z.number().int().nonnegative(),
+	files: z.array(z.strictObject({
+		path: z.string(),
+		fingerprint: z.string().min(1),
+		sources: z.array(fileLineRangeSchema)
+	})).max(1e4),
+	viewed: z.boolean()
+});
+/** Coverage survives new pins only when both complete file contents are unchanged. */
+async function reviewProgress(store, data, snapshot, signal = new AbortController().signal, partial) {
+	const marks = snapshot.shared ? /* @__PURE__ */ new Map() : store.viewedCoverage(snapshot.reviewId);
+	const pins = snapshot.pins ? (await data.resolveSource(snapshot)).pins : void 0;
+	const comparison = pins ? partial ?? await data.coverage(snapshot.reviewId, pins) : {
+		counted: true,
+		files: [],
+		fileSources: /* @__PURE__ */ new Map(),
+		alignments: /* @__PURE__ */ new Map()
+	};
+	const counting = !comparison.counted;
+	signal.throwIfAborted();
+	const documentKey = JSON.stringify(pins);
+	const comparisons = /* @__PURE__ */ new Map();
+	/** The comparison a reference's own pins name, shared across references. */
+	const ownComparison = (own) => {
+		const key = JSON.stringify(own);
+		let loading = comparisons.get(key);
+		if (loading) return loading;
+		if (partial) {
+			const state = data.coverageSnapshot(snapshot.reviewId, own);
+			if (state.pending) return state.comparison.counted ? Promise.resolve(state.comparison) : void 0;
+		}
+		loading = data.coverage(snapshot.reviewId, own);
+		comparisons.set(key, loading);
+		return loading;
+	};
+	const withViewed = (file) => ({
+		...file,
+		viewed: marks.get(file.path)?.fingerprint === file.fingerprint ? marks.get(file.path).coverage : emptyCoverage()
+	});
+	const files = comparison.files.map(withViewed);
+	const referenceFiles = {};
+	const fileSources = new Map(comparison.fileSources);
+	const alignments = new Map(comparison.alignments);
+	const resolvedSelections = {};
+	const unavailableSelections = {};
+	const pendingSources = /* @__PURE__ */ new Set();
+	const resolve = async (source) => {
+		const key = selectionKey(source);
+		if (resolvedSelections[key]) return resolvedSelections[key];
+		const sourcePins = anchorPins(source, pins);
+		const own = JSON.stringify(sourcePins) !== documentKey;
+		let ownFiles = files;
+		let ownAlignments = alignments;
+		if (own) {
+			const loading = ownComparison(sourcePins);
+			if (!loading) {
+				pendingSources.add(key);
+				return [];
+			}
+			const loaded = await loading;
+			ownFiles = loaded.files;
+			ownAlignments = loaded.alignments;
+		}
+		const file = ownFiles.find((file) => source.file === file.path || source.file === file.previousPath);
+		if (own) {
+			const group = referenceFiles[comparisonKey(sourcePins)] ??= {};
+			if (file) group[file.path] ??= withViewed(file);
+		}
+		let rows = file && ownAlignments.get(file.path);
+		if (!file && counting && !own) {
+			pendingSources.add(key);
+			return [];
+		}
+		if (!file) {
+			const [base, head] = await Promise.all(["base", "head"].map((side) => data.file(sourcePins, side, source.file).then((value) => value.text, (error) => {
+				if (error instanceof ReviewInputError && error.status === 404) return null;
+				throw error;
+			})));
+			if (base === null && head === null) throw new SelectionUnavailableError("missing_file", "File is unavailable at these pins.");
+			if (base !== null && head !== null && base !== head) throw new SelectionUnavailableError("no_alignment", "Changed context file has no alignment.");
+			rows = textualRows(source.file, "", base?.split("\n").length ?? 0, head?.split("\n").length ?? 0);
+		}
+		if (!rows) throw new SelectionUnavailableError("no_alignment", "File has no text alignment.");
+		const result = resolveDiffSelection(source, rows, file ?? { path: source.file });
+		resolvedSelections[key] = result;
+		return result;
+	};
+	const resolveAvailable = async (source) => {
+		try {
+			return await resolve(source);
+		} catch (error) {
+			unavailableSelections[selectionKey(source)] = error instanceof SelectionUnavailableError ? error.reason : "other";
+			return [];
+		}
+	};
+	const lenses = await Promise.all((snapshot.lenses ?? []).map(async (authored) => {
+		const lens = {
+			id: authored.id,
+			title: authored.title
+		};
+		try {
+			await Promise.all(lensSelections([authored]).map(({ source }) => resolveAvailable(source)));
+			const resolved = resolveFileLens(authored, files, fileSources, (source) => resolvedSelections[selectionKey(source)] ?? []);
+			return {
+				...lens,
+				...resolved,
+				pending: counting,
+				unavailable: counting || resolved.fileCount ? void 0 : "No files match these targets"
+			};
+		} catch {
+			return {
+				...lens,
+				sources: [],
+				unavailable: "Source links need updating at these pins"
+			};
+		}
+	}));
+	await Promise.all(selectionReferences(snapshot.document, {
+		tolerant: true,
+		repositoryId: boardRepositoryId(snapshot)
+	}).map(async ({ source }) => {
+		try {
+			await resolveAvailable(source);
+		} catch {}
+	}));
+	const uncategorized = counting ? [] : uncategorizedSources(files, lenses.filter((lens) => !lens.unavailable).flatMap((lens) => lens.sources));
+	lenses.push({
+		id: UNCATEGORIZED_LENS_ID,
+		title: "Uncategorized changes",
+		sources: uncategorized,
+		wholeFiles: false,
+		fileCount: new Set(uncategorized.map((source) => files.find((file) => source.file === (source.side === "base" ? file.previousPath ?? file.path : file.path))?.path ?? source.file)).size,
+		pending: counting,
+		unavailable: counting || uncategorized.length ? void 0 : "All changed lines are covered by lenses"
+	});
+	const progress = {
+		complete: !counting && !pendingSources.size,
+		files,
+		referenceFiles,
+		lenses,
+		resolvedSelections,
+		unavailableSelections
+	};
+	const untrackedFiles = pins ? await data.untrackedFiles(pins) : void 0;
+	if (untrackedFiles) progress.untrackedFiles = untrackedFiles;
+	return progress;
+}
+/** The most files an uncategorized report names; the rest are counted. */
+const REPORT_FILES = 50;
+/** What a lens author still has to place: the changed lines no lens selects,
+* grouped by file. */
+function uncategorizedReport(progress) {
+	const sources = progress.lenses.find((lens) => lens.id === "automatic-uncategorized")?.sources ?? [];
+	const byPath = /* @__PURE__ */ new Map();
+	for (const source of sources) {
+		const path = progress.files.find((file) => source.file === (source.side === "base" ? file.previousPath ?? file.path : file.path))?.path ?? source.file;
+		const entry = byPath.get(path) ?? {
+			path,
+			lines: 0,
+			ranges: []
+		};
+		entry.lines += source.toLine - source.fromLine + 1;
+		entry.ranges.push({
+			side: source.side,
+			fromLine: source.fromLine,
+			toLine: source.toLine
+		});
+		byPath.set(path, entry);
+	}
+	const files = [...byPath.values()];
+	const report = {
+		lines: files.reduce((total, file) => total + file.lines, 0),
+		files: files.slice(0, REPORT_FILES)
+	};
+	if (files.length > REPORT_FILES) report.moreFiles = files.length - REPORT_FILES;
+	return report;
+}
+/** Each lens as authored, with what it resolves to, for a lens author. */
+function lensReport(lenses, progress) {
+	return {
+		lenses: lenses.map((lens) => {
+			const resolved = progress.lenses.find((item) => item.id === lens.id);
+			return {
+				...lens,
+				fileCount: resolved?.fileCount ?? 0,
+				...resolved?.unavailable && { unavailable: resolved.unavailable }
+			};
+		}),
+		uncategorized: uncategorizedReport(progress)
+	};
+}
+//#endregion
+//#region src/sharing/export.ts
 function validateShareSources(snapshot) {
 	if (!snapshot.pins && readsAtBoardPins(snapshot)) throw new ReviewInputError("Reviews with code references need source pins before sharing.", 409);
 }
 /** The commits a board's references read at besides its base and head. A
-* recipient fetches them too. A shared board names no repository of its
-* own, so one stands in for its commit links. */
+* Desktop recipient fetches them too. A shared board names no repository of
+* its own, so one stands in for its commit links. */
 function referenceCommits(snapshot, repositoryId = boardRepositoryId(snapshot) ?? "shared") {
 	const own = /* @__PURE__ */ new Set([snapshot.pins?.base, snapshot.pins?.head]);
 	const commits = /* @__PURE__ */ new Set();
@@ -138,6 +362,40 @@ function referenceCommits(snapshot, repositoryId = boardRepositoryId(snapshot) ?
 	})) for (const commit of [source.pins?.base, source.pins?.head]) if (commit && !own.has(commit)) commits.add(commit);
 	return [...commits].sort();
 }
+/** One excerpt per run of overlapping or adjacent lines in a file at a commit. */
+async function cutExcerpts(data, ranges) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const range of ranges) {
+		const key = JSON.stringify([range.pins[range.side], range.file]);
+		groups.set(key, [...groups.get(key) ?? [], range]);
+	}
+	const merged = [...groups.values()].flatMap((group) => group.toSorted((a, b) => a.fromLine - b.fromLine).reduce((runs, range) => {
+		const last = runs.at(-1);
+		if (last && range.fromLine <= last.toLine + 1) last.toLine = Math.max(last.toLine, range.toLine);
+		else runs.push({ ...range });
+		return runs;
+	}, []));
+	return Promise.all(merged.map(async ({ pins, ...range }) => {
+		const quote = await data.quote(pins, range);
+		return {
+			kind: "excerpt",
+			file: range.file,
+			commit: quote.commit,
+			fromLine: range.fromLine,
+			lines: excerptLines(quote.text)
+		};
+	}));
+}
+const excerptLines = (text) => text.split(/\r?\n/).map((line) => line.replaceAll("\0", "�"));
+/** The create request body, within the upload limit. */
+function shareRequestBody(bundle, requestId) {
+	const body = JSON.stringify({
+		requestId,
+		bundle
+	});
+	if (Buffer.byteLength(body) > 16777216) throw new ReviewInputError(`Review exceeds the ${MAX_SHARE_BYTES / 1024 / 1024} MB sharing limit. Remove large traces, then retry.`);
+	return body;
+}
 /** Freeze one stored version before any asynchronous source reads. */
 async function exportShare(input) {
 	const stored = structuredClone(input.store.read(input.reviewId, input.version));
@@ -146,89 +404,162 @@ async function exportShare(input) {
 	if (target?.kind === "worktree") throw new ReviewInputError("Pin this review to commits before sharing it.");
 	documentSchema.parse(snapshot.document);
 	checkReferences(snapshot.document);
-	const objects = /* @__PURE__ */ new Map();
-	let totalBytes = 0;
-	const add = (bytes) => {
-		if (bytes.byteLength > 33554432) throw new ReviewInputError("A shared object exceeds the upload limit.");
-		const id = digestBytes(bytes);
-		if (!objects.has(id)) {
-			totalBytes += bytes.byteLength;
-			if (totalBytes > 134217728) throw new ReviewInputError("Review exceeds the sharing limit.");
-			objects.set(id, Uint8Array.from(bytes));
-		}
-		return id;
-	};
-	const json = (value) => add(Buffer.from(JSON.stringify(value)));
-	const resources = [];
-	const maps = {};
-	const sources = [...sourceReferences(snapshot.document, { repositoryId }), ...lensSelections(snapshot.lenses ?? []).flatMap((selection) => sourceAnchors(selection.source).map((source) => ({
-		...selection,
-		source,
-		peek: false
-	})))];
-	const pins = snapshot.pins;
 	validateShareSources(snapshot);
-	if ((pins || referenceCommits(stored).length) && !input.repository) throw new ReviewInputError("Shared source pins require a repository.", 409);
 	for (const block of elements(snapshot.document)) {
 		if (block.type !== "markdown") continue;
 		for (const node of markdownNodes(parseMarkdown(block.markdown))) if (node.type === "image") throw new ReviewInputError("Convert Markdown images to managed image blocks before sharing.");
 	}
+	const pins = snapshot.pins;
+	const references = [...sourceReferences(snapshot.document, { repositoryId }), ...lensSelections(snapshot.lenses ?? []).flatMap((selection) => sourceAnchors(selection.source).map((source) => ({ source })))];
+	const traces = /* @__PURE__ */ new Map();
+	const maps = /* @__PURE__ */ new Map();
 	for (const block of resourceReferences(snapshot.document)) {
 		await input.data.validateResource(pins, block);
-		const reference = resourceReference(block);
-		if (!reference || resources.some((resource) => resource.id === reference.id)) continue;
-		const { id } = reference;
-		const resource = input.store.resource(id);
-		resources.push({
-			id,
-			kind: z.enum([
-				"image",
-				"trace",
-				"map"
-			]).parse(resource.kind),
-			mimeType: z.enum(["image/png", "application/json"]).parse(resource.mimeType),
-			object: add(resource.data)
-		});
-		if (block.type === "software_map") {
+		const id = resourceReference(block)?.id;
+		if (!id || block.type === "image" || traces.has(id) || maps.has(id)) continue;
+		if (block.type === "trace_quote") traces.set(id, JSON.parse(Buffer.from(input.store.resource(id).data).toString()));
+		else if (block.type === "software_map") {
 			const map = await input.data.map(pins, id);
-			Object.defineProperty(maps, id, {
-				value: map,
-				enumerable: true
-			});
-			for (const element of map.elements) for (const range of element.sourceRanges ?? []) sources.push({
-				id: `${id}:${element.id}`,
-				source: {
-					...range,
-					side: map.side
-				}
-			});
-		}
+			maps.set(id, map);
+			for (const element of map.elements) for (const range of element.sourceRanges ?? []) references.push({ source: {
+				...range,
+				side: map.side
+			} });
+		} else throw new ReviewInputError("A shared resource has the wrong type.");
 	}
-	for (const reference of sources) await input.data.validateSource(anchorPins(reference.source, pins), reference.source, { peek: reference.peek ?? false });
-	const snapshotId = json(snapshot);
-	const presentationId = json({ maps });
-	const manifest = shareManifestSchema.parse({
+	for (const reference of references) await input.data.validateSource(anchorPins(reference.source, pins), reference.source, { peek: reference.peek ?? false });
+	const { resolvedSelections } = await reviewProgress(input.store, input.data, stored);
+	const selected = new Map([...lensSelections(snapshot.lenses ?? []), ...selectionReferences(snapshot.document, {
+		tolerant: true,
+		repositoryId
+	})].map(({ source }) => [selectionKey(source), source]));
+	const selections = Object.fromEntries(Object.entries(resolvedSelections).map(([key, ranges]) => {
+		const own = selected.get(key)?.pins;
+		return [key, ranges.map((range) => ({
+			...range,
+			...own && { pins: own }
+		}))];
+	}));
+	const excerpts = [...Object.values(selections).flat(), ...[...maps.values()].flatMap((map) => map.elements.flatMap((element) => (element.sourceRanges ?? []).map((range) => ({
+		...range,
+		side: map.side
+	}))))].map(({ side = "head", file, fromLine, toLine, ...range }) => ({
+		pins: anchorPins(range, pins),
+		side,
+		file,
+		fromLine,
+		toLine
+	}));
+	return {
 		format: SHARE_FORMAT,
 		reviewId: snapshot.reviewId,
 		version: snapshot.version,
 		title: snapshot.title,
-		snapshot: snapshotId,
-		presentation: presentationId,
-		objects: [...objects].map(([id, bytes]) => ({
-			id,
-			sha256: id,
-			size: bytes.byteLength
-		})),
-		resources,
-		repository: input.repository
-	});
-	if (Buffer.byteLength(JSON.stringify(manifest)) > 2097152) throw new ReviewInputError("The share manifest exceeds the upload limit.");
-	return {
-		manifest,
-		objects
+		snapshot,
+		images: {},
+		traces: Object.fromEntries(traces),
+		maps: Object.fromEntries(maps),
+		commits: pins ? await input.data.commits((await input.data.resolveSource(stored)).pins) : [],
+		selections,
+		sources: await cutExcerpts(input.data, excerpts),
+		...input.repository && { repository: input.repository }
 	};
 }
 //#endregion
+//#region src/sharing/client.ts
+const MAX_RESPONSE_BYTES = MAX_SHARE_BYTES;
+const linkSchema = z.strictObject({
+	shareId: z.uuid(),
+	url: z.url()
+});
+const receivedSchema = z.object({
+	sender: z.strictObject({ login: z.string().min(1).max(256) }),
+	sharedAt: z.number(),
+	size: z.number().int().positive().max(MAX_SHARE_BYTES)
+});
+/** Size is checked while reading, even if Content-Length is absent or false. */
+async function readBoundedBytes(response, limit) {
+	if (!response.ok || !response.body) throw new Error(`Download failed (${response.status}).`);
+	const declared = response.headers.get("content-length");
+	if (declared && Number(declared) > limit) {
+		await response.body.cancel().catch(() => {});
+		throw new Error("Download exceeds its declared limit.");
+	}
+	try {
+		return await readBoundedStream(response.body, limit);
+	} catch (error) {
+		if (error instanceof StreamLimitError) throw new Error("Download exceeds its declared limit.");
+		throw error;
+	}
+}
+/** The share service rejected the account token; the stored login is stale. */
+var ShareAuthError = class extends Error {
+	constructor() {
+		super("The share service rejected the stored login.");
+		this.name = "ShareAuthError";
+	}
+};
+/** Account tokens go only to the configured API origin. */
+var ShareClient = class {
+	token;
+	send;
+	origin;
+	constructor(origin, token, send = fetch) {
+		this.token = token;
+		this.send = send;
+		const url = new URL(origin);
+		if (url.username || url.password || url.protocol !== "https:" && !(url.protocol === "http:" && url.hostname === "localhost")) throw new Error("Use a secure share service origin.");
+		this.origin = url.origin;
+	}
+	async api(route, method = "GET", body, anonymous = false) {
+		return parseJsonText(Buffer.from(await this.request(route, method, body, anonymous, MAX_RESPONSE_BYTES)).toString());
+	}
+	async request(route, method, body, anonymous, maxBytes) {
+		const headers = new Headers({ "content-type": "application/json" });
+		if (this.token && !anonymous) headers.set("authorization", `Bearer ${this.token}`);
+		const init = {
+			method,
+			redirect: "error",
+			signal: AbortSignal.timeout(3e5),
+			headers
+		};
+		if (body !== void 0) init.body = body;
+		const response = await this.send(this.origin + route, init);
+		if (!response.ok) {
+			await response.body?.cancel();
+			if (response.status === 401 && !anonymous) throw new ShareAuthError();
+			throw new Error(`Share request failed (${response.status}).`);
+		}
+		return readBoundedBytes(response, maxBytes);
+	}
+	async create(bundle, requestId = randomUUID()) {
+		return linkSchema.parse(await this.api("/api/v2/shares", "POST", shareRequestBody(bundle, requestId)));
+	}
+	async list(cursor) {
+		const query = cursor ? `?cursor=${z.uuid().parse(cursor)}` : "";
+		return this.api(`/api/v2/shares${query}`);
+	}
+	async recoverLink(shareId) {
+		return linkSchema.parse(await this.api(`/api/v2/shares/${z.uuid().parse(shareId)}/link`));
+	}
+	async revoke(shareId) {
+		return this.api(`/api/v2/shares/${z.uuid().parse(shareId)}`, "DELETE");
+	}
+	/** The bundle and who shared it, read with the link's capability. */
+	async download(capability) {
+		const route = `/api/v2/shared/${capabilitySchema.parse(capability)}`;
+		const received = receivedSchema.parse(await this.api(route, "GET", void 0, true));
+		const bytes = await this.request(`${route}/bundle`, "GET", void 0, true, MAX_SHARE_BYTES);
+		return {
+			bundle: shareBundleSchema.parse(parseJsonText(new TextDecoder().decode(bytes))),
+			attribution: {
+				login: received.sender.login,
+				sharedAt: received.sharedAt
+			}
+		};
+	}
+};
+//#endregion
 //#region src/sharing/repository.ts
 /** A full commit id, SHA-1 or SHA-256. */
 const COMMIT_ID = /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/;
@@ -513,50 +844,41 @@ const mapSchema = softwareModelDataSchema.extend({
 		}))
 	})) }))
 });
-const sharePresentationSchema = z.strictObject({ maps: z.record(z.string(), mapSchema) });
-function validateShareBundle(bundle) {
-	const manifest = shareManifestSchema.parse(bundle.manifest);
-	if (Buffer.byteLength(JSON.stringify(manifest)) > 2097152) throw new Error("Share manifest is too large.");
-	if (bundle.objects.size !== manifest.objects.length) throw new Error("Share object count does not match its manifest.");
-	for (const object of manifest.objects) {
-		const bytes = bundle.objects.get(object.id);
-		if (!bytes || bytes.byteLength !== object.size || digestBytes(bytes) !== object.sha256) throw new Error(`Shared object ${object.id} is missing or corrupt.`);
-	}
-	const json = (id) => parseJsonText(Buffer.from(bundle.objects.get(id)).toString());
-	const stored = json(manifest.snapshot);
-	const snapshot = sharedSnapshotSchema.parse(isJsonObject(stored) && "document" in stored ? liftSharedLenses(stored, migrateStoredDocument(stored.document)) : stored);
-	if (snapshot.reviewId !== manifest.reviewId || snapshot.version !== manifest.version || snapshot.title !== manifest.title) throw new Error("Shared snapshot does not match its manifest.");
+z.strictObject({ maps: z.record(z.string(), mapSchema) });
+function validateShareBundle(input) {
+	const bundle = shareBundleSchema.parse(input);
+	const stored = bundle.snapshot;
+	const snapshot = sharedSnapshotSchema.parse(stored.document === void 0 ? stored : liftSharedLenses(stored, migrateStoredDocument(stored.document)));
+	if (snapshot.reviewId !== bundle.reviewId || snapshot.version !== bundle.version || snapshot.title !== bundle.title) throw new Error("Shared snapshot does not match its bundle.");
 	checkReferences(snapshot.document);
 	validateShareSources(snapshot);
 	assertCommitIds(referenceCommits(snapshot));
-	if (snapshot.pins && !manifest.repository) throw new Error("Shared source pins require a repository.");
-	const presentation = sharePresentationSchema.parse(json(manifest.presentation));
-	if (!snapshot.pins && Object.keys(presentation.maps).length) throw new Error("Shared maps require source pins.");
+	if ((snapshot.pins || referenceCommits(snapshot).length) && !bundle.repository) throw new ReviewInputError("This share can only be viewed in the browser.", 409);
+	const maps = z.record(z.string(), mapSchema).parse(bundle.maps);
+	if (!snapshot.pins && Object.keys(maps).length) throw new Error("Shared maps require source pins.");
 	const traces = /* @__PURE__ */ new Map();
 	for (const block of resourceReferences(snapshot.document)) {
-		const reference = resourceReference(block);
-		const resource = manifest.resources.find((item) => item.id === reference?.id);
-		if (!reference || !resource || resource.kind !== reference.kind) throw new Error("Missing or mismatched shared resource.");
 		if (block.type === "trace_quote") {
-			let events = traces.get(resource.object);
+			let events = traces.get(block.traceId);
 			if (!events) {
-				const trace = traceSchema.parse(json(resource.object));
+				if (!Object.hasOwn(bundle.traces, block.traceId)) throw new Error("Missing shared trace.");
+				const trace = traceSchema.parse(bundle.traces[block.traceId]);
 				events = new Map(trace.events.map((event) => [event.id, event]));
 				if (events.size !== trace.events.length) throw new Error("Duplicate shared trace event.");
-				traces.set(resource.object, events);
+				traces.set(block.traceId, events);
 			}
 			const event = events.get(block.eventId);
 			if (!event || !textIncludesQuote(event.text, block.text)) throw new Error("Shared quote does not match its trace.");
 		}
 		if (block.type === "software_map") {
-			const map = presentation.maps[block.mapVersionId];
+			const map = Object.hasOwn(maps, block.mapVersionId) ? maps[block.mapVersionId] : void 0;
 			if (!map || map.commit !== snapshot.pins?.[map.side]) throw new Error("Shared map pins do not match.");
 		}
 	}
 	return {
-		manifest,
+		bundle,
 		snapshot,
-		presentation
+		maps
 	};
 }
 function liftSharedLenses(stored, migrated) {
@@ -568,10 +890,10 @@ function liftSharedLenses(stored, migrated) {
 		...(kept.length || lenses.length) && { lenses: [...kept, ...lenses] }
 	};
 }
-function sharedReviewId(origin, shareId) {
+function sharedReviewId(origin, capability) {
 	const url = new URL(origin);
-	shareIdSchema.parse(shareId);
-	return `shared-${digestBytes(Buffer.from(JSON.stringify([url.origin, shareId])))}`;
+	capabilitySchema.parse(capability);
+	return `shared-${createHash("sha256").update(JSON.stringify([url.origin, capability])).digest("hex")}`;
 }
 /** Separate immutable directory tree; authoring mutation handlers cannot write it. */
 var SharedReviewStore = class {
@@ -662,7 +984,7 @@ var SharedReviewStore = class {
 		const saved = this.validated.get(id);
 		if (!saved) throw new ReviewInputError("Shared review is not available.", 404);
 		if (!saved.snapshot.pins) {
-			await this.prepareUnpinned(id, saved.manifest.repository?.cloneUrl);
+			await this.prepareUnpinned(id, saved.bundle.repository?.cloneUrl);
 			return;
 		}
 		if (!local) throw new ReviewInputError("Repository service is unavailable.", 409);
@@ -678,7 +1000,7 @@ var SharedReviewStore = class {
 					recursive: true,
 					force: true
 				});
-				await this.fetchRepository(root, saved.manifest.repository.cloneUrl, saved.snapshot.pins, false, commits);
+				await this.fetchRepository(root, saved.bundle.repository.cloneUrl, saved.snapshot.pins, false, commits);
 				await sharedGit(root, [
 					"checkout",
 					"--detach",
@@ -728,7 +1050,7 @@ var SharedReviewStore = class {
 			...anchorPins(source, pins),
 			repositoryId
 		}, source);
-		if (pins) for (const map of Object.values(saved.presentation.maps)) for (const element of map.elements) for (const range of element.sourceRanges ?? []) add(pins, {
+		if (pins) for (const map of Object.values(saved.maps)) for (const element of map.elements) for (const range of element.sourceRanges ?? []) add(pins, {
 			...range,
 			side: map.side
 		});
@@ -794,6 +1116,13 @@ var SharedReviewStore = class {
 		});
 		for (const id of await readdir(this.root)) {
 			if (!/^shared-[a-f0-9]{64}$/.test(id)) continue;
+			if (!existsSync(path.join(this.root, id, "bundle.json"))) {
+				await rm(path.join(this.root, id), {
+					recursive: true,
+					force: true
+				});
+				continue;
+			}
 			let saved;
 			try {
 				saved = await this.readValidated(id);
@@ -802,11 +1131,8 @@ var SharedReviewStore = class {
 				console.warn("A cached shared review was corrupt. Reopen its share link to download it again.");
 				continue;
 			}
-			const { bundle, validated } = saved;
-			this.loaded.set(id, {
-				manifest: bundle.manifest,
-				attribution: bundle.attribution
-			});
+			const { attribution, validated } = saved;
+			this.loaded.set(id, { attribution });
 			this.validated.set(id, validated);
 			let prepared = false;
 			try {
@@ -820,7 +1146,7 @@ var SharedReviewStore = class {
 				}
 			} catch {}
 			if (!validated.snapshot.pins) {
-				if (this.repositories.has(id) || !validated.manifest.repository) this.setStatus(id, "ready");
+				if (this.repositories.has(id) || !validated.bundle.repository) this.setStatus(id, "ready");
 				else this.prepare(id).catch(() => {});
 			} else if (prepared && this.local && await repositoryReady(this.repositoryRoot(id), validated.snapshot.pins, referenceCommits(validated.snapshot))) {
 				const repository = await this.local.data.register(this.repositoryRoot(id));
@@ -854,8 +1180,8 @@ var SharedReviewStore = class {
 		})}. Restore it with session_lifecycle({"sessionId":"${id}","state":"active"}) to continue.`, 409);
 	}
 	get(id) {
-		const bundle = this.loaded.get(id);
-		if (!bundle) throw new ReviewInputError("Shared review is not available.", 404);
+		const loaded = this.loaded.get(id);
+		if (!loaded) throw new ReviewInputError("Shared review is not available.", 404);
 		const validated = this.validated.get(id);
 		const repositoryId = this.repositories.get(id);
 		if (this.status(id).stage !== "ready" || validated.snapshot.pins && (!repositoryId || !existsSync(path.join(this.repositoryRoot(id), ".git")))) throw new ReviewInputError(this.status(id).error ?? "Fetch the shared repository before opening this review.", 409);
@@ -878,8 +1204,8 @@ var SharedReviewStore = class {
 					repositoryId
 				} : void 0,
 				shared: {
-					...bundle.attribution,
-					cloneUrl: bundle.manifest.repository?.cloneUrl
+					...loaded.attribution,
+					cloneUrl: validated.bundle.repository?.cloneUrl
 				}
 			}
 		};
@@ -899,15 +1225,6 @@ var SharedReviewStore = class {
 		}).toArray();
 		return this.local?.store.withDiffStats(reviews) ?? reviews;
 	}
-	async readObject(id, objectId) {
-		const entry = this.get(id).manifest.objects.find((object) => object.id === objectId);
-		if (!entry) throw new ReviewInputError("Shared object is unavailable.", 404);
-		const file = path.join(this.root, id, objectId);
-		if ((await stat(file)).size !== entry.size) throw new Error("Corrupt cached shared object.");
-		const bytes = await readFile(file);
-		if (digestBytes(bytes) !== entry.sha256) throw new Error("Corrupt cached shared object.");
-		return bytes;
-	}
 	async removeLocal(id) {
 		await this.jobs.get(id)?.catch(() => {});
 		if (!this.loaded.has(id)) throw new ReviewInputError("Shared review is not available.", 404);
@@ -959,9 +1276,9 @@ var SharedReviewStore = class {
 		this.attention.set(id, state);
 		for (const listener of this.listeners) listener();
 	}
-	async import(origin, shareId, bundle) {
+	async import(origin, capability, bundle, attribution) {
 		const validated = validateShareBundle(bundle);
-		const id = sharedReviewId(origin, shareId);
+		const id = sharedReviewId(origin, capability);
 		this.assertWritable(id);
 		await mkdir(this.root, {
 			recursive: true,
@@ -969,15 +1286,14 @@ var SharedReviewStore = class {
 		});
 		const staging = await mkdtemp(path.join(this.root, ".import-"));
 		try {
-			await writeFile(path.join(staging, "manifest.json"), JSON.stringify(bundle.manifest), { mode: 384 });
-			if (bundle.attribution) await writeFile(path.join(staging, "attribution.json"), JSON.stringify(bundle.attribution), { mode: 384 });
-			for (const [objectId, bytes] of bundle.objects) await writeFile(path.join(staging, objectId), bytes, { mode: 384 });
+			await writeFile(path.join(staging, "bundle.json"), JSON.stringify(validated.bundle), { mode: 384 });
+			if (attribution) await writeFile(path.join(staging, "attribution.json"), JSON.stringify(attribution), { mode: 384 });
 			try {
 				await rename(staging, path.join(this.root, id));
 			} catch (error) {
 				if (!(error instanceof Error && "code" in error && ["ENOTEMPTY", "EEXIST"].includes(String(error.code)))) throw error;
 				const existing = await this.read(id);
-				if (JSON.stringify(existing.manifest) !== JSON.stringify(bundle.manifest)) throw new Error("An immutable share changed its manifest.");
+				if (JSON.stringify(existing) !== JSON.stringify(validated.bundle)) throw new Error("An immutable share changed its bundle.");
 			}
 		} finally {
 			await rm(staging, {
@@ -985,29 +1301,20 @@ var SharedReviewStore = class {
 				force: true
 			});
 		}
-		this.loaded.set(id, {
-			manifest: bundle.manifest,
-			attribution: bundle.attribution
-		});
+		this.loaded.set(id, { attribution });
 		this.validated.set(id, validated);
 		for (const listener of this.listeners) listener();
 		await this.prepare(id);
 		return id;
 	}
 	async read(id) {
-		return (await this.readValidated(id)).bundle;
+		return (await this.readValidated(id)).validated.bundle;
 	}
 	async readValidated(id) {
 		if (!/^shared-[a-f0-9]{64}$/.test(id)) throw new Error("Invalid shared review ID.");
 		const dir = path.join(this.root, id);
-		if ((await stat(path.join(dir, "manifest.json"))).size > 2097152) throw new Error("Shared manifest is too large.");
-		const manifest = shareManifestSchema.parse(JSON.parse(await readFile(path.join(dir, "manifest.json"), "utf8")));
-		const objects = /* @__PURE__ */ new Map();
-		for (const object of manifest.objects) {
-			const file = path.join(dir, object.id);
-			if ((await stat(file)).size !== object.size) throw new Error("Corrupt cached shared object.");
-			objects.set(object.id, await readFile(file));
-		}
+		const file = path.join(dir, "bundle.json");
+		if ((await stat(file)).size > 16777216) throw new Error("Shared bundle is too large.");
 		let attribution;
 		try {
 			attribution = z.strictObject({
@@ -1015,203 +1322,11 @@ var SharedReviewStore = class {
 				sharedAt: z.number()
 			}).parse(JSON.parse(await readFile(path.join(dir, "attribution.json"), "utf8")));
 		} catch {}
-		const bundle = {
-			manifest,
-			objects,
-			attribution
-		};
 		return {
-			bundle,
-			validated: validateShareBundle(bundle)
-		};
-	}
-};
-//#endregion
-//#region src/sharing/client.ts
-const uploadSchema = z.strictObject({
-	url: z.url(),
-	headers: z.record(z.string(), z.string()),
-	expiresAt: z.string()
-});
-const createdSchema = z.strictObject({
-	shareId: z.uuid(),
-	upload: uploadSchema
-});
-const registeredSchema = z.object({
-	registered: z.literal(true),
-	uploads: z.record(z.string(), uploadSchema)
-});
-const UPLOAD_CONCURRENCY = 4;
-const MAX_UPLOAD_RESPONSE_BYTES = 8388608;
-const linkSchema = z.strictObject({
-	shareId: z.uuid(),
-	url: z.url()
-});
-const receivedSchema = z.strictObject({
-	manifest: shareManifestSchema,
-	sender: z.strictObject({ login: z.string().min(1).max(256) }),
-	sharedAt: z.number()
-});
-const signedUrlSchema = z.url().refine((value) => {
-	const url = new URL(value);
-	return url.protocol === "https:" && !url.username && !url.password;
-});
-const downloadSchema = z.strictObject({
-	url: z.url(),
-	expiresAt: z.string()
-});
-/** Size is checked while reading, even if Content-Length is absent or false. */
-async function readBoundedBytes(response, limit) {
-	if (!response.ok || !response.body) throw new Error(`Download failed (${response.status}).`);
-	const declared = response.headers.get("content-length");
-	if (declared && Number(declared) > limit) {
-		await response.body.cancel().catch(() => {});
-		throw new Error("Download exceeds its declared limit.");
-	}
-	try {
-		return await readBoundedStream(response.body, limit);
-	} catch (error) {
-		if (error instanceof StreamLimitError) throw new Error("Download exceeds its declared limit.");
-		throw error;
-	}
-}
-/** The share service rejected the account token; the stored login is stale. */
-var ShareAuthError = class extends Error {
-	constructor() {
-		super("The share service rejected the stored login.");
-		this.name = "ShareAuthError";
-	}
-};
-var SharePreflightError = class extends Error {
-	constructor(cause) {
-		super(cause instanceof Error ? cause.message : "Repository verification failed.", { cause });
-		this.name = "SharePreflightError";
-	}
-};
-var ShareRequestError = class extends Error {
-	status;
-	constructor(status) {
-		super(`Share request failed (${status}).`);
-		this.status = status;
-	}
-};
-/** Account tokens go only to the configured API origin, never to object storage. */
-var ShareClient = class {
-	token;
-	send;
-	origin;
-	constructor(origin, token, send = fetch) {
-		this.token = token;
-		this.send = send;
-		const url = new URL(origin);
-		if (url.username || url.password || url.protocol !== "https:" && !(url.protocol === "http:" && url.hostname === "localhost")) throw new Error("Use a secure share service origin.");
-		this.origin = url.origin;
-	}
-	async api(route, method = "GET", body, capability, maxBytes = MAX_SHARE_MANIFEST_BYTES) {
-		const headers = new Headers({ "content-type": "application/json" });
-		if (capability) headers.set("x-review-share-token", capability);
-		else if (this.token) headers.set("authorization", `Bearer ${this.token}`);
-		const init = {
-			method,
-			redirect: "error",
-			signal: AbortSignal.timeout(6e4),
-			headers
-		};
-		if (body !== void 0) init.body = JSON.stringify(body);
-		const response = await this.send(this.origin + route, init);
-		if (!response.ok) {
-			await response.body?.cancel();
-			if (response.status === 401 && !capability) throw new ShareAuthError();
-			throw new ShareRequestError(response.status);
-		}
-		return parseJsonText(Buffer.from(await readBoundedBytes(response, maxBytes)).toString());
-	}
-	async upload(upload, bytes) {
-		if (!signedUrlSchema.safeParse(upload.url).success) throw new Error("Invalid object upload URL.");
-		const response = await this.send(upload.url, {
-			method: "PUT",
-			headers: upload.headers,
-			body: Buffer.from(bytes),
-			redirect: "error",
-			signal: AbortSignal.timeout(12e4)
-		});
-		await response.body?.cancel();
-		if (!response.ok && response.status !== 412) throw new Error(`Object upload failed (${response.status}).`);
-	}
-	async create(bundle, requestId = randomUUID(), beforeUpload) {
-		try {
-			validateShareBundle(bundle);
-		} catch (cause) {
-			throw new SharePreflightError(new Error("Whiteboard could not prepare this review for sharing. Please report this issue.", { cause }));
-		}
-		const manifestBytes = Buffer.from(JSON.stringify(bundle.manifest));
-		const created = createdSchema.parse(await this.api("/api/shares", "POST", {
-			requestId,
-			manifest: {
-				size: manifestBytes.byteLength,
-				sha256: digestBytes(manifestBytes)
-			}
-		}));
-		const route = `/api/shares/${created.shareId}`;
-		await this.upload(created.upload, manifestBytes);
-		const { uploads } = registeredSchema.parse(await this.api(`${route}/manifest`, "POST", {}, void 0, MAX_UPLOAD_RESPONSE_BYTES));
-		try {
-			if (bundle.manifest.objects.some(({ id }) => !uploads[id])) throw new Error("The share service omitted an object upload URL.");
-			await beforeUpload?.();
-		} catch (error) {
-			await this.recoverLink(created.shareId).catch(async (failure) => {
-				if (failure instanceof ShareRequestError && failure.status === 409) await this.revoke(created.shareId);
-			}).catch(() => {});
-			throw new SharePreflightError(error);
-		}
-		for (let offset = 0; offset < bundle.manifest.objects.length; offset += UPLOAD_CONCURRENCY) {
-			const failed = (await Promise.allSettled(bundle.manifest.objects.slice(offset, offset + UPLOAD_CONCURRENCY).map(async (object) => {
-				await this.upload(uploads[object.id], bundle.objects.get(object.id));
-			}))).find((result) => result.status === "rejected");
-			if (failed) throw failed.reason;
-		}
-		for (let batch = 0; batch <= Math.ceil(bundle.manifest.objects.length / 32); batch++) {
-			const result = await this.api(`${route}/complete`, "POST", {});
-			if (linkSchema.safeParse(result).success) return linkSchema.parse(result);
-			z.strictObject({ complete: z.literal(false) }).parse(result);
-		}
-		throw new Error("Share verification did not finish.");
-	}
-	async list(cursor) {
-		const query = cursor ? `?cursor=${z.uuid().parse(cursor)}` : "";
-		return this.api(`/api/shares${query}`);
-	}
-	async recoverLink(shareId) {
-		return linkSchema.parse(await this.api(`/api/shares/${z.uuid().parse(shareId)}/link`));
-	}
-	async revoke(shareId) {
-		return this.api(`/api/shares/${z.uuid().parse(shareId)}`, "DELETE");
-	}
-	async download(shareId, capability) {
-		const route = `/api/shared/${z.uuid().parse(shareId)}`;
-		const received = receivedSchema.parse(await this.api(route, "GET", void 0, capability));
-		const manifest = received.manifest;
-		const objects = /* @__PURE__ */ new Map();
-		const download = async (object) => {
-			const signed = downloadSchema.parse(await this.api(`${route}/objects/${object.id}`, "GET", void 0, capability));
-			if (!signedUrlSchema.safeParse(signed.url).success) throw new Error("Invalid object download URL.");
-			const bytes = await readBoundedBytes(await this.send(signed.url, {
-				redirect: "error",
-				signal: AbortSignal.timeout(12e4)
-			}), object.size);
-			if (bytes.byteLength !== object.size || digestBytes(bytes) !== object.sha256) throw new Error("Downloaded share object failed its integrity check.");
-			objects.set(object.id, bytes);
-		};
-		for (let start = 0; start < manifest.objects.length; start += 4) await Promise.all(manifest.objects.slice(start, start + 4).map(download));
-		return {
-			manifest,
-			objects,
-			attribution: {
-				login: received.sender.login,
-				sharedAt: received.sharedAt
-			}
+			attribution,
+			validated: validateShareBundle(JSON.parse(await readFile(file, "utf8")))
 		};
 	}
 };
 //#endregion
-export { sharedReviewId as a, verifyShareRepository as c, validateShareSources as d, StreamLimitError as f, shareIdSchema as h, SharedReviewStore as i, exportShare as l, parseShareLink as m, ShareClient as n, validateShareBundle as o, readBoundedStream as p, SharePreflightError as r, readShareRepository as s, ShareAuthError as t, referenceCommits as u };
+export { readBoundedStream as _, verifyShareRepository as a, exportShare as c, legacyModeSchema as d, lensReport as f, StreamLimitError as g, uncategorizedReport as h, readShareRepository as i, referenceCommits as l, reviewProgress as m, sharedReviewId as n, ShareAuthError as o, progressUpdateSchema as p, validateShareBundle as r, ShareClient as s, SharedReviewStore as t, validateShareSources as u, parseShareLink as v, shareIdSchema as y };