@dev.fast/whiteboard 0.5.1 → 0.5.2-preview.20261104.147

package/dist/{import-YAIU6rB0.js → import-CjcW7EIQ.js}

@@ -1,8 +1,8 @@
 import { f as gitAt } from "./src-Y30gweiK.js";
 import { u as parseJsonText } from "./src-X9phtB2j.js";
-import { $ as comparisonKey, A as parseMarkdown, B as lensSchema, E as sourceReferences, L as UNCATEGORIZED_LENS_ID, M as checkReferences, O as markdownNodes, Q as anchorSelection, T as selectionReferences, V as lensSelections, Z as SelectionUnavailableError, _ as readsAtBoardPins, at as unionIntervals, c as documentSchema, h as pinsSchema, it as sourceAnchors, n as anchorPins, nt as resolveDiffSelection, o as boardRepositoryId, ot as ReviewInputError, q as fileLineRangeSchema, rt as selectionKey, u as elements, v as resourceReference, y as resourceReferences } from "./src-B2b8cCoI.js";
-import { s as safeStorageSegment } from "./review-home-paths-LdGS4SpR.js";
-import { D as scopedCoverage, O as sourcesForFile, T as emptyCoverage, b as textIncludesQuote, c as traceSchema, k as subtractIntervals, n as migrateStoredDocument, r as migrateStoredLenses, s as softwareModelDataSchema, t as liftFileLenses, u as pullRequestUrl, w as coverageSources, x as textualRows } from "./stored-document-migration-iwIQ4l5G.js";
+import { $ as comparisonKey, A as parseMarkdown, B as lensSchema, E as sourceReferences, L as UNCATEGORIZED_LENS_ID, M as checkReferences, O as markdownNodes, Q as anchorSelection, T as selectionReferences, V as lensSelections, Z as SelectionUnavailableError, _ as readsAtBoardPins, at as sourceAnchors, c as documentSchema, h as pinsSchema, it as selectionKey, n as anchorPins, nt as patchRows, o as boardRepositoryId, ot as unionIntervals, q as fileLineRangeSchema, rt as resolveDiffSelection, st as ReviewInputError, u as elements, v as resourceReference, y as resourceReferences } from "./src-DirPN_Qh.js";
+import { s as safeStorageSegment } from "./review-home-paths-BmZX2qiz.js";
+import { C as emptyCoverage, D as subtractIntervals, E as sourcesForFile, S as coverageSources, T as scopedCoverage, b as textIncludesQuote, c as traceSchema, n as migrateStoredDocument, r as migrateStoredLenses, s as softwareModelDataSchema, t as liftFileLenses, u as pullRequestUrl } from "./stored-document-migration-vg0NAzXG.js";
 import { N as devReviewHome } from "./s3-config-CjcLyFV5.js";
 import { createHash, randomUUID } from "node:crypto";
 import { z } from "zod";
@@ -36,51 +36,93 @@ const gitHubRepositoryUrlSchema = z.string().refine((value) => {
 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({
+const shareSourceSchema = z.discriminatedUnion("kind", [z.object({
 	kind: z.literal("excerpt"),
 	file: sharePathSchema,
 	commit: commitSchema,
 	fromLine: z.number().int().positive(),
 	lines: z.array(z.string()).min(1)
 })]);
-const lineRangeSchema = z.strictObject({
+const lineRangeSchema = z.object({
 	side: sideSchema,
 	file: sharePathSchema,
 	fromLine: z.number().int().positive(),
 	toLine: z.number().int().positive(),
-	pins: z.strictObject({
+	pins: z.object({
 		repositoryId: z.string(),
 		head: z.string(),
 		base: z.string().optional()
 	}).optional()
 });
-const shareBundleSchema = z.strictObject({
+/** 1-based base and head lines; null when a side lacks the line. */
+const alignmentRowSchema = z.tuple([z.number().int().positive().nullable(), z.number().int().positive().nullable()]);
+const shareAlignmentSchema = z.object({
+	file: sharePathSchema,
+	previousFile: sharePathSchema.optional(),
+	head: z.string(),
+	base: z.string().optional(),
+	rows: z.array(alignmentRowSchema).min(1)
+});
+/** Unknown fields drop, so a reader opens bundles from newer sharers. */
+const shareBundleSchema = z.object({
 	format: z.literal(SHARE_FORMAT),
 	reviewId: z.string().min(1).max(256),
 	version: z.number().int().nonnegative(),
 	title: z.string().max(4096),
 	/** 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() })),
+	images: z.record(z.string(), z.object({ 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()
+	/** The sharer's diff over the selections, since 0.4. */
+	alignments: z.array(shareAlignmentSchema).optional(),
+	repository: z.object({ cloneUrl: gitHubRepositoryUrlSchema }).optional(),
+	/** Quotes uncommitted changes: view only, never imported. Since 0.6. */
+	frozen: z.literal(true).optional()
 });
-z.strictObject({
+z.object({
 	requestId: z.uuid(),
 	bundle: shareBundleSchema
 });
+const shareCreatedSchema = z.strictObject({
+	shareId: shareIdSchema,
+	url: z.url()
+});
+const shareSizeSchema = z.number().int().positive().max(MAX_SHARE_BYTES);
+const shareRevisionRefSchema = z.object({
+	id: shareIdSchema,
+	version: z.number().int().nonnegative(),
+	createdAt: z.number()
+});
+const shareRevisionSchema = shareRevisionRefSchema.extend({
+	size: shareSizeSchema,
+	url: z.url()
+});
+const shareRevisionsSchema = z.object({
+	latest: shareIdSchema,
+	items: z.array(shareRevisionSchema)
+});
+const sharedMetaSchema = z.object({
+	sender: z.strictObject({ login: z.string().min(1).max(256) }),
+	sharedAt: z.number(),
+	size: shareSizeSchema,
+	revision: shareRevisionRefSchema,
+	latest: shareIdSchema
+});
 function parseShareLink(value) {
 	const url = new URL(value);
-	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 {
+	if (url.protocol !== "https:" || url.username || url.password || url.hash || [...url.searchParams.keys()].some((key) => key !== "app" && key !== "rev")) throw new Error("Use an HTTPS Whiteboard share link.");
+	const link = {
 		origin: url.origin,
 		capability: capabilitySchema.parse(/^\/s\/([^/]+)$/.exec(url.pathname)?.[1])
 	};
+	const revision = url.searchParams.get("rev");
+	if (revision !== null) link.revision = shareIdSchema.parse(revision);
+	return link;
 }
 //#endregion
 //#region src/server/bounded-stream.ts
@@ -257,7 +299,7 @@ async function reviewProgress(store, data, snapshot, signal = new AbortControlle
 			})));
 			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);
+			rows = patchRows("", 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 });
@@ -425,7 +467,11 @@ async function exportShare(input) {
 	const stored = structuredClone(input.store.read(input.reviewId, input.version));
 	const repositoryId = boardRepositoryId(stored);
 	const { target, staleSources: _staleSources, sourceUnavailable: _sourceUnavailable, lastEdit: _lastEdit, trashedAt: _trashedAt, personEdit: _personEdit, ...snapshot } = stored;
-	if (target?.kind === "worktree") throw new ReviewInputError("Pin this review to commits before sharing it.");
+	const live = target?.kind === "worktree" ? await input.data.sourcePins(stored) : void 0;
+	if (live) {
+		const { worktreeRevision: _worktreeRevision, ...committed } = live;
+		snapshot.pins = committed;
+	}
 	const pullRequestUrl = snapshot.origin?.pullRequestUrl;
 	const baseBranch = pullRequestUrl && !snapshot.origin?.baseBranch && (snapshot.origin?.pullRequestBaseBranch ?? input.data.pullRequestBaseBranch(pullRequestUrl));
 	if (baseBranch) snapshot.origin = {
@@ -439,7 +485,7 @@ async function exportShare(input) {
 		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 pins = live ?? 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();
@@ -480,7 +526,16 @@ async function exportShare(input) {
 		fromLine,
 		toLine
 	}));
-	return {
+	let frozen = false;
+	const sources = await cutExcerpts({ async quote(at, range) {
+		const quote = await input.data.quote(at, range);
+		if (at.worktreeRevision && range.side === "head" && !frozen) {
+			const { worktreeRevision: _worktreeRevision, ...committed } = at;
+			if (await input.data.quote(committed, range).then((head) => head.text !== quote.text, () => true)) frozen = true;
+		}
+		return quote;
+	} }, excerpts);
+	const bundle = {
 		format: SHARE_FORMAT,
 		reviewId: snapshot.reviewId,
 		version: snapshot.version,
@@ -491,9 +546,49 @@ async function exportShare(input) {
 		maps: Object.fromEntries(maps),
 		commits: pins ? await input.data.commits((await input.data.resolveSource(stored)).pins) : [],
 		selections,
-		sources: await cutExcerpts(input.data, excerpts),
+		sources,
 		...input.repository && { repository: input.repository }
 	};
+	if (frozen) bundle.frozen = true;
+	return bundle;
+}
+//#endregion
+//#region src/slug.ts
+/** Lowercase ASCII slug: runs of anything but `a-z0-9` become one `-`, outer
+* dashes go. Empty input, or input with no letters or digits, yields `""`;
+* callers choose their own fallback (`"section"`, `"diagram"`, `"database"`).
+* This is the rule sequence and lens ids were already published with, so it
+* must not change. */
+function slugify(text) {
+	return text.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+//#endregion
+//#region src/sharing/file.ts
+const WHITEBOARD_FILE_EXTENSION = ".whiteboard";
+const WHITEBOARD_UPGRADE_REQUIRED_MESSAGE = "This action requires a newer version of Whiteboard. Use Check for Updates, then try again.";
+const headerSchema = z.looseObject({ format: z.string() });
+function whiteboardFileName(title) {
+	return `${slugify(title) || "untitled"}${WHITEBOARD_FILE_EXTENSION}`;
+}
+function whiteboardFileText(bundle) {
+	return JSON.stringify(bundle, null, 2) + "\n";
+}
+function parseWhiteboardFile(text) {
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		parsed = void 0;
+	}
+	const header = headerSchema.safeParse(parsed);
+	if (!header.success) throw new ReviewInputError("This is not a Whiteboard file.", 400);
+	const version = /^review-share\/([1-9]\d*)$/.exec(header.data.format);
+	if (version && Number(version[1]) > Number("review-share/2".split("/")[1])) throw new ReviewInputError(WHITEBOARD_UPGRADE_REQUIRED_MESSAGE, 400);
+	if (header.data.format !== "review-share/2") throw new ReviewInputError("This file needs a different Whiteboard version.", 400);
+	return shareBundleSchema.parse(parsed);
+}
+function whiteboardFileKey(text) {
+	return createHash("sha256").update("whiteboard-file\0").update(text).digest("hex");
 }
 //#endregion
 //#region src/sharing/client.ts
@@ -512,15 +607,6 @@ const pooledFetch = (input, init) => {
 const jwtSchema = z.object({ token: z.string().min(1) });
 const jwtPayloadSchema = z.object({ exp: z.number() });
 const bearers = /* @__PURE__ */ new Map();
-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}).`);
@@ -543,6 +629,44 @@ var ShareAuthError = class extends Error {
 		this.name = "ShareAuthError";
 	}
 };
+var ShareRequestError = class extends Error {
+	status;
+	constructor(status, message) {
+		super(message);
+		this.status = status;
+		this.name = "ShareRequestError";
+	}
+};
+const errorSchema = z.object({ error: z.object({ code: z.string() }) });
+async function errorCode(response) {
+	if (!response.body) return void 0;
+	if (!response.headers.get("content-type")?.includes("application/json")) {
+		await response.body.cancel();
+		return;
+	}
+	try {
+		const bytes = await readBoundedStream(response.body, 16384);
+		return errorSchema.safeParse(parseJsonText(bytes.toString())).data?.error.code;
+	} catch {
+		return;
+	}
+}
+function requestErrorMessage(response, code) {
+	const { status, headers } = response;
+	if (status === 426 || code === "upgrade_required") return WHITEBOARD_UPGRADE_REQUIRED_MESSAGE;
+	if (status === 403 && headers.get("content-type")?.includes("text/html") && headers.get("server")?.toLowerCase() === "cloudflare") return "The sharing service's security filter blocked this request. Please report this issue.";
+	if (status === 413) return "This review is too large to share. Remove large resources, then retry.";
+	if (status === 429) return code === "share_quota_exceeded" ? "Your sharing storage limit has been reached. Please contact support." : "Too many sharing requests. Wait a moment, then retry.";
+	if (status === 400 && code === "invalid_request") return "The sharing service could not accept this review. Update Whiteboard or report this issue.";
+	if (status >= 500) return `The sharing service is temporarily unavailable (HTTP ${status}). Try again shortly.`;
+	return `The sharing service refused this request (HTTP ${status}). Please report this issue.`;
+}
+async function requestError(response) {
+	const message = requestErrorMessage(response, await errorCode(response));
+	const ray = response.headers.get("cf-ray");
+	const reference = ray && /^[a-f0-9]{16}(?:-[a-z]{3})?$/i.test(ray) ? ` Reference: ${ray}.` : "";
+	return new ShareRequestError(response.status, message + reference);
+}
 /** Account tokens go only to the configured API origin. */
 var ShareClient = class {
 	token;
@@ -570,9 +694,11 @@ var ShareClient = class {
 		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}).`);
+			if (response.status === 401 && !anonymous) {
+				await response.body?.cancel();
+				throw new ShareAuthError();
+			}
+			throw await requestError(response);
 		}
 		return readBoundedBytes(response, maxBytes);
 	}
@@ -595,13 +721,18 @@ var ShareClient = class {
 			headers: { authorization: `Bearer ${token}` }
 		});
 		if (!response.ok) {
-			await response.body?.cancel();
-			if (response.status === 404 || response.status === 405) return {
-				bearer: token,
-				until: Date.now() + 6e5
-			};
-			if (response.status === 401) throw new ShareAuthError();
-			throw new Error(`Share request failed (${response.status}).`);
+			if (response.status === 404 || response.status === 405) {
+				await response.body?.cancel();
+				return {
+					bearer: token,
+					until: Date.now() + 6e5
+				};
+			}
+			if (response.status === 401) {
+				await response.body?.cancel();
+				throw new ShareAuthError();
+			}
+			throw await requestError(response);
 		}
 		const { token: jwt } = jwtSchema.parse(parseJsonText(Buffer.from(await readBoundedBytes(response, 65536)).toString()));
 		const { exp } = jwtPayloadSchema.parse(parseJsonText(Buffer.from(jwt.split(".")[1] ?? "", "base64url").toString()));
@@ -618,29 +749,38 @@ var ShareClient = class {
 		})).body?.cancel();
 	}
 	async create(bundle, requestId = randomUUID()) {
-		return linkSchema.parse(await this.api("/api/v2/shares", "POST", shareRequestBody(bundle, requestId)));
+		return shareCreatedSchema.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`));
+		return shareCreatedSchema.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);
+	async revisions(shareId) {
+		return shareRevisionsSchema.parse(await this.api(`/api/v2/shares/${shareIdSchema.parse(shareId)}/revisions`));
+	}
+	/** Who shared a link's revision, and which revision is its latest. */
+	async shared(capability, revision) {
+		const query = revision === void 0 ? "" : `?rev=${shareIdSchema.parse(revision)}`;
+		return sharedMetaSchema.parse(await this.api(`/api/v2/shared/${capabilitySchema.parse(capability)}${query}`, "GET", void 0, true));
+	}
+	/** The bundle of the revision the meta names, and who shared it. */
+	async download(capability, revision) {
+		const meta = await this.shared(capability, revision);
+		const bytes = await this.request(`/api/v2/shared/${capability}/bundle?rev=${meta.revision.id}`, "GET", void 0, true, MAX_SHARE_BYTES);
 		return {
-			bundle: shareBundleSchema.parse(parseJsonText(new TextDecoder().decode(bytes))),
+			bundle: parseWhiteboardFile(new TextDecoder().decode(bytes)),
 			attribution: {
-				login: received.sender.login,
-				sharedAt: received.sharedAt
-			}
+				login: meta.sender.login,
+				sharedAt: meta.sharedAt
+			},
+			revision: meta.revision,
+			latest: meta.latest
 		};
 	}
 };
@@ -847,7 +987,7 @@ async function readShareRepository(root) {
 }
 //#endregion
 //#region src/sharing/import.ts
-const sharedSnapshotSchema = z.strictObject({
+const sharedSnapshotSchema = z.object({
 	reviewId: z.string().min(1),
 	version: z.number().int().nonnegative(),
 	/** Empty for a board never named; it reads "Untitled". */
@@ -859,7 +999,7 @@ const sharedSnapshotSchema = z.strictObject({
 	document: documentSchema,
 	lenses: z.array(lensSchema).optional(),
 	createdAt: z.string(),
-	origin: z.strictObject({
+	origin: z.object({
 		branch: z.string().optional(),
 		baseRef: z.string().optional(),
 		baseBranch: z.string().optional(),
@@ -871,7 +1011,7 @@ const sharedSnapshotSchema = z.strictObject({
 	}).optional()
 });
 const count = z.number().int().nonnegative();
-const counts = z.strictObject({
+const counts = z.object({
 	additions: count,
 	deletions: count
 });
@@ -881,9 +1021,9 @@ const mapSchema = softwareModelDataSchema.extend({
 	countsByElementPath: z.record(z.string(), counts),
 	unmappedByElementPath: z.record(z.string(), counts.extend({ files: z.array(counts.extend({
 		file: z.string(),
-		hunks: z.array(z.strictObject({
+		hunks: z.array(z.object({
 			startLine: count,
-			lines: z.array(z.strictObject({
+			lines: z.array(z.object({
 				kind: z.enum(["add", "remove"]),
 				oldLine: count.nullable(),
 				newLine: count.nullable(),
@@ -892,13 +1032,14 @@ const mapSchema = softwareModelDataSchema.extend({
 		}))
 	})) }))
 });
-z.strictObject({ maps: z.record(z.string(), mapSchema) });
+z.object({ maps: z.record(z.string(), mapSchema) });
 /** Commits and traces live in a checkout; a document alone needs none. */
 function needsRepository(bundle, snapshot) {
 	return Boolean(snapshot.pins || referenceCommits(snapshot).length || Object.keys(bundle.traces).length);
 }
 function validateShareBundle(input) {
 	const bundle = shareBundleSchema.parse(input);
+	if (bundle.frozen) throw new ReviewInputError("This whiteboard is a read-only snapshot of uncommitted changes. View it in the browser.", 409);
 	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.");
@@ -948,12 +1089,41 @@ function shareKey(origin, capability) {
 	capabilitySchema.parse(capability);
 	return createHash("sha256").update(JSON.stringify([url.origin, capability])).digest("hex");
 }
-/** Imports a share as an ordinary board, once per link: the link's copy
-* comes back while it exists, even from Trash. */
-async function importShare(input, key, received, attribution) {
+/** Which copy a served revision opens or refreshes in place; otherwise a new copy. */
+function planShareCopy(copies, served, pinned = false) {
+	const same = copies.find(({ shared }) => shared.revisionId === void 0 ? shared.sharedAt === served.revision.createdAt : shared.revisionId === served.revision.id);
+	if (same) return {
+		kind: "open",
+		reviewId: same.reviewId
+	};
+	const unedited = !pinned && served.revision.id === served.latest && copies.find((copy) => !copy.shared.pinned && copy.version === (copy.shared.importedVersion ?? 0));
+	return unedited ? {
+		kind: "refresh",
+		reviewId: unedited.reviewId,
+		version: unedited.version
+	} : { kind: "import" };
+}
+/** Opens, refreshes or copies a link's board by the revision it serves. */
+async function receiveShare(input, key, served, download, pinned = false) {
+	const plan = planShareCopy(input.store.copiesOf(key), served, pinned);
+	if (plan.kind === "open") return plan.reviewId;
+	const { bundle, attribution } = await download();
+	const provenance = {
+		...attribution,
+		revisionId: served.revision.id,
+		...pinned && { pinned }
+	};
+	if (plan.kind === "import") return importShare(input, key, bundle, provenance);
+	try {
+		return await importShare(input, key, bundle, provenance, plan);
+	} catch (error) {
+		if (error instanceof ReviewInputError && (error.status === 409 || error.status === 404)) return importShare(input, key, bundle, provenance);
+		throw error;
+	}
+}
+/** Imports a share as an ordinary board, or into a copy of its link. */
+async function importShare(input, key, received, provenance, into) {
 	const { store, data } = input;
-	const existing = store.copyOf(key);
-	if (existing) return existing;
 	const { bundle, snapshot, maps } = validateShareBundle(received);
 	const cloneUrl = bundle.repository?.cloneUrl;
 	let repositoryId;
@@ -988,7 +1158,7 @@ async function importShare(input, key, received, attribution) {
 	}
 	let document = JSON.stringify(snapshot.document);
 	for (const [id, copy] of ids) document = document.replaceAll(id, copy);
-	const { reviewId } = await store.execute({ operation: {
+	const create = { operation: {
 		type: "create",
 		...snapshot.title && { title: snapshot.title },
 		...pins ? { target: {
@@ -998,17 +1168,19 @@ async function importShare(input, key, received, attribution) {
 			kind: "project",
 			repositoryId
 		} }
-	} }, {
+	} };
+	const seed = {
 		document: JSON.parse(document),
 		lenses: snapshot.lenses,
 		origin: snapshot.origin,
 		shared: {
-			...attribution,
+			...provenance,
 			cloneUrl,
 			key
 		},
 		copiedFrom: snapshot.reviewId
-	}, { kind: "person" });
+	};
+	const { reviewId } = into ? await store.refreshCopy(into.reviewId, into.version, create, seed) : await store.execute(create, seed, { kind: "person" });
 	return reviewId;
 }
 /** A checkout of the share's repository with every commit it reads at: the
@@ -1050,4 +1222,4 @@ async function shareRepository({ store, data, ...git }, cloneUrl, pins, commits,
 	return repositoryId;
 }
 //#endregion
-export { readBoundedStream as _, forgetSharedCommits as a, shareBundleSchema as b, ShareClient as c, legacyModeSchema as d, lensReport as f, StreamLimitError as g, uncategorizedReport as h, validateShareBundle as i, exportShare as l, reviewProgress as m, needsRepository as n, readShareRepository as o, progressUpdateSchema as p, shareKey as r, ShareAuthError as s, importShare as t, validateShareSources as u, SHARE_FORMAT as v, shareIdSchema as x, parseShareLink as y };
+export { StreamLimitError as C, shareIdSchema as D, shareBundleSchema as E, uncategorizedReport as S, parseShareLink as T, validateShareSources as _, shareKey as a, progressUpdateSchema as b, readShareRepository as c, ShareRequestError as d, parseWhiteboardFile as f, exportShare as g, whiteboardFileText as h, receiveShare as i, ShareAuthError as l, whiteboardFileName as m, needsRepository as n, validateShareBundle as o, whiteboardFileKey as p, planShareCopy as r, forgetSharedCommits as s, importShare as t, ShareClient as u, legacyModeSchema as v, readBoundedStream as w, reviewProgress as x, lensReport as y };