wiki-viewer 1.0.0 → 1.0.1

package/.next/standalone/src/lib/proof/ops-applier.ts

@@ -0,0 +1,678 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import path from "node:path";
+import type { RootContent } from "mdast";
+import type { Op, Block, Snapshot, Sidecar, ProofEvent, Comment, Suggestion } from "./types";
+import { parseBlocks, blockToMarkdown, blocksToMarkdown } from "./blocks";
+import { assignRefs, resolveRef, computeRefDelta, textHash } from "./block-refs";
+import { wrapAsProofSpan, newSpanId } from "./proof-span";
+import { readSidecar, writeSidecar, emptySidecar } from "./sidecar";
+import { withFileMutex } from "./mutex";
+import { emitEvents, trimEvents } from "./event-bus";
+import { SIDECAR_EVENT_TRIM_SIZE, SIDECAR_TRIM_EVERY_N_MUTATIONS } from "../proof-config";
+
+function sha256file(content: string): string {
+	return "sha256:" + createHash("sha256").update(content, "utf8").digest("hex");
+}
+
+function shortId(prefix: string): string {
+	return prefix + Math.floor(Math.random() * 0xffff).toString(16).padStart(4, "0");
+}
+
+function nowIso(): string {
+	return new Date().toISOString();
+}
+
+function cloneSidecar(sc: Sidecar): Sidecar {
+	return JSON.parse(JSON.stringify(sc)) as Sidecar;
+}
+
+/**
+ * Wrap op markdown for AI agents: inserts proof-span marks on text-bearing blocks.
+ * Returns { wrappedMarkdown, blockProvenance }.
+ */
+function wrapForAi(
+	markdown: string,
+	by: string,
+	basis: string | undefined,
+	basisDetail: string | undefined,
+	inResponseTo: string | undefined,
+	sidecar: Sidecar,
+	blockRef: string,
+): string {
+	const attrs = {
+		spanId: newSpanId(),
+		origin: "ai" as const,
+		basis: basis ?? "inferred",
+		basisDetail,
+		by,
+		at: nowIso(),
+		inResponseTo,
+	};
+	const wrapped = wrapAsProofSpan(markdown, attrs);
+	if (wrapped === null) {
+		// Non-wrappable block type. Record in sidecar.blockProvenance instead.
+		if (!sidecar.blockProvenance) sidecar.blockProvenance = {};
+		sidecar.blockProvenance[blockRef] = attrs;
+		return markdown;
+	}
+	return wrapped;
+}
+
+/**
+ * Parse op markdown into mdast nodes, assign refs, and wrap for AI if needed.
+ */
+function opMarkdownToBlocks(
+	markdown: string,
+	by: string,
+	basis: string | undefined,
+	basisDetail: string | undefined,
+	inResponseTo: string | undefined,
+	isAi: boolean,
+	workingBlocks: Block[],
+	workingSidecar: Sidecar,
+): { nodes: RootContent[]; refs: string[] } {
+	const nodes = parseBlocks(markdown);
+	const usedRefs = new Set(workingBlocks.map((b) => b.ref));
+	const refs: string[] = [];
+
+	for (let i = 0; i < nodes.length; i++) {
+		const node = nodes[i];
+		let md = blockToMarkdown(node);
+
+		// Mint a provisional ref for this new block
+		const hash = "b" + createHash("sha256").update(md, "utf8").digest("hex").slice(0, 6);
+		let ref = hash;
+		let counter = 0;
+		while (usedRefs.has(ref)) {
+			ref = `${hash}_${counter++}`;
+		}
+		usedRefs.add(ref);
+		refs.push(ref);
+
+		if (isAi) {
+			md = wrapForAi(md, by, basis, basisDetail, inResponseTo, workingSidecar, ref);
+			// Reparse the wrapped markdown to get the updated node
+			const reparsed = parseBlocks(md);
+			if (reparsed.length > 0) {
+				nodes[i] = reparsed[0];
+			}
+		}
+	}
+
+	return { nodes, refs };
+}
+
+function buildSnapshot(
+	mdPath: string,
+	blocks: Block[],
+	sidecar: Sidecar,
+): Snapshot {
+	return {
+		path: mdPath,
+		revision: sidecar.revision,
+		createdAt: sidecar.createdAt,
+		updatedAt: sidecar.updatedAt,
+		fingerprint: sidecar.fingerprint,
+		blocks,
+		comments: sidecar.comments,
+		suggestions: sidecar.suggestions.filter((s) => s.status === "pending"),
+		lastEventId: sidecar.nextEventId - 1,
+	};
+}
+
+/**
+ * Pure read: load file, parse blocks, assign refs, return snapshot.
+ * Detects external edits (fingerprint mismatch) and records them in the sidecar.
+ */
+export async function readSnapshot(
+	rootDir: string,
+	mdPath: string,
+): Promise<Snapshot | null> {
+	const absPath = path.join(rootDir, mdPath);
+	let content: string;
+	try {
+		content = await readFile(absPath, "utf-8");
+	} catch (err) {
+		if ((err as NodeJS.ErrnoException).code === "ENOENT") return null;
+		throw err;
+	}
+
+	const sidecar = (await readSidecar(rootDir, mdPath)) ?? emptySidecar(mdPath);
+	const fingerprint = sha256file(content);
+
+	// Detect external edits: fingerprint set and mismatched
+	if (sidecar.fingerprint && sidecar.fingerprint !== fingerprint) {
+		return withFileMutex(mdPath, async () => {
+			// Re-read under mutex to avoid TOCTOU
+			let freshContent: string;
+			try {
+				freshContent = await readFile(absPath, "utf-8");
+			} catch (err) {
+				if ((err as NodeJS.ErrnoException).code === "ENOENT") return null;
+				throw err;
+			}
+			const freshSidecar = (await readSidecar(rootDir, mdPath)) ?? emptySidecar(mdPath);
+			const freshFingerprint = sha256file(freshContent);
+
+			if (freshSidecar.fingerprint && freshSidecar.fingerprint !== freshFingerprint) {
+				const freshNodes = parseBlocks(freshContent);
+				const { blocks: freshBlocks, newRefMap } = assignRefs(freshNodes, freshSidecar);
+				freshSidecar.refMap = newRefMap;
+				freshSidecar.revision += 1;
+				freshSidecar.updatedAt = nowIso();
+				freshSidecar.fingerprint = freshFingerprint;
+				emitEvents(freshSidecar, [{
+					type: "file.externallyEdited",
+					at: nowIso(),
+					by: "system",
+					fingerprint: freshFingerprint,
+				}]);
+				await writeSidecar(rootDir, mdPath, freshSidecar);
+				return buildSnapshot(mdPath, freshBlocks, freshSidecar);
+			}
+
+			// Another writer already updated — just build snapshot from current state
+			const nodes = parseBlocks(freshContent);
+			const { blocks } = assignRefs(nodes, freshSidecar);
+			return buildSnapshot(mdPath, blocks, freshSidecar);
+		});
+	}
+
+	const nodes = parseBlocks(content);
+	const { blocks, newRefMap } = assignRefs(nodes, sidecar);
+
+	// Sync sidecar refMap if it's empty (first read) and persist fingerprint
+	if (Object.keys(sidecar.refMap).length === 0) {
+		sidecar.refMap = newRefMap;
+		sidecar.fingerprint = fingerprint;
+		// Persist so future readSnapshot calls can detect external edits
+		await writeSidecar(rootDir, mdPath, sidecar);
+	}
+
+	return buildSnapshot(mdPath, blocks, sidecar);
+}
+
+type ApplyResult =
+	| { ok: true; snapshot: Snapshot; emittedEvents: ProofEvent[] }
+	| {
+			ok: false;
+			status: number;
+			code: string;
+			message: string;
+			snapshot?: Snapshot;
+	  };
+
+/**
+ * Apply a batch of ops to a file, with revision check, mutex, and atomic write.
+ */
+export async function applyOps(args: {
+	rootDir: string;
+	mdPath: string;
+	baseRevision: number;
+	by: string;
+	ops: Op[];
+}): Promise<ApplyResult> {
+	const { rootDir, mdPath, baseRevision, by, ops } = args;
+
+	return withFileMutex(mdPath, async (): Promise<ApplyResult> => {
+		const absPath = path.join(rootDir, mdPath);
+
+		let content: string;
+		try {
+			content = await readFile(absPath, "utf-8");
+		} catch (err) {
+			if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+				return { ok: false, status: 404, code: "FILE_NOT_FOUND", message: "File not found" };
+			}
+			throw err;
+		}
+
+		const fingerprint = sha256file(content);
+		let sidecar = (await readSidecar(rootDir, mdPath)) ?? emptySidecar(mdPath);
+
+		const isAi = by.startsWith("ai:");
+
+		// Detect external edits
+		if (sidecar.fingerprint && sidecar.fingerprint !== fingerprint) {
+			const nodes = parseBlocks(content);
+			const { blocks: freshBlocks, newRefMap } = assignRefs(nodes, sidecar);
+			sidecar.refMap = newRefMap;
+			sidecar.revision += 1;
+			sidecar.updatedAt = nowIso();
+			sidecar.fingerprint = fingerprint;
+			emitEvents(sidecar, [{
+				type: "file.externallyEdited",
+				at: nowIso(),
+				by: "system",
+				fingerprint,
+			}]);
+			await writeSidecar(rootDir, mdPath, sidecar);
+			// Return STALE_REVISION so caller knows to re-fetch
+			return {
+				ok: false,
+				status: 409,
+				code: "STALE_REVISION",
+				message: "File was externally edited. Fetch the new snapshot and retry.",
+				snapshot: buildSnapshot(mdPath, freshBlocks, sidecar),
+			};
+		}
+
+		// Initialize fingerprint if not set
+		if (!sidecar.fingerprint) {
+			sidecar.fingerprint = fingerprint;
+		}
+
+		const nodes = parseBlocks(content);
+		const { blocks: assignedBlocks, newRefMap } = assignRefs(nodes, sidecar);
+		sidecar.refMap = newRefMap;
+
+		// Revision check
+		if (baseRevision !== sidecar.revision) {
+			return {
+				ok: false,
+				status: 409,
+				code: "STALE_REVISION",
+				message: `Base revision ${baseRevision} does not match current revision ${sidecar.revision}.`,
+				snapshot: buildSnapshot(mdPath, assignedBlocks, sidecar),
+			};
+		}
+
+		// Working copies
+		let workingNodes = [...nodes];
+		let workingBlocks = [...assignedBlocks];
+		const workingSidecar = cloneSidecar(sidecar);
+		const workingEvents: Array<Omit<ProofEvent, "id">> = [];
+		const collectedAliases: Record<string, string> = {};
+
+		const currentRefs = () => new Set(workingBlocks.map((b) => b.ref));
+
+		function findBlockIndex(ref: string): number {
+			const resolved = resolveRef(workingSidecar, ref, currentRefs());
+			if (!resolved) return -1;
+			return workingBlocks.findIndex((b) => b.ref === resolved);
+		}
+
+		// Apply ops
+		for (const op of ops) {
+			const at = nowIso();
+
+			switch (op.type) {
+				case "block.replace": {
+					const idx = findBlockIndex(op.ref);
+					if (idx === -1) {
+						return {
+							ok: false,
+							status: 409,
+							code: "BLOCK_NOT_FOUND",
+							message: `Block ref "${op.ref}" not found.`,
+							snapshot: buildSnapshot(mdPath, workingBlocks, workingSidecar),
+						};
+					}
+					const oldRef = workingBlocks[idx].ref;
+
+					const { nodes: newNodes, refs: newRefs } = opMarkdownToBlocks(
+						op.markdown, by, op.basis, op.basisDetail, op.inResponseTo,
+						isAi, workingBlocks.filter((_, i) => i !== idx), workingSidecar,
+					);
+
+					workingNodes.splice(idx, 1, ...newNodes);
+					const newBlocks = newNodes.map((n, ni) => {
+						const md = blockToMarkdown(n);
+						return { ref: newRefs[ni], type: "paragraph" as const, markdown: md };
+					});
+					workingBlocks.splice(idx, 1, ...newBlocks);
+
+					// Re-assign proper block types
+					const reparse = assignRefs(newNodes, null);
+					for (let ni = 0; ni < newBlocks.length; ni++) {
+						workingBlocks[idx + ni] = { ...reparse.blocks[ni], ref: newRefs[ni] };
+					}
+
+					if (newRefs[0]) collectedAliases[oldRef] = newRefs[0];
+					workingEvents.push({
+						type: "block.replaced",
+						at,
+						by,
+						ref: oldRef,
+						newRef: newRefs[0] ?? null,
+					});
+					break;
+				}
+
+				case "block.insertAfter": {
+					const idx = findBlockIndex(op.ref);
+					if (idx === -1) {
+						return {
+							ok: false,
+							status: 409,
+							code: "BLOCK_NOT_FOUND",
+							message: `Block ref "${op.ref}" not found.`,
+							snapshot: buildSnapshot(mdPath, workingBlocks, workingSidecar),
+						};
+					}
+					const { nodes: newNodes, refs: newRefs } = opMarkdownToBlocks(
+						op.markdown, by, op.basis, op.basisDetail, op.inResponseTo,
+						isAi, workingBlocks, workingSidecar,
+					);
+					const newBlockList = newNodes.map((n, ni) => {
+						const reparse = assignRefs([n], null);
+						return { ...reparse.blocks[0], ref: newRefs[ni] };
+					});
+					workingNodes.splice(idx + 1, 0, ...newNodes);
+					workingBlocks.splice(idx + 1, 0, ...newBlockList);
+					workingEvents.push({ type: "block.inserted", at, by, after: op.ref, refs: newRefs });
+					break;
+				}
+
+				case "block.insertBefore": {
+					const idx = findBlockIndex(op.ref);
+					if (idx === -1) {
+						return {
+							ok: false,
+							status: 409,
+							code: "BLOCK_NOT_FOUND",
+							message: `Block ref "${op.ref}" not found.`,
+							snapshot: buildSnapshot(mdPath, workingBlocks, workingSidecar),
+						};
+					}
+					const { nodes: newNodes, refs: newRefs } = opMarkdownToBlocks(
+						op.markdown, by, op.basis, op.basisDetail, op.inResponseTo,
+						isAi, workingBlocks, workingSidecar,
+					);
+					const newBlockList = newNodes.map((n, ni) => {
+						const reparse = assignRefs([n], null);
+						return { ...reparse.blocks[0], ref: newRefs[ni] };
+					});
+					workingNodes.splice(idx, 0, ...newNodes);
+					workingBlocks.splice(idx, 0, ...newBlockList);
+					workingEvents.push({ type: "block.inserted", at, by, before: op.ref, refs: newRefs });
+					break;
+				}
+
+				case "block.delete": {
+					const idx = findBlockIndex(op.ref);
+					if (idx === -1) {
+						return {
+							ok: false,
+							status: 409,
+							code: "BLOCK_NOT_FOUND",
+							message: `Block ref "${op.ref}" not found.`,
+							snapshot: buildSnapshot(mdPath, workingBlocks, workingSidecar),
+						};
+					}
+					workingNodes.splice(idx, 1);
+					workingBlocks.splice(idx, 1);
+					workingEvents.push({ type: "block.deleted", at, by, ref: op.ref });
+					break;
+				}
+
+				case "block.append": {
+					const { nodes: newNodes, refs: newRefs } = opMarkdownToBlocks(
+						op.markdown, by, op.basis, op.basisDetail, op.inResponseTo,
+						isAi, workingBlocks, workingSidecar,
+					);
+					const newBlockList = newNodes.map((n, ni) => {
+						const reparse = assignRefs([n], null);
+						return { ...reparse.blocks[0], ref: newRefs[ni] };
+					});
+					workingNodes.push(...newNodes);
+					workingBlocks.push(...newBlockList);
+					workingEvents.push({ type: "block.inserted", at, by, position: "end", refs: newRefs });
+					break;
+				}
+
+				case "block.prepend": {
+					const { nodes: newNodes, refs: newRefs } = opMarkdownToBlocks(
+						op.markdown, by, op.basis, op.basisDetail, op.inResponseTo,
+						isAi, workingBlocks, workingSidecar,
+					);
+					const newBlockList = newNodes.map((n, ni) => {
+						const reparse = assignRefs([n], null);
+						return { ...reparse.blocks[0], ref: newRefs[ni] };
+					});
+					workingNodes.unshift(...newNodes);
+					workingBlocks.unshift(...newBlockList);
+					workingEvents.push({ type: "block.inserted", at, by, position: "start", refs: newRefs });
+					break;
+				}
+
+				case "comment.add": {
+					const refs = currentRefs();
+					const resolved = resolveRef(workingSidecar, op.ref, refs);
+					if (!resolved) {
+						return {
+							ok: false,
+							status: 409,
+							code: "BLOCK_NOT_FOUND",
+							message: `Block ref "${op.ref}" not found.`,
+							snapshot: buildSnapshot(mdPath, workingBlocks, workingSidecar),
+						};
+					}
+					const comment: Comment = {
+						id: shortId("c"),
+						ref: resolved,
+						resolved: false,
+						createdAt: at,
+						turns: [{ by, text: op.text, at }],
+					};
+					workingSidecar.comments.push(comment);
+					workingEvents.push({ type: "comment.added", at, by, commentId: comment.id, ref: resolved, text: op.text });
+					break;
+				}
+
+				case "comment.reply": {
+					const comment = workingSidecar.comments.find((c) => c.id === op.commentId);
+					if (!comment) {
+						return {
+							ok: false,
+							status: 409,
+							code: "COMMENT_NOT_FOUND",
+							message: `Comment "${op.commentId}" not found.`,
+							snapshot: buildSnapshot(mdPath, workingBlocks, workingSidecar),
+						};
+					}
+					comment.turns.push({ by, text: op.text, at });
+					workingEvents.push({ type: "comment.replied", at, by, commentId: op.commentId, text: op.text });
+					break;
+				}
+
+				case "comment.resolve": {
+					const comment = workingSidecar.comments.find((c) => c.id === op.commentId);
+					if (!comment) {
+						return {
+							ok: false,
+							status: 409,
+							code: "COMMENT_NOT_FOUND",
+							message: `Comment "${op.commentId}" not found.`,
+							snapshot: buildSnapshot(mdPath, workingBlocks, workingSidecar),
+						};
+					}
+					comment.resolved = true;
+					workingEvents.push({ type: "comment.resolved", at, by, commentId: op.commentId });
+					break;
+				}
+
+				case "comment.reopen": {
+					const comment = workingSidecar.comments.find((c) => c.id === op.commentId);
+					if (!comment) {
+						return {
+							ok: false,
+							status: 409,
+							code: "COMMENT_NOT_FOUND",
+							message: `Comment "${op.commentId}" not found.`,
+							snapshot: buildSnapshot(mdPath, workingBlocks, workingSidecar),
+						};
+					}
+					comment.resolved = false;
+					workingEvents.push({ type: "comment.reopened", at, by, commentId: op.commentId });
+					break;
+				}
+
+				case "suggestion.add": {
+					const refs = currentRefs();
+					const resolved = resolveRef(workingSidecar, op.ref, refs);
+					if (!resolved) {
+						return {
+							ok: false,
+							status: 409,
+							code: "BLOCK_NOT_FOUND",
+							message: `Block ref "${op.ref}" not found.`,
+							snapshot: buildSnapshot(mdPath, workingBlocks, workingSidecar),
+						};
+					}
+
+					const suggestion: Suggestion = {
+						id: shortId("s"),
+						ref: resolved,
+						kind: op.kind,
+						status: "pending",
+						by,
+						markdown: op.markdown,
+						basis: op.basis as Suggestion["basis"],
+						basisDetail: op.basisDetail,
+						createdAt: at,
+					};
+
+					if (op.status === "accepted") {
+						// Apply immediately
+						suggestion.status = "accepted";
+						suggestion.resolvedAt = at;
+						suggestion.resolvedBy = by;
+						workingSidecar.archivedSuggestions.push(suggestion);
+						workingEvents.push({ type: "suggestion.added", at, by, suggestionId: suggestion.id });
+						workingEvents.push({ type: "suggestion.accepted", at, by, suggestionId: suggestion.id });
+						// Apply as block op inline
+						const inlineOp: Op = op.kind === "replace"
+							? { type: "block.replace", ref: resolved, markdown: op.markdown ?? "" }
+							: op.kind === "insertAfter"
+							? { type: "block.insertAfter", ref: resolved, markdown: op.markdown ?? "" }
+							: op.kind === "insertBefore"
+							? { type: "block.insertBefore", ref: resolved, markdown: op.markdown ?? "" }
+							: { type: "block.delete", ref: resolved };
+						// Recursively handle by pushing to ops (not safe for complex cases, do inline)
+						// For simplicity, fall through to apply the block op directly
+						ops.push(inlineOp);
+					} else {
+						workingSidecar.suggestions.push(suggestion);
+						workingEvents.push({ type: "suggestion.added", at, by, suggestionId: suggestion.id });
+					}
+					break;
+				}
+
+				case "suggestion.accept": {
+					const sugIdx = workingSidecar.suggestions.findIndex((s) => s.id === op.suggestionId);
+					if (sugIdx === -1) {
+						return {
+							ok: false,
+							status: 409,
+							code: "SUGGESTION_NOT_FOUND",
+							message: `Suggestion "${op.suggestionId}" not found.`,
+							snapshot: buildSnapshot(mdPath, workingBlocks, workingSidecar),
+						};
+					}
+					const sug = workingSidecar.suggestions[sugIdx];
+					sug.status = "accepted";
+					sug.resolvedAt = at;
+					sug.resolvedBy = by;
+					workingSidecar.suggestions.splice(sugIdx, 1);
+					workingSidecar.archivedSuggestions.push(sug);
+
+					// Supersede other pending suggestions for the same ref
+					const toSupersede = workingSidecar.suggestions.filter(
+						(s) => s.ref === sug.ref && s.status === "pending",
+					);
+					for (const other of toSupersede) {
+						other.status = "rejected";
+						other.resolvedAt = at;
+						other.resolvedBy = "system";
+						workingSidecar.suggestions.splice(workingSidecar.suggestions.indexOf(other), 1);
+						workingSidecar.archivedSuggestions.push(other);
+						workingEvents.push({
+							type: "suggestion.rejected",
+							at,
+							by: "system",
+							suggestionId: other.id,
+							reason: "superseded",
+						});
+					}
+
+					// Apply as block op
+					const applyOp: Op = sug.kind === "replace"
+						? { type: "block.replace", ref: sug.ref, markdown: sug.markdown ?? "" }
+						: sug.kind === "insertAfter"
+						? { type: "block.insertAfter", ref: sug.ref, markdown: sug.markdown ?? "" }
+						: sug.kind === "insertBefore"
+						? { type: "block.insertBefore", ref: sug.ref, markdown: sug.markdown ?? "" }
+						: { type: "block.delete", ref: sug.ref };
+					ops.push(applyOp);
+					workingEvents.push({ type: "suggestion.accepted", at, by, suggestionId: op.suggestionId });
+					break;
+				}
+
+				case "suggestion.reject": {
+					const sugIdx = workingSidecar.suggestions.findIndex((s) => s.id === op.suggestionId);
+					if (sugIdx === -1) {
+						return {
+							ok: false,
+							status: 409,
+							code: "SUGGESTION_NOT_FOUND",
+							message: `Suggestion "${op.suggestionId}" not found.`,
+							snapshot: buildSnapshot(mdPath, workingBlocks, workingSidecar),
+						};
+					}
+					const sug = workingSidecar.suggestions[sugIdx];
+					sug.status = "rejected";
+					sug.resolvedAt = at;
+					sug.resolvedBy = by;
+					workingSidecar.suggestions.splice(sugIdx, 1);
+					workingSidecar.archivedSuggestions.push(sug);
+					workingEvents.push({ type: "suggestion.rejected", at, by, suggestionId: op.suggestionId });
+					break;
+				}
+
+				default:
+					return { ok: false, status: 400, code: "INVALID_PAYLOAD", message: "Unknown op type" };
+			}
+		}
+
+		// Rebuild final markdown from working nodes
+		const newMarkdown = blocksToMarkdown(workingNodes);
+		const newFingerprint = sha256file(newMarkdown);
+
+		// Recompute refMap and aliases
+		const reparsedNodes = parseBlocks(newMarkdown);
+		const { blocks: finalBlocks, newRefMap: finalRefMap } = assignRefs(reparsedNodes, workingSidecar);
+
+		const oldHashToRef = new Map<string, string>();
+		for (const [ref, entry] of Object.entries(workingSidecar.refMap)) {
+			if (!oldHashToRef.has(entry.textHash)) oldHashToRef.set(entry.textHash, ref);
+		}
+		const { refAliases } = computeRefDelta(workingSidecar.refMap, oldHashToRef, finalBlocks);
+		Object.assign(collectedAliases, refAliases);
+
+		workingSidecar.revision += 1;
+		workingSidecar.updatedAt = nowIso();
+		workingSidecar.fingerprint = newFingerprint;
+		workingSidecar.refMap = finalRefMap;
+		workingSidecar.refAliases = collectedAliases;
+
+		// Emit all collected events
+		const emitted = emitEvents(workingSidecar, workingEvents);
+
+		// Trim if needed
+		if (workingSidecar.revision % SIDECAR_TRIM_EVERY_N_MUTATIONS === 0) {
+			trimEvents(workingSidecar, SIDECAR_EVENT_TRIM_SIZE);
+		}
+
+		// Atomic write
+		await writeFile(path.join(rootDir, mdPath), newMarkdown, "utf-8");
+		await writeSidecar(rootDir, mdPath, workingSidecar);
+
+		return {
+			ok: true,
+			snapshot: buildSnapshot(mdPath, finalBlocks, workingSidecar),
+			emittedEvents: emitted,
+		};
+	});
+}

package/.next/standalone/src/lib/proof/owner-auth.ts

@@ -0,0 +1,2 @@
+// Removed: owner auth now handled by Better Auth (src/lib/auth/server.ts).
+export {};